예제 #1
0
파일: proxy.hpp 프로젝트: ocirne23/GLEngine
		type get_type() const {
			type t = type::none;
			auto pp = stack::push_pop(tbl);
			auto p = stack::probe_get_field<std::is_same<meta::unqualified_t<Table>, global_table>::value>(lua_state(), key, lua_gettop(lua_state()));
			if (p) {
				t = type_of(lua_state(), -1);
			}
			lua_pop(lua_state(), p.levels);
			return t;
		}
예제 #2
0
		int push(lua_State* Ls) const noexcept {
			if (lua_state() == nullptr) {
				lua_pushnil(Ls);
				return 1;
			}
			lua_pushvalue(lua_state(), index);
			if (Ls != lua_state()) {
				lua_xmove(lua_state(), Ls, 1);
			}
			return 1;
		}
예제 #3
0
파일: main.cpp 프로젝트: wonghoifung/tips
int main() {
	if (!lua_init()) {
		printf("cannot init lua\n");
		exit(1);
	}
	
	lua_register(lua_state(), "simpleclient_create", simpleclient_create_lua);
	lua_register(lua_state(), "simpleclient_destroy", simpleclient_destroy_lua);
	lua_register(lua_state(), "simpleclient_connect", simpleclient_connect_lua);

	lua_dofile("./scripts/main.lua");
	
	lua_fini();
}
예제 #4
0
	virtual int on_timeout(int tid) {
		lua_timer* ltimer = gtimers[tid];

		if (!ltimer) {
			printf("timer %d no callback\n", tid);
			return -1;
		}

		printf("%s\n", ltimer->cbname);

		lua_getglobal(lua_state(), ltimer->cbname);

	    lua_pushlightuserdata(lua_state(), (void*)ltimer);

	    lua_call(lua_state(), 1, 0);

	    return 0;
	}
예제 #5
0
		stack_reference(lua_State* L, const stack_reference& r) noexcept
		: luastate(L) {
			if (!r.valid()) {
				index = 0;
				return;
			}
			int i = r.stack_index();
			if (detail::xmovable(lua_state(), r.lua_state())) {
				lua_pushvalue(r.lua_state(), r.index);
				lua_xmove(r.lua_state(), luastate, 1);
				i = absolute_index(luastate, -1);
			}
			index = i;
		}
예제 #6
0
static int
lua_import_stream(stream_t* stream, const uuid_t uuid, luaimport_dump_t* dump) {
	lua_t* env;
	lua_State* state;
	int result = 0;
	lua_readstream_t read_stream = {
		.stream = stream,
	};

	env = lua_allocate();
	state = lua_state(env);

	if (lua_load(state, lua_read_stream, &read_stream, "import") != 0) {
		log_errorf(HASH_LUA, ERROR_INTERNAL_FAILURE, STRING_CONST("Lua load failed: %s"),
		           lua_tostring(state, -1));
		lua_pop(state, 1);
		result = -1;
		goto exit;
	}

	lua_dump(state, lua_import_dump_writer, dump);

	if (lua_pcall(state, 0, 0, 0) != 0) {
		log_errorf(HASH_LUA, ERROR_INTERNAL_FAILURE, STRING_CONST("Lua pcall failed: %s"),
		           lua_tostring(state, -1));
		lua_pop(state, 1);
		result = -1;
		goto exit;
	}

	log_debug(HASH_LUA, STRING_CONST("Lua bytecode dump successful"));

exit:

	lua_deallocate(env);

	return result;
}
예제 #7
0
		int push() const noexcept {
			return push(lua_state());
		}
예제 #8
0
		type get_type() const noexcept {
			int result = lua_type(lua_state(), index);
			return static_cast<type>(result);
		}
예제 #9
0
		void pop() const noexcept {
			pop(lua_state());
		}
예제 #10
0
파일: thread.hpp 프로젝트: Enverex/mame
		thread create() {
			return create(lua_state());
		}
예제 #11
0
파일: thread.hpp 프로젝트: Enverex/mame
		lua_State* thread_state() const {
			auto pp = stack::push_pop(*this);
			lua_State* lthread = lua_tothread(lua_state(), -1);
			return lthread;
		}
예제 #12
0
파일: proxy.hpp 프로젝트: ocirne23/GLEngine
		auto setup_table(std::true_type) {
			auto p = stack::probe_get_field<std::is_same<meta::unqualified_t<Table>, global_table>::value>(lua_state(), key, tbl.stack_index());
			lua_pop(lua_state(), p.levels);
			return p;
		}
