mod-mcabber-lua: comparison main.c

equal deleted inserted replaced

-:270ce1cfc823
+:b00f9ce82016
 #include <lualib.h>
 #include <stdio.h>
 #include <stdlib.h>    // getenv
 #include <string.h>    // strcmp
-#include <mcabber/logprint.h>    // scr_LogPrint
+#include <mcabber/logprint.h>    // scr_log_print
 #include <mcabber/screen.h>      // scr_Beep, scr_WriteIncomingMessage
 #include <mcabber/hbuf.h>        // HBB_PREFIX_INFO
 #include <mcabber/commands.h>    // process_command, cmd_add, cmd_del
 #include <mcabber/xmpp.h>        // xmpp_getstatus, xmpp_getstatusmsg, lconnection
 #include <mcabber/xmpp_helper.h> // xmpp_add_feature, xmpp_del_feature
 	"Provides command /lua" )
 #endif
 static module_info_t info_lua_experimental = {
 	.branch      = "experimental",
-	.api         = 5,
+	.api         = 10,
 	.version     = PROJECT_VERSION,
 	.description = DESCRIPTION,
 	.requires    = NULL,
 	.init        = mlua_init,
 	.uninit      = mlua_uninit,
 	.next        = NULL,
 };
 module_info_t info_lua = {
 	.branch      = "dev",
-	.api         = 4,
+	.api         = 11,
 	.version     = PROJECT_VERSION,
 	.description = DESCRIPTION,
 	.requires    = NULL,
 	.init        = mlua_init,
 	.uninit      = mlua_uninit,
 			luaL_addlstring (&B, xbuf, 8); // XXX
 		}
 	}
 	luaL_pushresult (&B);
-	scr_LogPrint (LPRINT_LOGNORM | LPRINT_NOTUTF8, lua_tostring (L, -1));
+	scr_log_print (LPRINT_LOGNORM | LPRINT_NOTUTF8, lua_tostring (L, -1));
 	return 0;
 }
 /// dopath
 /// Loads lua file from default location.
 		char *fname = g_strconcat (name, ".lua", NULL);
 		path = mcabber_config_filename (fname);
 		g_free (fname);
 	}
