void* DisplayMode::Value () { // if (_mode) { // _mode->height = height; // _mode->pixelFormat = pixelFormat; // _mode->refreshRate = refreshRate; // _mode->width = width; // return _mode; // } else { if (!init) { id_height = val_id ("height"); id_pixelFormat = val_id ("pixelFormat"); id_refreshRate = val_id ("refreshRate"); id_width = val_id ("width"); init = true; } value displayMode = alloc_empty_object (); alloc_field (displayMode, id_height, alloc_int (height)); alloc_field (displayMode, id_pixelFormat, alloc_int (pixelFormat)); alloc_field (displayMode, id_refreshRate, alloc_int (refreshRate)); alloc_field (displayMode, id_width, alloc_int (width)); return displayMode; // } }
void TouchEvent::Dispatch (TouchEvent* event) { if (TouchEvent::callback) { if (!init) { id_id = val_id ("id"); id_type = val_id ("type"); id_x = val_id ("x"); id_y = val_id ("y"); init = true; } value object = (TouchEvent::eventObject ? TouchEvent::eventObject->get () : alloc_empty_object ()); alloc_field (object, id_id, alloc_int (event->id)); alloc_field (object, id_type, alloc_int (event->type)); alloc_field (object, id_x, alloc_float (event->x)); alloc_field (object, id_y, alloc_float (event->y)); val_call1 (TouchEvent::callback->get (), object); } }
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; }
/** connect : { host => string, port => int, user => string, pass => string, socket => string? } -> 'connection <doc>Connect to a database using the connection informations</doc> **/ static value connect_mysql( value params ) { value host, port, user, pass, socket; val_check(params,object); host = val_field(params,val_id("host")); port = val_field(params,val_id("port")); user = val_field(params,val_id("user")); pass = val_field(params,val_id("pass")); socket = val_field(params,val_id("socket")); val_check(host,string); val_check(port,int); val_check(user,string); val_check(pass,string); if( !val_is_string(socket) && !val_is_null(socket) ) neko_error(); { connection *c = (connection*)alloc(sizeof(connection)); value v; c->m = mysql_init(NULL); c->conv_string = NULL; c->conv_date = NULL; c->conv_bytes = NULL; if( mysql_real_connect(c->m,val_string(host),val_string(user),val_string(pass),NULL,val_int(port),val_is_null(socket)?NULL:val_string(socket),0) == NULL ) { buffer b = alloc_buffer("Failed to connect to mysql server : "); buffer_append(b,mysql_error(c->m)); mysql_close(c->m); bfailure(b); } v = alloc_abstract(k_connection,c); val_gc(v,free_connection); return v; } }
value AudioBuffer::Value () { if (!init) { id_bitsPerSample = val_id ("bitsPerSample"); id_channels = val_id ("channels"); id_data = val_id ("data"); id_sampleRate = val_id ("sampleRate"); init = true; } if (val_is_null (mValue)) { mValue = alloc_empty_object (); } alloc_field (mValue, id_bitsPerSample, alloc_int (bitsPerSample)); alloc_field (mValue, id_channels, alloc_int (channels)); alloc_field (mValue, id_data, data ? data->Value () : alloc_null ()); alloc_field (mValue, id_sampleRate, alloc_int (sampleRate)); return mValue; }
AudioBuffer::AudioBuffer (value audioBuffer) { if (!init) { id_bitsPerSample = val_id ("bitsPerSample"); id_channels = val_id ("channels"); id_data = val_id ("data"); id_sampleRate = val_id ("sampleRate"); init = true; } if (!val_is_null (audioBuffer)) { bitsPerSample = val_int (val_field (audioBuffer, id_bitsPerSample)); channels = val_int (val_field (audioBuffer, id_channels)); data = new ArrayBufferView (val_field (audioBuffer, id_data)); sampleRate = val_int (val_field (audioBuffer, id_sampleRate)); } else { bitsPerSample = 0; channels = 0; data = new ArrayBufferView (); sampleRate = 0; } mValue = audioBuffer; }
void SensorEvent::Dispatch (SensorEvent* event) { if (SensorEvent::callback) { if (!init) { id_id = val_id ("id"); id_type = val_id ("type"); id_x = val_id ("x"); id_y = val_id ("y"); id_z = val_id ("z"); init = true; } value object = (SensorEvent::eventObject ? SensorEvent::eventObject->get () : alloc_empty_object ()); alloc_field (object, id_id, alloc_int (event->id)); alloc_field (object, id_type, alloc_int (event->type)); alloc_field (object, id_x, alloc_float (event->x)); alloc_field (object, id_y, alloc_float (event->y)); alloc_field (object, id_z, alloc_float (event->z)); val_call0 (SensorEvent::callback->get ()); } }
void GamepadEvent::Dispatch (GamepadEvent* event) { if (GamepadEvent::callback) { if (!init) { id_axis = val_id ("axis"); id_button = val_id ("button"); id_id = val_id ("id"); id_type = val_id ("type"); id_value = val_id ("value"); init = true; } value object = (GamepadEvent::eventObject ? GamepadEvent::eventObject->get () : alloc_empty_object ()); alloc_field (object, id_axis, alloc_int (event->axis)); alloc_field (object, id_button, alloc_int (event->button)); alloc_field (object, id_id, alloc_int (event->id)); alloc_field (object, id_type, alloc_int (event->type)); alloc_field (object, id_value, alloc_float (event->axisValue)); val_call0 (GamepadEvent::callback->get ()); } }
/** gc_stats : void -> { heap => int, free => int } <doc>Return the size of the GC heap and the among of free space, in bytes</doc> **/ static value gc_stats() { int heap, free; value o; neko_gc_stats(&heap,&free); o = alloc_object(NULL); alloc_field(o,val_id("heap"),alloc_int(heap)); alloc_field(o,val_id("free"),alloc_int(free)); return o; }
/** socket_init : void -> void <doc> Initialize the socket API. Must be called at least once per process before using any socket or host function. </doc> **/ static value socket_init() { #ifdef NEKO_WINDOWS if( !init_done ) { WSAStartup(MAKEWORD(2,0),&init_data); init_done = true; } #endif f_host = val_id("host"); f_port = val_id("port"); return alloc_bool(true); }
static value dialogs_open_file( value title, value msg, value initialdir, value mask,value multi) { value result = val_null; struct ARG_FILEFILTERS filters = {0,0,0}; struct RES_STRINGLIST files; val_check(title,string); val_check(msg,string); val_check(multi,bool); val_check(initialdir, string); if (val_is_object(mask)) { value count = val_field(mask,val_id("count")); value descriptions = val_field(mask,val_id("descriptions")); value extensions = val_field(mask,val_id("extensions")); val_check(count,int); val_check(descriptions,array); val_check(extensions,array); filters.count = val_int(count); if (filters.count) { long i = filters.count; filters.descriptions = (const char**) malloc(i*sizeof(char*)); filters.extensions = (const char**) malloc(i*sizeof(char*)); while(i) { i--; filters.descriptions[i] = val_string(val_array_i(descriptions,i)); filters.extensions[i] = val_string(val_array_i(extensions,i)); } } } systools_dialogs_open_file(val_string(title),val_string(msg),val_string(initialdir),filters.count? &filters : NULL ,val_bool(multi) ,&files); if (files.count) { result = alloc_array(files.count); while(files.count) { files.count--; val_array_set_i(result, files.count, alloc_string(files.strings[files.count])); free(files.strings[files.count]); } free(files.strings); } // clean up allocated mem. for filters: if (val_is_object(mask)) { free(filters.descriptions); free(filters.extensions); } return result; }
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; }
bool AbstractToJObject (value inValue, jobject &outObject) { JNIObject *jniobj = 0; if (AbstractToObject (inValue, jniobj)) { outObject = jniobj->GetJObject (); return true; } static int id__jobject = -1; if (id__jobject < 0) { id__jobject = val_id ("__jobject"); } value jobj = val_field (inValue, id__jobject); if (val_is_null (jobj)) { return false; } return AbstractToJObject (jobj, outObject); }
Val operator[](const Key& key) const { Val res; uint64_t id; if(!val_id(key, &res, &id)) return 0; return res; }
value hx_zmq_getint64sockopt(value socket_handle_,value option_) { val_check_kind(socket_handle_, k_zmq_socket_handle); if (!val_is_int(option_)) { val_throw(alloc_int(EINVAL)); return alloc_null(); } int rc = 0; int err = 0; uint64_t optval = 0; size_t optvallen = sizeof(optval); rc = zmq_getsockopt(val_data(socket_handle_),val_int(option_),&optval, &optvallen); err = zmq_errno(); if (rc != 0) { val_throw(alloc_int(err)); return alloc_int(0); } value ret = alloc_empty_object(); alloc_field(ret, val_id("hi"),alloc_int(optval >> 32)); alloc_field(ret, val_id("lo"),alloc_int(optval & 0xFFFFFFFF)); return ret; }
void RenderEvent::Dispatch (RenderEvent* event) { if (RenderEvent::callback) { if (RenderEvent::eventObject->IsCFFIValue ()) { if (!init) { id_type = val_id ("type"); } value object = (value)RenderEvent::eventObject->Get (); alloc_field (object, id_type, alloc_int (event->type)); } else { RenderEvent* eventObject = (RenderEvent*)RenderEvent::eventObject->Get (); eventObject->type = event->type; } RenderEvent::callback->Call (); } }
static value dialogs_save_file( value title, value msg, value initialdir, value mask) { char * v; struct ARG_FILEFILTERS filters = {0,0,0}; value result = val_null; val_check(title, string); val_check(msg, string); val_check(initialdir, string); if (val_is_object(mask)) { value count = val_field(mask,val_id("count")); value descriptions = val_field(mask,val_id("descriptions")); value extensions = val_field(mask,val_id("extensions")); val_check(count,int); val_check(descriptions,array); val_check(extensions,array); filters.count = val_int(count); if (filters.count) { long i = filters.count; filters.descriptions = (const char**) malloc(i*sizeof(char*)); filters.extensions = (const char**) malloc(i*sizeof(char*)); while(i) { i--; filters.descriptions[i] = val_string(val_array_i(descriptions,i)); filters.extensions[i] = val_string(val_array_i(extensions,i)); } } } result = val_null; v = systools_dialogs_save_file(val_string(title),val_string(msg),val_string(initialdir),filters.count? &filters : NULL); if (v) { result = alloc_string(v); free((void*)v); } // clean up allocated mem. for filters: if (val_is_object(mask)) { free(filters.descriptions); free(filters.extensions); } return result; }
EXTERN value neko_default_loader( char **argv, int argc ) { value o = alloc_object(NULL); value args = alloc_array(argc); int i; for(i=0;i<argc;i++) val_array_ptr(args)[i] = alloc_string(argv[i]); alloc_field(o,id_path,init_path(getenv("NEKOPATH"))); alloc_field(o,id_cache,alloc_object(NULL)); alloc_field(o,id_loader_libs,alloc_abstract(k_loader_libs,NULL)); alloc_field(o,val_id("args"),args); alloc_field(o,val_id("loadprim"),alloc_function(loader_loadprim,2,"loadprim")); alloc_field(o,val_id("loadmodule"),alloc_function(loader_loadmodule,2,"loadmodule")); #ifdef NEKO_PROF alloc_field(o,val_id("dump_prof"),alloc_function(dump_prof,0,"dump_prof")); #endif return o; }
value ImageBuffer::Value () { if (!init) { id_bitsPerPixel = val_id ("bitsPerPixel"); id_transparent = val_id ("transparent"); id_buffer = val_id ("buffer"); id_width = val_id ("width"); id_height = val_id ("height"); id_data = val_id ("data"); id_format = val_id ("format"); init = true; } mValue = alloc_empty_object (); alloc_field (mValue, id_width, alloc_int (width)); alloc_field (mValue, id_height, alloc_int (height)); alloc_field (mValue, id_bitsPerPixel, alloc_int (bitsPerPixel)); alloc_field (mValue, id_data, data ? data->Value () : alloc_null ()); alloc_field (mValue, id_transparent, alloc_bool (transparent)); alloc_field (mValue, id_format, alloc_int (format)); return mValue; }
// Display specific code static value display_get_screen_size() { #ifndef HX_LINUX dimensions dim; value w; value h; value o = alloc_empty_object(); systools_display_get_screen_size(&dim); w=alloc_int(dim.width); h=alloc_int(dim.height); alloc_field( o, val_id("w"), w ); alloc_field( o, val_id("h"), h ); return o; #else val_throw(alloc_string("function not available for this platform")); return val_null; #endif }
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; }
value AudioBuffer::Value (value audioBuffer) { if (!init) { id_bitsPerSample = val_id ("bitsPerSample"); id_channels = val_id ("channels"); id_data = val_id ("data"); id_sampleRate = val_id ("sampleRate"); init = true; } alloc_field (audioBuffer, id_bitsPerSample, alloc_int (bitsPerSample)); alloc_field (audioBuffer, id_channels, alloc_int (channels)); alloc_field (audioBuffer, id_data, data ? data->Value (val_field (audioBuffer, id_data)) : alloc_null ()); alloc_field (audioBuffer, id_sampleRate, alloc_int (sampleRate)); return audioBuffer; }
static int sni_callback( void *arg, mbedtls_ssl_context *ctx, const unsigned char *name, size_t len ){ if( name && arg ){ value ret = val_call1((value)arg, alloc_string((const char*)name)) ; if( !val_is_null(ret) ){ // TODO authmode and ca return mbedtls_ssl_set_hs_own_cert( ctx, val_cert(val_field(ret, val_id("cert"))), val_pkey(val_field(ret, val_id("key"))) ); } } return -1; }
//------------------------------------------------------------------------------------------------------------------- // wxMessageDialog implemetation, added to /haxe/lib/waxe/1.0.1/src/waxe/Dialog.cpp value wx_message_dialog_show(value ioData) { wxWindow *parent = 0; wxString message; wxString caption; int style; ValueToWX(val_field(ioData,val_id("parent")),parent); ValueToWX(val_field(ioData,val_id("message")),message); ValueToWX(val_field(ioData,val_id("caption")),caption); ValueToWX(val_field(ioData,val_id("style")),style); wxMessageDialog *dlg = new wxMessageDialog(parent,message, caption, style); int result = dlg->ShowModal(); dlg->Destroy(); return alloc_int(result); }
/** request : 'db -> sql:string -> 'result <doc>Executes the SQL request and returns its result</doc> **/ static value request( value v, value sql ) { database *db; result *r; const char *tl; int i,j; val_check_kind(v,k_db); val_check(sql,string); db = val_db(v); r = (result*)alloc(sizeof(result)); r->db = db; if( sqlite3_prepare(db->db,val_string(sql),val_strlen(sql),&r->r,&tl) != SQLITE_OK ) { buffer b = alloc_buffer("Sqlite error in "); val_buffer(b,sql); buffer_append(b," : "); buffer_append(b,sqlite3_errmsg(db->db)); val_throw(buffer_to_string(b)); } if( *tl ) { sqlite3_finalize(r->r); val_throw(alloc_string("Cannot execute several SQL requests at the same time")); } r->ncols = sqlite3_column_count(r->r); r->names = (field*)alloc_private(sizeof(field)*r->ncols); r->bools = (int*)alloc_private(sizeof(int)*r->ncols); r->first = 1; r->done = 0; for(i=0;i<r->ncols;i++) { field id = val_id(sqlite3_column_name(r->r,i)); const char *dtype = sqlite3_column_decltype(r->r,i); for(j=0;j<i;j++) if( r->names[j] == id ) { if( strcmp(sqlite3_column_name(r->r,i),sqlite3_column_name(r->r,j)) == 0 ) { buffer b = alloc_buffer("Error, same field is two times in the request "); val_buffer(b,sql); sqlite3_finalize(r->r); val_throw(buffer_to_string(b)); } else { buffer b = alloc_buffer("Error, same field ids for : "); buffer_append(b,sqlite3_column_name(r->r,i)); buffer_append(b," and "); buffer_append(b,sqlite3_column_name(r->r,j)); buffer_append_char(b,'.'); sqlite3_finalize(r->r); val_throw(buffer_to_string(b)); } } r->names[i] = id; r->bools[i] = dtype?(strcmp(dtype,"BOOL") == 0):0; } // changes in an update/delete if( db->last != NULL ) finalize_result(val_result(db->last),0); db->last = alloc_abstract(k_result,r); return db->last; }
void GamepadEvent::Dispatch (GamepadEvent* event) { if (GamepadEvent::callback) { if (GamepadEvent::eventObject->IsCFFIValue ()) { if (!init) { id_axis = val_id ("axis"); id_button = val_id ("button"); id_id = val_id ("id"); id_type = val_id ("type"); id_value = val_id ("axisValue"); init = true; } value object = (value)GamepadEvent::eventObject->Get (); alloc_field (object, id_axis, alloc_int (event->axis)); alloc_field (object, id_button, alloc_int (event->button)); alloc_field (object, id_id, alloc_int (event->id)); alloc_field (object, id_type, alloc_int (event->type)); alloc_field (object, id_value, alloc_float (event->axisValue)); } else { GamepadEvent* eventObject = (GamepadEvent*)GamepadEvent::eventObject->Get (); eventObject->axis = event->axis; eventObject->button = event->button; eventObject->id = event->id; eventObject->type = event->type; eventObject->axisValue = event->axisValue; } GamepadEvent::callback->Call (); } }
inline void initialize () { if (!init) { id_b = val_id ("b"); id_length = val_id ("length"); buffer b = alloc_buffer_len (1); if (buffer_data (b)) { useBuffer = true; } init = true; } }
static value alloc_result( connection *c, MYSQL_RES *r ) { result *res = (result*)alloc(sizeof(result)); value o = alloc_abstract(k_result,res); int num_fields = mysql_num_fields(r); int i,j; MYSQL_FIELD *fields = mysql_fetch_fields(r); res->r = r; res->conv_date = c->conv_date; res->conv_bytes = c->conv_bytes; res->conv_string = c->conv_string; res->current = NULL; res->nfields = num_fields; res->fields_ids = (field*)alloc_private(sizeof(field)*num_fields); res->fields_convs = (CONV*)alloc_private(sizeof(CONV)*num_fields); for(i=0;i<num_fields;i++) { field id; if( strchr(fields[i].name,'(') ) id = val_id("???"); // looks like an inner request : prevent hashing + cashing it else { id = val_id(fields[i].name); for(j=0;j<i;j++) if( res->fields_ids[j] == id ) { buffer b = alloc_buffer("Error, same field ids for : "); buffer_append(b,fields[i].name); buffer_append(b,":"); val_buffer(b,alloc_int(i)); buffer_append(b," and "); buffer_append(b,fields[j].name); buffer_append(b,":"); val_buffer(b,alloc_int(j)); buffer_append(b,"."); bfailure(b); } } res->fields_ids[i] = id; res->fields_convs[i] = convert_type(fields[i].type,fields[i].flags,fields[i].length); } val_gc(o,free_result); return o; }