mirror of
https://github.com/justinethier/cyclone.git
synced 2025-05-19 05:39:17 +02:00
106 lines
2.8 KiB
C
106 lines
2.8 KiB
C
#include "cyclone/types.h"
|
|
#include "cyclone/runtime.h"
|
|
#include "sys.h"
|
|
#include <unistd.h>
|
|
|
|
extern object __glo_signal_91done;
|
|
|
|
// Scheme function calls into this when it is done.
|
|
// We store results and longjmp back to where we started.
|
|
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;
|
|
longjmp(*(thd->jmp_start), 1);
|
|
}
|
|
|
|
// Call into Scheme function
|
|
void call_scm(gc_thread_data *thd, object obj)
|
|
{
|
|
mclosure0(after, (function_type)after_call_scm);
|
|
((closure)__glo_signal_91done)->fn(thd, 2, __glo_signal_91done, &after, obj);
|
|
}
|
|
|
|
void wait_and_signal(gc_thread_data *thd)
|
|
{
|
|
// print, wait couple secs, signal SCM side
|
|
printf("Hello from C thread\n");
|
|
sleep(1);
|
|
printf("C calling into SCM\n");
|
|
call_scm(thd, boolean_t);
|
|
}
|
|
|
|
void c_trampoline(gc_thread_data *parent_thd)
|
|
{
|
|
long stack_size = 100000;
|
|
char *stack_base = (char *)&stack_size;
|
|
char *stack_traces[MAX_STACK_TRACES];
|
|
gc_thread_data thd = {0};
|
|
jmp_buf jmp;
|
|
thd.jmp_start = &jmp;
|
|
thd.stack_start = stack_base;
|
|
#if STACK_GROWTH_IS_DOWNWARD
|
|
thd.stack_limit = stack_base - stack_size;
|
|
#else
|
|
thd.stack_limit = stack_base + stack_size;
|
|
#endif
|
|
thd.stack_traces = stack_traces; //calloc(MAX_STACK_TRACES, sizeof(char *));
|
|
//thd.stack_trace_idx = 0;
|
|
//thd.stack_prev_frame = NULL;
|
|
//thd.gc_cont = NULL;
|
|
|
|
thd.thread_id = pthread_self();
|
|
|
|
//thd.exception_handler_stack = NULL; // Default
|
|
|
|
// Copy thread params from the calling thread
|
|
object parent = parent_thd->param_objs; // Unbox parent thread's data
|
|
object child = NULL;
|
|
//thd.param_objs = NULL;
|
|
while (parent) {
|
|
if (thd.param_objs == NULL) {
|
|
alloca_pair(p, NULL, NULL);
|
|
thd.param_objs = p;
|
|
//thd.param_objs = gc_alloc_pair(thd, NULL, NULL);
|
|
child = thd.param_objs;
|
|
} else {
|
|
//pair_type *p = gc_alloc_pair(thd, NULL, NULL);
|
|
alloca_pair(p, NULL, NULL);
|
|
cdr(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)));
|
|
car(child) = cc;
|
|
parent = cdr(parent);
|
|
}
|
|
// Done initializing parameter objects
|
|
|
|
|
|
if (!setjmp(*(thd.jmp_start))) {
|
|
wait_and_signal(&thd);
|
|
} else {
|
|
printf("Received: ");
|
|
Cyc_write(&thd, thd.gc_cont, stdout);
|
|
printf("\n");
|
|
}
|
|
}
|
|
|
|
void *c_thread(void *arg)
|
|
{
|
|
c_trampoline(arg);
|
|
return NULL;
|
|
}
|
|
|
|
void start_c_thread(gc_thread_data *thd)
|
|
{
|
|
pthread_t thread;
|
|
pthread_attr_t attr;
|
|
pthread_attr_init(&attr);
|
|
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
|
|
if (pthread_create(&thread, &attr, c_thread, thd)) {
|
|
fprintf(stderr, "Error creating a new thread\n");
|
|
exit(1);
|
|
}
|
|
pthread_attr_destroy(&attr);
|
|
}
|