-	if (ret = luaL_loadfile (L, path))
+	if ((ret = luaL_loadfile (L, path)))
-		scr_LogPrint (LPRINT_LOGNORM, "lua: Unable to compile file %s: %s", path, lua_tostring (L, -1));
+		scr_log_print (LPRINT_LOGNORM, "lua: Unable to compile file %s: %s", path, lua_tostring (L, -1));
-	else if (ret = lua_pcall (L, 0, LUA_MULTRET, 0))
+	else if ((ret = lua_pcall (L, 0, LUA_MULTRET, 0)))
-		scr_LogPrint (LPRINT_LOGNORM, "lua: Runtime error in file %s: %s", path, lua_tostring (L, -1));
+		scr_log_print (LPRINT_LOGNORM, "lua: Runtime error in file %s: %s", path, lua_tostring (L, -1));
 	g_free (path);
 	if (ret)
 		return 1;
 	else
 /// A: log print type, message, message...
 static int lua_main_log (lua_State *L)
 {
 	int type = luaL_checkenum_multi (L, 1, lua_lprint);
 	lua_concat (L, lua_gettop (L) - 1);
-	scr_LogPrint (type, lua_tostring (L, -1));
+	scr_log_print (type, lua_tostring (L, -1));
 	return 0;
 }
 // expects table on top
 static void lua_options_callback (char *key, char *value, lua_State *L)
 static int lua_main_print_info (lua_State *L)
 {
 	char *jid  = to_utf8 (luaL_checkstring (L, 1));
 	char *to   = jidtodisp (jid);
 	char *mesg = to_utf8 (luaL_checkstring (L, 2));
-	scr_WriteIncomingMessage (to, mesg, 0, HBB_PREFIX_INFO, 0);
+	scr_write_incoming_message (to, mesg, 0, HBB_PREFIX_INFO, 0);
 	g_free (mesg);
 	g_free (to);
 	g_free (jid);
 	return 0;
 }
 /// main.beep
 /// Beeps with system speaker.
 static int lua_main_beep (lua_State *L)
 {
-	scr_Beep ();
+	scr_beep ();
 	return 0;
 }
 /// main.run
 /// Runs specified mcabber command.
 {
 	if (lua_gettop (L) > 0) { // Set
 		// XXX: we need not convert to utf, RS works on jids/names in locale charset,
 		// but will jidtodisp always correctly work on such tings?
 		char *jid = jidtodisp (luaL_checkstring (L, 1));
-		scr_RosterSearch (jid);
+		scr_roster_search (jid);
 		g_free (jid);
 		return 0;
 	} else { // Get
 		char *jid = from_utf8 (buddy_getjid (BUDDATA (current_buddy)));
 		lua_pushstring (L, jid);
 	lua_rawgeti (cb->L, LUA_REGISTRYINDEX, cb->reference);
 	luaL_pushenum (cb->L, context, lua_event_context);
 	lua_pushstring (cb -> L, arg);
 	if (lua_pcall (cb->L, 2, 1, 0)) {
-		scr_LogPrint (LPRINT_LOGNORM, "lua: Event callback execution error: %s", lua_tostring (cb->L, -1));
+		scr_log_print (LPRINT_LOGNORM, "lua: Event callback execution error: %s", lua_tostring (cb->L, -1));
 		lua_pop (cb->L, 1);
 	}
 	if (lua_toboolean (cb -> L, -1))
 		return TRUE;
 		luaL_pushargs (cb->L, args);
 	else
 		lua_pushstring (cb->L, args);
 	if (lua_pcall (cb->L, 1, 0, 0)) {
-		scr_LogPrint (LPRINT_LOGNORM, "lua: Command execution error: %s", lua_tostring (cb->L, -1));
+		scr_log_print (LPRINT_LOGNORM, "lua: Command execution error: %s", lua_tostring (cb->L, -1));
 		lua_pop (cb->L, 1);
 	}
 }
 /// main.parse_args
 {
 	guint  cid  = luaL_checkinteger (L, 1);
 	char  *word = to_utf8 (luaL_checkstring (L, 2)); // XXX
 	compl_add_category_word (cid, word);
 	g_free (word);
+	return 0;
 }
 /// main.del_completion
 /// Removes word from a completion list.
 /// A: integer (completion group id), string (word)
 {
 	guint  cid  = luaL_checkinteger (L, 1);
 	char  *word = to_utf8 (luaL_checkstring (L, 2)); // XXX
 	compl_del_category_word (cid, word);
 	g_free (word);
+	return 0;
 }
 /// main.command
 /// Associates or breaks association between mcabber command name and lua function.
 /// To unregister command omit function argument.
 static gboolean lua_timer_callback (lua_timer_callback_t *cb)
 {
 	int ret;
 	lua_rawgeti (cb->L, LUA_REGISTRYINDEX, cb->reference);
 	if (lua_pcall (cb->L, 0, 1, 0)) {
-		scr_LogPrint (LPRINT_LOGNORM, "lua: Timer callback execution error: %s", lua_tostring (cb->L, -1));
+		scr_log_print (LPRINT_LOGNORM, "lua: Timer callback execution error: %s", lua_tostring (cb->L, -1));
 		lua_pop (cb->L, 1);
 		return FALSE;
 	}
 	ret = lua_toboolean (cb->L, -1);
 	lua_pop (cb->L, 1);
 				break;
 			lua_rawgeti (cb->L, LUA_REGISTRYINDEX, cb->reference);
 			lua_pushlstring (cb->L, lua_bgread_buffer, read);
 			if (lua_pcall (cb->L, 1, 1, 0)) {
-				scr_LogPrint (LPRINT_LOGNORM, "lua: Bgread callback execution error: %s", lua_tostring (cb->L, -1));
+				scr_log_print (LPRINT_LOGNORM, "lua: Bgread callback execution error: %s", lua_tostring (cb->L, -1));
 				lua_pop (cb->L, 1);
 				return FALSE;
 			}
 			ret = lua_toboolean (cb->L, -1);
 			lua_pop (cb->L, 1);
 	if (condition & ~G_IO_IN) { // err or hup
 		lua_rawgeti (cb->L, LUA_REGISTRYINDEX, cb->reference);
 		lua_pushnil (cb->L);
 		if (lua_pcall (cb->L, 1, 1, 0)) {
-			scr_LogPrint (LPRINT_LOGNORM, "lua: Bgread callback execution error: %s", lua_tostring (cb->L, -1));
+			scr_log_print (LPRINT_LOGNORM, "lua: Bgread callback execution error: %s", lua_tostring (cb->L, -1));
 			lua_pop (cb->L, 1);
 			return FALSE;
 		}
 		ret = lua_toboolean (cb->L, -1);
 		lua_pop (cb->L, 1);
 	// unref?
 	return 0;
 }
-// MAIN INITIALIZATION CODE
+// HOOK HANDLING
-#ifdef LLM_LOG_HANDLER
+typedef struct {
-// FIXME: this should not be here
+	lua_State *L;       // lua environment for handler use
-guint lua_lm_log_handler_id;
+	int        nameref; // reference to hook name string
+	int        cbref;   // reference to hook handler function
-void lua_lm_log_handler (const gchar *domain, GLogLevelFlags log_level, const gchar *message, gpointer ignore)
+	int        selfref; // self-reference to object
-{
+	guint      hid;     // hook id for object destruction
-	if (settings_opt_get_int ("lua_lm_debug"))
+} lua_hook_t;
-		scr_LogPrint (LPRINT_LOGNORM, "%s: %s", domain, message);
-}
+/// hook handler result
-#endif
+/// What to do with hook processing afterwards
+/// G:
-static void do_lua(char *arg, lua_State *L)
+static const string2enum_t lua_hook_handler_result[] = {
-{
+	{ "proceed", HOOK_HANDLER_RESULT_ALLOW_MORE_HANDLERS       },
-	if (luaL_loadbuffer (L, arg, strlen (arg), "line")) {
+	{ "stop",    HOOK_HANDLER_RESULT_NO_MORE_HANDLER           },
-		scr_LogPrint (LPRINT_LOGNORM, "lua: Compilation error: %s", lua_tostring (L, -1));
+	{ "drop",    HOOK_HANDLER_RESULT_NO_MORE_HANDLER_DROP_DATA },
-		lua_pop (L, 1);
+	{ NULL,      HOOK_HANDLER_RESULT_ALLOW_MORE_HANDLERS       },
-		return;
+};
-	}
+/// hook handler priority
-	if (lua_pcall (L, 0, 0, 0)) {
+/// Feel free to specify just a number instead of some preset value.
-		scr_LogPrint (LPRINT_NORMAL, "lua: Runtime error: %s", lua_tostring(L, -1));
+/// G:
-		lua_pop (L, 1);
+static const string2enum_t lua_hook_handler_priority[] = {
-		return;
+	{ "high",      G_PRIORITY_HIGH         },
-	}
+	{ "default",   G_PRIORITY_DEFAULT      },
-}
+	{ "idle-high", G_PRIORITY_HIGH_IDLE    },
+	{ "idle",      G_PRIORITY_DEFAULT_IDLE },
-static void lua_hook (guint32 hookid, hk_arg_t *args, lua_State *L)
+	{ "low",       G_PRIORITY_LOW          },
-{
+	{ NULL,        G_PRIORITY_DEFAULT      },
-	hk_arg_t   *arg  = args;
+};
-	const char *hook = settings_opt_get ("lua_hook_function");
-	if (!hook)
+/// hook function
-		return;
+/// Function to be called, when hook will be processsed.
-	lua_getglobal (L, hook);
+/// XXX: we can provide object as argument, but is this necessary?
+/// A: table (arguments hash)
+/// R: hook handler result
+static guint lua_hook_cb (const gchar *hookid, hk_arg_t *args, gpointer data)
+{
+	lua_hook_t *cb  = data;
+	hk_arg_t   *arg = args;
+	guint       ret = HOOK_HANDLER_RESULT_ALLOW_MORE_HANDLERS;
+	lua_State  *L   = cb -> L;
+	if (cb -> cbref == LUA_NOREF)
+		return HOOK_HANDLER_RESULT_ALLOW_MORE_HANDLERS;
+	lua_rawgeti (L, LUA_REGISTRYINDEX, cb -> cbref);
 	if (!lua_isfunction (L, -1)) {
 		lua_pop (L, 1);
-		return;
+		return HOOK_HANDLER_RESULT_ALLOW_MORE_HANDLERS;
 	}
 	lua_newtable (L);
+	lua_pushliteral (L, "hook");
+	lua_pushstring  (L, hookid);
+	lua_settable (L, -3);
 	while (arg->name != NULL) {
 		char *name  = from_utf8 (arg->name);
 		char *value = from_utf8 (arg->value);
 		lua_pushstring (L, name);
 		lua_pushstring (L, value);
 		lua_settable (L, -3);
 		g_free (name);
 		g_free (value);
 		arg++;
 	}
-	if (lua_pcall (L, 1, 0, 0)) {
-		scr_LogPrint (LPRINT_NORMAL, "lua: Error in hook handler: %s", lua_tostring (L, -1));
+	if (lua_pcall (L, 1, 1, 0)) {
+		scr_log_print (LPRINT_NORMAL, "lua: Error in hook handler: %s", lua_tostring (L, -1));
 		lua_pop (L, 1);
+	} else {
+		switch (lua_type (L, -1)) {
+		case LUA_TSTRING:
+		case LUA_TNUMBER:
+			ret = luaL_checkenum (L, -1, lua_hook_handler_result);
+			break;
+		default:
+			ret = HOOK_HANDLER_RESULT_ALLOW_MORE_HANDLERS;
+			break;
+		}
+		lua_pop (L, 1);
+	}
+	return ret;
+}
+/// main.hook
+/// Installs hook handler, returns an object, that you need to keep until
+/// hook handling is no more needed.
+/// A: string (hook name), hook function, integer (priority, optional)
+/// R: userdata (hook object)
+static int lua_main_hook (lua_State *L)
+{
+	const char   *hook_name = luaL_checkstring (L, 1);
+	int           priority  = G_PRIORITY_DEFAULT;
+	lua_hook_t   *cb;
+	luaL_argcheck (L, lua_isfunction (L, 2), 2, "function expected");
+	if (lua_gettop (L) > 2)
+		priority = luaL_checkenum (L, 3, lua_hook_handler_priority);
+	cb = lua_newuserdata (L, sizeof (lua_hook_t));
+	luaL_getmetatable (L, "mcabber.hook");
+	lua_setmetatable (L, -2);
+	lua_pushvalue (L, -1);
+	cb -> selfref = luaL_ref (L, LUA_REGISTRYINDEX);
+	lua_pushvalue (L, 1);
+	cb -> nameref = luaL_ref (L, LUA_REGISTRYINDEX);
+	lua_pushvalue (L, 2);
+	cb -> cbref   = luaL_ref (L, LUA_REGISTRYINDEX);
+	cb -> L       = L;
+	cb -> hid     = hk_add_handler (lua_hook_cb, hook_name, priority, cb);
+	return 1;
+}
+static void lua_mcabber_unregister_hook (lua_State *L, lua_hook_t *cb)
+{
+	const char *name;
+	if (!cb -> hid || cb -> nameref == LUA_NOREF)
+		return;
+	lua_rawgeti (L, LUA_REGISTRYINDEX, cb -> nameref);
+	name = lua_tostring (L, -1);
+	if (name) {
+		hk_del_handler (name, cb -> hid);
+		cb -> hid = 0;
+	}
+	lua_pop (L, 1);
+}
+/// hook:del
+/// Unregisters given hook handler from mcabber. Object will be destroyed later.
+static int lua_mcabber_hook_del (lua_State *L)
+{
+	lua_hook_t *cb = luaL_checkudata (L, 1, "mcabber.hook");
+	luaL_argcheck (L, cb != NULL, 1, "mcabber hook object expected");
+	lua_mcabber_unregister_hook (L, cb);
+	if (cb -> selfref != LUA_NOREF) {
+		luaL_unref (L, LUA_REGISTRYINDEX, cb -> selfref);
+		cb -> selfref = LUA_NOREF;
+	}
+	return 0;
+}
+static int lua_mcabber_hook_gc (lua_State *L)
+{
+	lua_hook_t *cb = luaL_checkudata (L, 1, "mcabber.hook");
+	luaL_argcheck (L, cb != NULL, 1, "mcabber hook object expected");
+	lua_mcabber_unregister_hook (L, cb);
+	if (cb -> nameref != LUA_NOREF)
+		luaL_unref (L, LUA_REGISTRYINDEX, cb -> nameref);
+	if (cb -> cbref != LUA_NOREF)
+		luaL_unref (L, LUA_REGISTRYINDEX, cb -> cbref);
+	return 0;
+}
+static const luaL_Reg lua_mcabber_hook_reg_m[] = {
+	{ "del",  lua_mcabber_hook_del },
+	{ "__gc", lua_mcabber_hook_gc  },
+	{ NULL,   NULL                 },
+};
+static void lua_hook_init (lua_State *L)
+{
+	luaL_newmetatable (L, "mcabber.hook");
+	lua_pushvalue (L, -1);
+	lua_setfield (L, -2, "__index");
+	luaL_register (L, NULL, lua_mcabber_hook_reg_m);
+	lua_pop (L, 1);
+}
+#if 0
+// OPTION GUARDS
+GSList *lua_installed_guards = NULL;
+typedef struct {
+	lua_State *L;       // lua environment for handler use
+	int        nameref; // reference to key name string
+	int        cbref;   // reference to guard function
+//	int        objref;  // self_reference to object
+	guint      hid;     // hook id for object destruction
+} lua_guard_t;
+/// guard function
+/// Function to be called, when option changes it's value.
+/// Old option value is still accessible through main.option.
+/// A: string (key), string (new value)
+/// R: string (value to save in hash table)
+static gchar *lua_guard_cb (const gchar *key, const gchar *value)
+{
+	lua_guard_t *cb = ;// FIXME
+	lua_State   *L  = cb -> L;
+	if (cb -> cbref == LUA_NOREF)
+		return g_strdup (value);
+	lua_rawgeti (L, LUA_REGISTRYINDEX, cb -> cbref);
+	if (!lua_isfunction (L, -1)) {
+		lua_pop (L, 1);
+		return g_strdup (value);
+	}
+	lua_pushstring (L, key);
+	lua_psuhstring (L, value);
+	if (lua_pcall (L, 2, 1, 0)) {
+		scr_log_print (LPRINT_NORMAL, "lua: Error in hook handler: %s", lua_tostring (L, -1));
+		lua_pop (L, 1);
+		return g_strdup (value);
+	}
+	return g_strdup (lua_tostring (L, -1));
+}
+/// main.guard
+/// Installs option guard for given option. Returns guard object, that
+/// should be kept around as long, as guard is needed.
+/// A: string (option name), guard function
+/// R: userdata (guard object)
+static int lua_main_guard (lua_State *L)
+{
+	const char   *name      = luaL_checkstring (L, 1);
+	int           priority  = G_PRIORITY_DEFAULT;
+	lua_guard_t   *cb;
+	luaL_argcheck (L, lua_isfunction (L, 2), 2, "function expected");
+	cb = lua_newuserdata (L, sizeof (lua_guard_t));
+	luaL_getmetatable (L, "mcabber.guard");
+	lua_setmetatable (L, -2);
+	lua_pushvalue (L, 1);
+	cb -> nameref = luaL_ref (L, LUA_REGISTRYINDEX);
+	lua_pushvalue (L, 2);
+	cb -> cbref   = luaL_ref (L, LUA_REGISTRYINDEX);
+	cb -> L       = L;
+	settings_set_guard (name, lua_guard_cb)
+	return 1;
+}
+static void lua_mcabber_unregister_guard (lua_State *L, lua_guard_t *cb)
+{
+	const char *name;
+	if (cb -> nameref == LUA_NOREF)
+		return;
+	lua_rawgeti (L, LUA_REGISTRYINDEX, cb -> nameref);
+	name = lua_tostring (L, -1);
+	if (name) {
+		settings_del_guard (name);
+		luaL_unref (L, LUA_REGISTRYINDEX, cb -> nameref);
+		cb -> nameref = LUA_NOREF;
+	}
+	lua_pop (L, 1);
+}
+/// guard:del
+/// Unregisters given option guard from mcabber. Object will be destroyed later.
+static int lua_mcabber_guard_del (lua_State *L)
+{
+	lua_guard_t *cb = luaL_checkudata (L, 1, "mcabber.guard");
+	luaL_argcheck (L, cb != NULL, 1, "mcabber guard object expected");
+	lua_mcabber_unregister_guard (L, cb);
+	return 0;
+}
+static int lua_mcabber_guard_gc (lua_State *L)
+{
+	lua_hook_t *cb = luaL_checkudata (L, 1, "mcabber.guard");
+	luaL_argcheck (L, cb != NULL, 1, "mcabber guard object expected");
+	lua_mcabber_unregister_guard (L, cb);
+	if (cb -> cbref != LUA_NOREF)
+		luaL_unref (L, LUA_REGISTRYINDEX, cb -> cbref);
+	return 0;
+}
+static const luaL_Reg lua_mcabber_hook_reg_m[] = {
+	{ "del",  lua_mcabber_guard_del },
+	{ "__gc", lua_mcabber_guard_gc  },
+	{ NULL,   NULL                 },
+};
+static void lua_guard_init (lua_State *L)
+{
+	luaL_newmetatable (L, "mcabber.guard");
+	lua_pushvalue (L, -1);
+	lua_setfield (L, -2, "__index");
+	luaL_register (L, NULL, lua_mcabber_guard_reg_m);
+	lua_pop (L, 1);
+}
+static void lua_guard_uninit (lua_State *L)
+{
+}
+#endif
+// MAIN INITIALIZATION CODE
+#ifdef LLM_LOG_HANDLER
+// FIXME: this should not be here
+guint lua_lm_log_handler_id;
+void lua_lm_log_handler (const gchar *domain, GLogLevelFlags log_level, const gchar *message, gpointer ignore)
+{
+	if (settings_opt_get_int ("lua_lm_debug"))
+		scr_log_print (LPRINT_LOGNORM, "%s: %s", domain, message);
+}
+#endif
+static void do_lua(char *arg, lua_State *L)
+{
+	if (luaL_loadbuffer (L, arg, strlen (arg), "line")) {
+		scr_log_print (LPRINT_LOGNORM, "lua: Compilation error: %s", lua_tostring (L, -1));
+		lua_pop (L, 1);
+		return;
+	}
+	if (lua_pcall (L, 0, 0, 0)) {
+		scr_log_print (LPRINT_NORMAL, "lua: Runtime error: %s", lua_tostring(L, -1));
+		lua_pop (L, 1);
+		return;
 	}
 }
 static void *lua_alloc (void *ud, void *ptr, size_t osize, size_t nsize) {
 	if (nsize == 0) {
 	reg ( roster         )
 	reg ( current_buddy  )
 	reg ( full_jid       )
 	reg ( buddy_info     )
 	reg ( timer          )
+	reg ( alias          )
+	reg ( binding        )
+	reg ( fileoption     )
+	reg ( add_feature    )
+	reg ( del_feature    )
+	reg ( event          )
+	reg ( parse_args     )
+	reg ( add_category   )
+	reg ( del_category   )
+	reg ( add_completion )
+	reg ( del_completion )
+	reg ( command        )
+	reg ( print_info     )
+	reg ( beep           )
+	reg ( run            )
+	reg ( status         )
+	reg ( roster         )
+	reg ( current_buddy  )
+	reg ( full_jid       )
+	reg ( buddy_info     )
+	reg ( timer          )
 	reg ( bgread         )
+	reg ( hook           )
 	{ NULL, NULL },
 };
 #undef reg
 const gchar *g_module_check_init (GModule *module)
 #ifdef LLM_LOG_HANDLER
 	// FIXME: this should not be here.
 	lua_lm_log_handler_id = g_log_set_handler ("lua-lm", G_LOG_LEVEL_MASK, (GLogFunc) lua_lm_log_handler, NULL);
 #endif
+	lua_hook_init (lua);
 	{
 		char *initfile = expand_filename (settings_opt_get ("lua_init_filename"));
 		if (!initfile)
-			scr_LogPrint (LPRINT_LOGNORM, "lua: Cannot determine config file name");
+			scr_log_print (LPRINT_LOGNORM, "lua: Cannot determine config file name");
 		else {
 			if (luaL_loadfile(lua, initfile)) {
-				scr_LogPrint (LPRINT_LOGNORM, "lua: Unable to compile rc file: %s", lua_tostring (lua, -1));
+				scr_log_print (LPRINT_LOGNORM, "lua: Unable to compile rc file: %s", lua_tostring (lua, -1));
 				lua_pop (lua, 1);
 			} else if (lua_pcall (lua, 0, LUA_MULTRET, 0)) {
-				scr_LogPrint (LPRINT_LOGNORM, "lua: Runtime error in rc file: %s", lua_tostring(lua, -1));
+				scr_log_print (LPRINT_LOGNORM, "lua: Runtime error in rc file: %s", lua_tostring(lua, -1));
 				lua_pop (lua, 1);
 			} else
-				scr_LogPrint (LPRINT_LOGNORM, "lua: Loaded %s", initfile);
+				scr_log_print (LPRINT_LOGNORM, "lua: Loaded %s", initfile);
 			g_free (initfile);
 		}
 	}
-	hk_add_handler ((hk_handler_t) lua_hook, ~((guint32)0), lua);
 	{
 		hk_arg_t args[] = {
-			{ "hook", "hook-start" },
+			{ NULL, NULL },
-			{ NULL,   NULL         },
 		};
-		lua_hook (0, args, lua);
+		hk_run_handlers("hook-lua-start", args);
 	}
 }
 static void lua_events_cancel (gpointer data, gpointer ignore)
 {
 static void mlua_uninit (void)
 {
 	if (lua) {
 		hk_arg_t args[] = {
-			{ "hook", "hook-quit" },
+			{ NULL, NULL },
-			{ NULL,   NULL        },
 		};
-		lua_hook (0, args, lua);
+		hk_run_handlers ("hook-lua-quit", args);
-		hk_del_handler ((hk_handler_t) lua_hook, lua);
+		// hook handlers will be unregistered upon objects destruction
 		g_slist_foreach (lua_bgreads, (GFunc) lua_bgreads_destroy, NULL);
 		g_slist_free (lua_bgreads);
 		lua_bgreads = NULL;

changeset 97	b00f9ce82016
parent 95	f2f4c7810a72
child 98	59aeae623ac6