/**
enable_jit : ?bool -> ?bool
<doc>Enable or disable the JIT. Calling enable_jit(null) tells if JIT is enabled or not</doc>
**/
static value enable_jit( value b ) {
if( val_is_null(b) )
return alloc_bool(neko_vm_jit(neko_vm_current(),-1));
val_check(b,bool);
neko_vm_jit(neko_vm_current(),val_bool(b));
return val_null;
}
static void null_warn_proc( char *msg, int arg ) {
# ifdef GC_LOG
printf(msg,arg);
if( strstr(msg,"very large block") )
neko_vm_dump_stack(neko_vm_current());
# endif
}
static value init_module() {
neko_vm *vm = neko_vm_current();
mcontext *ctx = CONTEXT();
value env = vm->env;
ctx->main = NULL;
val_call1(val_array_ptr(env)[0],val_array_ptr(env)[1]);
cache_module(ctx->r->filename,FTIME(ctx->r),ctx->main);
return val_null;
}
static value print_redirect( value f ) {
neko_vm *vm = neko_vm_current();
if( val_is_null(f) ) {
neko_vm_redirect(vm,NULL,NULL);
return val_null;
}
val_check_function(f,1);
neko_vm_redirect(vm,print_callback,f);
return val_null;
}
/**
thread_current : void -> 'thread
<doc>Returns the current thread</doc>
**/
static value thread_current() {
vthread *t = neko_thread_current();
// should only occur for main thread !
if( t == NULL ) {
neko_vm *vm = neko_vm_current();
t = alloc_thread(vm);
neko_vm_set_custom(vm,k_thread,t);
}
return t->v;
}
static value run_llvm_jit(value mv) {
neko_module *m;
val_check_kind(mv,neko_kind_module);
m = (neko_module*)val_data(mv);
neko_vm * vm = neko_vm_current();
if( vm->fstats ) vm->fstats(vm,"neko_read_module_jit",1);
llvm_cpp_jit(vm, m);
if( vm->fstats ) vm->fstats(vm,"neko_read_module_jit",0);
return val_null;
}
/**
thread_create : f:function:1 -> p:any -> 'thread
<doc>Creates a thread that will be running the function [f(p)]</doc>
**/
static value thread_create( value f, value param ) {
tparams *p;
val_check_function(f,1);
p = (tparams*)alloc(sizeof(tparams));
p->callb = f;
p->callparam = param;
p->jit = neko_vm_jit(neko_vm_current(),-1);
if( !neko_thread_create(thread_init,thread_loop,p,&p->handle) )
neko_error();
return p->t->v;
}
static void handle_signal( int signal ) {
// reset to default handler
struct sigaction act;
act.sa_sigaction = NULL;
act.sa_handler = SIG_DFL;
act.sa_flags = 0;
sigemptyset(&act.sa_mask);
sigaction(SIGSEGV,&act,NULL);
// print signal VM stack
printf("**** SIGNAL %d CAUGHT ****\n",signal);
neko_vm_dump_stack(neko_vm_current());
// signal again
raise(signal);
}
value cgi_command( value v ) {
val_check(v,string);
if( strcmp(val_string(v),"stats") == 0 )
return neko_stats_build(neko_vm_current());
if( strcmp(val_string(v),"cache") == 0 ) {
cache *c = (cache*)local_get(cache_root);
value l = val_null;
while( c != NULL ) {
value a = alloc_array(4);
val_array_ptr(a)[0] = c->file;
val_array_ptr(a)[1] = c->main;
val_array_ptr(a)[2] = alloc_int(c->hits);
val_array_ptr(a)[3] = l;
l = a;
c = c->next;
}
return l;
}
neko_error();
}
static value loader_loadmodule( value mname, value vthis ) {
value o = val_this();
value cache;
val_check(o,object);
val_check(mname,string);
val_check(vthis,object);
cache = val_field(o,id_cache);
val_check(cache,object);
{
reader r;
readp p;
neko_module *m;
neko_vm *vm = NEKO_VM();
field mid = val_id(val_string(mname));
value mv = val_field(cache,mid);
if( val_is_kind(mv,neko_kind_module) ) {
m = (neko_module*)val_data(mv);
return m->exports;
}
open_module(val_field(o,id_path),val_string(mname),&r,&p);
if( vm->fstats ) vm->fstats(vm,"neko_read_module",1);
m = neko_read_module(r,p,vthis);
if( vm->fstats ) vm->fstats(vm,"neko_read_module",0);
close_module(p);
if( m == NULL ) {
buffer b = alloc_buffer("Invalid module : ");
val_buffer(b,mname);
bfailure(b);
}
m->name = alloc_string(val_string(mname));
mv = alloc_abstract(neko_kind_module,m);
alloc_field(cache,mid,mv);
if( vm->fstats ) vm->fstats(vm,val_string(mname),1);
neko_vm_execute(neko_vm_current(),m);
if( vm->fstats ) vm->fstats(vm,val_string(mname),0);
return m->exports;
}
}
/**
module_exec : 'module -> any
<doc>Execute the module, return the calculated value</doc>
**/
static value module_exec( value mv ) {
neko_module *m;
val_check_kind(mv,neko_kind_module);
m = (neko_module*)val_data(mv);
return neko_vm_execute(neko_vm_current(),m);
}
/**
set_trusted : bool -> void
<doc>
Change the trusted mode of the VM.
This can optimize some operations such as module loading by turning off some checks.
</doc>
**/
static value set_trusted( value b ) {
val_check(b,bool);
neko_vm_trusted(neko_vm_current(),val_bool(b));
return val_null;
}
static vthread *neko_thread_current() {
return (vthread*)neko_vm_custom(neko_vm_current(),k_thread);
}
