~mdw / ssr / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Initial revision
[ssr] / StraySrc / Libraries / Sapphire / s / coRoutine
1 ;
2 ; coRoutine.s
3 ;
4 ; Basic coroutine handling (MDW)
5 ;
6 ; © 1994-1998 Straylight
7 ;
8
9 ;----- Licensing note -------------------------------------------------------
10 ;
11 ; This file is part of Straylight's Sapphire library.
12 ;
13 ; Sapphire is free software; you can redistribute it and/or modify
14 ; it under the terms of the GNU General Public License as published by
15 ; the Free Software Foundation; either version 2, or (at your option)
16 ; any later version.
17 ;
18 ; Sapphire is distributed in the hope that it will be useful,
19 ; but WITHOUT ANY WARRANTY; without even the implied warranty of
20 ; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 ; GNU General Public License for more details.
22 ;
23 ; You should have received a copy of the GNU General Public License
24 ; along with Sapphire. If not, write to the Free Software Foundation,
25 ; 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
26
27 ;----- Standard header ------------------------------------------------------
28
29 GET libs:header
30 GET libs:swis
31
32 ;----- External dependencies ------------------------------------------------
33
34 GET sapphire:alloc
35 GET sapphire:sapphire
36 GET sapphire:seh
37 GET sapphire:suballoc
38
39 ;----- Main code ------------------------------------------------------------
40
41 AREA |Sapphire$$Code|,CODE,READONLY
42
43 coRout__stkSize EQU 1024
44
45 ; --- coRout_create ---
46 ;
47 ; On entry: R0 == pointer to coroutine
48 ; R1 == R10 value to pass to coroutine
49 ; R2 == R12 value to pass to coroutine
50 ; R3 == size of stack to pass (0 for default)
51 ;
52 ; On exit: R0 == coroutine handle
53 ; May return an error
54 ;
55 ; Use: Creates a new coroutine. It may be given control using
56 ; coRout_switch. Its registers are on entry:
57 ;
58 ; R0 == its coroutine handle
59 ; R10 == value passed to coRout_create in R1
60 ; R12 == value passed to coRout_create in R2
61 ; R13 == pointer to the stack created for it
62
63 EXPORT coRout_create
64 coRout_create ROUT
65
66 STMFD R13!,{R0-R4,R14} ;Save some registers away
67
68 ; --- Allocate a coroutine block ---
69
70 MOV R0,#coRout__blkSize ;Get the block size ready
71 BL sub_alloc ;Allocate the block
72 BVS %99coRout_create ;Quit if it failed
73 MOV R4,R0 ;Keep the block pointer
74
75 ; --- Allocate a stack ---
76
77 CMP R3,#0 ;Does he want default stack?
78 MOVEQ R3,#coRout__stkSize ;Yes -- give it to him
79 MOV R0,R3 ;Get the size in R0
80 BL alloc ;Try to allocate the stack
81 BLCS alloc_error ;If it failed, get an error
82 BCS %98coRout_create ;And quit if it didn't work
83 STR R0,[R4,#coRout__stack] ;Save the stack pointer away
84
85 ; --- Set up the try list ---
86
87 MOV R14,#0 ;Must clear the list head
88 STR R14,[R4,#coRout__tryList] ;Save that away for later
89
90 ; --- Fix everything up right ---
91
92 ADD R0,R0,R3 ;Point to the stack top
93 ADR R3,coRout__start ;Point to the start routine
94 MOV R14,PC ;Get the processor flags
95 AND R14,R14,#&FC000003 ;Leave only the flags
96 ORR R14,R3,R14 ;And add them on to it
97 MOV R3,R2 ;Get coroutine's R12 in R3
98 MOV R2,R11 ;Point to scratchpad in R2
99 STMFD R0!,{R1-R3,R14} ;And save all that lot away
100 SUB R0,R0,#32 ;Don't care about other regs
101 LDR R14,[R13,#0] ;Load the coroutine address
102 STMFD R0!,{R4,R14} ;Save them in R0 and R1
103 STR R0,[R4,#coRout__sp] ;And save its stack pointer
104
105 ; --- Return to caller ---
106
107 MOV R0,R4 ;Point to the coroutine block
108 ADD R13,R13,#4 ;Don't restore caller's R0
109 LDMFD R13!,{R1-R4,R14} ;And return to caller
110 BICS PC,R14,#V_flag
111
112 ; --- Handle errors ---
113
114 98coRout_create MOV R3,R0 ;Save the error pointer
115 MOV R0,R4 ;Point to the coroutine block
116 MOV R1,#coRout__blkSize ;Get the block's size
117 BL sub_free ;Free the block nicely
118 MOV R0,R3 ;Restore the error pointer
119
120 99coRout_create ADD R13,R13,#4 ;Don't restore caller's R0
121 LDMFD R13!,{R1-R4,R14} ;And return to caller
122 ORRS PC,R14,#V_flag
123
124 LTORG
125
126 ; --- coRout_switch ---
127 ;
128 ; On entry: R0 == coroutine to switch to, or 0 for main
129 ;
130 ; On exit: --
131 ;
132 ; Use: Switches context to another coroutine.
133
134 EXPORT coRout_switch
135 coRout_switch ROUT
136
137 STMFD R13!,{R12,R14} ;Save some registers
138 WSPACE coRout__wSpace ;Find my workspace address
139 LDR R14,coRout__current ;Get the current coroutine
140 CMP R14,R0 ;Switch to current one?
141 LDMEQFD R13!,{R12,PC}^ ;Silly sausage!
142
143 ; --- Perform a context switch ---
144
145 STMFD R13!,{R0-R11} ;Save all the other registers
146 MOV R1,R14 ;Move this to another reg
147 STR R0,coRout__current ;Save the new coroutine
148 BL seh_setListBase ;Use this try list now
149 CMP R1,#0 ;Are we running main routine?
150 ADREQ R1,coRout__main ;Yes -- point to dummy block
151 CMP R0,#0 ;Do we switch to main routine
152 ADREQ R0,coRout__main ;Yes -- point to dummy block
153 STR R13,[R1,#coRout__sp] ;Save the new stack pointer
154 LDR R13,[R0,#coRout__sp] ;Get a new stack pointer
155 LDMFD R13!,{R0-R12,PC}^ ;And switch context to it
156
157 LTORG
158
159 ; --- coRout_destroy ---
160 ;
161 ; On entry: R0 == coroutine handle to destroy
162 ;
163 ; On exit: --
164 ;
165 ; Use: Destroys a coroutine.
166
167 EXPORT coRout_destroy
168 coRout_destroy ROUT
169
170 STMFD R13!,{R12,R14} ;Save some registers away
171 WSPACE coRout__wSpace ;Find my workspace address
172 LDR R14,coRout__current ;Get the current coroutine
173 CMP R14,R0 ;Terminate the current one?
174 LDMEQFD R13!,{R12,R14} ;Yes -- unstack registers
175 BEQ coRout_end ;And end it normally
176
177 ; --- Now just destroy a coroutine ---
178
179 STMFD R13!,{R0,R1} ;Save some registers
180 MOV R1,R0 ;Keep the coroutine handle
181 LDR R0,[R1,#coRout__stack] ;Find the stack's address
182 BL free ;Free up the space it took
183 MOV R0,R1 ;Point at the coroutine blk
184 MOV R1,#coRout__blkSize ;Get the coroutine block size
185 BL sub_free ;And dispose of that too
186 LDMFD R13!,{R0,R1,R12,PC}^ ;And return to caller
187
188 LTORG
189
190 ; --- coRout__start ---
191 ;
192 ; On entry: R0 == coroutine handle
193 ; R1 == pointer to coroutine code
194 ;
195 ; On exit: R14 == pointer to coRout_end
196 ;
197 ; Use: Sets up a coroutine so that when it returns, it calls
198 ; coRout_end and dies properly.
199
200 coRout__start ROUT
201
202 ; --- Set up a handler to kill the coroutine ---
203
204 ADR R0,coRout__catch ;Point to our catch handler
205 BL seh_try ;Register that nicely
206
207 ; --- Now start up the coroutine proper ---
208
209 MOV R14,PC ;Set up the return address
210 MOV PC,R1 ;And call the main code
211
212 ; --- Fall through into coRout_end when done ---
213
214 ; --- coRout_end ---
215 ;
216 ; On entry: --
217 ;
218 ; On exit: Doesn't.
219 ;
220 ; Use: Terminates the current coroutine.
221
222 EXPORT coRout_end
223 coRout_end ROUT
224
225 ; --- Destroy the current coroutine ---
226
227 WSPACE coRout__wSpace ;Find my workspace
228 LDR R13,coRout__main+coRout__sp ;Return to main stack
229 LDR R1,coRout__current ;Get the current coroutine
230 LDR R0,[R1,#coRout__stack] ;Find the stack's address
231 BL free ;Free up the space it took
232 MOV R0,R1 ;Point at the coroutine blk
233 MOV R1,#coRout__blkSize ;Get the coroutine block size
234 BL sub_free ;And dispose of that too
235
236 ; --- Now rejoin the main routine ---
237
238 MOV R0,#0 ;Going back to main routine
239 STR R0,coRout__current ;So remember that
240 BL seh_setListBase ;Use main exception list
241 LDMFD R13!,{R0-R12,PC}^ ;And rejoin everything nicely
242
243 LTORG
244
245 ; --- Exception handling ---
246
247 coRout__catch MOVS PC,R14 ;No need for tidy-up
248 DCD -1 ;Catch all exceptions
249 B coRout__throw ;And throw them on again
250 DCD 0
251
252 coRout__throw WSPACE coRout__wSpace ;Find my workspace
253 LDR R13,coRout__main+coRout__sp ;Return to main stack
254 STMFD R13!,{R0-R3} ;Remember the exception
255 LDR R1,coRout__current ;Load the old coroutine hnd
256 LDR R0,[R1,#coRout__stack] ;Find the stack's address
257 BL free ;Free up the space it took
258 MOV R0,R1 ;Point at the coroutine blk
259 MOV R1,#coRout__blkSize ;Get the coroutine block size
260 BL sub_free ;And dispose of that too
261
262 MOV R0,#0 ;Going back to main routine
263 STR R0,coRout__current ;So remember that
264 BL seh_setListBase ;Use main exception list
265 LDMFD R13!,{R0-R3} ;Restore exception
266 B seh_throw ;And raise it again
267
268 coRout__wSpace DCD 0
269
270 ;----- Coroutine blocks -----------------------------------------------------
271
272 ^ 0
273 coRout__tryList # 4 ;SEH try list head for stack
274 coRout__stack # 4 ;Pointer to the stack
275 coRout__sp # 4 ;Coroutine's current R13
276 coRout__blkSize # 0 ;Size of a coroutine block
277
278 ;----- Workspace ------------------------------------------------------------
279
280 ^ 0,R12
281 coRout__wStart # 0
282
283 coRout__current # 4 ;The current coroutine or 0
284 coRout__main # coRout__blkSize ;Dummy coroutine block
285
286 coRout__wSize EQU {VAR}-coRout__wStart
287
288 AREA |Sapphire$$LibData|,CODE,READONLY
289
290 DCD coRout__wSize
291 DCD coRout__wSpace
292 DCD 0
293 DCD 0
294
295 ;----- That's all, folks ----------------------------------------------------
296
297 END
The Straylight Source Distribution (obsolete software for RISC OS)