예제 #13
0
int
lua_module_reload(lua_t* lua, const uuid_t uuid) {
	int ret = -1;
	lua_State* state = lua_state(lua);
	lua_modulemap_entry_t* entry = lua_module_registry_lookup(state, uuid);
	if (entry) {
		int stacksize = lua_gettop(state);

		lua_module_t module = lua_module_load_resource(uuid);
		if (module.size) {
			string_const_t uuidstr = string_from_uuid_static(uuid);
			log_debugf(HASH_LUA, STRING_CONST("Reloading module: %.*s"), STRING_FORMAT(uuidstr));
			if (lua_module_upload(state, module.bytecode, module.size) == 0) {
				//Check if module loaded as a table
				if (lua_istable(state, -1)) {
					lua_pushlstring(state, STRING_CONST(BUILD_REGISTRY_LOADED_MODULES));
					lua_gettable(state, LUA_REGISTRYINDEX);

					//Get and replace the old loaded module table
					lua_pushlightuserdata(state, entry);
					lua_gettable(state, -2);
					lua_replace(state, -2); //Get rid of loaded-modules registry table from stack
					if (lua_istable(state, -1)) {
						lua_pushlstring(state, STRING_CONST("__modulename"));
						lua_gettable(state, -2);

						size_t name_length = 0;
						const char* modulename = lua_isnil(state, -1)
						                         ? nullptr
						                         : luaL_checklstring(state, -1, &name_length);
						log_debugf(HASH_LUA, STRING_CONST("Replacing module table: %.*s (%.*s)"),
						           STRING_FORMAT(uuidstr), (int)name_length, modulename);
						lua_pop(state, 1); //Get rid of name from stack

						//Clear previous loaded-modules table
						lua_pushnil(state);
						while (lua_next(state, -2) != 0) {
							lua_pop(state, 1); //Old value
							lua_pushnil(state); //Replace with nil
							lua_settable(state, -3); //Erase in previous loaded-modules table
							lua_pushnil(state); //Restart lua_next
						}

						//Copy new module table to previous loaded-modules table
						lua_pushnil(state);
						while (lua_next(state, -3) != 0) { //Lookup in new module table
							lua_pushvalue(state, -2); //Copy key
							lua_pushvalue(state, -2); //Copy value
							lua_settable(state, -5); //Set in previous loaded-modules table
							lua_pop(state, 1); //Pop value, leaving key for lua_next iteration
						}

						lua_pushlstring(state, STRING_CONST("__modulename"));
						lua_pushlstring(state, modulename, name_length);
						lua_settable(state, -3);
					}
				}
				ret = 0;
			}
			else {
				uuidstr = string_from_uuid_static(uuid);
				log_warnf(HASH_LUA, WARNING_RESOURCE, STRING_CONST("Unable to reload module '%.*s'"),
				          STRING_FORMAT(uuidstr));
			}
		}
		else {
			string_const_t uuidstr = string_from_uuid_static(uuid);
			log_warnf(HASH_LUA, WARNING_RESOURCE, STRING_CONST("Unable to load module '%.*s'"),
			          STRING_FORMAT(uuidstr));
		}

		lua_settop(state, stacksize);
	}
	else {
		string_const_t uuidstr = string_from_uuid_static(uuid);
		log_debugf(HASH_LUA, STRING_CONST("Reloading module ignored, not loaded: %.*s"),
		           STRING_FORMAT(uuidstr));
	}
	return ret;
}
예제 #14
0
bool
lua_module_is_loaded(lua_t* lua, const uuid_t uuid) {
	return lua_module_registry_lookup(lua_state(lua), uuid) != nullptr;
}
예제 #15
0
void register_lua_timer() {
	lua_register(lua_state(), "create_timer", create_timer_lua);
	lua_register(lua_state(), "destroy_timer", destroy_timer_lua);
	lua_register(lua_state(), "start_timer", start_timer_lua);
	lua_register(lua_state(), "stop_timer", stop_timer_lua);
}
예제 #16
0
void register_lua_skeleton()
{
	lua_register(lua_state(), "skeleton_eventloop", skeleton_eventloop_lua);
	lua_register(lua_state(), "skeleton_init", skeleton_init_lua);
	lua_register(lua_state(), "skeleton_run", skeleton_run_lua);
}
예제 #17
0
파일: proxy.hpp 프로젝트: ocirne23/GLEngine
		bool is_valid(std::false_type) {
			auto pp = stack::push_pop(tbl);
			auto p = stack::probe_get_field<std::is_same<meta::unqualified_t<Table>, global_table>::value>(lua_state(), key, lua_gettop(lua_state()));
			lua_pop(lua_state(), p.levels);
			return p;
		}