bool CLuaHandleSynced::SetupUnsynced(const string& code, const string& filename) { if ((L == NULL) || code.empty()) { return false; } // make the UNSYNCED table unsyncedStr.Push(L); lua_newtable(L); lua_rawset(L, LUA_REGISTRYINDEX); unsyncedStr.GetRegistry(L); AddBasicCalls(); // into UNSYNCED // remove Script.Kill() lua_pushstring(L, "Script"); lua_rawget(L, -2); lua_pushstring(L, "Kill"); lua_pushnil(L); lua_rawset(L, -3); LuaPushNamedCFunc(L, "UpdateCallIn", CallOutUnsyncedUpdateCallIn); lua_pop(L, 1); lua_pushstring(L, "_G"); unsyncedStr.GetRegistry(L); lua_rawset(L, -3); LuaPushNamedCFunc(L, "loadstring", LoadStringData); LuaPushNamedCFunc(L, "CallAsTeam", CallAsTeam); // load our libraries if (!LuaSyncedTable::PushEntries(L) || !AddEntriesToTable(L, "VFS", LuaVFS::PushUnsynced) || !AddEntriesToTable(L, "UnitDefs", LuaUnitDefs::PushEntries) || !AddEntriesToTable(L, "WeaponDefs", LuaWeaponDefs::PushEntries) || !AddEntriesToTable(L, "FeatureDefs", LuaFeatureDefs::PushEntries) || !AddEntriesToTable(L, "Script", LuaUnsyncedCall::PushEntries) || !AddEntriesToTable(L, "Script", LuaScream::PushEntries) || !AddEntriesToTable(L, "Spring", LuaSyncedRead::PushEntries) || !AddEntriesToTable(L, "Spring", LuaUnsyncedCtrl::PushEntries) || !AddEntriesToTable(L, "Spring", LuaUnsyncedRead::PushEntries) || !AddEntriesToTable(L, "gl", LuaOpenGL::PushEntries) || !AddEntriesToTable(L, "GL", LuaConstGL::PushEntries) || !AddEntriesToTable(L, "Game", LuaConstGame::PushEntries) || !AddEntriesToTable(L, "CMD", LuaConstCMD::PushEntries) || !AddEntriesToTable(L, "CMDTYPE", LuaConstCMDTYPE::PushEntries)) { KillLua(); return false; } lua_pushstring(L, "math"); lua_newtable(L); lua_getglobal(L, "math"); LightCopyTable(-2, -1); lua_pop(L, 1); lua_rawset(L, -3); lua_pushstring(L, "table"); lua_newtable(L); lua_getglobal(L, "table"); LightCopyTable(-2, -1); lua_pop(L, 1); lua_rawset(L, -3); lua_pushstring(L, "string"); lua_newtable(L); lua_getglobal(L, "string"); LightCopyTable(-2, -1); lua_pop(L, 1); lua_rawset(L, -3); if (!CopyRealRandomFuncs()) { KillLua(); return false; } lua_settop(L, 0); // note the absence of loadstring() -- global access const char* labels[] = { "assert", "error", "print", "next", "pairs", "ipairs", "tonumber", "tostring", "type", "collectgarbage", "gcinfo", "unpack", "getmetatable", "setmetatable", "rawequal", "rawget", "rawset", "getfenv", "setfenv", "pcall", "xpcall", "_VERSION", NULL }; for (const char** l = labels; *l != NULL; l++) { CopyGlobalToUnsynced(*l); } // add code from the sub-class unsyncedStr.GetRegistry(L); if (!AddUnsyncedCode()) { KillLua(); return false; } lua_settop(L, 0); if (!LoadUnsyncedCode(code, filename)) { KillLua(); return false; } if (!SetupUnsyncedFunction("RecvFromSynced") || !SetupUnsyncedFunction("Update") || !SetupUnsyncedFunction("DrawGenesis") || !SetupUnsyncedFunction("DrawWorld") || !SetupUnsyncedFunction("DrawWorldPreUnit") || !SetupUnsyncedFunction("DrawWorldShadow") || !SetupUnsyncedFunction("DrawWorldReflection") || !SetupUnsyncedFunction("DrawWorldRefraction") || !SetupUnsyncedFunction("DrawScreenEffects") || !SetupUnsyncedFunction("DrawScreen") || !SetupUnsyncedFunction("DrawInMiniMap")) { return false; } return true; }
/* * Push a proxy userdata on the stack. * returns NULL if ok, else some error string related to bad idfunc behavior or module require problem * (error cannot happen with mode_ == eLM_ToKeeper) * * Initializes necessary structures if it's the first time 'idfunc' is being * used in this Lua state (metatable, registring it). Otherwise, increments the * reference count. */ char const* push_deep_proxy( struct s_Universe* U, lua_State* L, DEEP_PRELUDE* prelude, enum eLookupMode mode_) { DEEP_PRELUDE** proxy; // Check if a proxy already exists push_registry_subtable_mode( L, DEEP_PROXY_CACHE_KEY, "v"); // DPC lua_pushlightuserdata( L, prelude->deep); // DPC deep lua_rawget( L, -2); // DPC proxy if ( !lua_isnil( L, -1)) { lua_remove( L, -2); // proxy return NULL; } else { lua_pop( L, 1); // DPC } MUTEX_LOCK( &U->deep_lock); ++ (prelude->refcount); // one more proxy pointing to this deep data MUTEX_UNLOCK( &U->deep_lock); STACK_GROW( L, 7); STACK_CHECK( L); proxy = lua_newuserdata( L, sizeof( DEEP_PRELUDE*)); // DPC proxy ASSERT_L( proxy); *proxy = prelude; // Get/create metatable for 'idfunc' (in this state) lua_pushlightuserdata( L, prelude->idfunc); // DPC proxy idfunc get_deep_lookup( L); // DPC proxy metatable? if( lua_isnil( L, -1)) // // No metatable yet. { char const* modname; int oldtop = lua_gettop( L); // DPC proxy nil lua_pop( L, 1); // DPC proxy // 1 - make one and register it if( mode_ != eLM_ToKeeper) { prelude->idfunc( L, eDO_metatable); // DPC proxy metatable deepversion if( lua_gettop( L) - oldtop != 1 || !lua_istable( L, -2) || !lua_isstring( L, -1)) { lua_settop( L, oldtop); // DPC proxy X lua_pop( L, 3); // return "Bad idfunc(eOP_metatable): unexpected pushed value"; } luaG_pushdeepversion( L); // DPC proxy metatable deepversion deepversion if( !lua501_equal( L, -1, -2)) { lua_pop( L, 5); // return "Bad idfunc(eOP_metatable): mismatched deep version"; } lua_pop( L, 2); // DPC proxy metatable // make sure the idfunc didn't export __gc, as we will store our own lua_getfield( L, -1, "__gc"); // DPC proxy metatable __gc if( !lua_isnil( L, -1)) { lua_pop( L, 4); // return "idfunc-created metatable shouldn't contain __gc"; } lua_pop( L, 1); // DPC proxy metatable } else { // keepers need a minimal metatable that only contains __gc lua_newtable( L); // DPC proxy metatable } // Add our own '__gc' method lua_pushcfunction( L, deep_userdata_gc); // DPC proxy metatable __gc lua_setfield( L, -2, "__gc"); // DPC proxy metatable // Memorize for later rounds lua_pushvalue( L, -1); // DPC proxy metatable metatable lua_pushlightuserdata( L, prelude->idfunc); // DPC proxy metatable metatable idfunc set_deep_lookup( L); // DPC proxy metatable // 2 - cause the target state to require the module that exported the idfunc // this is needed because we must make sure the shared library is still loaded as long as we hold a pointer on the idfunc { int oldtop = lua_gettop( L); modname = (char const*) prelude->idfunc( L, eDO_module); // DPC proxy metatable // make sure the function pushed nothing on the stack! if( lua_gettop( L) - oldtop != 0) { lua_pop( L, 3); // return "Bad idfunc(eOP_module): should not push anything"; } } if( modname) // we actually got a module name { // somehow, L.registry._LOADED can exist without having registered the 'package' library. lua_getglobal( L, "require"); // DPC proxy metatable require() // check that the module is already loaded (or being loaded, we are happy either way) if( lua_isfunction( L, -1)) { lua_pushstring( L, modname); // DPC proxy metatable require() "module" lua_getfield( L, LUA_REGISTRYINDEX, "_LOADED"); // DPC proxy metatable require() "module" _R._LOADED if( lua_istable( L, -1)) { bool_t alreadyloaded; lua_pushvalue( L, -2); // DPC proxy metatable require() "module" _R._LOADED "module" lua_rawget( L, -2); // DPC proxy metatable require() "module" _R._LOADED module alreadyloaded = lua_toboolean( L, -1); if( !alreadyloaded) // not loaded { int require_result; lua_pop( L, 2); // DPC proxy metatable require() "module" // require "modname" require_result = lua_pcall( L, 1, 0, 0); // DPC proxy metatable error? if( require_result != LUA_OK) { // failed, return the error message lua_pushfstring( L, "error while requiring '%s' identified by idfunc(eOP_module): ", modname); lua_insert( L, -2); // DPC proxy metatable prefix error lua_concat( L, 2); // DPC proxy metatable error return lua_tostring( L, -1); } } else // already loaded, we are happy { lua_pop( L, 4); // DPC proxy metatable } } else // no L.registry._LOADED; can this ever happen? { lua_pop( L, 6); // return "unexpected error while requiring a module identified by idfunc(eOP_module)"; } } else // a module name, but no require() function :-( { lua_pop( L, 4); // return "lanes receiving deep userdata should register the 'package' library"; } } } STACK_MID( L, 2); // DPC proxy metatable ASSERT_L( lua_isuserdata( L, -2)); ASSERT_L( lua_istable( L, -1)); lua_setmetatable( L, -2); // DPC proxy // If we're here, we obviously had to create a new proxy, so cache it. lua_pushlightuserdata( L, (*proxy)->deep); // DPC proxy deep lua_pushvalue( L, -2); // DPC proxy deep proxy lua_rawset( L, -4); // DPC proxy lua_remove( L, -2); // proxy ASSERT_L( lua_isuserdata( L, -1)); STACK_END( L, 0); return NULL; }
/** * Look up a name in the given module. This works for functions, like * gtk.window_new(), constants, like gtk.WINDOW_TOPLEVEL, and global variables. * Lua Stack: [1]=gnome [2]=name * * @name __index * @luaparam mod The module to look in (a table) * @luaparam key The name of the item to look up * @luareturn Either a userdata (for ENUMs) or a closure (for * functions) */ static int lg_generic_index(lua_State *L) { size_t name_len, prefix_len = 0; const char *name = luaL_checklstring(L, 2, &name_len); struct func_info fi = { 0 }; char symname[70]; cmi mi; // Get the module. No checks here because this function is called // by Lua and should always have the correct arguments. lua_getfield(L, 1, "_modinfo"); mi = lua_touserdata(L, -1); lua_pop(L, 1); // check arguments if (!name || !*name) return luaL_error(L, "%s attempt to look up a NULL or empty string", msgprefix); prefix_len = strlen(mi->prefix_func); prefix_len = MAX(prefix_len, strlen(mi->prefix_constant)); if (name_len + prefix_len > sizeof(symname) - 10) return luaL_error(L, "%s key is too long, max is %d", msgprefix, sizeof(symname) - 10); /* if it starts with an uppercase letter, it's probably an ENUM. */ if (name[0] >= 'A' && name[0] <= 'Z') { int val; const char *prefix = mi->prefix_constant; typespec_t ts = { 0 }; ts.module_idx = mi->module_idx; for (;;) { sprintf(symname, "%s%s", prefix ? prefix : "", name); // strcpy(symname, prefix); // strcat(symname, name); switch (lg_find_constant(L, &ts, symname, -1, &val)) { case 1: // ENUM/FLAG found return lg_push_constant(L, ts, val); case 2: // integer found lua_pushinteger(L, val); /* fall through */ case 3: // string found - is on Lua stack return 1; } if (!prefix) break; prefix = NULL; } } // If it starts with "__", then remove that and don't look for // overrides. This is something that overrides written in Lua can use, // to avoid recursively calling itself instead of the Gtk function. if (name[0] == '_' && name[1] == '_') { strcpy(symname, name + 2); if (!lg_find_func(L, mi, symname, &fi)) return luaL_error(L, "%s not found: %s.%s", msgprefix, mi->name, name); goto found_func; } // Check for an override (with the function prefix). strcpy(symname, mi->prefix_func); strcat(symname, name); lua_pushstring(L, symname); lua_rawget(L, 1); if (!lua_isnil(L, -1)) { lua_pushstring(L, name); lua_pushvalue(L, -2); lua_rawset(L, 1); return 1; } lua_pop(L, 1); // Otherwise, simply look it up if (lg_find_func(L, mi, symname, &fi)) goto found_func; // maybe it's a function but with the prefix already added. if (*mi->prefix_func && lg_find_func(L, mi, name, &fi)) goto found_func; // Might be a global variable. This is not so common, therefore // it is not checked for earlier. if (lg_find_global(L, mi, symname)) return 1; // "name" might not need the prefix. if (lg_find_global(L, mi, name)) return 1; // Maybe it's Windows and a function with _utf8 suffix? While there // are a few with the gtk_ prefix and _utf8 suffix, most have the // g_ or gdk_ prefix, so don't automatically add this prefix. #ifdef LUAGNOME_win32 strcat(symname, "_utf8"); // sprintf(symname, "%s%s_utf8", prefix_func, name); if (lg_find_func(L, mi, symname, &fi)) goto found_func; #endif // Not found. return luaL_error(L, "%s not found: %s.%s", msgprefix, mi->name, name); found_func:; lg_push_closure(L, &fi, 2); // cache the result of this lookup, using the key given by the user, // and not necessarily the name of the function that was found. lua_pushvalue(L, 2); // key lua_pushvalue(L, -2); // the new closure lua_rawset(L, 1); // [1]=table return 1; }
static int aux_getfenv (lua_State *L) { lua_getfenv(L, -1); lua_pushliteral(L, "__fenv"); lua_rawget(L, -2); return !lua_isnil(L, -1); }
static int ngx_http_lua_coroutine_resume(lua_State *L) { lua_State *co; ngx_http_request_t *r; ngx_http_lua_ctx_t *ctx; ngx_http_lua_co_ctx_t *coctx; ngx_http_lua_co_ctx_t *p_coctx; /* parent co ctx */ co = lua_tothread(L, 1); luaL_argcheck(L, co, 1, "coroutine expected"); lua_pushlightuserdata(L, &ngx_http_lua_request_key); lua_rawget(L, LUA_GLOBALSINDEX); r = lua_touserdata(L, -1); lua_pop(L, 1); if (r == NULL) { return luaL_error(L, "no request found"); } ctx = ngx_http_get_module_ctx(r, ngx_http_lua_module); if (ctx == NULL) { return luaL_error(L, "no request ctx found"); } ngx_http_lua_check_context(L, ctx, NGX_HTTP_LUA_CONTEXT_REWRITE | NGX_HTTP_LUA_CONTEXT_ACCESS | NGX_HTTP_LUA_CONTEXT_CONTENT); p_coctx = ctx->cur_co_ctx; if (p_coctx == NULL) { return luaL_error(L, "no parent co ctx found"); } coctx = ngx_http_lua_get_co_ctx(co, ctx); if (coctx == NULL) { return luaL_error(L, "no co ctx found"); } ngx_http_lua_probe_user_coroutine_resume(r, L, co); if (coctx->co_status != NGX_HTTP_LUA_CO_SUSPENDED) { dd("coroutine resume: %d", coctx->co_status); lua_pushboolean(L, 0); lua_pushfstring(L, "cannot resume %s coroutine", ngx_http_lua_co_status_names[coctx->co_status]); return 2; } p_coctx->co_status = NGX_HTTP_LUA_CO_NORMAL; coctx->parent_co_ctx = p_coctx; dd("set coroutine to running"); coctx->co_status = NGX_HTTP_LUA_CO_RUNNING; ctx->co_op = NGX_HTTP_LUA_USER_CORO_RESUME; ctx->cur_co_ctx = coctx; /* yield and pass args to main thread, and resume target coroutine from * there */ return lua_yield(L, lua_gettop(L) - 1); }
static int ngx_stream_lua_socket_udp_setpeername(lua_State *L) { ngx_stream_session_t *s; ngx_stream_lua_ctx_t *ctx; ngx_str_t host; int port; ngx_resolver_ctx_t *rctx, temp; int saved_top; int n; u_char *p; size_t len; ngx_url_t url; ngx_int_t rc; ngx_stream_lua_srv_conf_t *lscf; ngx_udp_connection_t *uc; int timeout; ngx_stream_lua_co_ctx_t *coctx; ngx_stream_lua_socket_udp_upstream_t *u; /* * TODO: we should probably accept an extra argument to setpeername() * to allow the user bind the datagram unix domain socket himself, * which is necessary for systems without autobind support. */ n = lua_gettop(L); if (n != 2 && n != 3) { return luaL_error(L, "ngx.socket.udp setpeername: expecting 2 or 3 " "arguments (including the object), but seen %d", n); } s = ngx_stream_lua_get_session(L); if (s == NULL) { return luaL_error(L, "no session found"); } ctx = ngx_stream_get_module_ctx(s, ngx_stream_lua_module); if (ctx == NULL) { return luaL_error(L, "no ctx found"); } ngx_stream_lua_check_context(L, ctx, NGX_STREAM_LUA_CONTEXT_CONTENT | NGX_STREAM_LUA_CONTEXT_TIMER); luaL_checktype(L, 1, LUA_TTABLE); p = (u_char *) luaL_checklstring(L, 2, &len); host.data = ngx_palloc(s->connection->pool, len + 1); if (host.data == NULL) { return luaL_error(L, "no memory"); } host.len = len; ngx_memcpy(host.data, p, len); host.data[len] = '\0'; if (n == 3) { port = luaL_checkinteger(L, 3); if (port < 0 || port > 65536) { lua_pushnil(L); lua_pushfstring(L, "bad port number: %d", port); return 2; } } else { /* n == 2 */ port = 0; } lua_rawgeti(L, 1, SOCKET_CTX_INDEX); u = lua_touserdata(L, -1); lua_pop(L, 1); if (u) { if (u->session && u->session != s) { return luaL_error(L, "bad session"); } if (u->waiting) { lua_pushnil(L); lua_pushliteral(L, "socket busy"); return 2; } if (u->udp_connection.connection) { ngx_log_debug0(NGX_LOG_DEBUG_STREAM, s->connection->log, 0, "stream lua udp socket reconnect without " "shutting down"); ngx_stream_lua_socket_udp_finalize(s, u); } ngx_log_debug0(NGX_LOG_DEBUG_STREAM, s->connection->log, 0, "stream lua reuse socket upstream ctx"); } else { u = lua_newuserdata(L, sizeof(ngx_stream_lua_socket_udp_upstream_t)); if (u == NULL) { return luaL_error(L, "no memory"); } #if 1 lua_pushlightuserdata(L, &ngx_stream_lua_udp_udata_metatable_key); lua_rawget(L, LUA_REGISTRYINDEX); lua_setmetatable(L, -2); #endif lua_rawseti(L, 1, SOCKET_CTX_INDEX); } ngx_memzero(u, sizeof(ngx_stream_lua_socket_udp_upstream_t)); u->session = s; /* set the controlling session */ lscf = ngx_stream_get_module_srv_conf(s, ngx_stream_lua_module); u->conf = lscf; uc = &u->udp_connection; uc->log = *s->connection->log; dd("lua peer connection log: %p", &uc->log); lua_rawgeti(L, 1, SOCKET_TIMEOUT_INDEX); timeout = (ngx_int_t) lua_tointeger(L, -1); lua_pop(L, 1); if (timeout > 0) { u->read_timeout = (ngx_msec_t) timeout; } else { u->read_timeout = u->conf->read_timeout; } ngx_memzero(&url, sizeof(ngx_url_t)); url.url.len = host.len; url.url.data = host.data; url.default_port = (in_port_t) port; url.no_resolve = 1; if (ngx_parse_url(s->connection->pool, &url) != NGX_OK) { lua_pushnil(L); if (url.err) { lua_pushfstring(L, "failed to parse host name \"%s\": %s", host.data, url.err); } else { lua_pushfstring(L, "failed to parse host name \"%s\"", host.data); } return 2; } u->resolved = ngx_pcalloc(s->connection->pool, sizeof(ngx_stream_lua_resolved_t)); if (u->resolved == NULL) { return luaL_error(L, "no memory"); } if (url.addrs && url.addrs[0].sockaddr) { ngx_log_debug0(NGX_LOG_DEBUG_STREAM, s->connection->log, 0, "stream lua udp socket network address given directly"); u->resolved->sockaddr = url.addrs[0].sockaddr; u->resolved->socklen = url.addrs[0].socklen; u->resolved->naddrs = 1; u->resolved->host = url.addrs[0].name; } else { u->resolved->host = host; u->resolved->port = (in_port_t) port; } if (u->resolved->sockaddr) { rc = ngx_stream_lua_socket_resolve_retval_handler(s, u, L); if (rc == NGX_AGAIN) { return lua_yield(L, 0); } return rc; } temp.name = host; rctx = ngx_resolve_start(lscf->resolver, &temp); if (rctx == NULL) { u->ft_type |= NGX_STREAM_LUA_SOCKET_FT_RESOLVER; lua_pushnil(L); lua_pushliteral(L, "failed to start the resolver"); return 2; } if (rctx == NGX_NO_RESOLVER) { u->ft_type |= NGX_STREAM_LUA_SOCKET_FT_RESOLVER; lua_pushnil(L); lua_pushfstring(L, "no lua_resolver defined to resolve \"%s\"", host.data); return 2; } rctx->name = host; #if !defined(nginx_version) || nginx_version < 1005008 rctx->type = NGX_RESOLVE_A; #endif rctx->handler = ngx_stream_lua_socket_resolve_handler; rctx->data = u; rctx->timeout = lscf->resolver_timeout; u->co_ctx = ctx->cur_co_ctx; u->resolved->ctx = rctx; saved_top = lua_gettop(L); coctx = ctx->cur_co_ctx; ngx_stream_lua_cleanup_pending_operation(coctx); coctx->cleanup = ngx_stream_lua_udp_resolve_cleanup; if (ngx_resolve_name(rctx) != NGX_OK) { ngx_log_debug0(NGX_LOG_DEBUG_STREAM, s->connection->log, 0, "stream lua udp socket fail to run resolver " "immediately"); u->ft_type |= NGX_STREAM_LUA_SOCKET_FT_RESOLVER; u->resolved->ctx = NULL; lua_pushnil(L); lua_pushfstring(L, "%s could not be resolved", host.data); return 2; } if (u->waiting == 1) { /* resolved and already connecting */ return lua_yield(L, 0); } n = lua_gettop(L) - saved_top; if (n) { /* errors occurred during resolving or connecting * or already connected */ return n; } /* still resolving */ u->waiting = 1; u->prepare_retvals = ngx_stream_lua_socket_resolve_retval_handler; coctx->data = u; ctx->write_event_handler = ngx_stream_lua_content_wev_handler; return lua_yield(L, 0); }
static int ngx_http_lua_uthread_wait(lua_State *L) { int i, nargs, nrets; lua_State *sub_co; ngx_http_request_t *r; ngx_http_lua_ctx_t *ctx; ngx_http_lua_co_ctx_t *coctx, *sub_coctx; lua_pushlightuserdata(L, &ngx_http_lua_request_key); lua_rawget(L, LUA_GLOBALSINDEX); r = lua_touserdata(L, -1); lua_pop(L, 1); if (r == NULL) { return luaL_error(L, "no request found"); } ctx = ngx_http_get_module_ctx(r, ngx_http_lua_module); if (ctx == NULL) { return luaL_error(L, "no request ctx found"); } ngx_http_lua_check_context(L, ctx, NGX_HTTP_LUA_CONTEXT_REWRITE | NGX_HTTP_LUA_CONTEXT_ACCESS | NGX_HTTP_LUA_CONTEXT_CONTENT); coctx = ctx->cur_co_ctx; nargs = lua_gettop(L); for (i = 1; i <= nargs; i++) { sub_co = lua_tothread(L, i); luaL_argcheck(L, sub_co, i, "lua thread expected"); sub_coctx = ngx_http_lua_get_co_ctx(sub_co, ctx); if (sub_coctx == NULL) { return luaL_error(L, "no co ctx found for the ngx.thread " "instance given"); } if (!sub_coctx->is_uthread) { return luaL_error(L, "attempt to wait on a coroutine that is " "not a user thread"); } if (sub_coctx->parent_co_ctx != coctx) { return luaL_error(L, "only the parent coroutine can wait on the " "thread"); } switch (sub_coctx->co_status) { case NGX_HTTP_LUA_CO_ZOMBIE: ngx_http_lua_probe_info("found zombie child"); nrets = lua_gettop(sub_coctx->co); dd("child retval count: %d, %s: %s", n, luaL_typename(sub_coctx->co, -1), lua_tostring(sub_coctx->co, -1)); if (nrets) { lua_xmove(sub_coctx->co, L, nrets); } #if 1 ngx_http_lua_del_thread(r, L, ctx, sub_coctx); ctx->uthreads--; #endif return nrets; default: /* still alive */ break; } ngx_http_lua_probe_user_thread_wait(L, sub_coctx->co); sub_coctx->waited_by_parent = 1; } return lua_yield(L, 0); }
/* args-opts -- proc/nil error */ static int ex_spawn(lua_State *L) { struct spawn_params *params; int have_options; switch (lua_type(L, 1)) { default: return luaL_typerror(L, 1, "string or table"); case LUA_TSTRING: switch (lua_type(L, 2)) { default: return luaL_typerror(L, 2, "table"); case LUA_TNONE: have_options = 0; break; case LUA_TTABLE: have_options = 1; break; } break; case LUA_TTABLE: have_options = 1; /* avoid issues with strict.lua */ lua_pushstring(L, "command"); /* opts ... cmd */ lua_rawget(L, 1); if (!lua_isnil(L, -1)) { /* convert {command=command,arg1,...} to command {arg1,...} */ lua_insert(L, 1); /* cmd opts ... */ } else { /* convert {arg0,arg1,...} to arg0 {arg1,...} */ size_t i, n = lua_objlen(L, 1); lua_rawgeti(L, 1, 1); /* opts ... nil cmd */ lua_insert(L, 1); /* cmd opts ... nil */ for (i = 2; i <= n; i++) { lua_rawgeti(L, 2, i); /* cmd opts ... nil argi */ lua_rawseti(L, 2, i - 1); /* cmd opts ... nil */ } lua_rawseti(L, 2, n); /* cmd opts ... */ } if (lua_type(L, 1) != LUA_TSTRING) return luaL_error(L, "bad command option (string expected, got %s)", luaL_typename(L, 1)); break; } params = spawn_param_init(L); /* get filename to execute */ spawn_param_filename(params); /* get arguments, environment, and redirections */ if (have_options) { lua_getfield(L, 2, "args"); /* cmd opts ... argtab */ switch (lua_type(L, -1)) { default: return luaL_error(L, "bad args option (table expected, got %s)", luaL_typename(L, -1)); case LUA_TNIL: lua_pop(L, 1); /* cmd opts ... */ lua_pushvalue(L, 2); /* cmd opts ... opts */ if (0) /*FALLTHRU*/ case LUA_TTABLE: if (lua_objlen(L, 2) > 0) return luaL_error(L, "cannot specify both the args option and array values"); spawn_param_args(params); /* cmd opts ... */ break; } lua_getfield(L, 2, "env"); /* cmd opts ... envtab */ switch (lua_type(L, -1)) { default: return luaL_error(L, "bad env option (table expected, got %s)", luaL_typename(L, -1)); case LUA_TNIL: break; case LUA_TTABLE: spawn_param_env(params); /* cmd opts ... */ break; } lua_getfield(L, 2, "show"); /* cmd opts ... envtab */ spawn_param_show(params, lua_type(L, -1) == LUA_TBOOLEAN ? lua_toboolean(L, -1) : 0); lua_getfield(L, 2, "shell"); /* cmd opts ... envtab */ spawn_param_useshell(params, lua_type(L, -1) == LUA_TBOOLEAN ? lua_toboolean(L, -1) : 1); get_redirect(L, 2, "stdin", params); /* cmd opts ... */ get_redirect(L, 2, "stdout", params); /* cmd opts ... */ get_redirect(L, 2, "stderr", params); /* cmd opts ... */ } return spawn_param_execute(params); /* proc/nil error */ }
//in: linda_ud key [[val] ...] //out: true or nil int keepercall_set( lua_State* L) { bool_t should_wake_writers = FALSE; STACK_GROW( L, 6); // retrieve fifos associated with the linda push_table( L, 1); // ud key [val [, ...]] fifos lua_replace( L, 1); // fifos key [val [, ...]] // make sure we have a value on the stack if( lua_gettop( L) == 2) // fifos key { keeper_fifo* fifo; lua_pushvalue( L, -1); // fifos key key lua_rawget( L, 1); // fifos key fifo|nil // empty the fifo for the specified key: replace uservalue with a virgin table, reset counters, but leave limit unchanged! fifo = (keeper_fifo*) lua_touserdata( L, -1); if( fifo != NULL) // might be NULL if we set a nonexistent key to nil { // fifos key fifo if( fifo->limit < 0) // fifo limit value is the default (unlimited): we can totally remove it { lua_pop( L, 1); // fifos key lua_pushnil( L); // fifos key nil lua_rawset( L, -3); // fifos } else { // we create room if the fifo was full but it is no longer the case should_wake_writers = (fifo->limit > 0) && (fifo->count >= fifo->limit); lua_remove( L, -2); // fifos fifo lua_newtable( L); // fifos fifo {} lua_setuservalue( L, -2); // fifos fifo fifo->first = 1; fifo->count = 0; } } } else // set/replace contents stored at the specified key? { int count = lua_gettop( L) - 2; // number of items we want to store keeper_fifo* fifo; // fifos key [val [, ...]] lua_pushvalue( L, 2); // fifos key [val [, ...]] key lua_rawget( L, 1); // fifos key [val [, ...]] fifo|nil fifo = (keeper_fifo*) lua_touserdata( L, -1); if( fifo == NULL) // can be NULL if we store a value at a new key { // fifos key [val [, ...]] nil // no need to wake writers in that case, because a writer can't wait on an inexistent key lua_pop( L, 1); // fifos key [val [, ...]] fifo_new( L); // fifos key [val [, ...]] fifo lua_pushvalue( L, 2); // fifos key [val [, ...]] fifo key lua_pushvalue( L, -2); // fifos key [val [, ...]] fifo key fifo lua_rawset( L, 1); // fifos key [val [, ...]] fifo } else // the fifo exists, we just want to update its contents { // fifos key [val [, ...]] fifo // we create room if the fifo was full but it is no longer the case should_wake_writers = (fifo->limit > 0) && (fifo->count >= fifo->limit) && (count < fifo->limit); // empty the fifo for the specified key: replace uservalue with a virgin table, reset counters, but leave limit unchanged! lua_newtable( L); // fifos key [val [, ...]] fifo {} lua_setuservalue( L, -2); // fifos key [val [, ...]] fifo fifo->first = 1; fifo->count = 0; } fifo = prepare_fifo_access( L, -1); // move the fifo below the values we want to store lua_insert( L, 3); // fifos key fifo [val [, ...]] fifo_push( L, fifo, count); // fifos key fifo } return should_wake_writers ? (lua_pushboolean( L, 1), 1) : 0; }
static void ngx_http_lua_timer_handler(ngx_event_t *ev) { int n; lua_State *L; ngx_int_t rc; ngx_connection_t *c = NULL; ngx_http_request_t *r = NULL; ngx_http_lua_ctx_t *ctx; ngx_http_cleanup_t *cln; ngx_pool_cleanup_t *pcln; ngx_http_lua_timer_ctx_t tctx; ngx_http_lua_main_conf_t *lmcf; ngx_http_core_loc_conf_t *clcf; ngx_http_lua_timer_log_ctx_t *logctx; ngx_log_debug0(NGX_LOG_DEBUG_HTTP, ngx_cycle->log, 0, "lua ngx.timer expired"); ngx_memcpy(&tctx, ev->data, sizeof(ngx_http_lua_timer_ctx_t)); ngx_free(ev); ev = NULL; lmcf = tctx.lmcf; lmcf->pending_timers--; if (lmcf->running_timers >= lmcf->max_running_timers) { ngx_log_error(NGX_LOG_ALERT, ngx_cycle->log, 0, "%i lua_max_running_timers are not enough", lmcf->max_running_timers); goto failed; } c = ngx_http_lua_create_fake_connection(tctx.pool); if (c == NULL) { goto failed; } logctx = ngx_palloc(c->pool, sizeof(ngx_http_lua_timer_log_ctx_t)); if (logctx == NULL) { goto failed; } logctx->connection = c; c->log->handler = ngx_http_lua_log_timer_error; c->log->data = logctx; c->listening = tctx.listening; c->addr_text = tctx.client_addr_text; r = ngx_http_lua_create_fake_request(c); if (r == NULL) { goto failed; } r->main_conf = tctx.main_conf; r->srv_conf = tctx.srv_conf; r->loc_conf = tctx.loc_conf; clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module); #if defined(nginx_version) && nginx_version >= 1003014 ngx_set_connection_log(r->connection, clcf->error_log); #else c->log->file = clcf->error_log->file; if (!(c->log->log_level & NGX_LOG_DEBUG_CONNECTION)) { c->log->log_level = clcf->error_log->log_level; } #endif dd("lmcf: %p", lmcf); ctx = ngx_http_lua_create_ctx(r); if (ctx == NULL) { goto failed; } if (tctx.vm_state) { ctx->vm_state = tctx.vm_state; pcln = ngx_pool_cleanup_add(r->pool, 0); if (pcln == NULL) { goto failed; } pcln->handler = ngx_http_lua_cleanup_vm; pcln->data = tctx.vm_state; } ctx->cur_co_ctx = &ctx->entry_co_ctx; L = ngx_http_lua_get_lua_vm(r, ctx); cln = ngx_http_cleanup_add(r, 0); if (cln == NULL) { goto failed; } cln->handler = ngx_http_lua_request_cleanup_handler; cln->data = ctx; ctx->cleanup = &cln->handler; ctx->entered_content_phase = 1; ctx->context = NGX_HTTP_LUA_CONTEXT_TIMER; r->read_event_handler = ngx_http_block_reading; ctx->cur_co_ctx->co_ref = tctx.co_ref; ctx->cur_co_ctx->co = tctx.co; ctx->cur_co_ctx->co_status = NGX_HTTP_LUA_CO_RUNNING; dd("r connection: %p, log %p", r->connection, r->connection->log); /* save the request in coroutine globals table */ ngx_http_lua_set_req(tctx.co, r); lmcf->running_timers++; lua_pushboolean(tctx.co, tctx.premature); n = lua_gettop(tctx.co); if (n > 2) { lua_insert(tctx.co, 2); } #ifdef NGX_LUA_USE_ASSERT ctx->cur_co_ctx->co_top = 1; #endif rc = ngx_http_lua_run_thread(L, r, ctx, n - 1); dd("timer lua run thread: %d", (int) rc); if (rc == NGX_ERROR || rc >= NGX_OK) { /* do nothing */ } else if (rc == NGX_AGAIN) { rc = ngx_http_lua_content_run_posted_threads(L, r, ctx, 0); } else if (rc == NGX_DONE) { rc = ngx_http_lua_content_run_posted_threads(L, r, ctx, 1); } else { rc = NGX_OK; } ngx_http_lua_finalize_request(r, rc); return; failed: if (tctx.co_ref && tctx.co) { lua_pushlightuserdata(tctx.co, &ngx_http_lua_coroutines_key); lua_rawget(tctx.co, LUA_REGISTRYINDEX); luaL_unref(tctx.co, -1, tctx.co_ref); lua_settop(tctx.co, 0); } if (tctx.vm_state) { ngx_http_lua_cleanup_vm(tctx.vm_state); } if (c) { ngx_http_lua_close_fake_connection(c); } else if (tctx.pool) { ngx_destroy_pool(tctx.pool); } }
static int ngx_http_lua_ngx_timer_at(lua_State *L) { int nargs, co_ref; u_char *p; lua_State *vm; /* the main thread */ lua_State *co; ngx_msec_t delay; ngx_event_t *ev; ngx_http_request_t *r; ngx_connection_t *saved_c = NULL; ngx_http_lua_ctx_t *ctx; #if 0 ngx_http_connection_t *hc; #endif ngx_http_lua_timer_ctx_t *tctx = NULL; ngx_http_lua_main_conf_t *lmcf; #if 0 ngx_http_core_main_conf_t *cmcf; #endif nargs = lua_gettop(L); if (nargs < 2) { return luaL_error(L, "expecting at least 2 arguments but got %d", nargs); } delay = (ngx_msec_t) (luaL_checknumber(L, 1) * 1000); luaL_argcheck(L, lua_isfunction(L, 2) && !lua_iscfunction(L, 2), 2, "Lua function expected"); r = ngx_http_lua_get_req(L); if (r == NULL) { return luaL_error(L, "no request"); } ctx = ngx_http_get_module_ctx(r, ngx_http_lua_module); if (ngx_exiting && delay > 0) { lua_pushnil(L); lua_pushliteral(L, "process exiting"); return 2; } lmcf = ngx_http_get_module_main_conf(r, ngx_http_lua_module); if (lmcf->pending_timers >= lmcf->max_pending_timers) { lua_pushnil(L); lua_pushliteral(L, "too many pending timers"); return 2; } if (lmcf->watcher == NULL) { /* create the watcher fake connection */ ngx_log_debug0(NGX_LOG_DEBUG_HTTP, ngx_cycle->log, 0, "lua creating fake watcher connection"); if (ngx_cycle->files) { saved_c = ngx_cycle->files[0]; } lmcf->watcher = ngx_get_connection(0, ngx_cycle->log); if (ngx_cycle->files) { ngx_cycle->files[0] = saved_c; } if (lmcf->watcher == NULL) { return luaL_error(L, "no memory"); } /* to work around the -1 check in ngx_worker_process_cycle: */ lmcf->watcher->fd = (ngx_socket_t) -2; lmcf->watcher->idle = 1; lmcf->watcher->read->handler = ngx_http_lua_abort_pending_timers; lmcf->watcher->data = lmcf; } vm = ngx_http_lua_get_lua_vm(r, ctx); co = lua_newthread(vm); /* L stack: time func [args] thread */ ngx_http_lua_probe_user_coroutine_create(r, L, co); lua_createtable(co, 0, 0); /* the new globals table */ /* co stack: global_tb */ lua_createtable(co, 0, 1); /* the metatable */ ngx_http_lua_get_globals_table(co); lua_setfield(co, -2, "__index"); lua_setmetatable(co, -2); /* co stack: global_tb */ ngx_http_lua_set_globals_table(co); /* co stack: <empty> */ dd("stack top: %d", lua_gettop(L)); lua_xmove(vm, L, 1); /* move coroutine from main thread to L */ /* L stack: time func [args] thread */ /* vm stack: empty */ lua_pushvalue(L, 2); /* copy entry function to top of L*/ /* L stack: time func [args] thread func */ lua_xmove(L, co, 1); /* move entry function from L to co */ /* L stack: time func [args] thread */ /* co stack: func */ ngx_http_lua_get_globals_table(co); lua_setfenv(co, -2); /* co stack: func */ lua_pushlightuserdata(L, &ngx_http_lua_coroutines_key); lua_rawget(L, LUA_REGISTRYINDEX); /* L stack: time func [args] thread corountines */ lua_pushvalue(L, -2); /* L stack: time func [args] thread coroutines thread */ co_ref = luaL_ref(L, -2); lua_pop(L, 1); /* L stack: time func [args] thread */ if (nargs > 2) { lua_pop(L, 1); /* L stack: time func [args] */ lua_xmove(L, co, nargs - 2); /* L stack: time func */ /* co stack: func [args] */ } p = ngx_alloc(sizeof(ngx_event_t) + sizeof(ngx_http_lua_timer_ctx_t), r->connection->log); if (p == NULL) { goto nomem; } ev = (ngx_event_t *) p; ngx_memzero(ev, sizeof(ngx_event_t)); p += sizeof(ngx_event_t); tctx = (ngx_http_lua_timer_ctx_t *) p; tctx->premature = 0; tctx->co_ref = co_ref; tctx->co = co; tctx->main_conf = r->main_conf; tctx->srv_conf = r->srv_conf; tctx->loc_conf = r->loc_conf; tctx->lmcf = lmcf; tctx->pool = ngx_create_pool(128, ngx_cycle->log); if (tctx->pool == NULL) { goto nomem; } if (r->connection) { tctx->listening = r->connection->listening; } else { tctx->listening = NULL; } if (r->connection->addr_text.len) { tctx->client_addr_text.data = ngx_palloc(tctx->pool, r->connection->addr_text.len); if (tctx->client_addr_text.data == NULL) { goto nomem; } ngx_memcpy(tctx->client_addr_text.data, r->connection->addr_text.data, r->connection->addr_text.len); tctx->client_addr_text.len = r->connection->addr_text.len; } else { tctx->client_addr_text.len = 0; tctx->client_addr_text.data = NULL; } if (ctx && ctx->vm_state) { tctx->vm_state = ctx->vm_state; tctx->vm_state->count++; } else { tctx->vm_state = NULL; } ev->handler = ngx_http_lua_timer_handler; ev->data = tctx; ev->log = ngx_cycle->log; lmcf->pending_timers++; ngx_add_timer(ev, delay); lua_pushinteger(L, 1); return 1; nomem: if (tctx && tctx->pool) { ngx_destroy_pool(tctx->pool); } lua_pushlightuserdata(L, &ngx_http_lua_coroutines_key); lua_rawget(L, LUA_REGISTRYINDEX); luaL_unref(L, -1, co_ref); return luaL_error(L, "no memory"); }
ngx_int_t ngx_http_lua_wev_handler(ngx_http_request_t *r) { ngx_int_t rc; ngx_http_lua_ctx_t *ctx; ngx_http_lua_main_conf_t *lmcf; lua_State *cc; ngx_str_t *body_str; ngx_http_headers_out_t *sr_headers; ngx_list_part_t *part; ngx_table_elt_t *header; ngx_uint_t i, index; dd("wev handler %.*s %.*s a:%d, postponed:%p", (int) r->uri.len, r->uri.data, (int) ngx_cached_err_log_time.len, ngx_cached_err_log_time.data, r == r->connection->data, r->postponed); #if 0 ngx_http_lua_dump_postponed(r); #endif ctx = ngx_http_get_module_ctx(r, ngx_http_lua_module); if (ctx == NULL) { goto error; } dd("ctx = %p", ctx); dd("request done: %d", (int) r->done); dd("cleanup done: %p", ctx->cleanup); if (ctx->cleanup == NULL) { /* already done */ dd("cleanup is null: %.*s", (int) r->uri.len, r->uri.data); if (ctx->entered_content_phase) { ngx_http_finalize_request(r, ngx_http_lua_flush_postponed_outputs(r)); } return NGX_DONE; } dd("waiting: %d, done: %d", (int) ctx->waiting, ctx->done); if (ctx->waiting && ! ctx->done) { dd("%.*s waiting and not done", (int) r->uri.len, r->uri.data); #if 0 ngx_http_lua_dump_postponed(r); #endif if (r == r->connection->data && r->postponed) { if (r->postponed->request) { r->connection->data = r->postponed->request; #if defined(nginx_version) && nginx_version >= 8012 ngx_http_post_request(r->postponed->request, NULL); #else ngx_http_post_request(r->postponed->request); #endif } else { ngx_http_lua_flush_postponed_outputs(r); } } return NGX_DONE; } ctx->done = 0; dd("nsubreqs: %d", (int) ctx->nsubreqs); for (index = 0; index < ctx->nsubreqs; index++) { dd("summary: reqs %d, subquery %d, waiting %d, req %.*s", (int) ctx->nsubreqs, (int) index, (int) ctx->waiting, (int) r->uri.len, r->uri.data); cc = ctx->cc; /* {{{ construct ret value */ lua_newtable(cc); /* copy captured status */ lua_pushinteger(cc, ctx->sr_statuses[index]); lua_setfield(cc, -2, "status"); /* copy captured body */ body_str = &ctx->sr_bodies[index]; lua_pushlstring(cc, (char *) body_str->data, body_str->len); lua_setfield(cc, -2, "body"); if (body_str->data) { dd("free body buffer ASAP"); ngx_pfree(r->pool, body_str->data); } /* copy captured headers */ lua_newtable(cc); /* res.header */ sr_headers = ctx->sr_headers[index]; if (sr_headers->content_length == NULL && sr_headers->content_length_n >= 0) { lua_pushliteral(cc, "Content-Length"); /* header key */ lua_pushnumber(cc, sr_headers->content_length_n); /* head key value */ lua_rawset(cc, -3); /* head */ } if (sr_headers->content_type.len) { lua_pushliteral(cc, "Content-Type"); /* header key */ lua_pushlstring(cc, (char *) sr_headers->content_type.data, sr_headers->content_type.len); /* head key value */ lua_rawset(cc, -3); /* head */ } dd("saving subrequest response headers"); part = &sr_headers->headers.part; header = part->elts; for (i = 0; /* void */; i++) { if (i >= part->nelts) { if (part->next == NULL) { break; } part = part->next; header = part->elts; i = 0; } dd("checking sr header %.*s", (int) header[i].key.len, header[i].key.data); #if 1 if (header[i].hash == 0) { continue; } #endif dd("pushing sr header %.*s", (int) header[i].key.len, header[i].key.data); lua_pushlstring(cc, (char *) header[i].key.data, header[i].key.len); /* header key */ lua_pushvalue(cc, -1); /* stack: table key key */ /* check if header already exists */ lua_rawget(cc, -3); /* stack: table key value */ if (lua_isnil(cc, -1)) { lua_pop(cc, 1); /* stack: table key */ lua_pushlstring(cc, (char *) header[i].value.data, header[i].value.len); /* stack: table key value */ lua_rawset(cc, -3); /* stack: table */ } else { if (! lua_istable(cc, -1)) { /* already inserted one value */ lua_createtable(cc, 4, 0); /* stack: table key value table */ lua_insert(cc, -2); /* stack: table key table value */ lua_rawseti(cc, -2, 1); /* stack: table key table */ lua_pushlstring(cc, (char *) header[i].value.data, header[i].value.len); /* stack: table key table value */ lua_rawseti(cc, -2, lua_objlen(cc, -2) + 1); /* stack: table key table */ lua_rawset(cc, -3); /* stack: table */ } else { lua_pushlstring(cc, (char *) header[i].value.data, header[i].value.len); /* stack: table key table value */ lua_rawseti(cc, -2, lua_objlen(cc, -2) + 1); /* stack: table key table */ lua_pop(cc, 2); /* stack: table */ } } } lua_setfield(cc, -2, "header"); /* }}} */ } dd("free sr_statues/headers/bodies memory ASAP"); #if 1 ngx_pfree(r->pool, ctx->sr_statuses); ctx->sr_statuses = NULL; ctx->sr_headers = NULL; ctx->sr_bodies = NULL; #endif lmcf = ngx_http_get_module_main_conf(r, ngx_http_lua_module); dd("about to run thread for %.*s...", (int) r->uri.len, r->uri.data); rc = ngx_http_lua_run_thread(lmcf->lua, r, ctx, ctx->nsubreqs); dd("already run thread for %.*s...", (int) r->uri.len, r->uri.data); if (rc == NGX_AGAIN || rc == NGX_DONE) { return NGX_DONE; } dd("entered content phase: %d", (int) ctx->entered_content_phase); if (ctx->entered_content_phase) { ngx_http_finalize_request(r, rc); } if (rc == NGX_OK) { return NGX_DECLINED; } return rc; error: if (ctx->entered_content_phase) { ngx_http_finalize_request(r, ctx->headers_sent ? NGX_ERROR: NGX_HTTP_INTERNAL_SERVER_ERROR); } return NGX_ERROR; }
static void lua_pushluaobject(lua_State *L, LuaObject *f) // lua stack [-0, +1] { lua_pushlightuserdata(L, f); lua_rawget(L, LUA_REGISTRYINDEX); }
void THAnimation::persist(LuaPersistWriter *pWriter) const { lua_State *L = pWriter->getStack(); // Write the next chained thing lua_rawgeti(L, luaT_environindex, 2); lua_pushlightuserdata(L, m_pNext); lua_rawget(L, -2); pWriter->fastWriteStackObject(-1); lua_pop(L, 2); // Write the THDrawable fields pWriter->writeVUInt(m_iFlags); #define IsUsingFunctionSet(d, ht) m_fnDraw == (THAnimation_ ## d) \ && m_fnHitTest == (THAnimation_ ## ht) if(IsUsingFunctionSet(Draw, HitTest)) pWriter->writeVUInt(1); else if(IsUsingFunctionSet(DrawChild, HitTestChild)) pWriter->writeVUInt(2); else if(IsUsingFunctionSet(DrawMorph, HitTestMorph)) { // NB: Prior version of code used the number 3 here, and forgot // to persist the morph target. pWriter->writeVUInt(4); lua_rawgeti(L, luaT_environindex, 2); lua_pushlightuserdata(L, m_pMorphTarget); lua_rawget(L, -2); pWriter->writeStackObject(-1); lua_pop(L, 2); } else pWriter->writeVUInt(0); #undef IsUsingFunctionSet // Write the simple fields pWriter->writeVUInt(m_iAnimation); pWriter->writeVUInt(m_iFrame); pWriter->writeVInt(m_iX); pWriter->writeVInt(m_iY); pWriter->writeVInt((int)m_iSoundToPlay); // Not a VUInt, for compatibility pWriter->writeVInt(0); // For compatibility if(m_iFlags & THDF_Crop) pWriter->writeVInt(m_iCropColumn); // Write the unioned fields if(m_fnDraw != THAnimation_DrawChild) { pWriter->writeVInt(m_iSpeedX); pWriter->writeVInt(m_iSpeedY); } else { lua_rawgeti(L, luaT_environindex, 2); lua_pushlightuserdata(L, m_pParent); lua_rawget(L, -2); pWriter->writeStackObject(-1); lua_pop(L, 2); } // Write the layers int iNumLayers = 13; for( ; iNumLayers >= 1; --iNumLayers) { if(m_oLayers.iLayerContents[iNumLayers - 1] != 0) break; } pWriter->writeVUInt(iNumLayers); pWriter->writeByteStream(m_oLayers.iLayerContents, iNumLayers); }
// increase lua function reference counter, return functionId int LuaJavaBridge::retainLuaFunction(lua_State *L, int functionIndex, int *retainCountReturn) { /* L: f ... */ lua_pushstring(L, LUAJ_REGISTRY_FUNCTION); /* L: f ... key */ lua_rawget(L, LUA_REGISTRYINDEX); /* L: f ... f_id */ if (!lua_istable(L, -1)) { lua_pop(L, 1); lua_newtable(L); lua_pushstring(L, LUAJ_REGISTRY_FUNCTION); lua_pushvalue(L, -2); lua_rawset(L, LUA_REGISTRYINDEX); } lua_pushstring(L, LUAJ_REGISTRY_RETAIN); /* L: f ... f_id key */ lua_rawget(L, LUA_REGISTRYINDEX); /* L: f ... f_id id_r */ if (!lua_istable(L, -1)) { lua_pop(L, 1); lua_newtable(L); lua_pushstring(L, LUAJ_REGISTRY_RETAIN); lua_pushvalue(L, -2); lua_rawset(L, LUA_REGISTRYINDEX); } // get function id lua_pushvalue(L, functionIndex - 2); /* L: f ... f_id id_r f */ lua_rawget(L, -3); /* L: f ... f_id id_r id */ int functionId; if (lua_type(L, -1) != LUA_TNUMBER) { // first retain, create new id lua_pop(L, 1); /* L: f ... f_id id_r */ s_newFunctionId++; functionId = s_newFunctionId; lua_pushvalue(L, functionIndex - 2); /* L: f ... f_id id_r f */ lua_pushinteger(L, functionId); /* L: f ... f_id id_r f id */ lua_rawset(L, -4); /* f_id[f] = id, L: f ... f_id id_r */ lua_pushinteger(L, functionId); /* L: f ... f_id id_r id */ } else { functionId = lua_tonumber(L, -1); } // get function retain lua_pushvalue(L, -1); /* L: f ... f_id id_r id id */ lua_rawget(L, -3); /* L: f ... f_id id_r id r */ int retainCount = 1; if (lua_type(L, -1) != LUA_TNUMBER) { // first retain, set retain count = 1 lua_pop(L, 1); lua_pushinteger(L, retainCount); } else { // add retain count retainCount = lua_tonumber(L, -1); retainCount++; lua_pop(L, 1); lua_pushinteger(L, retainCount); } lua_rawset(L, -3); /* id_r[id] = r, L: f ... f_id id_r */ lua_pop(L, 2); /* L: f ... */ if (retainCountReturn) *retainCountReturn = retainCount; return functionId; }
// in: linda_ud [, key [, ...]] int keepercall_count( lua_State* L) { int top; push_table( L, 1); // ud keys fifos switch( lua_gettop( L)) { // no key is specified: return a table giving the count of all known keys case 2: // ud fifos lua_newtable( L); // ud fifos out lua_replace( L, 1); // out fifos lua_pushnil( L); // out fifos nil while( lua_next( L, 2)) // out fifos key fifo { keeper_fifo* fifo = prepare_fifo_access( L, -1); // out fifos key fifo lua_pop( L, 1); // out fifos key lua_pushvalue( L, -1); // out fifos key key lua_pushinteger( L, fifo->count); // out fifos key key count lua_rawset( L, -5); // out fifos key } lua_pop( L, 1); // out break; // 1 key is specified: return its count case 3: // ud key fifos { keeper_fifo* fifo; lua_replace( L, 1); // fifos key lua_rawget( L, -2); // fifos fifo|nil if( lua_isnil( L, -1)) // the key is unknown { // fifos nil lua_remove( L, -2); // nil } else // the key is known { // fifos fifo fifo = prepare_fifo_access( L, -1); // fifos fifo lua_pushinteger( L, fifo->count); // fifos fifo count lua_replace( L, -3); // count fifo lua_pop( L, 1); // count } } break; // a variable number of keys is specified: return a table of their counts default: // ud keys fifos lua_newtable( L); // ud keys fifos out lua_replace( L, 1); // out keys fifos // shifts all keys up in the stack. potentially slow if there are a lot of them, but then it should be bearable lua_insert( L, 2); // out fifos keys while( (top = lua_gettop( L)) > 2) { keeper_fifo* fifo; lua_pushvalue( L, -1); // out fifos keys key lua_rawget( L, 2); // out fifos keys fifo|nil fifo = prepare_fifo_access( L, -1); // out fifos keys fifo|nil lua_pop( L, 1); // out fifos keys if( fifo != NULL) // the key is known { lua_pushinteger( L, fifo->count); // out fifos keys count lua_rawset( L, 1); // out fifos keys } else // the key is unknown { lua_pop( L, 1); // out fifos keys } } lua_pop( L, 1); // out } ASSERT_L( lua_gettop( L) == 1); return 1; }
static void luaL_rawgetptr(lua_State *L, int idx, void *ptr) { idx = abs_index(L, idx); lua_pushlightuserdata(L, ptr); lua_rawget(L, idx); }
static int findkey(lua_State *L, int oper, const char *key, va_list va) { char *buf; const char *s, *e; int ret = 0; int blen; blen = vsnprintf(NULL, 0, key, va); if (blen <= 0) { return -1; } buf = xmalloc(blen + 1); vsnprintf(buf, blen + 1, key, va); s = e = buf; lua_pushglobaltable(L); for (;;) { if (*e == '\0' || *e == '.') { if (e != s) { lua_pushlstring(L, s, e-s); switch (oper) { case FINDKEY_REMOVE: if (*e == '\0') { lua_pushnil(L); lua_rawset(L, -3); lua_pop(L, 1); break; } case FINDKEY_RETURN: lua_rawget(L, -2); lua_remove(L, -2); break; case FINDKEY_CREATE: lua_rawget(L, -2); if (!lua_istable(L, -1)) { lua_pop(L, 1); lua_newtable(L); lua_pushlstring(L, s, e-s); lua_pushvalue(L, -2); lua_rawset(L, -4); } lua_remove(L, -2); break; } } if (*e == '\0') break; if (!lua_istable(L, -1)) { lua_pop(L, 1); ret = -1; break; } s = e+1; } e++; } free(buf); return ret; }
static int js_getter_index (lua_State* L) { // stack: self, key, _self while (lua_gettop(L) < 3) { lua_pushnil(L); } // _self or self if (lua_isnil(L, 3)) { lua_pushvalue(L, 1); } else { lua_pushvalue(L, 3); } if (lua_getmetatable(L, -1) == 0) { lua_pushnil(L); return 1; } // stack: self, key, _self, (_self or self), mt // Check getters lua_getfield(L, -1, "getters"); if (!lua_isnil(L, -1)) { lua_pushvalue(L, 2); lua_rawget(L, -2); if (!lua_isnil(L, -1)) { lua_pushvalue(L, 1); lua_call(L, 1, 1); return 1; } lua_remove(L, -1); } lua_remove(L, -1); // stack: self, key, _self, (_self or self), mt // Get raw key or defer to proto getter lua_pushvalue(L, 2); // stack: self, key, _self, (_self or self), mt, key lua_rawget(L, -3); // stack: self, key, _self, (_self or self), mt, (_self or self)[key] if (lua_isnil(L, -1)) { // stack: self, key, _self, (_self or self), mt, nil lua_getfield(L, -2, "proto"); // stack: self, key, _self, (_self or self), mt, nil, mt.proto lua_insert(L, 2); // stack: self, mt.proto, key, _self, (_self or self), mt, nil lua_remove(L, -1); // stack: self, mt.proto, key, _self, (_self or self), mt lua_remove(L, -1); // stack: self, mt.proto, key, _self, (_self or self) lua_remove(L, -1); // stack: self, mt.proto, key, _self lua_remove(L, -1); // stack: self, mt.proto, key return js_proto_get(L); } return 1; }
const char *LuaSerializer::unpickle(lua_State *l, const char *pos) { LUA_DEBUG_START(l); // tables are also unpickled recursively, so we can run out of Lua stack space if we're not careful // start by ensuring we have enough (this grows the stack if necessary) // (20 is somewhat arbitrary) if (!lua_checkstack(l, 20)) luaL_error(l, "The Lua stack couldn't be extended (not enough memory?)"); char type = *pos++; switch (type) { case 'f': { char *end; double f = strtod(pos, &end); if (pos == end) throw SavedGameCorruptException(); lua_pushnumber(l, f); pos = end+1; // skip newline break; } case 'b': { if (*pos != '0' && *pos != '1') throw SavedGameCorruptException(); bool b = (*pos == '0') ? false : true; lua_pushboolean(l, b); pos++; break; } case 's': { char *end; int len = strtol(pos, const_cast<char**>(&end), 0); if (pos == end) throw SavedGameCorruptException(); end++; // skip newline lua_pushlstring(l, end, len); pos = end + len; break; } case 't': { lua_newtable(l); lua_getfield(l, LUA_REGISTRYINDEX, "PiSerializerTableRefs"); pos = unpickle(l, pos); lua_pushvalue(l, -3); lua_rawset(l, -3); lua_pop(l, 1); while (*pos != 'n') { pos = unpickle(l, pos); pos = unpickle(l, pos); lua_rawset(l, -3); } pos++; break; } case 'r': { pos = unpickle(l, pos); lua_getfield(l, LUA_REGISTRYINDEX, "PiSerializerTableRefs"); lua_pushvalue(l, -2); lua_rawget(l, -2); if (lua_isnil(l, -1)) throw SavedGameCorruptException(); lua_insert(l, -3); lua_pop(l, 2); break; } case 'u': { const char *end; if (!LuaObjectBase::Deserialize(pos, &end)) throw SavedGameCorruptException(); pos = end; break; } case 'o': { const char *end = strchr(pos, '\n'); if (!end) throw SavedGameCorruptException(); int len = end - pos; end++; // skip newline const char *cl = pos; // unpickle the object, and insert it beneath the method table value pos = unpickle(l, end); // If it is a reference, don't run the unserializer. It has either // already been run, or the data is still building (cyclic // references will do that to you.) if (*end != 'r') { // get PiSerializerClasses[typename] lua_getfield(l, LUA_REGISTRYINDEX, "PiSerializerClasses"); lua_pushlstring(l, cl, len); lua_gettable(l, -2); lua_remove(l, -2); if (lua_isnil(l, -1)) { lua_pop(l, 2); break; } lua_getfield(l, -1, "Unserialize"); if (lua_isnil(l, -1)) { lua_pushlstring(l, cl, len); luaL_error(l, "No Unserialize method found for class '%s'\n", lua_tostring(l, -1)); } lua_insert(l, -3); lua_pop(l, 1); pi_lua_protected_call(l, 1, 1); } break; } default: throw SavedGameCorruptException(); } LUA_DEBUG_END(l, 1); return pos; }
int CLuaVector4Defs::Create ( lua_State* luaVM ) { CVector4D vector; CScriptArgReader argStream ( luaVM ); if ( argStream.NextIsTable () ) { lua_pushvalue ( luaVM, 1 ); lua_pushstring ( luaVM, "x" ); lua_rawget ( luaVM, -2 ); if ( lua_isnumber ( luaVM, -1 ) ) { vector.fX = ( float ) lua_tonumber ( luaVM, -1 ); lua_pop ( luaVM, 1 ); } else { lua_pop ( luaVM, 1 ); lua_rawgeti ( luaVM, -1, 1 ); if ( lua_isnumber ( luaVM, -1 ) ) vector.fX = ( float ) lua_tonumber ( luaVM, -1 ); lua_pop ( luaVM, 1 ); } lua_pushstring ( luaVM, "y" ); lua_rawget ( luaVM, -2 ); if ( lua_isnumber ( luaVM, -1 ) ) { vector.fY = ( float ) lua_tonumber ( luaVM, -1 ); lua_pop ( luaVM, 1 ); } else { lua_pop ( luaVM, 1 ); lua_rawgeti ( luaVM, -1, 2 ); if ( lua_isnumber ( luaVM, -1 ) ) vector.fY = ( float ) lua_tonumber ( luaVM, -1 ); lua_pop ( luaVM, 1 ); } lua_pushstring ( luaVM, "z" ); lua_rawget ( luaVM, -2 ); if ( lua_isnumber ( luaVM, -1 ) ) { vector.fZ = ( float ) lua_tonumber ( luaVM, -1 ); lua_pop ( luaVM, 1 ); } else { lua_pop ( luaVM, 1 ); lua_rawgeti ( luaVM, -1, 3 ); if ( lua_isnumber ( luaVM, -1 ) ) vector.fZ = ( float ) lua_tonumber ( luaVM, -1 ); lua_pop ( luaVM, 1 ); } lua_pushstring ( luaVM, "w" ); lua_rawget ( luaVM, -2 ); if ( lua_isnumber ( luaVM, -1 ) ) { vector.fW = ( float ) lua_tonumber ( luaVM, -1 ); lua_pop ( luaVM, 1 ); } else { lua_pop ( luaVM, 1 ); lua_rawgeti ( luaVM, -1, 4 ); if ( lua_isnumber ( luaVM, -1 ) ) vector.fW = ( float ) lua_tonumber ( luaVM, -1 ); lua_pop ( luaVM, 1 ); } } else if ( argStream.NextIsNumber () ) { argStream.ReadNumber ( vector.fX ); if ( argStream.NextIsNumber () ) { argStream.ReadNumber ( vector.fY ); if ( argStream.NextIsNumber () ) argStream.ReadNumber ( vector.fZ ); if ( argStream.NextIsNumber () ) argStream.ReadNumber ( vector.fW ); } } else if ( argStream.NextIsVector4D () ) { argStream.ReadVector4D ( vector ); } lua_pushvector ( luaVM, vector ); return 1; }
void LuaSerializer::pickle(lua_State *l, int to_serialize, std::string &out, std::string key) { static char buf[256]; LUA_DEBUG_START(l); // tables are pickled recursively, so we can run out of Lua stack space if we're not careful // start by ensuring we have enough (this grows the stack if necessary) // (20 is somewhat arbitrary) if (!lua_checkstack(l, 20)) luaL_error(l, "The Lua stack couldn't be extended (out of memory?)"); to_serialize = lua_absindex(l, to_serialize); int idx = to_serialize; if (lua_getmetatable(l, idx)) { lua_getfield(l, -1, "class"); if (lua_isnil(l, -1)) lua_pop(l, 2); else { const char *cl = lua_tostring(l, -1); snprintf(buf, sizeof(buf), "o%s\n", cl); lua_getfield(l, LUA_REGISTRYINDEX, "PiSerializerClasses"); lua_getfield(l, -1, cl); if (lua_isnil(l, -1)) luaL_error(l, "No Serialize method found for class '%s'\n", cl); lua_getfield(l, -1, "Serialize"); if (lua_isnil(l, -1)) luaL_error(l, "No Serialize method found for class '%s'\n", cl); lua_pushvalue(l, idx); pi_lua_protected_call(l, 1, 1); idx = lua_gettop(l); if (lua_isnil(l, idx)) { lua_pop(l, 5); LUA_DEBUG_END(l, 0); return; } out += buf; } } switch (lua_type(l, idx)) { case LUA_TNIL: break; case LUA_TNUMBER: { snprintf(buf, sizeof(buf), "f%f\n", lua_tonumber(l, idx)); out += buf; break; } case LUA_TBOOLEAN: { snprintf(buf, sizeof(buf), "b%d", lua_toboolean(l, idx) ? 1 : 0); out += buf; break; } case LUA_TSTRING: { lua_pushvalue(l, idx); size_t len; const char *str = lua_tolstring(l, -1, &len); snprintf(buf, sizeof(buf), "s" SIZET_FMT "\n", len); out += buf; out.append(str, len); lua_pop(l, 1); break; } case LUA_TTABLE: { lua_pushinteger(l, lua_Integer(lua_topointer(l, to_serialize))); // ptr lua_getfield(l, LUA_REGISTRYINDEX, "PiSerializerTableRefs"); // ptr reftable lua_pushvalue(l, -2); // ptr reftable ptr lua_rawget(l, -2); // ptr reftable ??? if (!lua_isnil(l, -1)) { out += "r"; pickle(l, -3, out, key); lua_pop(l, 3); // [empty] } else { out += "t"; lua_pushvalue(l, -3); // ptr reftable nil ptr lua_pushvalue(l, to_serialize); // ptr reftable nil ptr table lua_rawset(l, -4); // ptr reftable nil pickle(l, -3, out, key); lua_pop(l, 3); // [empty] lua_pushvalue(l, idx); lua_pushnil(l); while (lua_next(l, -2)) { lua_pushvalue(l, -2); const char *k = lua_tostring(l, -1); std::string new_key = key + "." + (k? std::string(k) : "<" + std::string(lua_typename(l, lua_type(l, -1))) + ">"); lua_pop(l, 1); // Copy the values to pickle, as they might be mutated by the pickling process. pickle(l, -2, out, new_key); pickle(l, -1, out, new_key); lua_pop(l, 1); } lua_pop(l, 1); out += "n"; } break; } case LUA_TUSERDATA: { out += "u"; LuaObjectBase *lo = static_cast<LuaObjectBase*>(lua_touserdata(l, idx)); void *o = lo->GetObject(); if (!o) Error("Lua serializer '%s' tried to serialize an invalid '%s' object", key.c_str(), lo->GetType()); out += lo->Serialize(); break; } default: Error("Lua serializer '%s' tried to serialize %s value", key.c_str(), lua_typename(l, lua_type(l, idx))); break; } if (idx != lua_absindex(l, to_serialize)) // It means we called a transformation function on the data, so we clean it up. lua_pop(l, 5); LUA_DEBUG_END(l, 0); }
static int luaB_rawget (lua_State *L) { luaL_checktype(L, 1, LUA_TTABLE); luaL_checkany(L, 2); lua_rawget(L, 1); return 1; }
int tLuaObject::index(lua_State* L) { lua_rawget(L, -2); return 1; }
int ngx_http_lua_coroutine_create_helper(lua_State *L, ngx_http_request_t **pr, ngx_http_lua_ctx_t **pctx, ngx_http_lua_co_ctx_t **pcoctx) { lua_State *mt; /* the main thread */ lua_State *co; /* new coroutine to be created */ ngx_http_request_t *r; ngx_http_lua_main_conf_t *lmcf; ngx_http_lua_ctx_t *ctx; ngx_http_lua_co_ctx_t *coctx; /* co ctx for the new coroutine */ luaL_argcheck(L, lua_isfunction(L, 1) && !lua_iscfunction(L, 1), 1, "Lua function expected"); lua_pushlightuserdata(L, &ngx_http_lua_request_key); lua_rawget(L, LUA_GLOBALSINDEX); r = lua_touserdata(L, -1); lua_pop(L, 1); if (r == NULL) { return luaL_error(L, "no request found"); } ctx = ngx_http_get_module_ctx(r, ngx_http_lua_module); if (ctx == NULL) { return luaL_error(L, "no request ctx found"); } ngx_http_lua_check_context(L, ctx, NGX_HTTP_LUA_CONTEXT_REWRITE | NGX_HTTP_LUA_CONTEXT_ACCESS | NGX_HTTP_LUA_CONTEXT_CONTENT); lmcf = ngx_http_get_module_main_conf(r, ngx_http_lua_module); mt = lmcf->lua; /* create new coroutine on root Lua state, so it always yields * to main Lua thread */ co = lua_newthread(mt); ngx_http_lua_probe_user_coroutine_create(r, L, co); coctx = ngx_http_lua_create_co_ctx(r, ctx); if (coctx == NULL) { return luaL_error(L, "out of memory"); } coctx->co = co; coctx->co_status = NGX_HTTP_LUA_CO_SUSPENDED; /* make new coroutine share globals of the parent coroutine. * NOTE: globals don't have to be separated! */ lua_pushvalue(L, LUA_GLOBALSINDEX); lua_xmove(L, co, 1); lua_replace(co, LUA_GLOBALSINDEX); lua_xmove(mt, L, 1); /* move coroutine from main thread to L */ lua_pushvalue(L, 1); /* copy entry function to top of L*/ lua_xmove(L, co, 1); /* move entry function from L to co */ if (pcoctx) { *pcoctx = coctx; } if (pctx) { *pctx = ctx; } if (pr) { *pr = r; } return 1; /* return new coroutine to Lua */ }
static void mar_encode_value(lua_State *L, mar_Buffer *buf, int val, size_t *idx) { size_t l; int val_type = lua_type(L, val); lua_pushvalue(L, val); buf_write(L, (void*)&val_type, MAR_CHR, buf); switch (val_type) { case LUA_TBOOLEAN: { int int_val = lua_toboolean(L, -1); buf_write(L, (void*)&int_val, MAR_CHR, buf); break; } case LUA_TSTRING: { const char *str_val = lua_tolstring(L, -1, &l); buf_write(L, (void*)&l, MAR_I32, buf); buf_write(L, str_val, l, buf); break; } case LUA_TNUMBER: { lua_Number num_val = lua_tonumber(L, -1); buf_write(L, (void*)&num_val, MAR_I64, buf); break; } case LUA_TTABLE: { int tag, ref; lua_pushvalue(L, -1); lua_rawget(L, SEEN_IDX); if (!lua_isnil(L, -1)) { ref = lua_tointeger(L, -1); tag = MAR_TREF; buf_write(L, (void*)&tag, MAR_CHR, buf); buf_write(L, (void*)&ref, MAR_I32, buf); lua_pop(L, 1); } else { mar_Buffer rec_buf; lua_pop(L, 1); /* pop nil */ if (luaL_getmetafield(L, -1, "__persist")) { tag = MAR_TUSR; lua_pushvalue(L, -2); /* self */ lua_call(L, 1, 1); if (!lua_isfunction(L, -1)) { luaL_error(L, "__persist must return a function"); } lua_remove(L, -2); /* __persist */ lua_newtable(L); lua_pushvalue(L, -2); /* callback */ lua_rawseti(L, -2, 1); buf_init(L, &rec_buf); mar_encode_table(L, &rec_buf, idx); buf_write(L, (void*)&tag, MAR_CHR, buf); buf_write(L, (void*)&rec_buf.head, MAR_I32, buf); buf_write(L, rec_buf.data, rec_buf.head, buf); buf_done(L, &rec_buf); lua_pop(L, 1); } else { tag = MAR_TVAL; lua_pushvalue(L, -1); lua_pushinteger(L, (*idx)++); lua_rawset(L, SEEN_IDX); lua_pushvalue(L, -1); buf_init(L, &rec_buf); mar_encode_table(L, &rec_buf, idx); lua_pop(L, 1); buf_write(L, (void*)&tag, MAR_CHR, buf); buf_write(L, (void*)&rec_buf.head, MAR_I32, buf); buf_write(L, rec_buf.data,rec_buf.head, buf); buf_done(L, &rec_buf); } } break; } case LUA_TFUNCTION: { int tag, ref; lua_pushvalue(L, -1); lua_rawget(L, SEEN_IDX); if (!lua_isnil(L, -1)) { ref = lua_tointeger(L, -1); tag = MAR_TREF; buf_write(L, (void*)&tag, MAR_CHR, buf); buf_write(L, (void*)&ref, MAR_I32, buf); lua_pop(L, 1); } else { mar_Buffer rec_buf; int i; lua_Debug ar; lua_pop(L, 1); /* pop nil */ lua_pushvalue(L, -1); lua_getinfo(L, ">nuS", &ar); if (ar.what[0] != 'L') { luaL_error(L, "attempt to persist a C function '%s'", ar.name); } tag = MAR_TVAL; lua_pushvalue(L, -1); lua_pushinteger(L, (*idx)++); lua_rawset(L, SEEN_IDX); lua_pushvalue(L, -1); buf_init(L, &rec_buf); lua_dump(L, (lua_Writer)buf_write, &rec_buf); buf_write(L, (void*)&tag, MAR_CHR, buf); buf_write(L, (void*)&rec_buf.head, MAR_I32, buf); buf_write(L, rec_buf.data, rec_buf.head, buf); buf_done(L, &rec_buf); lua_pop(L, 1); lua_newtable(L); for (i=1; i <= ar.nups; i++) { lua_getupvalue(L, -2, i); lua_rawseti(L, -2, i); } buf_init(L, &rec_buf); mar_encode_table(L, &rec_buf, idx); buf_write(L, (void*)&rec_buf.head, MAR_I32, buf); buf_write(L, rec_buf.data, rec_buf.head, buf); buf_done(L, &rec_buf); lua_pop(L, 1); } break; } case LUA_TUSERDATA: { int tag, ref; lua_pushvalue(L, -1); lua_rawget(L, SEEN_IDX); if (!lua_isnil(L, -1)) { ref = lua_tointeger(L, -1); tag = MAR_TREF; buf_write(L, (void*)&tag, MAR_CHR, buf); buf_write(L, (void*)&ref, MAR_I32, buf); lua_pop(L, 1); } else { mar_Buffer rec_buf; lua_pop(L, 1); /* pop nil */ if (luaL_getmetafield(L, -1, "__persist")) { tag = MAR_TUSR; lua_pushvalue(L, -2); lua_pushinteger(L, (*idx)++); lua_rawset(L, SEEN_IDX); lua_pushvalue(L, -2); lua_call(L, 1, 1); if (!lua_isfunction(L, -1)) { luaL_error(L, "__persist must return a function"); } lua_newtable(L); lua_pushvalue(L, -2); lua_rawseti(L, -2, 1); lua_remove(L, -2); buf_init(L, &rec_buf); mar_encode_table(L, &rec_buf, idx); buf_write(L, (void*)&tag, MAR_CHR, buf); buf_write(L, (void*)&rec_buf.head, MAR_I32, buf); buf_write(L, rec_buf.data, rec_buf.head, buf); buf_done(L, &rec_buf); } else { luaL_error(L, "attempt to encode userdata (no __persist hook)"); } lua_pop(L, 1); } break; } case LUA_TNIL: break; default: luaL_error(L, "invalid value type (%s)", lua_typename(L, val_type)); } lua_pop(L, 1); }
TOLUA_API void tolua_open (lua_State* L) { int top = lua_gettop(L); lua_pushstring(L,"tolua_opened"); lua_rawget(L,LUA_REGISTRYINDEX); if (!lua_isboolean(L,-1)) { lua_pushstring(L,"tolua_opened"); lua_pushboolean(L,1); lua_rawset(L,LUA_REGISTRYINDEX); /** create value root table */ lua_pushstring(L, TOLUA_VALUE_ROOT); lua_newtable(L); lua_rawset(L, LUA_REGISTRYINDEX); #ifndef LUA_VERSION_NUM /* only prior to lua 5.1 */ /* create peer object table */ lua_pushstring(L, "tolua_peers"); lua_newtable(L); /* make weak key metatable for peers indexed by userdata object */ lua_newtable(L); lua_pushliteral(L, "__mode"); lua_pushliteral(L, "k"); lua_rawset(L, -3); /* stack: string peers mt */ lua_setmetatable(L, -2); /* stack: string peers */ lua_rawset(L,LUA_REGISTRYINDEX); #endif /* create object ptr -> udata mapping table */ lua_pushstring(L,"tolua_ubox"); lua_newtable(L); /* make weak value metatable for ubox table to allow userdata to be garbage-collected */ lua_newtable(L); lua_pushliteral(L, "__mode"); lua_pushliteral(L, "v"); lua_rawset(L, -3); /* stack: string ubox mt */ lua_setmetatable(L, -2); /* stack: string ubox */ lua_rawset(L,LUA_REGISTRYINDEX); // /* create object ptr -> class type mapping table */ // lua_pushstring(L, "tolua_ptr2type"); // lua_newtable(L); // lua_rawset(L, LUA_REGISTRYINDEX); lua_pushstring(L,"tolua_super"); lua_newtable(L); lua_rawset(L,LUA_REGISTRYINDEX); lua_pushstring(L,"tolua_gc"); lua_newtable(L); lua_rawset(L,LUA_REGISTRYINDEX); /* create gc_event closure */ lua_pushstring(L, "tolua_gc_event"); lua_pushstring(L, "tolua_gc"); lua_rawget(L, LUA_REGISTRYINDEX); lua_pushstring(L, "tolua_super"); lua_rawget(L, LUA_REGISTRYINDEX); lua_pushcclosure(L, class_gc_event, 2); lua_rawset(L, LUA_REGISTRYINDEX); tolua_newmetatable(L,"tolua_commonclass"); tolua_module(L,NULL,0); tolua_beginmodule(L,NULL); tolua_module(L,"tolua",0); tolua_beginmodule(L,"tolua"); tolua_function(L,"type",tolua_bnd_type); tolua_function(L,"takeownership",tolua_bnd_takeownership); tolua_function(L,"releaseownership",tolua_bnd_releaseownership); tolua_function(L,"cast",tolua_bnd_cast); tolua_function(L,"isnull",tolua_bnd_isnulluserdata); tolua_function(L,"inherit", tolua_bnd_inherit); #ifdef LUA_VERSION_NUM /* lua 5.1 */ tolua_function(L, "setpeer", tolua_bnd_setpeer); tolua_function(L, "getpeer", tolua_bnd_getpeer); #endif tolua_endmodule(L); tolua_endmodule(L); } lua_settop(L,top); }
// decrease lua function reference counter, return counter int LuaJavaBridge::releaseLuaFunctionById(int functionId) { lua_State *L = s_luaState; /* L: */ lua_pushstring(L, LUAJ_REGISTRY_FUNCTION); /* L: key */ lua_rawget(L, LUA_REGISTRYINDEX); /* L: f_id */ if (!lua_istable(L, -1)) { lua_pop(L, 1); LOGD("%s", "luajreleaseLuaFunctionById() - LUAJ_REGISTRY_FUNCTION not exists"); return 0; } lua_pushstring(L, LUAJ_REGISTRY_RETAIN); /* L: f_id key */ lua_rawget(L, LUA_REGISTRYINDEX); /* L: f_id id_r */ if (!lua_istable(L, -1)) { lua_pop(L, 2); LOGD("%s", "luajreleaseLuaFunctionById() - LUAJ_REGISTRY_RETAIN not exists"); return 0; } lua_pushinteger(L, functionId); /* L: f_id id_r id */ lua_rawget(L, -2); /* L: f_id id_r r */ if (lua_type(L, -1) != LUA_TNUMBER) { lua_pop(L, 3); LOGD("luajreleaseLuaFunctionById() - function id %d not found", functionId); return 0; } int retainCount = lua_tonumber(L, -1); retainCount--; if (retainCount > 0) { // update counter lua_pop(L, 1); /* L: f_id id_r */ lua_pushinteger(L, functionId); /* L: f_id id_r id */ lua_pushinteger(L, retainCount); /* L: f_id id_r id r */ lua_rawset(L, -3); /* id_r[id] = r, L: f_id id_r */ lua_pop(L, 2); LOGD("luajreleaseLuaFunctionById() - function id %d retain count = %d", functionId, retainCount); return retainCount; } // remove lua function reference lua_pop(L, 1); /* L: f_id id_r */ lua_pushinteger(L, functionId); /* L: f_id id_r id */ lua_pushnil(L); /* L: f_id id_r id nil */ lua_rawset(L, -3); /* id_r[id] = nil, L: f_id id_r */ lua_pop(L, 1); /* L: f_id */ lua_pushnil(L); /* L: f_id nil */ while (lua_next(L, -2) != 0) /* L: f_id f id */ { int value = lua_tonumber(L, -1); lua_pop(L, 1); /* L: f_id f */ if (value == functionId) { lua_pushnil(L); /* L: f_id f nil */ lua_rawset(L, -3); /* f_id[f] = nil, L: f_id */ break; } } /* L: f_id */ lua_pop(L, 1); LOGD("luajreleaseLuaFunctionById() - function id %d released", functionId); return 0; }
LUALIB_API void luaL_getmetatable (lua_State *L, const char *tname) { lua_pushstring(L, tname); lua_rawget(L, LUA_REGISTRYINDEX); }
int AudioBinder::Sound_create(lua_State *L) { StackChecker checker(L, "AudioBinder::Sound_create", 1); Binder binder(L); const char *fileName = luaL_checkstring(L, 1); std::vector<char> sig; int flags = gpath_getDriveFlags(gpath_getPathDrive(fileName)); if (flags & GPATH_RO) { append(sig, fileName, strlen(fileName) + 1); } else { if (flags & GPATH_REAL) { append(sig, fileName, strlen(fileName) + 1); struct stat s; stat(gpath_transform(fileName), &s); append(sig, &s.st_mtime, sizeof(s.st_mtime)); } } GGSound *sound = NULL; luaL_rawgetptr(L, LUA_REGISTRYINDEX, &keySound); if (sig.empty()) { lua_pushnil(L); } else { lua_pushlstring(L, &sig[0], sig.size()); lua_rawget(L, -2); } if (!lua_isnil(L, -1)) { sound = static_cast<GGSound*>(lua_touserdata(L, -1)); sound->ref(); } else { gaudio_Error error; sound = new GGSound(L, fileName, &error, sig); switch (error) { case GAUDIO_NO_ERROR: break; case GAUDIO_CANNOT_OPEN_FILE: sound->unref(); luaL_error(L, "%s: No such file or directory.", fileName); break; case GAUDIO_UNRECOGNIZED_FORMAT: sound->unref(); luaL_error(L, "%s: Sound format is not recognized.", fileName); break; case GAUDIO_ERROR_WHILE_READING: sound->unref(); luaL_error(L, "%s: Error while reading.", fileName); break; case GAUDIO_UNSUPPORTED_FORMAT: sound->unref(); luaL_error(L, "%s: Sound format is not supported.", fileName); break; case GAUDIO_INTERNAL_ERROR: sound->unref(); luaL_error(L, "%s: Sound internal error.", fileName); break; } } lua_pop(L, 2); binder.pushInstance("Sound", sound); return 1; }