int neko_execute_self( neko_vm *vm, value mload ) {
value args[] = { alloc_string("std@module_read"), alloc_int(2) };
value args2[] = { alloc_string("std@module_exec"), alloc_int(1) };
value args3[] = { alloc_function(read_bytecode,3,"boot_read_bytecode"), mload };
value exc = NULL;
value module_read, module_exec, module_val;
module_read = val_callEx(mload,val_field(mload,val_id("loadprim")),args,2,&exc);
if( exc != NULL ) {
report(vm,exc,1);
return 1;
}
module_exec = val_callEx(mload,val_field(mload,val_id("loadprim")),args2,2,&exc);
if( exc != NULL ) {
report(vm,exc,1);
return 1;
}
module_val = val_callEx(val_null,module_read,args3,2,&exc);
fclose(self);
if( exc != NULL ) {
report(vm,exc,1);
return 1;
}
alloc_field(val_field(mload,val_id("cache")),val_id("_self"),module_val);
val_callEx(val_null,module_exec,&module_val,1,&exc);
if( exc != NULL ) {
report(vm,exc,1);
return 1;
}
return 0;
}
static int boot_main(int argc, char *argv[] ) {
neko_vm *vm;
value args[2];
value mload, exc = NULL;
char* root = getSwitch(argc,argv,"swroot");
char* rootFromBundle = root ? NULL : getSwitchFromBundle("swroot");
char* index = getSwitch(argc,argv,"swindex");
if(!index) index = getSwitchFromBundle("swindex");
#if OSX
char* tmpRootBuffer = NULL;
if (rootFromBundle) {
if (stricmp("SW_BUNDLE_PARENT",rootFromBundle)==0) {
// folder containing bundle is path:
root = getBundleRoot();
strcat(root,"/..");
} else {
// path is relative to bundle:
root = tmpRootBuffer = malloc(FILENAME_MAX);
sprintf(root,"%s/%s",getBundleRoot(),rootFromBundle);
}
}
#endif
// if root folder is specified, change the current directory:
if( root ) {
chdir(root);
# if OSX
if (tmpRootBuffer)
free(tmpRootBuffer);
# endif
}
// printf("boot-loader computed working folder: %s\n",root);
// printf("boot-loader set working folder: %s\n",getcwd(NULL));
// initialize Neko Virtual Machine
neko_global_init(&vm);
vm = neko_vm_alloc(NULL);
neko_vm_jit(vm,1);
neko_vm_select(vm);
mload = neko_default_loader(argv, argc);
args[0] = alloc_string(index ? index : DEFAULT_INDEX);
args[1] = mload;
val_callEx(mload,val_field(mload,val_id("loadmodule")),args,2,&exc);
if( exc != NULL )
report(vm,exc);
vm = NULL;
neko_global_free();
while(switches_count--) {
free(switches[switches_count]);
}
if (switches) free(switches);
return( exc != NULL );
}
void NekoVM::Execute (const char *modulePath) {
neko_vm *vm;
neko_global_init ();
vm = neko_vm_alloc (NULL);
neko_vm_select (vm);
std_main ();
value mload = neko_default_loader(NULL, 0);
value args2[] = { alloc_string(modulePath), mload };
value exc = NULL;
val_callEx(mload,val_field(mload,val_id("loadmodule")),args2,2,&exc);
if( exc != NULL ) {
report(vm,exc,1);
//return 1;
}
//return 0;
}
EXTERN int val_compare( value a, value b ) {
char tmp_buf[32];
switch( C(val_type(a),val_type(b)) ) {
case C(VAL_INT,VAL_INT):
return icmp(val_int(a),val_int(b));
case C(VAL_INT32,VAL_INT):
return icmp(val_int32(a),val_int(b));
case C(VAL_INT,VAL_INT32):
return icmp(val_int(a),val_int32(b));
case C(VAL_INT32,VAL_INT32):
return icmp(val_int32(a),val_int32(b));
case C(VAL_INT,VAL_FLOAT):
return fcmp(val_int(a),val_float(b));
case C(VAL_INT32,VAL_FLOAT):
return fcmp(val_int32(a),val_float(b));
case C(VAL_INT,VAL_STRING):
return scmp(tmp_buf,sprintf(tmp_buf,"%d",val_int(a)),val_string(b),val_strlen(b));
case C(VAL_INT32,VAL_STRING):
return scmp(tmp_buf,sprintf(tmp_buf,"%d",val_int32(a)),val_string(b),val_strlen(b));
case C(VAL_FLOAT,VAL_INT):
return fcmp(val_float(a),val_int(b));
case C(VAL_FLOAT,VAL_INT32):
return fcmp(val_float(a),val_int32(b));
case C(VAL_FLOAT,VAL_FLOAT):
return fcmp(val_float(a),val_float(b));
case C(VAL_FLOAT,VAL_STRING):
return scmp(tmp_buf,sprintf(tmp_buf,FLOAT_FMT,val_float(a)),val_string(b),val_strlen(b));
case C(VAL_STRING,VAL_INT):
return scmp(val_string(a),val_strlen(a),tmp_buf,sprintf(tmp_buf,"%d",val_int(b)));
case C(VAL_STRING,VAL_INT32):
return scmp(val_string(a),val_strlen(a),tmp_buf,sprintf(tmp_buf,"%d",val_int32(b)));
case C(VAL_STRING,VAL_FLOAT):
return scmp(val_string(a),val_strlen(a),tmp_buf,sprintf(tmp_buf,FLOAT_FMT,val_float(b)));
case C(VAL_STRING,VAL_BOOL):
return scmp(val_string(a),val_strlen(a),val_bool(b)?"true":"false",val_bool(b)?4:5);
case C(VAL_BOOL,VAL_STRING):
return scmp(val_bool(a)?"true":"false",val_bool(a)?4:5,val_string(b),val_strlen(b));
case C(VAL_STRING,VAL_STRING):
return scmp(val_string(a),val_strlen(a),val_string(b),val_strlen(b));
case C(VAL_BOOL,VAL_BOOL):
return (a == b) ? 0 : (val_bool(a) ? 1 : -1);
case C(VAL_OBJECT,VAL_OBJECT):
if( a == b )
return 0;
{
value tmp = val_field(a,id_compare);
if( tmp == val_null )
return invalid_comparison;
a = val_callEx(a,tmp,&b,1,NULL);
}
if( val_is_int(a) )
return val_int(a);
return invalid_comparison;
default:
if( a == b )
return 0;
return invalid_comparison;
}
}
static void preload_module( const char *name, server_rec *serv ) {
value exc = NULL;
neko_vm *vm = neko_vm_alloc(NULL);
value mload = neko_default_loader(NULL,0);
value m, read_path, exec;
time_t time = 0;
neko_vm_select(vm);
if( config.use_jit ) neko_vm_jit(vm,1);
if( !exc ) {
value args[] = { alloc_string("std@module_read_path"), alloc_int(3) };
read_path = val_callEx(mload,val_field(mload,val_id("loadprim")),args,2,&exc);
}
if( !exc ) {
value args[] = { alloc_string("std@module_exec"), alloc_int(1) };
exec = val_callEx(mload,val_field(mload,val_id("loadprim")),args,2,&exc);
}
if( !exc ) {
value args[] = { val_null, alloc_string(name), mload };
char *p = strrchr(val_string(args[1]),'.');
if( p != NULL ) *p = 0;
m = val_callEx(mload,read_path,args,3,&exc);
}
if( !exc ) {
struct stat t;
if( stat(name,&t) )
exc = alloc_string("failed to stat()");
else
time = t.st_mtime;
}
if( !exc ) {
value f = alloc_function(init_module,0,"init_module");
value env = alloc_array(2);
val_array_ptr(env)[0] = exec;
val_array_ptr(env)[1] = m;
((vfunction*)f)->env = env;
cache_module(name,time,f);
}
if( exc ) {
buffer b = alloc_buffer(NULL);
val_buffer(b,exc);
ap_log_error(APLOG_MARK,APLOG_WARNING,LOG_SUCCESS serv,"Failed to preload module '%s' : %s",name,val_string(buffer_to_string(b)));
}
neko_vm_select(NULL);
}
static int execute_file( neko_vm *vm, char *file, value mload ) {
value args[] = { alloc_string(file), mload };
value exc = NULL;
val_callEx(mload,val_field(mload,val_id("loadmodule")),args,2,&exc);
if( exc != NULL ) {
report(vm,exc,1);
return 1;
}
return 0;
}
static void thread_loop( void *_p ) {
tparams *p = (tparams*)_p;
value exc = NULL;
val_callEx(val_null,p->callb,&p->callparam,1,&exc);
// display exception
if( exc != NULL ) {
buffer b = alloc_buffer(NULL);
fprintf(stderr,"An exception occured in a neko Thread :\n");
val_buffer(b,exc);
fprintf(stderr,"%s\n",val_string(buffer_to_string(b)));
}
// cleanup
neko_vm_select(NULL);
p->t->v = val_null;
p->t->vm = NULL;
}
static value closure_callback( value *args, int nargs ) {
value env = NEKO_VM()->env;
int cargs = val_array_size(env) - 2;
value *a = val_array_ptr(env);
value f = a[0];
value o = a[1];
int fargs = val_fun_nargs(f);
int i;
if( fargs != cargs + nargs && fargs != VAR_ARGS )
return val_null;
if( nargs == 0 )
a = val_array_ptr(env) + 2;
else if( cargs == 0 )
a = args;
else {
a = (value*)alloc(sizeof(value)*(nargs+cargs));
for(i=0;i<cargs;i++)
a[i] = val_array_ptr(env)[i+2];
for(i=0;i<nargs;i++)
a[i+cargs] = args[i];
}
return val_callEx(o,f,a,nargs+cargs,NULL);
}
static void val_buffer_rec( buffer b, value v, vlist *stack ) {
char buf[32];
int i, l;
vlist *vtmp = stack;
while( vtmp != NULL ) {
if( vtmp->v == v ) {
buffer_append_sub(b,"...",3);
return;
}
vtmp = vtmp->next;
}
switch( val_type(v) ) {
case VAL_INT:
buffer_append_sub(b,buf,sprintf(buf,"%d",val_int(v)));
break;
case VAL_STRING:
buffer_append_sub(b,val_string(v),val_strlen(v));
break;
case VAL_FLOAT:
buffer_append_sub(b,buf,sprintf(buf,FLOAT_FMT,val_float(v)));
break;
case VAL_NULL:
buffer_append_sub(b,"null",4);
break;
case VAL_BOOL:
if( val_bool(v) )
buffer_append_sub(b,"true",4);
else
buffer_append_sub(b,"false",5);
break;
case VAL_FUNCTION:
buffer_append_sub(b,buf,sprintf(buf,"#function:%d",val_fun_nargs(v)));
break;
case VAL_OBJECT:
{
value s = val_field(v,id_string);
if( s != val_null )
s = val_callEx(v,s,NULL,0,NULL);
if( val_is_string(s) )
buffer_append_sub(b,val_string(s),val_strlen(s));
else {
vlist2 vtmp;
vtmp.v = v;
vtmp.next = stack;
vtmp.b = b;
vtmp.prev = 0;
buffer_append_sub(b,"{",1);
val_iter_fields(v,val_buffer_fields,&vtmp);
if( vtmp.prev )
buffer_append_sub(b," }",2);
else
buffer_append_sub(b,"}",1);
}
break;
}
case VAL_ARRAY:
buffer_append_sub(b,"[",1);
l = val_array_size(v);
{
vlist vtmp;
vtmp.v = v;
vtmp.next = stack;
for(i=0;i<l;i++) {
value vi = val_array_ptr(v)[i];
val_buffer_rec(b,vi,&vtmp);
if( i != l - 1 )
buffer_append_sub(b,",",1);
}
}
buffer_append_sub(b,"]",1);
break;
case VAL_INT32:
buffer_append_sub(b,buf,sprintf(buf,"%d",val_int32(v)));
break;
case VAL_ABSTRACT:
buffer_append_sub(b,"#abstract",9);
break;
default:
buffer_append_sub(b,"#unknown",8);
break;
}
}
EXTERN value val_ocallN( value o, field f, value *args, int nargs ) {
return val_callEx(o,val_field(o,f),args,nargs,NULL);
}
EXTERN value val_callN( value f, value *args, int nargs ) {
return val_callEx(NULL,f,args,nargs,NULL);
}
static int neko_handler_rec( request_rec *r ) {
mcontext ctx;
neko_vm *vm;
const char *ctype;
value exc = NULL;
/*
Seems to crash on Windows. And on Linux, we rarely have libGC 7.x installed anyway
# if defined(APACHE_2_X) || defined(NEKO_WINDOWS)
// we are using threads, so let's make sure that the current thread is registered
neko_thread_register(true);
# endif
*/
config.hits++;
ctx.r = r;
ctx.main = cache_find(r);
ctx.post_data = val_null;
ctx.headers_sent = false;
ctx.content_type = alloc_string("text/html");
r->content_type = val_string(ctx.content_type);
if( ap_setup_client_block(r,REQUEST_CHUNKED_ERROR) != 0 ) {
send_headers(&ctx);
apache_error(APLOG_WARNING,r,"ap_setup_client_block failed");
return OK;
}
ctype = ap_table_get(r->headers_in,"Content-Type");
if( (!ctype || strstr(ctype,"multipart/form-data") == NULL) && ap_should_client_block(r) ) {
# define MAXLEN 1024
char buf[MAXLEN];
int len;
int tlen = 0;
buffer b = alloc_buffer(NULL);
while( (len = ap_get_client_block(r,buf,MAXLEN)) > 0 ) {
if( tlen < config.max_post_size )
buffer_append_sub(b,buf,len);
tlen += len;
}
if( tlen >= config.max_post_size ) {
send_headers(&ctx);
apache_error(APLOG_WARNING,r,"Maximum POST data exceeded. Try using multipart encoding");
return OK;
}
ctx.post_data = buffer_to_string(b);
}
vm = neko_vm_alloc(NULL);
if( config.use_stats ) neko_vm_set_stats(vm,neko_stats_measure,config.use_prim_stats?neko_stats_measure:NULL);
neko_vm_set_custom(vm,k_mod_neko,&ctx);
if( config.use_jit && !neko_vm_jit(vm,1) ) {
send_headers(&ctx);
apache_error(APLOG_WARNING,r,"JIT required by env. var but not enabled in NekoVM");
return OK;
}
neko_vm_redirect(vm,request_print,&ctx);
neko_vm_select(vm);
if( ctx.main != NULL ) {
value old = ctx.main;
if( config.use_stats ) neko_stats_measure(vm,r->filename,1);
val_callEx(val_null,old,NULL,0,&exc);
if( config.use_stats ) neko_stats_measure(vm,r->filename,0);
if( old != ctx.main ) cache_module(r->filename,FTIME(r),ctx.main);
} else {
char *base_uri = request_base_uri(r);
value mload = neko_default_loader(&base_uri,1);
value args[] = { alloc_string(r->filename), mload };
char *p = strrchr(val_string(args[0]),'.');
if( p != NULL )
*p = 0;
val_callEx(mload,val_field(mload,val_id("loadmodule")),args,2,&exc);
if( ctx.main != NULL && config.use_cache )
cache_module(r->filename,FTIME(r),ctx.main);
}
if( exc != NULL ) {
buffer b = alloc_buffer(NULL);
value v;
int i;
const char *p, *start;
value st = neko_exc_stack(vm);
val_buffer(b,exc);
config.exceptions++;
ap_soft_timeout("Client Timeout",r);
send_headers(&ctx);
v = buffer_to_string(b);
p = val_string(v);
start = p;
ap_rprintf(r,"Uncaught exception - ");
while( *p ) {
if( *p == '<' || *p == '>' ) {
ap_rwrite(start,(int)(p - start),r);
ap_rwrite((*p == '<')?"<":">",4, r);
start = p + 1;
}
p++;
}
ap_rwrite(start,(int)(p - start),r);
ap_rprintf(r,"<br/><br/>");
for(i=0;i<val_array_size(st);i++) {
value s = val_array_ptr(st)[i];
if( val_is_null(s) )
ap_rprintf(r,"Called from a C function<br/>");
else if( val_is_string(s) ) {
ap_rprintf(r,"Called from %s (no debug available)<br/>",val_string(s));
} else if( val_is_array(s) && val_array_size(s) == 2 && val_is_string(val_array_ptr(s)[0]) && val_is_int(val_array_ptr(s)[1]) )
ap_rprintf(r,"Called from %s line %d<br/>",val_string(val_array_ptr(s)[0]),val_int(val_array_ptr(s)[1]));
else {
b = alloc_buffer(NULL);
val_buffer(b,s);
ap_rprintf(r,"Called from %s<br/>",val_string(buffer_to_string(b)));
}
}
ap_kill_timeout(r);
return OK;
}
send_headers(&ctx);
return OK;
}
