void reg_luaredis(lua_State *L){ lua_newtable(L); REGISTER_FUNCTION("close",lua_redisClose); REGISTER_FUNCTION("redis_connect",lua_redis_connect); REGISTER_FUNCTION("redisCommandSync",lua_redisCommandSync); REGISTER_FUNCTION("redisCommandAsync",lua_redisCommandAsync); lua_setglobal(L,"CRedis"); }
void reg_group_c_function(lua_State *L){ lua_getglobal(L,"GroupApp"); if(!lua_istable(L, -1)) { lua_pop(L,1); lua_newtable(L); lua_pushvalue(L,-1); lua_setglobal(L,"GroupApp"); } REGISTER_FUNCTION("reg_cmd_handler",®_cmd_handler); REGISTER_FUNCTION("grouplog",&lua_grouplog); lua_pop(L,1); }
void registerLuaAPI() { lua_State* L = m_engine->getState(); #define REGISTER_FUNCTION(F, name) \ do { \ auto* f = &Lumix::LuaWrapper::wrapMethod<App, decltype(&App::F), &App::F>; \ Lumix::LuaWrapper::createSystemFunction(L, "App", name, f); \ } while(false) \ REGISTER_FUNCTION(loadUniverse, "loadUniverse"); REGISTER_FUNCTION(frame, "frame"); REGISTER_FUNCTION(exit, "exit"); #undef REGISTER_FUNCTION Lumix::LuaWrapper::createSystemVariable(L, "App", "instance", this); Lumix::LuaWrapper::createSystemVariable(L, "App", "universe", m_universe); auto& fs = m_engine->getFileSystem(); Lumix::FS::ReadCallback cb; cb.bind<App, &App::startupScriptLoaded>(this); fs.openAsync(fs.getDefaultDevice(), Lumix::Path(m_startup_script_path), Lumix::FS::Mode::OPEN_AND_READ, cb); }
void Model::registerLuaAPI(lua_State* L) { #define REGISTER_FUNCTION(F)\ do { \ auto f = &LuaWrapper::wrapMethod<Model, decltype(&Model::F), &Model::F>; \ LuaWrapper::createSystemFunction(L, "Model", #F, f); \ } while(false) \ REGISTER_FUNCTION(getBoneCount); #undef REGISTER_FUNCTION #define REGISTER_FUNCTION(F)\ do { \ auto f = &LuaWrapper::wrap<decltype(&F), &F>; \ LuaWrapper::createSystemFunction(L, "Model", #F, f); \ } while(false) \ REGISTER_FUNCTION(getBonePosition); REGISTER_FUNCTION(getBoneParent); #undef REGISTER_FUNCTION }
static double quantize_easy(double x, double a, double b) { return quantize_255(255.0*(x-a)/(b-a)); } struct predefined_function { void (*f)(void); char *name; int nargs; float value; } global_table_of_predefined_functions[] = { #define REGISTER_FUNCTION(x,n) {(void(*)(void))x, #x, n, 0} #define REGISTER_FUNCTIONN(x,xn,n) {(void(*)(void))x, xn, n, 0} REGISTER_FUNCTION(acos,1), REGISTER_FUNCTION(acosh,1), REGISTER_FUNCTION(asin,1), REGISTER_FUNCTION(asinh,1), REGISTER_FUNCTION(atan,1), REGISTER_FUNCTION(atanh,1), REGISTER_FUNCTION(cbrt,1), REGISTER_FUNCTION(ceil,1), REGISTER_FUNCTION(cos,1), REGISTER_FUNCTION(cosh,1), REGISTER_FUNCTION(erf,1), REGISTER_FUNCTION(erfc,1), REGISTER_FUNCTION(exp,1), REGISTER_FUNCTION(exp2,1), REGISTER_FUNCTION(expm1,1), REGISTER_FUNCTION(fabs,1),
TRI_associative_pointer_t* TRI_InitialiseFunctionsAql (void) { TRI_associative_pointer_t* functions; bool result = true; functions = (TRI_associative_pointer_t*) TRI_Allocate(TRI_UNKNOWN_MEM_ZONE, sizeof(TRI_associative_pointer_t), false); if (!functions) { return NULL; } TRI_InitAssociativePointer(functions, TRI_UNKNOWN_MEM_ZONE, TRI_HashStringKeyAssociativePointer, HashFunction, EqualName, NULL); // . = argument of any type (except collection) // c = collection name, will be converted into list with documents // h = collection name, will be converted into string // z = null // b = bool // n = number // s = string // p = primitive // l = list // a = array // type check functions REGISTER_FUNCTION("IS_NULL", "IS_NULL", true, false, "."); REGISTER_FUNCTION("IS_BOOL", "IS_BOOL", true, false, "."); REGISTER_FUNCTION("IS_NUMBER", "IS_NUMBER", true, false, "."); REGISTER_FUNCTION("IS_STRING", "IS_STRING", true, false, "."); REGISTER_FUNCTION("IS_LIST", "IS_LIST", true, false, "."); REGISTER_FUNCTION("IS_DOCUMENT", "IS_DOCUMENT", true, false, "."); // cast functions REGISTER_FUNCTION("TO_NUMBER", "CAST_NUMBER", true, false, "."); REGISTER_FUNCTION("TO_STRING", "CAST_STRING", true, false, "."); REGISTER_FUNCTION("TO_BOOL", "CAST_BOOL", true, false, "."); // string functions REGISTER_FUNCTION("CONCAT", "STRING_CONCAT", true, false, "sz,sz|+"); REGISTER_FUNCTION("CONCAT_SEPARATOR", "STRING_CONCAT_SEPARATOR", true, false, "s,sz,sz|+"); REGISTER_FUNCTION("CHAR_LENGTH", "STRING_LENGTH", true, false, "s"); REGISTER_FUNCTION("LOWER", "STRING_LOWER", true, false, "s"); REGISTER_FUNCTION("UPPER", "STRING_UPPER", true, false, "s"); REGISTER_FUNCTION("SUBSTRING", "STRING_SUBSTRING", true, false, "s,n|n"); REGISTER_FUNCTION("CONTAINS", "STRING_CONTAINS", true, false, "s,s"); // numeric functions REGISTER_FUNCTION("FLOOR", "NUMBER_FLOOR", true, false, "n"); REGISTER_FUNCTION("CEIL", "NUMBER_CEIL", true, false, "n"); REGISTER_FUNCTION("ROUND", "NUMBER_ROUND", true, false, "n"); REGISTER_FUNCTION("ABS", "NUMBER_ABS", true, false, "n"); REGISTER_FUNCTION("RAND", "NUMBER_RAND", false, false, ""); // list functions REGISTER_FUNCTION("UNION", "UNION", true, false, "l,l|+"); REGISTER_FUNCTION("LENGTH", "LENGTH", true, true, "l"); REGISTER_FUNCTION("MIN", "MIN", true, true, "l"); REGISTER_FUNCTION("MAX", "MAX", true, true, "l"); REGISTER_FUNCTION("SUM", "SUM", true, true, "l"); REGISTER_FUNCTION("UNIQUE", "UNIQUE", true, false, "l"); REGISTER_FUNCTION("REVERSE", "REVERSE", true, false, "l"); REGISTER_FUNCTION("FIRST", "FIRST", true, false, "l"); REGISTER_FUNCTION("LAST", "LAST", true, false, "l"); // document functions REGISTER_FUNCTION("HAS", "HAS", true, false, "az,s"); REGISTER_FUNCTION("MERGE", "MERGE", true, false, "a,a|+"); // geo functions REGISTER_FUNCTION("NEAR", "GEO_NEAR", false, false, "h,n,n,n|s"); REGISTER_FUNCTION("WITHIN", "GEO_WITHIN", false, false, "h,n,n,n|s"); // graph functions REGISTER_FUNCTION("PATHS", "GRAPH_PATHS", false, false, "c,h|s,b"); // misc functions REGISTER_FUNCTION("FAIL", "FAIL", false, false, "|s"); // FAIL is non-deterministic, otherwise query optimisation will fail! REGISTER_FUNCTION("PASSTHRU", "PASSTHRU", false, false, "."); // simple non-deterministic wrapper to avoid optimisations at parse time REGISTER_FUNCTION("COLLECTIONS", "COLLECTIONS", false, false, ""); REGISTER_FUNCTION("NOT_NULL", "NOT_NULL", true, false, ".,."); if (!result) { TRI_FreeFunctionsAql(functions); return NULL; } return functions; }
void reg_luasocket(lua_State *L){ lua_newtable(L); REGISTER_CONST(AF_INET); REGISTER_CONST(AF_INET6); REGISTER_CONST(AF_LOCAL); REGISTER_CONST(IPPROTO_TCP); REGISTER_CONST(IPPROTO_UDP); REGISTER_CONST(SOCK_STREAM); REGISTER_CONST(SOCK_DGRAM); REGISTER_FUNCTION("new1",luasocket_new1); REGISTER_FUNCTION("new2",luasocket_new2); REGISTER_FUNCTION("establish",luasocket_establish); REGISTER_FUNCTION("close",luasocket_close); REGISTER_FUNCTION("stream_send",luasocket_stream_send); REGISTER_FUNCTION("stream_syncsend",luasocket_stream_syncsend); REGISTER_FUNCTION("datagram_send",luasocket_datagram_send); REGISTER_FUNCTION("listen",luasocket_listen); REGISTER_FUNCTION("connect",luasocket_connect); REGISTER_FUNCTION("tostring",luasocket_tostring); REGISTER_FUNCTION("rawdecoder",lua_new_rawdecoder); REGISTER_FUNCTION("rpkdecoder",lua_new_rpkdecoder); REGISTER_FUNCTION("datagram_rawdecoder",lua_new_datagram_rawdecoder); REGISTER_FUNCTION("datagram_rpkdecoder",lua_new_datagram_rpkdecoder); lua_setglobal(L,"CSocket"); reg_luapacket(L); mainmailbox = kn_setup_mailbox(g_engine,on_mail); }
static void init_servo() { LOGI("initializing native application for Servo"); setenv("RUST_LOG", "servo,gfx,msg,util,layers,js,glut,std,rt,extra", 1); // setenv("SERVO_URL", "/mnt/sdcard/html/demo.html", 1); // setenv("RUST_THREADS", "1", 1); // char* size_stack = getenv("RUST_MIN_STACK"); // char* rust_log = getenv("RUST_LOG"); // char* servo_url = getenv("SERVO_URL"); // LOGI("Stack Size is : %s", size_stack); // LOGI("RUST_LOG flag is : %s", rust_log); // LOGI("loading url is : %s", servo_url); LOGI("load servo library"); void* libservo = android_dlopen("/data/data/com.example.ServoAndroid/lib/libservo.so"); if (libservo == NULL) { LOGW("failed to load servo lib: %s", dlerror()); return; } REGISTER_FUNCTION(libservo, glutMainLoopEvent); REGISTER_FUNCTION(libservo, glutInit); REGISTER_FUNCTION(libservo, glutInitDisplayMode); REGISTER_FUNCTION(libservo, glutCreateWindow); REGISTER_FUNCTION(libservo, glutDestroyWindow); REGISTER_FUNCTION(libservo, glutPostRedisplay); REGISTER_FUNCTION(libservo, glutSwapBuffers); REGISTER_FUNCTION(libservo, glutGetWindow); REGISTER_FUNCTION(libservo, glutSetWindow); REGISTER_FUNCTION(libservo, glutReshapeWindow); REGISTER_FUNCTION(libservo, glutDisplayFunc); REGISTER_FUNCTION(libservo, glutReshapeFunc); REGISTER_FUNCTION(libservo, glutTimerFunc); REGISTER_FUNCTION(libservo, glutGet); REGISTER_FUNCTION(libservo, glutKeyboardFunc); REGISTER_FUNCTION(libservo, glutMouseFunc); REGISTER_FUNCTION(libservo, glutMouseWheelFunc); REGISTER_FUNCTION(libservo, glutSetWindowTitle); REGISTER_FUNCTION(libservo, glutIdleFunc); REGISTER_FUNCTION(libservo, glutInitWindowSize); REGISTER_FUNCTION(libservo, glutGetModifiers); void (*main)(int, char**); *(void**)(&main) = dlsym(libservo, "android_start"); if (main) { LOGI("go into android_start()"); static char* argv[] = {"servo", "/mnt/sdcard/html/about-mozilla.html"}; (*main)(2, argv); return; } LOGW("could not find android_start() in the libServo shared library"); }
void init() { ZCodeExecuter::registerIdentifier("console", new ZSharedVariant(new ZConsole)); ZCodeExecuter::registerIdentifier("sys", new ZSharedVariant(new ZSystem)); ZCodeExecuter::registerIdentifier("int", new ZSharedVariant(new ZInt)); ZCodeExecuter::registerIdentifier("double", new ZSharedVariant(new ZDouble)); ZCodeExecuter::registerIdentifier("bool", new ZSharedVariant(new ZBool)); ZCodeExecuter::registerIdentifier("string", new ZSharedVariant(new ZString)); REGISTER_FUNCTION(ZVariant::String, String::toInt); REGISTER_FUNCTION(ZVariant::String, String::append); REGISTER_FUNCTION(ZVariant::String, String::at); REGISTER_FUNCTION(ZVariant::String, String::contains); REGISTER_FUNCTION(ZVariant::String, String::count); REGISTER_FUNCTION(ZVariant::String, String::endsWith); REGISTER_FUNCTION(ZVariant::String, String::indexOf); REGISTER_FUNCTION(ZVariant::String, String::insert); REGISTER_FUNCTION(ZVariant::String, String::isEmpty); REGISTER_FUNCTION(ZVariant::String, String::isNull); REGISTER_FUNCTION(ZVariant::String, String::lastIndexOf); REGISTER_FUNCTION(ZVariant::String, String::left); REGISTER_FUNCTION(ZVariant::String, String::length); REGISTER_FUNCTION(ZVariant::String, String::mid); REGISTER_FUNCTION(ZVariant::String, String::prepend); REGISTER_FUNCTION(ZVariant::String, String::remove); REGISTER_FUNCTION(ZVariant::String, String::replace); REGISTER_FUNCTION(ZVariant::String, String::right); REGISTER_FUNCTION(ZVariant::String, String::split); REGISTER_FUNCTION(ZVariant::String, String::startsWith); REGISTER_FUNCTION(ZVariant::List, List::append); REGISTER_FUNCTION(ZVariant::List, List::at); REGISTER_FUNCTION(ZVariant::List, List::contains); REGISTER_FUNCTION(ZVariant::List, List::count); REGISTER_FUNCTION(ZVariant::List, List::indexOf); REGISTER_FUNCTION(ZVariant::List, List::insert); REGISTER_FUNCTION(ZVariant::List, List::isEmpty); REGISTER_FUNCTION(ZVariant::List, List::lastIndexOf); REGISTER_FUNCTION(ZVariant::List, List::length); REGISTER_FUNCTION(ZVariant::List, List::mid); REGISTER_FUNCTION(ZVariant::List, List::prepend); REGISTER_FUNCTION(ZVariant::List, List::removeAll); REGISTER_FUNCTION(ZVariant::List, List::removeAt); REGISTER_FUNCTION(ZVariant::List, List::removeOne); REGISTER_FUNCTION(ZVariant::List, List::replace); REGISTER_FUNCTION(ZVariant::List, List::join); REGISTER_FUNCTION(ZVariant::List, List::clear); REGISTER_FUNCTION(ZVariant::List, List::last); REGISTER_FUNCTION(ZVariant::List, List::first); }
TRI_associative_pointer_t* TRI_CreateFunctionsAql (void) { TRI_associative_pointer_t* functions; bool result; int res; functions = (TRI_associative_pointer_t*) TRI_Allocate(TRI_UNKNOWN_MEM_ZONE, sizeof(TRI_associative_pointer_t), false); if (functions == NULL) { return NULL; } res = TRI_InitAssociativePointer(functions, TRI_UNKNOWN_MEM_ZONE, TRI_HashStringKeyAssociativePointer, HashFunction, EqualName, NULL); if (res != TRI_ERROR_NO_ERROR) { TRI_Free(TRI_UNKNOWN_MEM_ZONE, functions); return NULL; } // . = argument of any type (except collection) // c = collection name, will be converted into list with documents // h = collection name, will be converted into string // z = null // b = bool // n = number // s = string // p = primitive // l = list // a = (hash) array/document // r = regex (a string with a special format). note: the regex type is mutually exclusive with all other types result = true; // type check functions REGISTER_FUNCTION("IS_NULL", "IS_NULL", true, false, ".", NULL); REGISTER_FUNCTION("IS_BOOL", "IS_BOOL", true, false, ".", NULL); REGISTER_FUNCTION("IS_NUMBER", "IS_NUMBER", true, false, ".", NULL); REGISTER_FUNCTION("IS_STRING", "IS_STRING", true, false, ".", NULL); REGISTER_FUNCTION("IS_LIST", "IS_LIST", true, false, ".", NULL); REGISTER_FUNCTION("IS_DOCUMENT", "IS_DOCUMENT", true, false, ".", NULL); // cast functions REGISTER_FUNCTION("TO_NUMBER", "CAST_NUMBER", true, false, ".", NULL); REGISTER_FUNCTION("TO_STRING", "CAST_STRING", true, false, ".", NULL); REGISTER_FUNCTION("TO_BOOL", "CAST_BOOL", true, false, ".", NULL); REGISTER_FUNCTION("TO_LIST", "CAST_LIST", true, false, ".", NULL); // string functions REGISTER_FUNCTION("CONCAT", "STRING_CONCAT", true, false, "sz,sz|+", NULL); REGISTER_FUNCTION("CONCAT_SEPARATOR", "STRING_CONCAT_SEPARATOR", true, false, "s,sz,sz|+", NULL); REGISTER_FUNCTION("CHAR_LENGTH", "CHAR_LENGTH", true, false, "s", NULL); REGISTER_FUNCTION("LOWER", "STRING_LOWER", true, false, "s", NULL); REGISTER_FUNCTION("UPPER", "STRING_UPPER", true, false, "s", NULL); REGISTER_FUNCTION("SUBSTRING", "STRING_SUBSTRING", true, false, "s,n|n", NULL); REGISTER_FUNCTION("CONTAINS", "STRING_CONTAINS", true, false, "s,s|b", NULL); REGISTER_FUNCTION("LIKE", "STRING_LIKE", true, false, "s,r|b", NULL); REGISTER_FUNCTION("LEFT", "STRING_LEFT", true, false, "s,n", NULL); REGISTER_FUNCTION("RIGHT", "STRING_RIGHT", true, false, "s,n", NULL); REGISTER_FUNCTION("TRIM", "STRING_TRIM", true, false, "s|n", NULL); // numeric functions REGISTER_FUNCTION("FLOOR", "NUMBER_FLOOR", true, false, "n", NULL); REGISTER_FUNCTION("CEIL", "NUMBER_CEIL", true, false, "n", NULL); REGISTER_FUNCTION("ROUND", "NUMBER_ROUND", true, false, "n", NULL); REGISTER_FUNCTION("ABS", "NUMBER_ABS", true, false, "n", NULL); REGISTER_FUNCTION("RAND", "NUMBER_RAND", false, false, "", NULL); REGISTER_FUNCTION("SQRT", "NUMBER_SQRT", true, false, "n", NULL); // list functions REGISTER_FUNCTION("RANGE", "RANGE", true, false, "n,n|n", NULL); REGISTER_FUNCTION("UNION", "UNION", true, false, "l,l|+", NULL); REGISTER_FUNCTION("UNION_DISTINCT", "UNION_DISTINCT", true, false, "l,l|+", NULL); REGISTER_FUNCTION("MINUS", "MINUS", true, false, "l,l|+", NULL); REGISTER_FUNCTION("INTERSECTION", "INTERSECTION", true, false, "l,l|+", NULL); REGISTER_FUNCTION("LENGTH", "LENGTH", true, true, "las", NULL); REGISTER_FUNCTION("MIN", "MIN", true, true, "l", NULL); REGISTER_FUNCTION("MAX", "MAX", true, true, "l", NULL); REGISTER_FUNCTION("SUM", "SUM", true, true, "l", NULL); REGISTER_FUNCTION("MEDIAN", "MEDIAN", true, true, "l", NULL); REGISTER_FUNCTION("AVERAGE", "AVERAGE", true, true, "l", NULL); REGISTER_FUNCTION("VARIANCE_SAMPLE", "VARIANCE_SAMPLE", true, true, "l", NULL); REGISTER_FUNCTION("VARIANCE_POPULATION", "VARIANCE_POPULATION", true, true, "l", NULL); REGISTER_FUNCTION("STDDEV_SAMPLE", "STDDEV_SAMPLE", true, true, "l", NULL); REGISTER_FUNCTION("STDDEV_POPULATION", "STDDEV_POPULATION", true, true, "l", NULL); REGISTER_FUNCTION("UNIQUE", "UNIQUE", true, false, "l", NULL); // note: REVERSE() can be applied on strings, too REGISTER_FUNCTION("REVERSE", "REVERSE", true, false, "ls", NULL); REGISTER_FUNCTION("FIRST", "FIRST", true, false, "l", NULL); REGISTER_FUNCTION("LAST", "LAST", true, false, "l", NULL); // document functions REGISTER_FUNCTION("HAS", "HAS", true, false, "az,s", NULL); REGISTER_FUNCTION("ATTRIBUTES", "ATTRIBUTES", true, false, "a|b,b", NULL); REGISTER_FUNCTION("MERGE", "MERGE", true, false, "a,a|+", NULL); REGISTER_FUNCTION("MERGE_RECURSIVE", "MERGE_RECURSIVE", true, false, "a,a|+", NULL); REGISTER_FUNCTION("DOCUMENT", "DOCUMENT", false, false, "h.|.", NULL); REGISTER_FUNCTION("MATCHES", "MATCHES", true, false, ".,l|b", NULL); REGISTER_FUNCTION("UNSET", "UNSET", true, false, "a,sl|+", NULL); REGISTER_FUNCTION("KEEP", "KEEP", true, false, "a,sl|+", NULL); // geo functions REGISTER_FUNCTION("NEAR", "GEO_NEAR", false, false, "h,n,n|nz,s", NULL); REGISTER_FUNCTION("WITHIN", "GEO_WITHIN", false, false, "h,n,n,n|s", NULL); // fulltext functions REGISTER_FUNCTION("FULLTEXT", "FULLTEXT", false, false, "h,s,s", NULL); // graph functions REGISTER_FUNCTION("PATHS", "GRAPH_PATHS", false, false, "c,h|s,b", &OptimisePaths); REGISTER_FUNCTION("TRAVERSAL", "GRAPH_TRAVERSAL", false, false, "h,h,s,s,a", NULL); REGISTER_FUNCTION("TRAVERSAL_TREE", "GRAPH_TRAVERSAL_TREE", false, false, "h,h,s,s,s,a", NULL); REGISTER_FUNCTION("EDGES", "GRAPH_EDGES", false, false, "h,s,s|l", NULL); REGISTER_FUNCTION("NEIGHBORS", "GRAPH_NEIGHBORS", false, false, "h,h,s,s|l", NULL); // misc functions REGISTER_FUNCTION("FAIL", "FAIL", false, false, "|s", NULL); // FAIL is non-deterministic, otherwise query optimisation will fail! REGISTER_FUNCTION("PASSTHRU", "PASSTHRU", false, false, ".", NULL); // simple non-deterministic wrapper to avoid optimisations at parse time REGISTER_FUNCTION("SLEEP", "SLEEP", false, false, "n", NULL); // sleep function REGISTER_FUNCTION("COLLECTIONS", "COLLECTIONS", false, false, "", NULL); REGISTER_FUNCTION("NOT_NULL", "NOT_NULL", true, false, ".|+", NULL); REGISTER_FUNCTION("FIRST_LIST", "FIRST_LIST", true, false, ".|+", NULL); REGISTER_FUNCTION("FIRST_DOCUMENT", "FIRST_DOCUMENT", true, false, ".|+", NULL); REGISTER_FUNCTION("PARSE_IDENTIFIER", "PARSE_IDENTIFIER", true, false, ".", NULL); if (! result) { TRI_FreeFunctionsAql(functions); return NULL; } return functions; }