Fcalva/cyclone
1
0
Fork 0
mirror of https://github.com/justinethier/cyclone.git synced 2025-05-21 14:49:17 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

Cleanup

Browse source
This commit is contained in:
Justin Ethier 2020-08-09 17:32:40 -04:00
parent 8047da95d2
commit 4560e115bd
2 changed files with 15 additions and 17 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

30
examples/callbacks/sys.c
View file

@ -16,13 +16,13 @@ extern object __glo_signal_91done;
* into Scheme code. In a real application this thread would probably do * into Scheme code. In a real application this thread would probably do
* quite a bit more work in C, only calling into Scheme code as necessary. * quite a bit more work in C, only calling into Scheme code as necessary.
*/ */
void *c_thread(void *arg) void *c_thread(void *parent_thd)
{ {
printf("Hello from C thread\n"); printf("Hello from C thread\n");
sleep(1); sleep(1);
printf("C calling into SCM\n"); printf("C calling into SCM\n");
object obj = c_trampoline(arg, __glo_signal_91done, boolean_t); object obj = scm_call_no_gc(parent_thd, __glo_signal_91done, boolean_t);
printf("C received: "); printf("C received: ");
Cyc_write(NULL, obj, stdout); Cyc_write(NULL, obj, stdout);
@ -45,7 +45,6 @@ void *c_thread(void *arg)
*/ */
void after_call_scm(gc_thread_data *thd, int argc, object k, object result) void after_call_scm(gc_thread_data *thd, int argc, object k, object result)
{ {
// TODO: need to check this, does NOT work if result is a stack obj!!
thd->gc_cont = result; thd->gc_cont = result;
longjmp(*(thd->jmp_start), 1); longjmp(*(thd->jmp_start), 1);
} }
@ -71,7 +70,7 @@ void call_scm(gc_thread_data *thd, object fnc, object obj)
* or re-allocated (EG: malloc) before returning it * or re-allocated (EG: malloc) before returning it
* to the C layer. * to the C layer.
*/ */
object c_trampoline(gc_thread_data *parent_thd, object fnc, object arg) object scm_call_no_gc(gc_thread_data *parent_thd, object fnc, object arg)
{ {
long stack_size = 100000; long stack_size = 100000;
char *stack_base = (char *)&stack_size; char *stack_base = (char *)&stack_size;
@ -85,39 +84,38 @@ object c_trampoline(gc_thread_data *parent_thd, object fnc, object arg)
#else #else
thd.stack_limit = stack_base + stack_size; thd.stack_limit = stack_base + stack_size;
#endif #endif
thd.stack_traces = stack_traces; //calloc(MAX_STACK_TRACES, sizeof(char *)); thd.stack_traces = stack_traces;
//thd.stack_trace_idx = 0;
//thd.stack_prev_frame = NULL;
//thd.gc_cont = NULL;
thd.thread_id = pthread_self(); thd.thread_id = pthread_self();
thd.thread_state = CYC_THREAD_STATE_RUNNABLE; thd.thread_state = CYC_THREAD_STATE_RUNNABLE;
//thd.exception_handler_stack = NULL; // Default // Copy parameter objects from the calling thread
// Copy thread params from the calling thread
object parent = parent_thd->param_objs; // Unbox parent thread's data object parent = parent_thd->param_objs; // Unbox parent thread's data
object child = NULL; object child = NULL;
//thd.param_objs = NULL;
while (parent) { while (parent) {
if (thd.param_objs == NULL) { if (thd.param_objs == NULL) {
alloca_pair(p, NULL, NULL); alloca_pair(p, NULL, NULL);
thd.param_objs = p; thd.param_objs = p;
//thd.param_objs = gc_alloc_pair(thd, NULL, NULL);
child = thd.param_objs; child = thd.param_objs;
} else { } else {
//pair_type *p = gc_alloc_pair(thd, NULL, NULL);
alloca_pair(p, NULL, NULL); alloca_pair(p, NULL, NULL);
cdr(child) = p; cdr(child) = p;
child = p; child = p;
} }
//car(child) = gc_alloc_pair(thd, car(car(parent)), cdr(car(parent)));
alloca_pair(cc, car(car(parent)), cdr(car(parent))); alloca_pair(cc, car(car(parent)), cdr(car(parent)));
car(child) = cc; car(child) = cc;
parent = cdr(parent); parent = cdr(parent);
} }
// Done initializing parameter objects
// Setup trampoline and call into Scheme
//
// When the Scheme call is done we return result back to C
//
// It is very important to know that the result, IF ON THE STACK,
// is further up the stack than the caller and will be overwritten
// by subsequent C calls on this thread. Thus the caller will want
// to immediately create a copy of the object...
//
if (!setjmp(*(thd.jmp_start))) { if (!setjmp(*(thd.jmp_start))) {
call_scm(&thd, fnc, arg); call_scm(&thd, fnc, arg);
} else { } else {

2
examples/callbacks/sys.h
View file

@ -1,4 +1,4 @@
#include "cyclone/types.h" #include "cyclone/types.h"
void start_c_thread(gc_thread_data *thd); void start_c_thread(gc_thread_data *thd);
object c_trampoline(gc_thread_data *parent_thd, object fnc, object arg); object scm_call_no_gc(gc_thread_data *parent_thd, object fnc, object arg);