/*
signals.c : irssi
- Copyright (C) 1999 Timo Sirainen
+ Copyright (C) 1999-2002 Timo Sirainen
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
-#include "../common.h"
+#include "module.h"
#include "signals.h"
#include "modules.h"
-#define SIGNAL_LISTS 3
+typedef struct _SignalHook {
+ struct _SignalHook *next;
+
+ int priority;
+ const char *module;
+ SIGNAL_FUNC func;
+ void *user_data;
+} SignalHook;
typedef struct {
int id; /* signal id */
+ int refcount;
int emitting; /* signal is being emitted */
- int altered; /* some signal functions are marked as NULL */
int stop_emit; /* this signal was stopped */
+ int continue_emit; /* this signal emit was continued elsewhere */
+ int remove_count; /* hooks were removed from signal */
- GPtrArray *modulelist[SIGNAL_LISTS]; /* list of what signals belong
- to which module */
- GPtrArray *siglist[SIGNAL_LISTS]; /* signal lists */
-} SIGNAL_REC;
+ SignalHook *hooks;
+} Signal;
-#define signal_is_emitlist_empty(a) \
- (!(a)->siglist[0] && !(a)->siglist[1] && !(a)->siglist[2])
+void *signal_user_data;
-static GMemChunk *signals_chunk;
static GHashTable *signals;
-static SIGNAL_REC *current_emitted_signal;
+static Signal *current_emitted_signal;
+static SignalHook *current_emitted_hook;
-void signal_add_to(const char *module, int pos,
- const char *signal, SIGNAL_FUNC func)
-{
- g_return_if_fail(signal != NULL);
-
- signal_add_to_id(module, pos, signal_get_uniq_id(signal), func);
-}
+#define signal_ref(signal) ++(signal)->refcount
+#define signal_unref(signal) (signal_unref_full(signal, TRUE))
-/* bind a signal */
-void signal_add_to_id(const char *module, int pos,
- int signal_id, SIGNAL_FUNC func)
+static int signal_unref_full(Signal *rec, int remove)
{
- SIGNAL_REC *rec;
+ g_assert(rec->refcount > 0);
- g_return_if_fail(signal_id >= 0);
- g_return_if_fail(func != NULL);
- g_return_if_fail(pos >= 0 && pos < SIGNAL_LISTS);
+ if (--rec->refcount != 0)
+ return TRUE;
- rec = g_hash_table_lookup(signals, GINT_TO_POINTER(signal_id));
- if (rec == NULL) {
- rec = g_mem_chunk_alloc0(signals_chunk);
- rec->id = signal_id;
- g_hash_table_insert(signals, GINT_TO_POINTER(signal_id), rec);
+ /* remove whole signal from memory */
+ if (rec->hooks != NULL) {
+ g_error("signal_unref(%s) : BUG - hook list wasn't empty",
+ signal_get_id_str(rec->id));
}
- if (rec->siglist[pos] == NULL) {
- rec->siglist[pos] = g_ptr_array_new();
- rec->modulelist[pos] = g_ptr_array_new();
- }
+ if (remove)
+ g_hash_table_remove(signals, GINT_TO_POINTER(rec->id));
+ g_free(rec);
- g_ptr_array_add(rec->siglist[pos], (void *) func);
- g_ptr_array_add(rec->modulelist[pos], (void *) module);
+ return FALSE;
}
-/* Destroy the whole signal */
-static void signal_destroy(int signal_id)
+static void signal_hash_ref(void *key, Signal *rec)
{
- SIGNAL_REC *rec;
-
- rec = g_hash_table_lookup(signals, GINT_TO_POINTER(signal_id));
- if (rec != NULL) {
- /* remove whole signal from memory */
- g_hash_table_remove(signals, GINT_TO_POINTER(signal_id));
- g_free(rec);
- }
+ signal_ref(rec);
}
-static int signal_list_find(GPtrArray *array, void *data)
+static int signal_hash_unref(void *key, Signal *rec)
{
- unsigned int n;
-
- for (n = 0; n < array->len; n++) {
- if (g_ptr_array_index(array, n) == data)
- return n;
- }
+ return !signal_unref_full(rec, FALSE);
+}
- return -1;
+void signal_add_full(const char *module, int priority,
+ const char *signal, SIGNAL_FUNC func, void *user_data)
+{
+ signal_add_full_id(module, priority, signal_get_uniq_id(signal),
+ func, user_data);
}
-static void signal_remove_from_list(SIGNAL_REC *rec, int signal_id,
- int list, int index)
+/* bind a signal */
+void signal_add_full_id(const char *module, int priority,
+ int signal_id, SIGNAL_FUNC func, void *user_data)
{
- if (rec->emitting) {
- g_ptr_array_index(rec->siglist[list], index) = NULL;
- rec->altered = TRUE;
- } else {
- g_ptr_array_remove_index(rec->siglist[list], index);
- g_ptr_array_remove_index(rec->modulelist[list], index);
- if (signal_is_emitlist_empty(rec))
- signal_destroy(signal_id);
+ Signal *signal;
+ SignalHook *hook, **tmp;
+
+ g_return_if_fail(signal_id >= 0);
+ g_return_if_fail(func != NULL);
+
+ signal = g_hash_table_lookup(signals, GINT_TO_POINTER(signal_id));
+ if (signal == NULL) {
+ /* new signal */
+ signal = g_new0(Signal, 1);
+ signal->id = signal_id;
+ g_hash_table_insert(signals, GINT_TO_POINTER(signal_id), signal);
+ }
+
+ hook = g_new0(SignalHook, 1);
+ hook->priority = priority;
+ hook->module = module;
+ hook->func = func;
+ hook->user_data = user_data;
+
+ /* insert signal to proper position in list */
+ for (tmp = &signal->hooks; ; tmp = &(*tmp)->next) {
+ if (*tmp == NULL) {
+ /* last in list */
+ *tmp = hook;
+ break;
+ } else if (priority <= (*tmp)->priority) {
+ /* insert before others with same priority */
+ hook->next = *tmp;
+ *tmp = hook;
+ break;
+ }
}
+
+ signal_ref(signal);
}
-/* Remove signal from emit lists */
-static int signal_remove_from_lists(SIGNAL_REC *rec, int signal_id,
- SIGNAL_FUNC func)
+static void signal_remove_hook(Signal *rec, SignalHook **hook_pos)
{
- int n, index;
+ SignalHook *hook;
+
+ hook = *hook_pos;
+ *hook_pos = hook->next;
- for (n = 0; n < SIGNAL_LISTS; n++) {
- if (rec->siglist[n] == NULL)
- continue;
+ g_free(hook);
- index = signal_list_find(rec->siglist[n], (void *) func);
- if (index != -1) {
- /* remove the function from emit list */
- signal_remove_from_list(rec, signal_id, n, index);
- return 1;
+ signal_unref(rec);
+}
+
+/* Remove function from signal's emit list */
+static int signal_remove_func(Signal *rec, SIGNAL_FUNC func, void *user_data)
+{
+ SignalHook **hook;
+
+ for (hook = &rec->hooks; *hook != NULL; hook = &(*hook)->next) {
+ if ((*hook)->func == func && (*hook)->user_data == user_data) {
+ if (rec->emitting) {
+ /* mark it removed after emitting is done */
+ (*hook)->func = NULL;
+ rec->remove_count++;
+ } else {
+ /* remove the function from emit list */
+ signal_remove_hook(rec, hook);
+ }
+ return TRUE;
}
}
- return 0;
+ return FALSE;
}
-void signal_remove_id(int signal_id, SIGNAL_FUNC func)
+void signal_remove_id(int signal_id, SIGNAL_FUNC func, void *user_data)
{
- SIGNAL_REC *rec;
+ Signal *rec;
g_return_if_fail(signal_id >= 0);
g_return_if_fail(func != NULL);
rec = g_hash_table_lookup(signals, GINT_TO_POINTER(signal_id));
if (rec != NULL)
- signal_remove_from_lists(rec, signal_id, func);
+ signal_remove_func(rec, func, user_data);
}
/* unbind signal */
-void signal_remove(const char *signal, SIGNAL_FUNC func)
+void signal_remove_full(const char *signal, SIGNAL_FUNC func, void *user_data)
{
g_return_if_fail(signal != NULL);
- signal_remove_id(signal_get_uniq_id(signal), func);
+ signal_remove_id(signal_get_uniq_id(signal), func, user_data);
}
-/* Remove all NULL functions from signal list */
-static void signal_list_clean(SIGNAL_REC *rec)
+static void signal_hooks_clean(Signal *rec)
{
- int n, index;
+ SignalHook **hook, **next;
+ int count;
- for (n = 0; n < SIGNAL_LISTS; n++) {
- if (rec->siglist[n] == NULL)
- continue;
+ count = rec->remove_count;
+ rec->remove_count = 0;
- for (index = rec->siglist[n]->len-1; index >= 0; index--) {
- if (g_ptr_array_index(rec->siglist[n], index) == NULL) {
- g_ptr_array_remove_index(rec->siglist[n], index);
- g_ptr_array_remove_index(rec->modulelist[n], index);
- }
+ for (hook = &rec->hooks; *hook != NULL; hook = next) {
+ next = &(*hook)->next;
+
+ if ((*hook)->func == NULL) {
+ next = hook;
+ signal_remove_hook(rec, hook);
+
+ if (--count == 0)
+ break;
}
}
}
-static int signal_emit_real(SIGNAL_REC *rec, gconstpointer *arglist)
+static int signal_emit_real(Signal *rec, int params, va_list va,
+ SignalHook *first_hook)
{
- SIGNAL_REC *prev_emitted_signal;
- SIGNAL_FUNC func;
- int n, index, stopped, stop_emit_count;
+ const void *arglist[SIGNAL_MAX_ARGUMENTS];
+ Signal *prev_emitted_signal;
+ SignalHook *hook, *prev_emitted_hook;
+ int i, stopped, stop_emit_count, continue_emit_count;
+
+ for (i = 0; i < SIGNAL_MAX_ARGUMENTS; i++)
+ arglist[i] = i >= params ? NULL : va_arg(va, const void *);
/* signal_stop_by_name("signal"); signal_emit("signal", ...);
fails if we compare rec->stop_emit against 0. */
stop_emit_count = rec->stop_emit;
+ continue_emit_count = rec->continue_emit;
+
+ signal_ref(rec);
stopped = FALSE;
rec->emitting++;
- for (n = 0; n < SIGNAL_LISTS; n++) {
- /* run signals in emit lists */
- if (rec->siglist[n] == NULL)
- continue;
- for (index = rec->siglist[n]->len-1; index >= 0; index--) {
- func = (SIGNAL_FUNC) g_ptr_array_index(rec->siglist[n], index);
+ prev_emitted_signal = current_emitted_signal;
+ prev_emitted_hook = current_emitted_hook;
+ current_emitted_signal = rec;
+
+ for (hook = first_hook; hook != NULL; hook = hook->next) {
+ if (hook->func == NULL)
+ continue; /* removed */
- if (func != NULL) {
- prev_emitted_signal = current_emitted_signal;
- current_emitted_signal = rec;
+ current_emitted_hook = hook;
#if SIGNAL_MAX_ARGUMENTS != 6
-# error SIGNAL_MAX_ARGS changed - update code
+# error SIGNAL_MAX_ARGUMENTS changed - update code
#endif
- func(arglist[0], arglist[1], arglist[2], arglist[3], arglist[4], arglist[5]);
- current_emitted_signal = prev_emitted_signal;
- }
+ signal_user_data = hook->user_data;
+ hook->func(arglist[0], arglist[1], arglist[2], arglist[3],
+ arglist[4], arglist[5]);
- if (rec->stop_emit != stop_emit_count) {
- stopped = TRUE;
- rec->stop_emit--;
- n = SIGNAL_LISTS;
- break;
- }
+ if (rec->continue_emit != continue_emit_count)
+ rec->continue_emit--;
+
+ if (rec->stop_emit != stop_emit_count) {
+ stopped = TRUE;
+ rec->stop_emit--;
+ break;
}
}
+
+ current_emitted_signal = prev_emitted_signal;
+ current_emitted_hook = prev_emitted_hook;
+
rec->emitting--;
+ signal_user_data = NULL;
if (!rec->emitting) {
- if (rec->stop_emit != 0) {
- /* signal_stop() used too many times */
- rec->stop_emit = 0;
- }
- if (rec->altered) {
- signal_list_clean(rec);
- rec->altered = FALSE;
- }
+ g_assert(rec->stop_emit == 0);
+ g_assert(rec->continue_emit == 0);
+
+ if (rec->remove_count > 0)
+ signal_hooks_clean(rec);
}
+ signal_unref(rec);
return stopped;
}
-static int signal_emitv_id(int signal_id, int params, va_list va)
+int signal_emit(const char *signal, int params, ...)
{
- gconstpointer arglist[SIGNAL_MAX_ARGUMENTS];
- SIGNAL_REC *rec;
- int n;
+ Signal *rec;
+ va_list va;
+ int signal_id;
- g_return_val_if_fail(signal_id >= 0, FALSE);
g_return_val_if_fail(params >= 0 && params <= SIGNAL_MAX_ARGUMENTS, FALSE);
- for (n = 0; n < SIGNAL_MAX_ARGUMENTS; n++)
- arglist[n] = n >= params ? NULL : va_arg(va, gconstpointer);
+ signal_id = signal_get_uniq_id(signal);
rec = g_hash_table_lookup(signals, GINT_TO_POINTER(signal_id));
- if (rec != NULL && signal_emit_real(rec, arglist))
- return TRUE;
+ if (rec != NULL) {
+ va_start(va, params);
+ signal_emit_real(rec, params, va, rec->hooks);
+ va_end(va);
+ }
return rec != NULL;
}
-int signal_emit(const char *signal, int params, ...)
+int signal_emit_id(int signal_id, int params, ...)
{
+ Signal *rec;
va_list va;
- int signal_id, ret;
- /* get arguments */
- signal_id = signal_get_uniq_id(signal);
+ g_return_val_if_fail(signal_id >= 0, FALSE);
+ g_return_val_if_fail(params >= 0 && params <= SIGNAL_MAX_ARGUMENTS, FALSE);
- va_start(va, params);
- ret = signal_emitv_id(signal_id, params, va);
- va_end(va);
+ rec = g_hash_table_lookup(signals, GINT_TO_POINTER(signal_id));
+ if (rec != NULL) {
+ va_start(va, params);
+ signal_emit_real(rec, params, va, rec->hooks);
+ va_end(va);
+ }
- return ret;
+ return rec != NULL;
}
-int signal_emit_id(int signal_id, int params, ...)
+void signal_continue(int params, ...)
{
+ Signal *rec;
va_list va;
- int ret;
-
- /* get arguments */
- va_start(va, params);
- ret = signal_emitv_id(signal_id, params, va);
- va_end(va);
- return ret;
+ rec = current_emitted_signal;
+ if (rec == NULL || rec->emitting <= rec->continue_emit)
+ g_warning("signal_continue() : no signals are being emitted currently");
+ else {
+ va_start(va, params);
+
+ /* stop the signal */
+ if (rec->emitting > rec->stop_emit)
+ rec->stop_emit++;
+
+ /* re-emit */
+ rec->continue_emit++;
+ signal_emit_real(rec, params, va, current_emitted_hook->next);
+ va_end(va);
+ }
}
/* stop the current ongoing signal emission */
void signal_stop(void)
{
- SIGNAL_REC *rec;
+ Signal *rec;
rec = current_emitted_signal;
if (rec == NULL)
/* stop ongoing signal emission by signal name */
void signal_stop_by_name(const char *signal)
{
- SIGNAL_REC *rec;
+ Signal *rec;
int signal_id;
signal_id = signal_get_uniq_id(signal);
/* return the ID of the signal that is currently being emitted */
int signal_get_emitted_id(void)
{
- SIGNAL_REC *rec;
+ Signal *rec;
rec = current_emitted_signal;
g_return_val_if_fail(rec != NULL, -1);
/* return TRUE if specified signal was stopped */
int signal_is_stopped(int signal_id)
{
- SIGNAL_REC *rec;
+ Signal *rec;
rec = g_hash_table_lookup(signals, GINT_TO_POINTER(signal_id));
g_return_val_if_fail(rec != NULL, FALSE);
return rec->emitting <= rec->stop_emit;
}
-static void signal_remove_module(void *signal, SIGNAL_REC *rec,
+static void signal_remove_module(void *signal, Signal *rec,
const char *module)
{
- unsigned int index;
- int signal_id, list;
+ SignalHook **hook, **next;
- signal_id = GPOINTER_TO_INT(signal);
+ for (hook = &rec->hooks; *hook != NULL; hook = next) {
+ next = &(*hook)->next;
- for (list = 0; list < SIGNAL_LISTS; list++) {
- if (rec->modulelist[list] == NULL)
- continue;
-
- for (index = 0; index < rec->modulelist[list]->len; index++) {
- if (g_strcasecmp(g_ptr_array_index(rec->modulelist[list], index), module) == 0)
- signal_remove_from_list(rec, signal_id, list, index);
+ if (strcasecmp((*hook)->module, module) == 0) {
+ next = hook;
+ signal_remove_hook(rec, hook);
}
}
}
{
g_return_if_fail(module != NULL);
- g_hash_table_foreach(signals, (GHFunc) signal_remove_module, (void *) module);
+ g_hash_table_foreach(signals, (GHFunc) signal_hash_ref, NULL);
+ g_hash_table_foreach(signals, (GHFunc) signal_remove_module,
+ (void *) module);
+ g_hash_table_foreach_remove(signals, (GHRFunc) signal_hash_unref, NULL);
}
void signals_init(void)
{
- signals_chunk = g_mem_chunk_new("signals", sizeof(SIGNAL_REC),
- sizeof(SIGNAL_REC)*200, G_ALLOC_AND_FREE);
- signals = g_hash_table_new((GHashFunc) g_direct_hash, (GCompareFunc) g_direct_equal);
+ signals = g_hash_table_new(NULL, NULL);
}
-static void signal_free(void *key, SIGNAL_REC *rec)
+static void signal_free(void *key, Signal *rec)
{
- int n;
+ /* refcount-1 because we just referenced it ourself */
+ g_warning("signal_free(%s) : signal still has %d references:",
+ signal_get_id_str(rec->id), rec->refcount-1);
- for (n = 0; n < SIGNAL_LISTS; n++) {
- if (rec->siglist[n] != NULL) {
- g_ptr_array_free(rec->siglist[n], TRUE);
- g_ptr_array_free(rec->modulelist[n], TRUE);
- }
- }
+ while (rec->hooks != NULL) {
+ g_warning(" - module '%s' function %p",
+ rec->hooks->module, rec->hooks->func);
- g_mem_chunk_free(signals_chunk, rec);
- current_emitted_signal = NULL;
+ signal_remove_hook(rec, &rec->hooks);
+ }
}
void signals_deinit(void)
{
- g_hash_table_foreach(signals, (GHFunc) signal_free, NULL);
+ g_hash_table_foreach(signals, (GHFunc) signal_hash_ref, NULL);
+ g_hash_table_foreach(signals, (GHFunc) signal_free, NULL);
+ g_hash_table_foreach_remove(signals, (GHRFunc) signal_hash_unref, NULL);
g_hash_table_destroy(signals);
module_uniq_destroy("signals");
- g_mem_chunk_destroy(signals_chunk);
}
projects / crypto.git / blobdiff