~mdw / ssr / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Initial revision
[ssr] / StraySrc / SDLS / DLLManager / s / app
1 ;
2 ; app.s
3 ;
4 ; Handling of application blocks
5 ;
6 ; © 1994-1998 Straylight
7 ;
8
9 ;----- Licensing note -------------------------------------------------------
10 ;
11 ; This file is part of Straylight's Dynamic Linking System (SDLS)
12 ;
13 ; SDLS 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 ; SDLS 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 SDLS. 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 sh.wSpace
37 GET sh.appblock
38 GET sh.linkblock
39 GET sh.dllblock
40
41 GET sh.misc
42 GET sh.suballoc
43 GET sh.dll
44
45 GET sh.messages
46
47 ;----- External routines ----------------------------------------------------
48
49 AREA |DLLM$$Code|,CODE,READONLY
50
51 GBLL debug
52 debug SETL {FALSE}
53
54 ; --- app_init ---
55 ;
56 ; On entry: --
57 ; On exit: --
58
59 EXPORT app_init
60 app_init ROUT
61
62 STMFD R13!,{R1,R2,R14} ;Save some registers
63
64 ; --- Save workspace address ---
65 ;
66 ; This is so that app__epilogue can find our workspace.
67
68 STR R12,app__pw ;Store data relocation
69
70 ; --- Now locate the OS's pid word ---
71 ;
72 ; We do this using a table indexed by the OS version on the
73 ; grounds that it's easier to update if the address changes.
74 ; This is unlikely however, since DDEUtils uses this address
75 ; too, and it's right before the VDU driver workspace at
76 ; &1000, which seems to indicate it's there forever.
77
78 MOV R0,#&81 ;Read the OS version number
79 MOV R1,#0 ;Set up the odd arguments
80 MOV R2,#255 ;This is really very strange
81 SWI XOS_Byte ;Do the read operation
82
83 ADR R14,app__verTable ;Point to the table
84 00 LDMIA R14!,{R0,R2} ;Load version and address
85 CMP R0,R1 ;How do the versions compare?
86 BCC %b00 ;No match -- keep going
87
88 STR R2,app__pidAddr ;If matched, store address
89 LDMFD R13!,{R1,R2,PC}^ ;Restore caller's registers
90 BICS PC,R14,#V_flag ;And return to caller
91
92 app__verTable DCD -1,&FF8 ;All versions have PID here
93
94 LTORG
95
96 app__pw DCD 0 ;Where to store private word
97
98 ; --- app_checkQuit ---
99 ;
100 ; On entry: --
101 ; On exit: --
102
103 EXPORT app_checkQuit
104 app_checkQuit ROUT
105
106 LDR R0,app__list ;Get list head pointer
107 CMP R0,#0 ;Are there any applications?
108 MOVEQS PC,R14 ;No -- that's OK then
109 ADRL R0,msg_errInUse ;Point to error
110 ORRS PC,R14,#V_flag ;Return an error
111
112 LTORG
113
114 ; --- app_findDLL ---
115 ;
116 ; On entry: R0 == pointer to name of DLL to find
117 ; R1 == version number to load
118 ; On exit: R0 == DLL handle loaded
119
120 EXPORT app_findDLL
121 app_findDLL ROUT
122
123 STMFD R13!,{R11,R14} ;Stack registers nicely
124 BL app__sFindDLL ;Find the DLL etc.
125 BVC app__ok ;If it worked, make permanent
126 B app__dead ;Otherwise, tidy up
127
128 LTORG
129
130 ; --- app_loseDLL ---
131 ;
132 ; On entry: R0 == pointer to DLL to lose
133 ; On exit: --
134
135 EXPORT app_loseDLL
136 app_loseDLL ROUT
137
138 STMFD R13!,{R1-R3,R11,R14} ;Look after some registers
139 MOV R11,R0 ;Keep hold of pointer
140
141 ; --- Find the application's handle ---
142
143 BL app_getHandle ;Find application's time
144 BLVC app__find ;Find the application block
145 LDMVSFD R13!,{R1-R3,R11,PC} ;Return an error if any
146
147 ; --- Find the link block ---
148
149 MOV R3,R0 ;Keep hold of app pointer
150 MOV R1,R11 ;Point to application
151 BL app__findLink ;Find the link block
152 LDMVSFD R13!,{R1-R3,R11,PC} ;Return an error if any
153
154 ; --- Remove the link block ---
155
156 MOV R1,R0 ;Point to the link block
157 MOV R0,R3 ;Point to the application
158 BL app__freeLink ;Free the link block up
159
160 ; --- Decrement the DLL count ---
161 ;
162 ; This will release the DLL if it no longer has any clients
163
164 MOV R0,R11 ;Point to DLL
165 BL dll_dec ;Decrement its counter
166
167 ; --- Uncache the current link if we've removed it ---
168
169 LDR R0,[R3,#app_cachedll] ;Find which DLL we cached
170 CMP R0,R11 ;Have we just unlinked it?
171 MOVEQ R0,#0 ;Yes -- clear out the handle
172 STREQ R0,[R3,#app_cachedll] ;Won't match any more
173 STREQ R0,[R3,#app_cacheptr]
174
175 ; --- Return, deleting application if necessary ---
176
177 MOV R0,R3 ;Point to application
178 LDMFD R13!,{R1-R3,R11,R14} ;Unstack registers
179 B app__freeUnused ;Kill app block if no DLLs
180
181 LTORG
182
183 ; --- app_setname ---
184 ;
185 ; On entry: R0 == pointer to application's name
186 ; On exit: --
187
188 EXPORT app_setname
189 app_setname ROUT
190
191 STMFD R13!,{R1,R14} ;Store registers and things
192 MOV R1,R0 ;Keep pointer to the name
193 BL app__add ;Make sure the app exists
194
195 ADDVC R0,R0,#app_name ;Point to the name
196 BLVC misc_strcpy ;Copy the string across
197 LDMFD R13!,{R1,PC} ;Return to caller
198
199 LTORG
200
201 ; --- app_fromtable ---
202 ;
203 ; On entry: R0 == pointer to start of external DLL block
204 ; R1 == pointer to limit of same
205 ; On exit: --
206
207 EXPORT app_fromtable
208 app_fromtable ROUT
209
210 STMFD R13!,{R11,R14} ;Look after registers
211 BL app_sfromtbl ;Do primitive operation
212 BVC app__ok ;If it worked, to gadget
213 B app__dead ;If it failed,tidy up
214
215 LTORG
216
217 ; --- app_sfromtbl ---
218 ;
219 ; On entry: R0 == pointer to start of external DLL block
220 ; R1 == pointer to limit of same
221 ; On exit: --
222
223 EXPORT app_sfromtbl
224 app_sfromtbl ROUT
225
226 STMFD R13!,{R1-R5,R10,R11,R14} ;Stack some registers
227
228 MOV R10,R0 ;Keep pointer to base
229 MOV R11,R1 ;Keep pointer to limit
230
231 00app_sfromtbl CMP R10,R11 ;Is there anything to do?
232 LDMEQFD R13!,{R1-R5,R10,R11,PC}^ ;No -- return to caller
233
234 ; --- Load an entry from the table ---
235
236 LDMIA R10!,{R0-R3} ;Load values from table
237 BL app__sFindDLL ;Try to find the DLL
238 LDMVSFD R13!,{R1-R5,R10,R11,PC} ;Return the error if any
239
240 ; --- Fill in the veneer table ---
241
242 MOV R1,R2 ;Point to first name to load
243 MOV R2,R0 ;Keep pointer to DLL base
244 LDR R5,[R2,#dl_entries] ;Load the entry count
245 BIC R4,R5,#&FF000000 ;Clear entry type bits
246
247 01app_sfromtbl LDR R0,[R3,#0] ;Load value from table
248 CMP R0,R4 ;Is it a valid ordinal?
249 BHS %05app_sfromtbl ;No -- look up the name then
250
251 LDR R14,[R2,#dl_eveneer] ;Yes -- load entry point base
252 TST R5,#dl_shortEntries ;Are the entries short?
253 ADDEQ R0,R14,R0,LSL #4 ;No -- find base of veneer
254 LDRNE R0,[R14,R0,LSL #2] ;Yes -- load address
255 B %10app_sfromtbl ;And skip past name lookup
256
257 05app_sfromtbl LDRB R0,[R1] ;Load first byte from string
258 CMP R0,#0 ;Is it a zero (end of list)?
259 BEQ %00app_sfromtbl ;Yes -- do next table entry
260
261 ; --- Find entry point address ---
262
263 MOV R0,R2 ;Point to DLL base
264 BL dll_findEntry ;Find the entry point
265 LDMVSFD R13!,{R1-R5,R10,R11,PC} ;Return the error if any
266 MOV R4,#0 ;Remember to bump name
267
268 ; --- Convert it into a branch ---
269
270 10app_sfromtbl SUB R0,R0,R3 ;Convert to offset from R3
271 SUB R0,R0,#8 ;Subtract 8 (pipeline)
272 MOV R0,R0,LSR #2 ;Shift right to word align
273 BIC R0,R0,#&FF000000 ;Clear top (opcode and cond)
274 ORR R0,R0,#&EA000000 ;Put in BAL (Branch always)
275 STR R0,[R3],#4 ;Store in veneer table
276 CMP R4,#0 ;Did we look up a name?
277 BNE %01app_sfromtbl ;No -- examine next entry pt
278
279 ; --- Find next entry point address ---
280
281 02app_sfromtbl LDRB R0,[R1],#1 ;Load a byte from the name
282 CMP R0,#0 ;Is it the string end?
283 BNE %02app_sfromtbl ;No -- get another
284 B %01app_sfromtbl ;Fill in another entry point
285
286 LTORG
287
288 ; --- app_findNamed ---
289 ;
290 ; On entry: R0 == name of an application
291 ; On exit: R0 == pointer to application block base
292
293 EXPORT app_findNamed
294 app_findNamed ROUT
295
296 STMFD R13!,{R1-R3,R14} ;Preserve registers
297 MOV R1,R0 ;Keep pointer to string
298 LDR R3,app__list ;And load the pointer to list
299
300 00app_findNamed CMP R3,#0 ;Is this the end of the line?
301 BEQ %40app_findNamed ;Yes -- give an error
302 ADD R0,R3,#app_name ;Find the name string
303 MOV R2,#0 ;Caseless compare
304 BL misc_strcmp ;Compare the strings
305 LDRNE R3,[R3,#app_next] ;If no match, move on...
306 BNE %00app_findNamed ;... and try again
307 MOV R0,R3 ;Point to DLL (give handle)
308 LDMFD R13!,{R1-R3,PC}^ ;And return to caller
309
310 40app_findNamed ADRL R0,msg_errAppNotFound ;Couldn't find DLL name
311 BL misc_error ;... create an error message
312 LDMFD R13!,{R1-R3,R14} ;... restore registers
313 ORRS PC,R14,#V_flag ;... and return an error
314
315 LTORG
316
317 ; --- app_setBtable ---
318 ;
319 ; On entry: R0 == pointer to entry point table
320 ; R1 == pointer to name table
321 ; On exit: --
322
323 EXPORT app_setBtable
324 app_setBtable ROUT
325
326 STMFD R13!,{R1,R2,R14} ;Stick 'em on the stack
327 MOV R2,R0 ;Keep this safe
328 BL app__add ;Create an entry for the app
329 STRVC R2,[R0,#app_btable] ;Store the entry table ptr
330 STRVC R1,[R0,#app_nametable] ;Store the name table ptr
331 LDMFD R13!,{R1,R2,PC} ;Return to caller
332
333 LTORG
334
335 ; --- app_appEntry ---
336 ;
337 ; On entry: R0 == pointer to name to find
338 ; On exit: R0 == pointer to entry point
339
340 EXPORT app_appEntry
341 app_appEntry ROUT
342
343 STMFD R13!,{R1,R2,R14} ;Stack registers away
344
345 ; --- Find the application ---
346
347 MOV R2,R0 ;Point to name start
348 BL app_getHandle
349 BLVC app__find ;Try to find the app block
350 LDMVSFD R13!,{R1,R2,PC} ;If not there, error
351
352 ; --- Get the entry table info out ---
353
354 LDR R1,[R0,#app_nametable] ;Find name table address
355 LDR R0,[R0,#app_btable] ;Find entry table address
356 CMP R0,#0 ;Is there no entry table?
357 BEQ %50app_appEntry ;No -- complain about it
358
359 ; --- Find the entry point ---
360
361 BL dll_appEntry ;Do the actual find
362 LDMFD R13!,{R1,R2,PC} ;Return to caller
363
364 ; --- Application has no entry points ---
365
366 50app_appEntry ADRL R0,msg_errAppNoEntry ;Point to error message
367 LDMFD R13!,{R1,R2,R14} ;Unstack registers
368 ORRS PC,R14,#V_flag ;Return the error to caller
369
370 LTORG
371
372 ALIGN
373
374 ; --- app_fixExtension ---
375 ;
376 ; On entry: R0 == pointer to name table
377 ; R1 == pointer to branch table to fill in
378 ; On exit: --
379
380 EXPORT app_fixExtension
381 app_fixExtension
382
383 STMFD R13!,{R14} ;Save return address
384 BL app_fix ;Do the real job
385 LDMVSFD R13!,{PC} ;If it failed, return now
386 MOV R0,#0 ;Otherwise do global resync
387 SWI XOS_SynchroniseCodeAreas ;Do that then
388 LDMFD R13!,{R14} ;Restore return address
389 BICS PC,R14,#V_flag ;And return with V clear
390
391 LTORG
392
393 ; --- app_fix ---
394 ;
395 ; On entry: R0 == pointer to name table
396 ; R1 == pointer to branch table to fill in
397 ; On exit: --
398
399 EXPORT app_fix
400 app_fix ROUT
401
402 STMFD R13!,{R1-R6,R14} ;Stack registers away
403
404 ; --- Find the application ---
405
406 MOV R2,R0 ;Point to name start
407 MOV R3,R1 ;Keep entry table safe
408 BL app_getHandle
409 BLVC app__find ;Try to find the app block
410 LDMVSFD R13!,{R1-R6,PC} ;If not there, error
411
412 ; --- Get the entry table info out ---
413
414 LDR R4,[R0,#app_btable] ;Find entry table address
415 LDR R5,[R0,#app_nametable] ;Find name table address
416 MOV R6,#&1000 ;Guess number of entries
417 CMP R4,#0 ;Is there no entry table?
418 BEQ %50app_fix ;No -- complain about it
419
420 ; --- Set up for a nice loop ---
421
422 00app_fix LDR R0,[R3,#0] ;Load the word from btable
423 CMP R0,R6 ;Is it moderately sensible?
424 ADDLO R0,R4,R0,LSL #2 ;Yes -- find the entry
425 MOVLO R14,#1 ;Remember we done this
426 BLO %10app_fix ;And fill in the branch
427 LDRB R0,[R2] ;Get the first entry byte
428 CMP R0,#0 ;Is it the end of the table?
429 LDMEQFD R13!,{R1-R6,PC}^ ;Yes -- we did it OK
430
431 ; --- Find another entry point address ---
432
433 MOV R0,R4 ;Point to entry table
434 MOV R1,R5 ;Point to name table
435 BL dll_appEntry ;Find the actual entry name
436 LDMVSFD R13!,{R1-R6,PC} ;If not there, return error
437 MOV R6,#0 ;Move on to next string
438
439 ; --- Convert it to a branch instruction ---
440
441 10app_fix SUB R0,R0,R3 ;Convert to offset from R3
442 SUB R0,R0,#8 ;Subtract 8 (pipeline)
443 MOV R0,R0,LSR #2 ;Shift right to word align
444 BIC R0,R0,#&FF000000 ;Clear top (opcode and cond)
445 ORR R0,R0,#&EA000000 ;Put in BAL (Branch always)
446 STR R0,[R3],#4 ;Store in veneer table
447
448 ; --- Find next entry point address ---
449
450 CMP R6,#0 ;Do we need to move on?
451 BNE %00app_fix ;No -- just loop then
452 01app_fix LDRB R0,[R2],#1 ;Load a byte from the name
453 CMP R0,#0 ;Is it the string end?
454 BNE %01app_fix ;No -- get another
455 B %00app_fix ;Fill in another entry point
456
457 ; --- Application has no entry points to offer ---
458
459 50app_fix ADRL R0,msg_errAppNoEntry ;Point to error message
460 LDMFD R13!,{R1-R6,R14} ;Unstack registers
461 ORRS PC,R14,#V_flag ;Return the error to caller
462
463 LTORG
464
465 ; --- app_listDLLs ---
466 ;
467 ; On entry: R0 == pointer to name of an application
468 ; On exit: --
469
470 EXPORT app_listDLLs
471 app_listDLLs ROUT
472
473 STMFD R13!,{R1,R14} ;Stack registers nicely
474 BL app_findNamed ;Find the application block
475 LDMVSFD R13!,{R1,PC} ;Return if not found
476 LDR R1,[R0,#app_dlls] ;Load head of DLL list
477 CMP R1,#0 ;This shouldn't be 0
478 BEQ %01app_listDLLs ;If it is, print a message
479
480 BL dll_writeTitle ;Display the line along top
481
482 ; --- Main loop thing ---
483
484 00app_listDLLs LDR R0,[R1,#lk_dll] ;Point to the DLL
485 BL dll_writeInfo ;Display information about it
486 LDR R1,[R1,#lk_next] ;Move onto the next one
487 CMP R1,#0 ;Is that all?
488 BNE %00app_listDLLs ;No -- continue round
489
490 LDMFD R13!,{R1,PC}^ ;Return to caller
491
492 ; --- No DLLs to list. Hmm... ---
493
494 01app_listDLLs ADRL R0,msg_noDLLsForApp ;Point to the message
495 SWI OS_Write0 ;And display it
496 LDMFD R13!,{R1,PC}^ ;Return to caller
497
498 LTORG
499
500 ; --- app_listUsing ---
501 ;
502 ; On entry: R0 == pointer to a DLL name
503 ; On exit: --
504
505 EXPORT app_listUsing
506 app_listUsing ROUT
507
508 STMFD R13!,{R1,R2,R8-R11,R14} ;Stack registers
509
510 ; --- Check that the DLL exists ---
511
512 MOV R8,R0 ;Keep the name pointer safe
513 MOV R1,#0 ;Don't care which version
514 BL dll_find ;Try to find it
515 BVS %11app_listUsing ;If it's not there, error
516
517 ; --- Start a loop through the apps ---
518
519 LDR R11,app__list ;Find the list head pointer
520 MOV R10,#0 ;No matching DLLs found yet
521 CMP R11,#0 ;Are there any apps?
522 BEQ %10app_listUsing ;No -- print a message then
523
524 ; --- Start a loop through the DLLs with this app
525
526 00app_listUsing LDR R9,[R11,#app_dlls] ;Find the DLL list
527 CMP R9,#0 ;Are there any DLLs?
528 BEQ %03app_listUsing ;No -- move on to the next
529
530 ; --- Loop through DLLs on this app ---
531
532 01app_listUsing LDR R0,[R9,#lk_dll] ;Point to the DLL base
533 MOV R1,R8 ;Point to DLL name
534 MOV R2,#0 ;Don't care what version
535 BL dll_compare ;Compare with stuff given
536 CMP R0,#1 ;Is there a match?
537 BNE %02app_listUsing ;Move onto the next one
538
539 ; --- Print out info about this app ---
540
541 CMP R10,#1 ;Have we printed the title?
542 ADRNEL R0,msg_appHeader ;No -- point to header
543 SWINE XOS_Write0 ;And print it
544 MOV R10,#1 ;We've printed it now
545 ADD R0,R11,#app_name ;Point to application name
546 MOV R1,#12 ;Field width
547 BL dll_field ;Print it out
548 LDR R0,[R9,#lk_dll] ;Find DLL pointer again
549 LDR R0,[R0,#dl_version] ;Load version number
550 BL dll_convertVersion ;Convert it into a string
551 SWI XOS_Write0 ;Write it out as a string
552 SWI XOS_NewLine ;And move onto the next line
553
554 ; --- Finish off loop through app's DLLs ---
555
556 02app_listUsing LDR R9,[R9,#lk_next] ;Move on to next link block
557 CMP R9,#0 ;Anything to do here?
558 BNE %01app_listUsing ;Yes -- check that one too
559
560 ; --- Finish off loop through all apps ---
561
562 03app_listUsing LDR R11,[R11,#app_next] ;Move on to next application
563 CMP R11,#0 ;Is there any more to do?
564 BNE %00app_listUsing ;Yes -- do its DLLs
565
566 CMP R10,#0 ;Were any messages printed?
567 BEQ %10app_listUsing ;No -- print one
568 LDMFD R13!,{R1,R2,R8-R11,PC}^ ;Return to caller
569
570 ; --- No matching DLLs were found ---
571
572 10app_listUsing ADRL R0,msg_noAppsForDLL ;Point to message skeleton
573 MOV R1,R8 ;Point to the DLL name
574 BL misc_subst ;Do the substitution
575 SWI XOS_Write0 ;Display the string
576 LDMFD R13!,{R1,R2,R8-R11,PC}^
577
578 ; --- Print an error message about this ---
579
580 11app_listUsing MOV R1,R8 ;Point to DLL name
581 ADRL R0,msg_errDLLNotInMem ;Point to error block
582 BL misc_error ;Create error message fully
583 LDMFD R13!,{R1,R2,R8-R11,R14} ;Unstack all registers
584 ORRS PC,R14,#V_flag ;Return to caller with error
585
586 LTORG
587
588 ; --- app_list ---
589 ;
590 ; On entry: --
591 ; On exit: --
592
593 EXPORT app_list
594 app_list ROUT
595
596 STMFD R13!,{R1,R14} ;Stack registers
597
598 ; --- Prepare for a loop ---
599
600 LDR R1,app__list ;Point to first entry
601 CMP R1,#0 ;Are there any entries?
602 BEQ %10app_list ;No -- give a message
603
604 ; --- Display entries in order ---
605
606 00app_list ADD R0,R1,#app_name ;Point to name in structure
607 SWI XOS_Write0 ;Display the app's name
608 SWI XOS_NewLine ;Display a new line char
609 LDR R1,[R1,#app_next] ;Get next entry in the list
610 CMP R1,#0 ;Is it the end yet?
611 BNE %00app_list ;No -- do the next one
612 LDMFD R13!,{R1,PC}^ ;Return to caller
613
614 ; --- Display message about no apps ---
615
616 10app_list ADRL R0,msg_noApps ;Point to the message
617 SWI XOS_Write0 ;Display it on the screen
618 LDMFD R13!,{R1,PC}^ ;Return to caller
619
620 LTORG
621
622 ; --- app_dying ---
623 ;
624 ; On entry: --
625 ; On exit: --
626
627 EXPORT app_dying
628 app_dying ROUT
629
630 STMFD R13!,{R14} ;Stack return address
631 BL app_getHandle ;Find application's time
632 BLVC app__find ;Find the application block
633 LDMFD R13!,{R14} ;Retrieve the return address
634 BVC app_kill ;If there's no error, kill it
635 ORRS PC,R14,#V_flag ;Return to caller with error
636
637 LTORG
638
639 ; --- app_kill --
640 ;
641 ; On entry: R0 == pointer to application base
642 ; On exit: --
643
644 EXPORT app_kill
645 app_kill ROUT
646
647 STMFD R13!,{R1,R2,R14} ;Stack registers nicely
648 MOV R2,R0 ;Keep hold of this pointer
649
650 ; --- Free each DLL link ---
651
652 LDR R1,[R0,#app_dlls] ;Find head of link list
653 CMP R1,#0 ;Are there any DLLs?
654 BEQ %01app_kill ;No -- don't free them then
655
656 00app_kill LDR R0,[R1,#lk_dll] ;Find the DLL pointer
657 BL dll_dec ;Decrement its counter
658 MOV R0,R1 ;Point to old block
659 LDR R1,[R0,#lk_next] ;Point to next block
660 BL sub_free ;Free the old block
661 CMP R1,#0 ;Are there any more to do?
662 BNE %00app_kill ;Yes -- do the next one
663
664 ; --- Free the application block ---
665
666 01app_kill MOV R0,R2 ;Point to application block
667 LDMFD R13!,{R1,R2,R14} ;Restore registers
668 B app__free ;Free the application block
669
670 LTORG
671
672 ; --- app_killAll ---
673 ;
674 ; On entry: --
675 ; On exit: --
676
677 EXPORT app_killAll
678 app_killAll ROUT
679
680 STMFD R13!,{R1,R2,R14}
681
682 ; --- Start up the main loop ---
683
684 LDR R2,app__list ;Point to application list
685 CMP R2,#0 ;Is there anything to do?
686 BEQ %01app_killAll ;No -- skip the loop
687 MOV R0,#7 ;Free memory reason code
688
689 00app_killAll LDR R1,[R2,#app_next] ;Find next block in the list
690 SWI XOS_Module ;Free the block
691 MOVS R2,R1 ;Point to the next one
692 BNE %00app_killAll ;Loop round for the next one
693
694 01app_killAll STR R2,app__list ;Clear out list head pointer
695 STR R2,app__cachePtr ;Clear out cached pointer
696 STR R2,app__cacheHnd ;Clear out cached handle
697 LDMFD R13!,{R1,R2,PC}^ ;Return to caller
698
699 LTORG
700
701 ; --- app_instvars ---
702 ;
703 ; On entry: R0 == anything for first call, or pointer to data block
704 ; R4 == 0 for first call, or pointer to link block
705 ; On exit: R0 == size of block required
706 ; R4 == pointer to next link block, or 0 to end
707
708 EXPORT app_instvars
709 app_instvars ROUT
710
711 STMFD R13!,{R1,R14} ;Keep hold of link register
712 CMP R4,#0 ;Is this the first call?
713 BNE %00app_instvars ;No -- skip ahead quickly
714
715 ; --- Find start of application list ---
716
717 BL app_getHandle ;Get app's start time
718 BLVC app__find ;Locate the application
719 LDMVSFD R13!,{R1,PC}^ ;Return to caller on error
720 LDR R4,[R0,#app_dlls] ;Load list head pointer
721 B %01app_instvars ;Don't try registering vars
722
723 ; --- Register instance variables ---
724
725 00app_instvars CMP R0,#0 ;Check the allocator worked
726 BEQ %40app_instvars ;If not, give an error
727 MOV R1,R0 ;Point to the new block
728 LDR R0,[R4,#lk_dll] ;Point to the DLL block
729 BL dll_instvars ;Register the instance vars
730 LDR R0,[R4,#lk_dll] ;Point to the DLL block again
731 BL dll_convreloc ;Convert to a relocation
732 STR R0,[R4,#lk_work] ;Store relocation
733
734 ; --- Is this the end of the line? ---
735
736 02app_instvars LDR R4,[R4,#lk_next] ;Move to next block in list
737 01app_instvars CMP R4,#0 ;Is this the end?
738 LDMEQFD R13!,{R1,PC}^ ;Yes -- return to caller
739 LDR R0,[R4,#lk_work] ;Find workspace pointer
740 CMP R0,#0 ;Is there one yet?
741 BNE %02app_instvars ;Yes -- skip this one
742 LDR R0,[R4,#lk_dll] ;Point to DLL
743 BL dll_datasize ;Find how much space we need
744 CMP R0,#0 ;Is there any required?
745 BEQ %02app_instvars ;No -- skip to next block
746 LDMFD R13!,{R1,PC}^ ;Return -- that's done
747
748 40app_instvars ADRL R0,msg_errDLLNoMem ;Point to error message
749 LDMFD R13!,{R1,R14} ;Restore registers
750 ORRS PC,R14,#V_flag ;Return the error
751
752 LTORG
753
754 ; --- app_giveclib ---
755 ;
756 ; On entry: R0 == pointer to CLib data (__iob)
757 ; On exit: --
758
759 EXPORT app_giveclib
760 app_giveclib ROUT
761
762 STMFD R13!,{R1,R14} ;Stack registers
763 MOV R1,R0 ;Keep pointer to data
764 BL app__add ;Make sure there's an app
765 STRVC R1,[R0,#app_clibdata] ;Store the pointer nicely
766 LDMFD R13!,{R1,PC} ;Return to caller nicely
767
768 LTORG
769
770 ; --- app_appdata ---
771 ;
772 ; On entry: R0 == application's stack limit
773 ; On exit: --
774
775 EXPORT app_appdata
776 app_appdata ROUT
777
778 STMFD R13!,{R1,R14} ;Stack registers
779 LDR R1,[R0,#-536] ;Find application's reloc
780 BL app__add ;Ensure the app is present
781 STRVC R1,[R0,#app_owndata] ;Store the relocation nicely
782 LDMFD R13!,{R1,PC} ;Return to caller nicely
783
784 LTORG
785
786 ; --- app_findclib ---
787 ;
788 ; On entry: --
789 ; On exit: R0 == pointer to CLib data
790
791 EXPORT app_findclib
792 app_findclib ROUT
793
794 STMFD R13!,{R14} ;Keep return address safe
795 BL app_getHandle ;Find app's start time
796 BLVC app__find ;Look up application's block
797 LDRVC R0,[R0,#app_clibdata] ;Find C Library data pointer
798 LDMFD R13!,{PC} ;Return to caller
799
800 LTORG
801
802 ; --- app_readstackptr ---
803 ;
804 ; On entry: --
805 ; On exit: R0 == `magic cookie' for the stack pointer
806
807 EXPORT app_readstkptr
808 app_readstkptr ROUT
809
810 STMFD R13!,{R14} ;Keep return address safe
811 BL app_getHandle ;Find app's start time
812 BLVC app__find ;Locate the app's data block
813 LDRVC R0,[R0,#app_stackPtr] ;Find the stack pointer
814 LDMFD R13!,{PC}^ ;Return to caller
815
816 LTORG
817
818 ; --- app_setstkptr ---
819 ;
820 ; On entry: R0 == `magic cookie' from app_readstkptr
821 ; R1 == app's current stack limit
822
823 EXPORT app_setstkptr
824 app_setstkptr ROUT
825
826 STMFD R13!,{R11,R14} ;Keep return address safe
827
828 ; --- Find the application block ---
829
830 MOV R11,R0 ;Keep hold of new pointer
831 BL app_getHandle ;Find the app's start time
832 BLVC app__find ;Find the app's data block
833 LDMVSFD R13!,{R11,PC} ;If failed, return error
834
835 ; --- Find out what there is to do ---
836
837 LDR R14,[R0,#app_stackPtr] ;Load the old pointer
838 CMP R11,R14 ;How does it shape up?
839 LDMEQFD R13!,{R11,PC}^ ;Nothing doing here
840
841 ; --- Put back the new stack pointer and set relocation ---
842
843 STR R11,[R0,#app_stackPtr] ;Store new pointer
844 CMP R11,#0 ;Was the stack at top level?
845 ADDNE R0,R0,#app_stack ;Point to base of stack
846 SUBNE R11,R11,#8 ;Point to base of stack entry
847 LDRNE R0,[R0,R11] ;Find data relocation
848 LDREQ R0,[R0,#app_owndata] ;If toplevel, get client data
849 STR R0,[R1,#-536] ;Store in stack limit struct
850 LDMFD R13!,{R11,PC}^ ;Return to caller
851
852 LTORG
853
854 ; --- app_prologue ---
855 ;
856 ; On entry: R0 == return address for routine
857 ; R1 == pointer to stack limit structure
858 ; R2 == pointer to base of DLL code
859 ; On exit: R0 == new return address
860 ;
861 ; Note -- I'm directly accessing the DLL data here, which may be considered
862 ; naughty by some. I don't care.
863
864 EXPORT app_prologue
865 app_prologue ROUT
866
867 STMFD R13!,{R9-R11,R14} ;Stack some registers
868
869 ; --- Find application block ---
870
871 MOV R11,R0 ;Keep hold of this
872 BL app__add ;Make sure the app exists
873 LDMVSFD R13!,{R9-R11,PC} ;Return the error on fail
874
875 ; --- Stack current relocation and return address ---
876
877 LDR R14,[R0,#app_stackPtr] ;Find the stack pointer
878 CMP R14,#4096 ;Where is it currently?
879 BGE %00app_prologue ;Give error on overflow
880 ADD R10,R0,#app_stack ;Point to stack base
881 ADD R10,R10,R14 ;Add on stack pointer
882 LDR R9,[R1,#-536] ;Find the current reloc
883 STMIA R10,{R9,R11} ;Store registers on the stack
884 MOV R10,R1 ;Keep pointer to stack limit
885 ADD R14,R14,#8 ;Bump along stack pointer
886 STR R14,[R0,#app_stackPtr] ;Store stack pointer
887
888 ; --- Find workspace pointer ---
889
890 CMP R2,#0 ;What's the DLL pointer?
891 LDREQ R1,[R0,#app_owndata] ;0 -- find app workspace
892 BEQ %10app_prologue ;... and finish search
893 LDR R14,[R2,#dl_next-dl_extra] ;Find DLL's next ptr
894 CMP R14,#-1 ;Is it shared?
895 LDREQ R1,[R2,#dl_wspace-dl_extra] ;No -- find DLL workspace
896 BEQ %10app_prologue ;... and finish search
897
898 ; --- Get shared DLL workspace pointer ---
899
900 SUB R1,R2,#dl_extra ;Point to DLL handle
901 BL app__findLink ;Find the link block
902 LDMVSFD R13!,{R9-R11,PC} ;Return error if it failed
903 LDR R1,[R0,#lk_work] ;Find relocation offset
904
905 ; --- Round everything off ---
906
907 10app_prologue ADR R0,app__epilogue ;Point to tidy-up routine
908 STR R1,[R10,#-536] ;Store new data relocation
909 LDMFD R13!,{R9-R11,PC}^ ;Return to caller happy
910
911 ; --- Stack overflow error ---
912
913 00app_prologue ADRL R0,msg_errStackOvf ;Point to error
914 LDMFD R13!,{R9-R11,R14} ;Unstack registers
915 ORRS PC,R14,#V_flag ;Return the error
916
917 LTORG
918
919 ; --- app_restoreHandle ---
920 ;
921 ; On entry: R0 == an application handle to assume
922 ; On exit: --
923
924 EXPORT app_restoreHandle
925 app_restoreHandle ROUT
926
927 [ :LNOT::DEF:ddeutils_pid
928
929 STMFD R13!,{R0-R2,R14} ;Save some registers
930 SWI XOS_GetEnv ;Read current command string
931 MOV R1,R13 ;Point to new start time
932 SWI XOS_WriteEnv ;Set the start time back
933 LDMFD R13!,{R0-R2,PC}^ ;And return to caller
934
935 |
936
937 MOVS PC,R14 ;No need to do this
938
939 ]
940
941 LTORG
942
943 ; --- app_getHandle ---
944 ;
945 ; On entry: --
946 ; On exit: R0 == application's start time
947 ;
948 ; Since the application's start time is held in *five* bytes we use only the
949 ; least significant 4 (the four that change most).
950
951 EXPORT app_getHandle
952 app_getHandle ROUT
953
954 [ :LNOT::DEF:ddeutils_pid
955
956 STMFD R13!,{R1,R2,R14} ;Save some registers
957 SWI XOS_GetEnv ;Get the session info
958 LDR R0,[R2,#0] ;Load the start time nicely
959 LDMFD R13!,{R1,R2,PC}^ ;And return to caller
960
961 |
962
963 LDR R0,app__pidAddr ;Load the PID address
964 LDR R0,[R0] ;And load the current PID
965 MOVS PC,R14 ;Return to caller when done
966
967 ]
968
969 LTORG
970
971 ;----- Private routines -----------------------------------------------------
972
973 ; --- app__epilogue ---
974 ;
975 ; On entry: --
976 ; On exit: a1,a2 preserved. otherwise as APCS-R
977 ;
978 ; I've used APCS register names throughout here.
979
980 app__epilogue ROUT
981
982 STMFD sp!,{a1,a2} ;Keep two return values
983 LDR ip,app__pw ;Point to private word ptr
984 BL app_getHandle ;Find app's start time
985 BL app__find ;Find app block
986 LDR a2,[a1,#app_stackPtr] ;Find the stack pointer
987 ADD a3,a1,#app_stack ;Point to the stack base
988 ADD a3,a3,a2 ;Point to current stack pos
989 LDMDB a3!,{a4,lr} ;Find relocation and ret addr
990 SUB a2,a2,#8 ;Bump down the stack ptr
991 STR a2,[a1,#app_stackPtr] ;Store back in app block
992 STR a4,[sl,#-536] ;Store relocation offset
993 LDMFD sp!,{a1,a2} ;Restore return values
994 MOVS pc,lr ;Return to caller
995
996 LTORG
997
998 ; --- app__find ---
999 ;
1000 ; On entry: R0 == application handle (i.e. start time)
1001 ; On exit: R0 == pointer to application block, or error
1002
1003 app__find ROUT
1004
1005 STMFD R13!,{R1,R2,R14} ;Preserve nice registers
1006
1007 ; --- Try looking at the cached value ---
1008
1009 LDR R1,app__cacheHnd ;Load the cached handle
1010 CMP R1,R0 ;Is it a match?
1011 LDREQ R0,app__cachePtr ;Yes -- load the pointer
1012 LDMEQFD R13!,{R1,R2,PC}^ ;And return!
1013
1014 ; --- Otherwise, scan the list ---
1015
1016 LDR R2,app__list ;Get list head pointer
1017 CMP R2,#0 ;Is there an entry here?
1018 BEQ %10app__find ;No -- return an error
1019 00app__find LDR R1,[R2,#app_handle] ;Get the app's handle
1020 CMP R1,R0 ;Is it a match?
1021 BEQ %01app__find ;Yes -- deal with it
1022 LDR R2,[R2,#app_next] ;No -- get the next pointer
1023 CMP R2,#0 ;Is this the end?
1024 BNE %00app__find ;No -- continue round
1025
1026 ; --- Couldn't find the application ---
1027
1028 10app__find ADRL R0,msg_errUnknownApp ;Point to error message
1029 LDMFD R13!,{R1,R2,R14} ;Pull back registers
1030 ORRS PC,R14,#V_flag ;And return with an error
1031
1032 ; --- Found an application -- update the cache ---
1033
1034 01app__find STR R0,app__cacheHnd ;Store the new handle
1035 STR R2,app__cachePtr ;And the new pointer
1036 MOV R0,R2 ;Return the pointer to caller
1037 LDMFD R13!,{R1,R2,PC}^ ;And live happily ever after
1038
1039 LTORG
1040
1041 ; --- app__add ---
1042 ;
1043 ; On entry: --
1044 ; On exit: Application handle
1045
1046 app__add ROUT
1047
1048 STMFD R13!,{R1-R3,R14} ;Stack registers
1049
1050 ; --- Find out whether the app is registered yet ---
1051
1052 BL app_getHandle ;Find app's start time
1053 MOV R1,R0 ;Look after a copy
1054 BL app__find ;Call the find routine
1055 LDMVCFD R13!,{R1-R3,PC}^ ;If already there, return
1056
1057 ; --- Allocate a block from the RMA ---
1058
1059 MOV R0,#6 ;Code to allocate some store
1060 LDR R3,=app_strSize ;The size of an app block
1061 SWI XOS_Module ;Allocate the memory
1062 LDMVSFD R13!,{R1-R3,PC} ;If it failed, return error
1063
1064 ; --- Link the block into the list ---
1065
1066 LDR R0,app__list ;Find the list header
1067 STR R0,[R2,#app_next] ;Store in next pointer
1068 CMP R0,#0 ;Is there a next block?
1069 STRNE R2,[R0,#app_prev] ;Yes -- link in new block
1070 MOV R0,#0 ;Zero out the previous link
1071 STR R0,[R2,#app_prev] ;Store in previous entry
1072 STR R2,app__list ;Store this as new block
1073
1074 ; --- Set this block up in the cache ---
1075
1076 STR R1,app__cacheHnd ;Cache the app's start time
1077 STR R2,app__cachePtr ;Cache the app's pointer
1078
1079 ; --- Set up the block's data ---
1080
1081 MOV R0,#0 ;Zero some entries in block
1082 STR R0,[R2,#app_cachedll] ;No cached DLL yet
1083 STR R0,[R2,#app_cacheptr] ;No cached DLL yet
1084 STR R0,[R2,#app_dlls] ;No DLLs registered yet
1085 STR R0,[R2,#app_stackPtr] ;No entries on the stack
1086 STR R0,[R2,#app_btable] ;App has no entry table
1087 STR R1,[R2,#app_handle] ;Store the app's time info
1088 ADD R0,R2,#app_name ;Point to app's name field
1089 ADRL R1,msg_appName ;Point to default name
1090 BL misc_strcpy ;Copy the string across
1091
1092 ; --- Return the app's handle ---
1093
1094 MOV R0,R2 ;Return the app's pointer
1095 LDMFD R13!,{R1-R3,PC}^ ;Return to caller
1096
1097 LTORG
1098
1099 ; --- app__free ---
1100 ;
1101 ; On entry: R0 == pointer to app to free
1102 ; On exit: --
1103
1104 app__free ROUT
1105
1106 STMFD R13!,{R1,R2,R14} ;Keep registers safe
1107
1108 ; --- Remove the block from the list ---
1109
1110 LDR R1,[R0,#app_next] ;Get next block in the list
1111 LDR R2,[R0,#app_prev] ;Get previous block too
1112 CMP R1,#0 ;Is there a next block?
1113 STRNE R2,[R1,#app_prev] ;Yes -- fix up its prev
1114 CMP R2,#0 ;Is there a previous block?
1115 ADREQ R2,app__list ;No -- point to list head
1116 STR R1,[R2,#app_next] ;Fix up next pointer
1117
1118 ; --- Remove this app from the cache ---
1119
1120 LDR R2,app__cachePtr ;Find which app was cached
1121 CMP R2,R0 ;Is it this one?
1122 MOVEQ R2,#0 ;Yes -- overwrite handle
1123 STREQ R2,app__cacheHnd ;Won't match this app now
1124 STREQ R2,app__cachePtr
1125
1126 ; --- Free the block ---
1127
1128 MOV R2,R0 ;Point to the block to free
1129 MOV R0,#7 ;Magic reason code
1130 SWI XOS_Module ;Free the block
1131 LDMFD R13!,{R1,R2,PC} ;Return to caller if failed
1132
1133 LTORG
1134
1135 ; --- app__freeUnused ---
1136 ;
1137 ; On entry: R0 == pointer to application
1138 ; On exit: --
1139
1140 app__freeUnused ROUT
1141
1142 STMFD R13!,{R14} ;Keep link register
1143 LDR R14,[R0,#app_dlls] ;Find DLL link list
1144 CMP R14,#0 ;Are there any in the list?
1145 LDMFD R13!,{R14} ;Restore link register
1146 MOVNES PC,R14 ;Return is still attached
1147 B app__free ;Otherwise kill the app
1148
1149 LTORG
1150
1151 ; --- app__sFindDLL ---
1152 ;
1153 ; On entry: R0 == pointer to name of DLL to find
1154 ; R1 == version number to load
1155 ; On exit: R0 == DLL handle loaded
1156
1157 app__sFindDLL ROUT
1158
1159 STMFD R13!,{R1,R2,R9-R11,R14} ;Stack loads of registers
1160
1161 MOV R11,R0 ;Keep pointer safe
1162
1163 ; --- Ensure that the application structure is there ---
1164
1165 BL app__add ;Add the application if reqd.
1166 LDMVSFD R13!,{R1,R2,R9-R11,PC} ;If it failed, return now
1167 MOV R10,R0 ;Keep pointer to app block
1168
1169 ; --- Find out if there's anything to do ---
1170
1171 MOV R2,R1 ;Put version number nicely
1172 MOV R1,R11 ;Point to required name
1173 BL app__findNamedLink ;Is there anything to do?
1174 LDMVCFD R13!,{R1,R2,R9-R11,PC}^ ;If found, return to caller
1175 MOV R1,R2 ;Put version number back
1176
1177 ; --- Load the DLL if necessary ---
1178
1179 MOV R0,R11 ;Move DLL pointer back
1180 BL dll_ensure ;Load the DLL into memory
1181 MOVVS R9,R0 ;If it failed, keep the error
1182 BVS %50app__sFindDLL ;And tidy up properly
1183 MOV R11,R0 ;Keep pointer to DLL
1184 BL dll_tentative ;Mark the DLL as tentative
1185
1186 ; --- Add the link between the two ---
1187
1188 MOV R0,R10 ;Point to application
1189 MOV R1,R11 ;Point to DLL block
1190 BL app__addLink ;Link them together
1191 MOVVS R9,R0 ;Keep error if any
1192 BVS %51app__sFindDLL ;And tidy things up
1193
1194 ; --- Now we're done ---
1195
1196 MOV R0,R11 ;Point to DLL structure
1197 LDMFD R13!,{R1,R2,R9-R11,PC}^ ;Restore registers
1198
1199 ; --- Tidy up if link allocation failed ---
1200
1201 51app__sFindDLL
1202 50app__sFindDLL MOV R0,R10 ;Point to application block
1203 BL app__freeUnused ;If not being used, kill it
1204
1205 ; --- Return the error to the caller ---
1206
1207 MOV R0,R9 ;Point to the error message
1208 LDMFD R13!,{R1,R2,R9-R11,R14} ;Restore registers
1209 ORRS PC,R14,#V_flag ;Return to caller
1210
1211 LTORG
1212
1213 ; --- app__ok ---
1214 ;
1215 ; On entry: --
1216 ; On exit: All registers preserved
1217 ;
1218 ; Expects a stacked R11 and R14
1219
1220 app__ok ROUT
1221
1222 MOV R11,R0 ;Look after error pointer
1223 BL dll_confirm ;Cancel tentative DLL blocks
1224 BL app_getHandle ;Find app time info
1225 BLVC app__find ;Find the application block
1226 BLVC app__confLink ;Cancel tentative links
1227
1228 ; --- Resync code areas ---
1229 ;
1230 ; This seems as good a place as any to do this. I'm going
1231 ; to do a global resync, because I suspect that lots of
1232 ; local ones are going to be rather slower, actually.
1233 ; Besides, loading libraries isn't something which gets done
1234 ; /that/ often.
1235
1236 MOV R0,#0 ;Resync everything
1237 SWI XOS_SynchroniseCodeAreas ;Do that then, please
1238
1239 MOV R0,R11 ;Point to error again
1240 LDMFD R13!,{R11,R14} ;Restore registers
1241 BICS PC,R14,#V_flag ;Return to caller with V clr
1242
1243 LTORG
1244
1245 ; --- app__dead ---
1246 ;
1247 ; On entry: --
1248 ; On exit: All registers preserved
1249 ;
1250 ; Expects a stacked R11 and R14
1251
1252 app__dead ROUT
1253
1254 MOV R11,R0 ;Look after error pointer
1255 CMP R0,R0 ;Clear the V flag
1256 BL dll_retrace ;Destroy tentative DLL blocks
1257 BL app_getHandle ;Find app time info
1258 BLVC app__find ;Find the application block
1259 BLVC app__cancel ;Destroy tentative links
1260 MOV R0,R11 ;Point to error again
1261 LDMFD R13!,{R11,R14} ;Restore registers
1262 ORRS PC,R14,#V_flag ;Return to caller with V set
1263
1264 LTORG
1265
1266 ; --- app__findNamedLk ---
1267 ;
1268 ; On entry: R0 == pointer to application
1269 ; R1 == pointer to DLL's name
1270 ; R2 == DLL's version number
1271 ; On exit: R0 == V set if couldn't be found, clear otherwise
1272
1273 app__findNamedLink ROUT
1274
1275 STMFD R13!,{R3,R4,R14} ;Stack registers safely
1276 LDR R3,[R0,#app_dlls] ;Point to first DLL block
1277 CMP R3,#0 ;Is there anything to do?
1278 BEQ %20app__findNamedLink ;No -- that's an error
1279
1280 ; --- Now construct the proper DLL name ---
1281
1282 MOV R0,R1 ;Point to the DLL name
1283 00 LDRB R14,[R0],#1 ;Load the next byte
1284 CMP R14,#'[' ;Is this a new-style DAN?
1285 BEQ %f05 ;Yes -- sort this out then
1286 CMP R14,#'.' ;Or is it a dot?
1287 MOVEQ R1,R0 ;Yes -- remember this place
1288 CMP R14,#&20 ;End of the string yet?
1289 BCS %b00 ;No -- keep going
1290
1291 ADR R0,misc__sharedBuf ;Find the shared buffer
1292 00 LDRB R14,[R1],#1 ;Load a byte from the name
1293 CMP R14,#&20 ;Finished yet?
1294 MOVCC R14,#0 ;Yes -- zero-terminate
1295 STRB R14,[R0],#1 ;And store it out
1296 BCS %b00 ;No -- keep going
1297 B %10app__findNamedLink ;And skip to main matcher
1298
1299 ; --- Handle a new-style DAN ---
1300
1301 05 ADR R1,misc__sharedBuf ;Find the shared buffer
1302 00 LDRB R14,[R0],#1 ;Load a byte from the name
1303 CMP R14,#']' ;End of the name yet?
1304 MOVEQ R14,#0 ;Yes -- terminate here then
1305 CMP R14,#&20 ;Finished yet?
1306 MOVCC R14,#0 ;Yes -- zero-terminate
1307 STRB R14,[R1],#1 ;And store it out
1308 BCS %b00 ;No -- keep going
1309
1310 10app__findNamedLink
1311 ADR R1,misc__sharedBuf ;Point to the DLL name
1312
1313 00 LDR R0,[R3,#lk_dll] ;Find DLL pointer for block
1314 BL dll_compare ;Compare with passed values
1315 CMP R0,#1 ;Did it return TRUE?
1316 BEQ %30app__findNamedLink ;Yes -- be happy
1317 LDR R3,[R3,#lk_next] ;Find next pointer
1318 CMP R3,#0 ;Is there any more to do?
1319 BNE %b00 ;Yes -- loop round and do it
1320
1321 20app__findNamedLink
1322 LDMFD R13!,{R3,R4,R14} ;Restore registers
1323 ORRS PC,R14,#V_flag ;Return with V set
1324
1325 30app__findNamedLink
1326 LDR R0,[R3,#lk_dll] ;Load DLL pointer again
1327 LDMFD R13!,{R3,R4,R14} ;Restore registers
1328 BICS PC,R14,#V_flag ;Return with V clear
1329
1330 LTORG
1331
1332 ; --- app__findLink ---
1333 ;
1334 ; On entry: R0 == pointer to application
1335 ; R1 == pointer to DLL
1336 ; On exit: R0 == pointer to link structure
1337
1338 app__findLink ROUT
1339
1340 STMFD R13!,{R1,R2,R14} ;Preserve nice registers
1341
1342 ; --- Try looking at the cached value ---
1343
1344 LDR R2,[R0,#app_cachedll] ;Load the cached handle
1345 CMP R2,R1 ;Is it a match?
1346 LDREQ R0,[R0,#app_cacheptr] ;Yes -- load the pointer
1347 LDMEQFD R13!,{R1,R2,PC}^ ;And return!
1348
1349 ; --- Otherwise, scan the list ---
1350
1351 LDR R2,[R0,#app_dlls] ;Get list head pointer
1352 CMP R2,#0 ;Is there an entry here?
1353 BEQ %10app__findLink ;No -- return an error
1354 00app__findLink LDR R14,[R2,#lk_dll] ;Get the DLL's pointer
1355 CMP R1,R14 ;Is it a match?
1356 BEQ %01app__findLink ;Yes -- deal with it
1357 LDR R2,[R2,#lk_next] ;No -- get the next pointer
1358 CMP R2,#0 ;Is this the end?
1359 BNE %00app__findLink ;No -- continue round
1360
1361 ; --- Couldn't find the application ---
1362
1363 10app__findLink ADRL R0,msg_errLinkNotFound ;Point to error message
1364 LDMFD R13!,{R1,R2,R14} ;Pull back registers
1365 ORRS PC,R14,#V_flag ;And return with an error
1366
1367 ; --- Found an application -- update the cache ---
1368
1369 01app__findLink STR R1,[R0,#app_cachedll] ;Store the new handle
1370 STR R2,[R0,#app_cacheptr] ;And the new pointer
1371 MOV R0,R2 ;Return the pointer to caller
1372 LDMFD R13!,{R1,R2,PC}^ ;And live happily ever after
1373
1374 LTORG
1375
1376 ; --- app__addLink ---
1377 ;
1378 ; On entry: R0 == pointer to application
1379 ; R1 == pointer to DLL
1380 ; On exit: --
1381
1382 app__addLink ROUT
1383
1384 STMFD R13!,{R1,R11,R14} ;Stack registers
1385 MOV R11,R0 ;Keep pointer to application
1386
1387 ; --- Find out whether the link is registered yet ---
1388
1389 BL app__findLink ;Call the find routine
1390 LDMVCFD R13!,{R1,R11,PC}^ ;If already there, return
1391
1392 ; --- Allocate a block from the RMA ---
1393
1394 CMP R0,R0 ;Clear V flag
1395 BL sub_alloc ;Allocate a link block
1396 LDMVSFD R13!,{R1,R11,PC} ;If it failed, return error
1397
1398 ; --- Link the block into the list ---
1399
1400 LDR R14,[R11,#app_dlls] ;Find the list header
1401 STR R14,[R0,#lk_next] ;Store in next pointer
1402 CMP R14,#0 ;Is there a next block?
1403 STRNE R0,[R14,#lk_prev] ;Yes -- link in new block
1404 MOV R14,#0 ;Zero out the previous link
1405 STR R14,[R0,#lk_prev] ;Store in previous entry
1406 STR R0,[R11,#app_dlls] ;Store this as new block
1407
1408 ; --- Set this block up in the cache ---
1409
1410 STR R1,[R11,#app_cachedll] ;Cache the DLL's pointer
1411 STR R0,[R11,#app_cacheptr] ;Cache the app's pointer
1412
1413 ; --- Set up the block's data ---
1414
1415 STR R1,[R0,#lk_dll] ;Store pointer to DLL
1416 MOV R1,#0 ;No workspace yet
1417 STR R1,[R0,#lk_work] ;So store in the block
1418
1419 ; --- Mark as currently tentative ---
1420
1421 MOV R1,#lk_tentative ;Tentative flag
1422 STR R1,[R0,#lk_flags] ;Store in block's flags area
1423
1424 ; --- Return the app's handle ---
1425
1426 LDMFD R13!,{R1,R11,PC}^ ;Return to caller
1427
1428 LTORG
1429
1430 ; --- app__freeLink ---
1431 ;
1432 ; On entry: R0 == pointer to application
1433 ; R1 == pointer to link structure
1434 ; On exit: --
1435
1436 app__freeLink ROUT
1437
1438 STMFD R13!,{R1,R2,R14} ;Stack registers
1439
1440 ; --- Fix up list ---
1441
1442 LDR R2,[R1,#lk_next] ;Get next pointer
1443 LDR R14,[R1,#lk_prev] ;Get previous pointer
1444 CMP R2,#0 ;Is there a real next block?
1445 STRNE R14,[R2,#lk_prev] ;Yes -- fix backwards link
1446 CMP R14,#0 ;Is there a real prev block?
1447 ADDEQ R14,R0,#app_dlls ;No -- point to list head
1448 STR R2,[R14,#lk_next] ;Fix forwards link
1449
1450 ; --- Free the link ---
1451
1452 MOV R0,R1 ;Point to the link
1453 LDMFD R13!,{R1,R2,R14} ;Retreive registers
1454 B sub_free ;Free the link block
1455
1456 LTORG
1457
1458 ; --- app__confLk ---
1459 ;
1460 ; On entry: R0 == application to confirm
1461 ; On exit: --
1462
1463 app__confLink ROUT
1464
1465 STMFD R13!,{R1,R14} ;Stack registers
1466 LDR R0,[R0,#app_dlls] ;Find head of the link list
1467 CMP R0,#0 ;Is it empty?
1468 LDMEQFD R13!,{R1,PC}^ ;Yes -- return to caller
1469 00app__confLink LDR R1,[R0,#lk_next] ;Find the next entry
1470 LDR R14,[R0,#lk_flags] ;Load flags word
1471 BIC R14,R14,#lk_tentative ;Clear the magic flag
1472 STR R14,[R0,#lk_flags] ;Store the flags word back
1473 MOVS R0,R1 ;Move to next entry
1474 BNE %00app__confLink ;If more to do, do next one
1475 LDMFD R13!,{R1,PC}^ ;Return to caller, confirmed
1476
1477 LTORG
1478
1479 ; --- app__cancel ---
1480 ;
1481 ; On entry: R0 == app to cancel
1482 ; On exit: --
1483
1484 app__cancel ROUT
1485
1486 STMFD R13!,{R1,R2,R14} ;Stack registers
1487 MOV R2,R0 ;Keep pointer to app block
1488 LDR R0,[R0,#app_dlls] ;Find head of the link list
1489 CMP R0,#0 ;Is it empty?
1490 LDMEQFD R13!,{R1,R2,PC}^ ;Yes -- return to caller
1491 00app__cancel LDR R1,[R0,#lk_next] ;Find the next entry
1492 LDR R14,[R0,#lk_flags] ;Load flags word
1493 TST R14,#lk_tentative ;Is the flag set?
1494 BEQ %01app__cancel ;No -- move on to next one
1495
1496 LDR R14,[R0,#lk_prev] ;Find pointer to previous
1497 CMP R1,#0 ;Is there a next block?
1498 STRNE R14,[R1,#lk_prev] ;Fix up previous pointer
1499 CMP R14,#0 ;Is there a previous block?
1500 ADDEQ R14,R2,#app_dlls ;No -- point to list base
1501 STR R1,[R14,#lk_next] ;Fix up next pointer
1502 BL sub_free ;Free the block
1503
1504 01app__cancel MOVS R0,R1 ;Move to next entry
1505 BNE %00app__cancel ;If more to do, do next one
1506
1507 MOV R0,R2 ;Point to application block
1508 BL app__freeUnused ;If nothing left, kill app
1509 LDMFD R13!,{R1,R2,PC}^ ;Return to caller, cancelled
1510
1511 LTORG
1512
1513 ;----- That's all folks -----------------------------------------------------
1514
1515 END
The Straylight Source Distribution (obsolete software for RISC OS)