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;
}
