0 branches 0 tags
65
Allow Coroutine_Delete(NULL)
jonroach 8 Dec 2025 11:44
1 contributor
784 lines20.8 KB
Text Raw Blame
  • Delete
1#include "coroutine.h"
2#include <assert.h>
3#include <setjmp.h>
4#include <stdbool.h>
5#include <stddef.h>
6#include "cor_platform.h"
7
8// see CPython again, this time from ctypes.h
9#if (defined (__SVR4) && defined (__sun)) || defined(COROUTINE_HAVE_ALLOCA_H)
10# include <alloca.h>
11#elif defined(MS_WIN32)
12# include <malloc.h>
13#endif
14
15/* If the system does not define alloca(), we have to hope for a compiler builtin. */
16#ifndef alloca
17# if defined __GNUC__ || (__clang_major__ >= 4)
18# define alloca __builtin_alloca
19# else
20# error "Could not define alloca() on your platform."
21# endif
22#endif
23
24static void Coroutine_RunNext(void);
25static void _Coroutine_Continue(Coroutine *cor, void *value, bool early);
26static unsigned char *StackTopNow(void);
27
28///////////////////////////////////////////////////////////////////////////////
29// 2-way linked lists...
30//
31// Brought inline here to avoid namespace polution
32///////////////////////////////////////////////////////////////////////////////
33
34typedef struct List_Link List_Link;
35struct List_Link {
36 List_Link *next;
37 List_Link *prev;
38};
39
40typedef struct List_Head List_Head;
41struct List_Head {
42 union {
43 struct {
44 List_Link link;
45 List_Link *filler;
46 } fwd;
47 struct {
48 List_Link *filler;
49 List_Link link;
50 } back;
51 };
52};
53
54
55static inline bool List_IsEmpty(
56 const List_Head *list
57){
58 return list->fwd.link.next == &list->back.link;
59}
60
61
62static inline List_Link *List_GetHead(
63 const List_Head *list
64){
65 return List_IsEmpty(list) ? NULL : list->fwd.link.next;
66}
67
68
69// static inline List_Link *List_GetTail(
70// const List_Head *list
71// ){
72// return List_IsEmpty(list) ? NULL : list->back.link.prev;
73// }
74
75
76#define OFFSETOF(Container, Field) ((char *)&((Container *)4)->Field - (char *)(Container *)4)
77#define List_Link_Container(Container, Link, link) ((Container *)((char *)(link) - OFFSETOF(Container, Link)))
78
79
80static inline void List_Init(
81 List_Head *list
82){
83 list->fwd.link.next = &list->back.link;
84 list->fwd.link.prev = NULL;
85 list->back.link.prev = &list->fwd.link;
86}
87
88
89static inline void List_AddHead(
90 List_Head *list,
91 List_Link *link
92){
93 List_Link *first = list->fwd.link.next;
94 link->next = first;
95 link->prev = &list->fwd.link;
96 first->prev = link;
97 list->fwd.link.next = link;
98}
99
100
101static inline void List_AddTail(
102 List_Head *list,
103 List_Link *link
104){
105 List_Link *last = list->back.link.prev;
106 link->prev = last;
107 link->next = &list->back.link;
108 last->next = link;
109 list->back.link.prev = link;
110}
111
112
113static inline void List_Remove(
114 List_Link *link
115){
116 link->prev->next = link->next;
117 link->next->prev = link->prev;
118}
119
120///////////////////////////////////////////////////////////////////////////////
121// ...2-way linked lists
122///////////////////////////////////////////////////////////////////////////////
123
124typedef struct Coroutines Coroutines;
125
126enum {
127 Coroutines_Idle,
128 Coroutines_Starting,
129 Coroutines_Started,
130 Coroutines_Active,
131 Coroutines_Stopping
132};
133
134enum {
135 Chunk_Initial,
136 Chunk_Create,
137 Chunk_Enter
138};
139
140typedef enum Coroutine_State {
141 Coroutine_Free,
142 Coroutine_Idle,
143 Coroutine_Running,
144 Coroutine_Waiting,
145 Coroutine_Complete
146} Coroutine_State;
147
148enum {
149 Coroutines_Init,
150 Coroutines_AllocatedChunk,
151 Coroutines_CoroutineComplete,
152};
153
154struct Coroutine {
155 Coroutines *coroutines; // so can work with it off-thread
156 List_Link link; // for whichever list it's on
157 jmp_buf buf; // how to get back to it
158 unsigned char *guard; // where the stack overrun guard is
159 Coroutine_Start start; // entry point
160 void *entry_param; // to pass to start
161 void *value; // yielded/returned
162 unsigned char *stack_top; // recorded at yield
163 Coroutine_State state;
164};
165
166struct Coroutines {
167 _Cor_Mutex mutex;
168 jmp_buf controller; // to return from Coroutine_Run
169 jmp_buf chunk_allocated;// for chunk allocation
170 unsigned char *guard; // the stack guard for the startup sequence
171
172 // singletons
173 Coroutine *tip; // top of stack chunk
174 Coroutine *active; // currently running coroutine
175 Coroutine *primary; // Coroutine_Run coroutine
176 unsigned char *stack_limit; // when not NULL, where the stack finishes
177
178 // lists
179 List_Head free;
180 List_Head inactive; // idle or complete
181 List_Head runable; // running or waiting to run
182 List_Head waiting; // yielded / waiting to run
183 _Cor_Mutex waiting_mutex;
184
185 // Summary of the system
186 Coroutine_Report report;
187
188 // state
189 char state;
190};
191
192_Cor_thread_local Coroutines g_c;
193
194static void stack_chunk_chunk(Coroutine *parent, size_t chunk_size);
195static void stack_chunk_base(void);
196
197
198#define GUARD_PATTERN_SIZE (4)
199// Check whether the guard is intact
200static inline bool Check_Guard(
201 unsigned char *guard
202){
203 return !guard ||
204 (guard[0] == 0xde &&
205 guard[1] == 0xad &&
206 guard[2] == 0xbe &&
207 guard[3] == 0xef);
208}
209
210
211static inline void Apply_Guard(unsigned char *guard){
212 guard[0] = 0xde;
213 guard[1] = 0xad;
214 guard[2] = 0xbe;
215 guard[3] = 0xef;
216}
217
218
219static bool Coroutine_StackHasNotOverrun(void){
220 unsigned char *stack_top = StackTopNow();
221 unsigned char *stack_limit = g_c.stack_limit;
222 if (stack_limit && stack_top < stack_limit){
223 // current stack top is beyond limit - we are overrunning NOW
224 return false;
225 }
226 Coroutine *me = g_c.active;
227 if (!me){
228 return true;
229 }
230 if (me->guard){
231 return Check_Guard(me->guard);
232 }
233 unsigned char *coroutine_limit;
234 if (!stack_limit || stack_limit <= (unsigned char *)me - 2*COROUTINE_STACK_SIZE){
235 // no stack limit, or can start a coroutine, so limit ourselves to one unit of coroutine stack
236 coroutine_limit = (unsigned char *)me - 1*COROUTINE_STACK_SIZE + GUARD_PATTERN_SIZE;
237 } else {
238 // can't start coroutine, and have a stack limit - use that
239 coroutine_limit = stack_limit;
240 }
241 return stack_top >= coroutine_limit;
242}
243
244
245static void Coroutine_PrimeStackChunks(void)
246{
247 unsigned char chunk_of_stack[COROUTINE_STARTUP_STACK_SIZE + GUARD_PATTERN_SIZE];
248 Apply_Guard(chunk_of_stack);
249 assert(Check_Guard(chunk_of_stack));
250
251 // Stacks grow down in memory (almost always), so if the caller of this function changes
252 // the guard before entering the coroutine system, it has overrun the startup stack
253 g_c.guard = chunk_of_stack;
254
255 stack_chunk_base();
256}
257
258
259static void stack_chunk_chunk(
260 Coroutine *parent,
261 size_t chunk_size
262){
263 unsigned char *chunk_of_stack = alloca(chunk_size);
264#if COROUTINE_RECORD_LOWEST_HEADROOM
265 for (size_t i = 0; i <= chunk_size-GUARD_PATTERN_SIZE; i += GUARD_PATTERN_SIZE){
266 Apply_Guard(&chunk_of_stack[i]);
267 }
268#else
269 Apply_Guard(chunk_of_stack);
270#endif
271 parent->guard = chunk_of_stack;
272 stack_chunk_base();
273}
274
275
276static void stack_chunk_base(
277 void
278){
279 Coroutine here;
280 here.state = Coroutine_Free;
281 here.guard = NULL;
282 here.coroutines = &g_c;
283 List_AddHead(&g_c.free, &here.link);
284 g_c.report.coroutines_pool_size += 1;
285 g_c.tip = &here;
286 for(;;){
287 switch (setjmp(here.buf)) {
288 case Chunk_Initial:
289 if (here.state == Coroutine_Free){
290 // return to the coroutine allocator
291 longjmp(g_c.chunk_allocated, 1);
292 } else {
293 assert(here.state == Coroutine_Complete);
294 // we finish here to ensure the setjmp is redone
295 if (g_c.primary == &here) {
296 // if primary coroutine - return to Coroutine_Run
297 longjmp(g_c.controller, Coroutines_CoroutineComplete);
298 }
299 _Cor_Mutex_Unlock(&g_c.mutex);
300 Coroutine_RunNext();
301 assert(false);
302 }
303 case Chunk_Create:
304 // Request to create a new chunk on the stack
305 // We're here if the coroutine is:
306 // Allocated, but not 'run' (Coroutine_Idle)
307 // Run, but not not entered yet (Coroutine_Running)
308 // Completed (Coroutine_Complete)
309 assert(here.state == Coroutine_Idle || here.state == Coroutine_Running || here.state == Coroutine_Complete);
310 unsigned char *ideal_limit = (unsigned char *)&here - COROUTINE_STACK_SIZE;
311 stack_chunk_chunk(&here, StackTopNow() - ideal_limit);
312 assert(false);
313 case Chunk_Enter:
314 // request to start a coroutine (ie use the chunk for a coroutine)
315 // arrive here with mutex locked
316 assert(here.state == Coroutine_Running);
317 g_c.active = &here;
318 _Cor_Mutex_Unlock(&g_c.mutex);
319 here.value = here.start(here.entry_param);
320
321 // check the guard
322 assert(Check_Guard(here.guard));
323
324 _Cor_Mutex_Lock(&g_c.mutex);
325 g_c.active = NULL;
326 assert(here.state == Coroutine_Running);
327 List_Remove(&here.link);
328 here.state = Coroutine_Complete;
329 List_AddTail(&g_c.inactive, &here.link);
330 // Coroutine has completed
331 // Loop round to redo the setjmp() - if this coroutine yielded, then the setjmp will
332 // need reseting
333 }
334 }
335}
336
337
338static void Coroutine_RunNext(void)
339{
340 // arrive here with mutex unlocked
341 _Cor_Mutex_Lock(&g_c.waiting_mutex);
342 _Cor_Mutex_Lock(&g_c.mutex);
343 Coroutine *next = List_Link_Container(Coroutine, link, List_GetHead(&g_c.runable));
344 assert(next->state == Coroutine_Running);
345 longjmp(next->buf, Chunk_Enter);
346 assert(false);
347}
348
349
350void Coroutine_StartSystem(void)
351{
352 assert(g_c.state == Coroutines_Idle);
353 g_c.state = Coroutines_Starting;
354
355 _Cor_Mutex_ctor(&g_c.mutex);
356
357 g_c.tip = NULL;
358 g_c.active = NULL;
359
360 List_Init(&g_c.free);
361 List_Init(&g_c.inactive);
362 List_Init(&g_c.runable);
363 List_Init(&g_c.waiting);
364 _Cor_Mutex_ctor(&g_c.waiting_mutex);
365 _Cor_Mutex_Lock(&g_c.waiting_mutex);
366
367 g_c.report.coroutines_created = 0;
368 g_c.report.coroutines_pool_size = 0;
369
370 // prime the chunk system
371 if (!setjmp(g_c.chunk_allocated)){
372 Coroutine_PrimeStackChunks();
373 assert(false);
374 }
375
376 assert(g_c.state == Coroutines_Starting);
377 g_c.state = Coroutines_Started;
378}
379
380
381void Coroutine_SetStackLimit(void *limit){
382 assert(!limit || !(g_c.state == Coroutines_Started || g_c.state == Coroutines_Active) || (unsigned char *)limit < (unsigned char *)g_c.tip);
383 g_c.stack_limit = limit;
384}
385
386
387Coroutine_Report Coroutine_StopSystem(void)
388{
389 _Cor_Mutex_Lock(&g_c.mutex);
390 assert(g_c.state == Coroutines_Started);
391 g_c.state = Coroutines_Stopping;
392
393 uintptr_t stackminheadroom;;
394#if COROUTINE_RECORD_LOWEST_HEADROOM
395 stackminheadroom = COROUTINE_STACK_SIZE;
396 for (List_Link *link = g_c.free.fwd.link.next; link->next; link = link->next){
397 Coroutine *cor = List_Link_Container(Coroutine, link, link);
398 if (cor->guard){
399 for (uintptr_t i = 4; i < COROUTINE_STACK_SIZE-3; i += 4){
400 if (!Check_Guard(&cor->guard[i])){
401 stackminheadroom = i < stackminheadroom ? i : stackminheadroom;
402 break;
403 }
404 }
405 }
406 }
407#else
408 stackminheadroom = 0;
409#endif
410 g_c.report.lowest_headroom = stackminheadroom;
411
412 assert(List_IsEmpty(&g_c.inactive));
413 _Cor_Mutex_Unlock(&g_c.waiting_mutex);
414 _Cor_Mutex_dtor(&g_c.waiting_mutex);
415
416 assert(g_c.state == Coroutines_Stopping);
417 g_c.state = Coroutines_Idle;
418 _Cor_Mutex_Unlock(&g_c.mutex);
419 _Cor_Mutex_dtor(&g_c.mutex);
420
421 return g_c.report;
422}
423
424
425void Coroutine_Run_Coroutine(
426 Coroutine *cor,
427 void *value
428){
429 Coroutines *cors = cor->coroutines;
430 assert(&g_c == cors);
431 _Cor_Mutex_Lock(&cors->mutex);
432 assert(cors->state == Coroutines_Started);
433 cors->state = Coroutines_Active;
434 cors->primary = cor;
435
436 _Coroutine_Continue(cor, value, true);
437
438 if (!setjmp(cors->controller)){
439 _Cor_Mutex_Unlock(&cors->mutex);
440
441 // check the guard
442 assert(Check_Guard(cors->guard));
443
444 // start the first coroutine
445 Coroutine_RunNext();
446 }
447 // arrive here with mutex locked
448 assert(List_IsEmpty(&cors->runable));
449 assert(List_IsEmpty(&cors->waiting));
450 assert(cors->state == Coroutines_Active);
451 cors->state = Coroutines_Started;
452 _Cor_Mutex_Unlock(&cors->mutex);
453}
454
455
456void *Coroutine_Run(
457 Coroutine_Start start,
458 void *value
459){
460 if (g_c.active){
461 return start(value);
462 }
463 assert(g_c.state == Coroutines_Idle || g_c.state == Coroutines_Started);
464 bool need_start = g_c.state == Coroutines_Idle;
465 if (need_start){
466 Coroutine_StartSystem();
467 }
468 Coroutine *cor = Coroutine_New(start);
469 assert(cor);
470 Coroutine_Run_Coroutine(cor, value);
471 void *res = Coroutine_GetValue(cor);
472 Coroutine_Delete(cor);
473 if (need_start){
474 Coroutine_StopSystem();
475 }
476 return res;
477}
478
479
480Coroutine *Coroutine_New(
481 Coroutine_Start start
482){
483 assert((g_c.state == Coroutines_Started && List_IsEmpty(&g_c.inactive)) || g_c.state == Coroutines_Active);
484 assert(Coroutine_StackHasNotOverrun());
485
486 // if none free - add one
487 if (List_IsEmpty(&g_c.free)){
488 // no free stack blocks
489 if (g_c.stack_limit && g_c.stack_limit > (unsigned char *)g_c.tip - 2*COROUTINE_STACK_SIZE){
490 // no space for a new stack block
491 return NULL;
492 }
493 Coroutine *tip = g_c.tip;
494 Coroutine *me = g_c.active;
495 if (tip == me) {
496 if (!setjmp(g_c.chunk_allocated)){
497 unsigned char *ideal_limit = (unsigned char *)me - COROUTINE_STACK_SIZE;
498 stack_chunk_chunk(me, StackTopNow() - ideal_limit);
499 }
500 } else {
501 if (!setjmp(g_c.chunk_allocated)){
502 longjmp(tip->buf, Chunk_Create);
503 }
504 }
505 }
506
507 Coroutine *cor = List_Link_Container(Coroutine, link, List_GetHead(&g_c.free));
508 assert(cor->state == Coroutine_Free);
509 cor->state = Coroutine_Idle;
510 cor->start = start;
511 cor->value = NULL;
512 List_Remove(&cor->link);
513 List_AddHead(&g_c.inactive, &cor->link);
514
515 g_c.report.coroutines_created += 1;
516
517 return cor;
518}
519
520
521void Coroutine_Delete(
522 Coroutine *cor
523){
524 assert(Coroutine_StackHasNotOverrun());
525 if (cor){
526 Coroutines *cors = cor->coroutines;
527 _Cor_Mutex_Lock(&cors->mutex);
528 assert(cor->state == Coroutine_Idle || cor->state == Coroutine_Complete);
529 cor->state = Coroutine_Free;
530 List_Remove(&cor->link);
531 List_AddTail(&cors->free, &cor->link);
532 _Cor_Mutex_Unlock(&cors->mutex);
533 }
534}
535
536
537// Coroutine_Continue, assuming the mutex is claimed
538static void _Coroutine_Continue(
539 Coroutine *cor,
540 void *value,
541 bool early
542){
543 Coroutines *cors = cor->coroutines;
544 assert(cor->state == Coroutine_Idle || cor->state == Coroutine_Waiting);
545 cor->entry_param = value;
546 cor->state = Coroutine_Running;
547 List_Remove(&cor->link);
548 if ( early ) {
549 List_AddHead(&cors->runable, &cor->link);
550 } else {
551 List_AddTail(&cors->runable, &cor->link);
552 }
553 _Cor_Mutex_Unlock(&cors->waiting_mutex);
554}
555
556
557void Coroutine_Continue(
558 Coroutine *cor,
559 void *value,
560 bool early
561){
562 assert(Coroutine_StackHasNotOverrun());
563 Coroutines *cors = cor->coroutines;
564 _Cor_Mutex_Lock(&cors->mutex);
565 _Coroutine_Continue(cor, value, early);
566 _Cor_Mutex_Unlock(&cors->mutex);
567}
568
569
570void *Coroutine_Yield(
571 void *value,
572 Coroutine_YieldCallback on_yield,
573 void *yield_me
574){
575 Coroutine *me = g_c.active;
576 assert(me);
577 assert(Coroutine_StackHasNotOverrun());
578
579 _Cor_Mutex_Lock(&g_c.mutex);
580 Coroutines *cors = me->coroutines;
581 assert(me && me->state == Coroutine_Running && cors == &g_c);
582 me->stack_top = StackTopNow();
583 me->value = value;
584 me->state = Coroutine_Waiting;
585
586 List_Remove(&me->link);
587 if (!List_IsEmpty(&cors->runable)){
588 _Cor_Mutex_Unlock(&cors->waiting_mutex);
589 }
590 List_AddTail(&cors->waiting, &me->link);
591
592 switch (setjmp(me->buf)){
593 case Chunk_Initial:
594 _Cor_Mutex_Unlock(&cors->mutex);
595 on_yield(yield_me);
596 Coroutine_RunNext();
597 assert(false);
598 case Chunk_Create:
599 assert(me == g_c.tip);
600 unsigned char *ideal_limit = (unsigned char *)me - COROUTINE_STACK_SIZE;
601 stack_chunk_chunk(me, me->stack_top - ideal_limit);
602 assert(false);
603 case Chunk_Enter:
604 // arrive here with mutex locked
605 cors->active = me;
606 assert(Coroutine_StackHasNotOverrun());
607 // when we return here - we are running again
608 assert(me->state == Coroutine_Running);
609 void *res = me->entry_param;
610 _Cor_Mutex_Unlock(&cors->mutex);
611 return res;
612 }
613 return NULL;
614}
615
616
617void *Coroutine_GetValue(
618 Coroutine *cor
619){
620 return cor->value;
621}
622
623
624Coroutine *Coroutine_GetActive(void)
625{
626 return g_c.active;
627}
628
629
630intptr_t Coroutine_GetStackHeadroom(void){
631 assert(Coroutine_StackHasNotOverrun());
632 Coroutine *me = g_c.active;
633 if (!me){
634 // no active coroutine
635 unsigned char *stack_limit = g_c.stack_limit;
636 if (stack_limit){
637 // no stack limit - assume we'll use COROUTINE_STACK_SIZE
638 return StackTopNow() - stack_limit;
639 } else {
640 // no information where the stack ends - return something
641 return COROUTINE_STACK_SIZE;
642 }
643 }
644 unsigned char *stack_top = StackTopNow();
645 if (me->guard){
646 // guard established - that's where we'll measure to
647 return stack_top - me->guard;
648 }
649 intptr_t used = (unsigned char *)me - stack_top;
650 unsigned char *stack_limit = g_c.stack_limit;
651 if (!stack_limit){
652 // no stack limit - assume we'll use COROUTINE_STACK_SIZE
653 return COROUTINE_STACK_SIZE - used;
654 }
655 intptr_t available = (unsigned char *)me - stack_limit;
656 if (available < (intptr_t)(2*COROUTINE_STACK_SIZE)){
657 // can't start another coroutine, so whatever's left in the C stack is what we've got
658 return available - used;
659 }
660 // can start another coroutine, so limit ourselves to a coroutine stack size's worth
661 return COROUTINE_STACK_SIZE - used;
662}
663
664
665// This is used to avoid compiler warnings about returning the address of a local
666static inline void *StopAddressWarnings(void *p)
667{
668 return p;
669}
670
671
672void *Coroutine_GetStackHWM(void){
673 assert(g_c.state == Coroutines_Active);
674 assert(Coroutine_StackHasNotOverrun());
675 // Find where the guards end
676 unsigned char *guard;
677 for (guard = g_c.active->guard; Check_Guard(guard); guard += 4){
678 // do nothing
679 }
680 return guard;
681}
682
683
684void Coroutine_ClearStackForHWM(void){
685 assert(g_c.state == Coroutines_Active);
686 assert(Coroutine_StackHasNotOverrun());
687 unsigned char *end = StackTopNow() - GUARD_PATTERN_SIZE;
688 for (unsigned char *guard = g_c.active->guard+GUARD_PATTERN_SIZE; guard <= end; guard += GUARD_PATTERN_SIZE){
689 Apply_Guard(guard);
690 }
691}
692
693
694bool Coroutine_CanStartCoroutine(void){
695 assert(g_c.state == Coroutines_Started || g_c.state == Coroutines_Active);
696 assert(Coroutine_StackHasNotOverrun());
697 if (!List_IsEmpty(&g_c.free)){
698 return true;
699 }
700
701 return !g_c.stack_limit || g_c.stack_limit <= (unsigned char *)g_c.tip - 2*COROUTINE_STACK_SIZE;
702}
703
704
705void *Coroutine_GetCStackTop(void){
706 assert(Coroutine_StackHasNotOverrun());
707 if ((g_c.state == Coroutines_Started || g_c.state == Coroutines_Active) && g_c.tip != g_c.active) {
708 return g_c.tip->stack_top;
709 } else {
710 return StackTopNow();
711 }
712}
713
714
715static unsigned char *StackTopNow(void){
716 unsigned char here[4];
717 return StopAddressWarnings(here);
718}
719
720
721struct Coroutine_ChainParam {
722 Coroutine_Start start;
723 void *value;
724 Coroutine *ret;
725};
726
727
728static void *Coroutine_ChainFn(
729 void *param
730){
731 struct Coroutine_ChainParam *params = (struct Coroutine_ChainParam *)param;
732 Coroutine_Continue(params->ret, params->start(params->value), true);
733 return NULL;
734}
735
736
737static void Coroutine_ChainYield(
738 void *unused
739){
740 (void)unused;
741}
742
743
744void *Coroutine_Chain(
745 Coroutine_Start start,
746 void *value
747){
748 assert(Check_Guard(Coroutine_GetActive()->guard));
749 Coroutine *cor = Coroutine_New(Coroutine_ChainFn);
750 assert(cor);
751 struct Coroutine_ChainParam params = {
752 start,
753 value,
754 Coroutine_GetActive()
755 };
756 Coroutine_Continue(cor, &params, true);
757 void *res = Coroutine_Yield(NULL, Coroutine_ChainYield, NULL);
758 Coroutine_Delete(cor);
759 return res;
760}
761
762
763bool Coroutine_IsRunning(
764 Coroutine *cor
765)
766{
767 int state = cor->state;
768 return state == Coroutine_Running || state == Coroutine_Waiting;
769}
770
771
772bool Coroutine_IsComplete(
773 Coroutine *cor
774)
775{
776 int state = cor->state;
777 return state == Coroutine_Complete;
778}
779
780
781bool Coroutine_IsStarted(void){
782 return g_c.state == Coroutines_Active || g_c.state == Coroutines_Started;
783}
784