apps/irssi/src/core/signals.c

   1 /*
   2  signals.c : irssi
   3
   4     Copyright (C) 1999 Timo Sirainen
   5
   6     This program is free software; you can redistribute it and/or modify
   7     it under the terms of the GNU General Public License as published by
   8     the Free Software Foundation; either version 2 of the License, or
   9     (at your option) any later version.
  10
  11     This program is distributed in the hope that it will be useful,
  12     but WITHOUT ANY WARRANTY; without even the implied warranty of
  13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14     GNU General Public License for more details.
  15
  16     You should have received a copy of the GNU General Public License
  17     along with this program; if not, write to the Free Software
  18     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19 */
  20
  21 #include "../common.h"
  22 #include "signals.h"
  23 #include "modules.h"
  24
  25 #define SIGNAL_LISTS 3
  26
  27 typedef struct {
  28         int id; /* signal id */
  29         int refcount;
  30
  31         int emitting; /* signal is being emitted */
  32         int stop_emit; /* this signal was stopped */
  33
  34         GPtrArray *modulelist[SIGNAL_LISTS]; /* list of what signals belong
  35                                                 to which module */
  36         GPtrArray *siglist[SIGNAL_LISTS]; /* signal lists */
  37 } SIGNAL_REC;
  38
  39 #define signal_is_emitlist_empty(a) \
  40         (!(a)->siglist[0] && !(a)->siglist[1] && !(a)->siglist[2])
  41
  42 static GMemChunk *signals_chunk;
  43 static GHashTable *signals;
  44 static SIGNAL_REC *current_emitted_signal;
  45
  46 #define signal_ref(signal) ++(signal)->refcount
  47 #define signal_unref(rec) (signal_unref_full(rec, TRUE))
  48
  49 static int signal_unref_full(SIGNAL_REC *rec, int remove_hash)
  50 {
  51         if (rec->refcount == 0) {
  52                 g_error("signal_unref(%s) : BUG - reference counter == 0",
  53                         signal_get_id_str(rec->id));
  54         }
  55
  56         if (--rec->refcount != 0)
  57                 return FALSE;
  58
  59         /* remove whole signal from memory */
  60         if (!signal_is_emitlist_empty(rec)) {
  61                 g_error("signal_unref(%s) : BUG - emitlist wasn't empty",
  62                         signal_get_id_str(rec->id));
  63         }
  64
  65         if (remove_hash)
  66                 g_hash_table_remove(signals, GINT_TO_POINTER(rec->id));
  67         g_mem_chunk_free(signals_chunk, rec);
  68         return TRUE;
  69 }
  70
  71 static void signal_unref_count(SIGNAL_REC *rec, int count)
  72 {
  73         while (count-- > 0)
  74                 signal_unref(rec);
  75 }
  76
  77 void signal_add_to(const char *module, int pos,
  78                    const char *signal, SIGNAL_FUNC func)
  79 {
  80         g_return_if_fail(signal != NULL);
  81
  82         signal_add_to_id(module, pos, signal_get_uniq_id(signal), func);
  83 }
  84
  85 /* bind a signal */
  86 void signal_add_to_id(const char *module, int pos,
  87                       int signal_id, SIGNAL_FUNC func)
  88 {
  89         SIGNAL_REC *rec;
  90
  91         g_return_if_fail(signal_id >= 0);
  92         g_return_if_fail(func != NULL);
  93         g_return_if_fail(pos >= 0 && pos < SIGNAL_LISTS);
  94
  95         rec = g_hash_table_lookup(signals, GINT_TO_POINTER(signal_id));
  96         if (rec == NULL) {
  97                 rec = g_mem_chunk_alloc0(signals_chunk);
  98                 rec->id = signal_id;
  99                 g_hash_table_insert(signals, GINT_TO_POINTER(signal_id), rec);
 100         }
 101
 102         if (rec->siglist[pos] == NULL) {
 103                 rec->siglist[pos] = g_ptr_array_new();
 104                 rec->modulelist[pos] = g_ptr_array_new();
 105         }
 106
 107         g_ptr_array_add(rec->siglist[pos], (void *) func);
 108         g_ptr_array_add(rec->modulelist[pos], (void *) module);
 109
 110         signal_ref(rec);
 111 }
 112
 113 static int signal_list_find(GPtrArray *array, void *data)
 114 {
 115         unsigned int n;
 116
 117         for (n = 0; n < array->len; n++) {
 118                 if (g_ptr_array_index(array, n) == data)
 119                         return n;
 120         }
 121
 122         return -1;
 123 }
 124
 125 static void signal_list_free(SIGNAL_REC *rec, int list)
 126 {
 127         g_ptr_array_free(rec->siglist[list], TRUE);
 128         g_ptr_array_free(rec->modulelist[list], TRUE);
 129         rec->siglist[list] = NULL;
 130         rec->modulelist[list] = NULL;
 131 }
 132
 133 /* Returns TRUE if the whole signal is removed after this remove */
 134 static void signal_remove_from_list(SIGNAL_REC *rec, int list, int index)
 135 {
 136         g_ptr_array_remove_index(rec->siglist[list], index);
 137         g_ptr_array_remove_index(rec->modulelist[list], index);
 138
 139         if (rec->siglist[list]->len == 0)
 140                 signal_list_free(rec, list);
 141
 142         signal_unref(rec);
 143 }
 144
 145 /* Remove signal from emit lists */
 146 static int signal_remove_from_lists(SIGNAL_REC *rec, SIGNAL_FUNC func)
 147 {
 148         int n, index;
 149
 150         for (n = 0; n < SIGNAL_LISTS; n++) {
 151                 if (rec->siglist[n] == NULL)
 152                         continue;
 153
 154                 index = signal_list_find(rec->siglist[n], (void *) func);
 155                 if (index != -1) {
 156                         /* remove the function from emit list */
 157                         signal_remove_from_list(rec, n, index);
 158                         return 1;
 159                 }
 160         }
 161
 162         return 0;
 163 }
 164
 165 void signal_remove_id(int signal_id, SIGNAL_FUNC func)
 166 {
 167         SIGNAL_REC *rec;
 168
 169         g_return_if_fail(signal_id >= 0);
 170         g_return_if_fail(func != NULL);
 171
 172         rec = g_hash_table_lookup(signals, GINT_TO_POINTER(signal_id));
 173         if (rec != NULL)
 174                 signal_remove_from_lists(rec, func);
 175 }
 176
 177 /* unbind signal */
 178 void signal_remove(const char *signal, SIGNAL_FUNC func)
 179 {
 180         g_return_if_fail(signal != NULL);
 181
 182         signal_remove_id(signal_get_uniq_id(signal), func);
 183 }
 184
 185 static int signal_emit_real(SIGNAL_REC *rec, int params, va_list va)
 186 {
 187         gconstpointer arglist[SIGNAL_MAX_ARGUMENTS];
 188         SIGNAL_REC *prev_emitted_signal;
 189         SIGNAL_FUNC func;
 190         int n, index, stopped, stop_emit_count;
 191
 192         for (n = 0; n < SIGNAL_MAX_ARGUMENTS; n++)
 193                 arglist[n] = n >= params ? NULL : va_arg(va, gconstpointer);
 194
 195         /* signal_stop_by_name("signal"); signal_emit("signal", ...);
 196            fails if we compare rec->stop_emit against 0. */
 197         stop_emit_count = rec->stop_emit;
 198
 199         signal_ref(rec);
 200
 201         stopped = FALSE;
 202         rec->emitting++;
 203         for (n = 0; n < SIGNAL_LISTS; n++) {
 204                 /* run signals in emit lists */
 205                 if (rec->siglist[n] == NULL)
 206                         continue;
 207
 208                 for (index = rec->siglist[n]->len-1; index >= 0; index--) {
 209                         func = (SIGNAL_FUNC) g_ptr_array_index(rec->siglist[n], index);
 210
 211                         prev_emitted_signal = current_emitted_signal;
 212                         current_emitted_signal = rec;
 213 #if SIGNAL_MAX_ARGUMENTS != 6
 214 #  error SIGNAL_MAX_ARGUMENTS changed - update code
 215 #endif
 216                         func(arglist[0], arglist[1], arglist[2], arglist[3], arglist[4], arglist[5]);
 217                         current_emitted_signal = prev_emitted_signal;
 218
 219                         if (rec->stop_emit != stop_emit_count) {
 220                                 stopped = TRUE;
 221                                 rec->stop_emit--;
 222                                 n = SIGNAL_LISTS;
 223                                 break;
 224                         }
 225                 }
 226         }
 227         rec->emitting--;
 228
 229         if (!rec->emitting) {
 230                 if (rec->stop_emit != 0) {
 231                         /* signal_stop() used too many times */
 232                         rec->stop_emit = 0;
 233                 }
 234         }
 235
 236         signal_unref(rec);
 237         return stopped;
 238 }
 239
 240 int signal_emit(const char *signal, int params, ...)
 241 {
 242         SIGNAL_REC *rec;
 243         va_list va;
 244         int signal_id;
 245
 246         g_return_val_if_fail(params >= 0 && params <= SIGNAL_MAX_ARGUMENTS, FALSE);
 247
 248         signal_id = signal_get_uniq_id(signal);
 249
 250         rec = g_hash_table_lookup(signals, GINT_TO_POINTER(signal_id));
 251         if (rec != NULL) {
 252                 va_start(va, params);
 253                 signal_emit_real(rec, params, va);
 254                 va_end(va);
 255         }
 256
 257         return rec != NULL;
 258 }
 259
 260 int signal_emit_id(int signal_id, int params, ...)
 261 {
 262         SIGNAL_REC *rec;
 263         va_list va;
 264
 265         g_return_val_if_fail(signal_id >= 0, FALSE);
 266         g_return_val_if_fail(params >= 0 && params <= SIGNAL_MAX_ARGUMENTS, FALSE);
 267
 268         rec = g_hash_table_lookup(signals, GINT_TO_POINTER(signal_id));
 269         if (rec != NULL) {
 270                 va_start(va, params);
 271                 signal_emit_real(rec, params, va);
 272                 va_end(va);
 273         }
 274
 275         return rec != NULL;
 276 }
 277
 278 /* stop the current ongoing signal emission */
 279 void signal_stop(void)
 280 {
 281         SIGNAL_REC *rec;
 282
 283         rec = current_emitted_signal;
 284         if (rec == NULL)
 285                 g_warning("signal_stop() : no signals are being emitted currently");
 286         else if (rec->emitting > rec->stop_emit)
 287                 rec->stop_emit++;
 288 }
 289
 290 /* stop ongoing signal emission by signal name */
 291 void signal_stop_by_name(const char *signal)
 292 {
 293         SIGNAL_REC *rec;
 294         int signal_id;
 295
 296         signal_id = signal_get_uniq_id(signal);
 297         rec = g_hash_table_lookup(signals, GINT_TO_POINTER(signal_id));
 298         if (rec == NULL)
 299                 g_warning("signal_stop_by_name() : unknown signal \"%s\"", signal);
 300         else if (rec->emitting > rec->stop_emit)
 301                 rec->stop_emit++;
 302 }
 303
 304 /* return the name of the signal that is currently being emitted */
 305 const char *signal_get_emitted(void)
 306 {
 307         return signal_get_id_str(signal_get_emitted_id());
 308 }
 309
 310 /* return the ID of the signal that is currently being emitted */
 311 int signal_get_emitted_id(void)
 312 {
 313         SIGNAL_REC *rec;
 314
 315         rec = current_emitted_signal;
 316         g_return_val_if_fail(rec != NULL, -1);
 317         return rec->id;
 318 }
 319
 320 /* return TRUE if specified signal was stopped */
 321 int signal_is_stopped(int signal_id)
 322 {
 323         SIGNAL_REC *rec;
 324
 325         rec = g_hash_table_lookup(signals, GINT_TO_POINTER(signal_id));
 326         g_return_val_if_fail(rec != NULL, FALSE);
 327
 328         return rec->emitting <= rec->stop_emit;
 329 }
 330
 331 static void signal_remove_module(void *signal, SIGNAL_REC *rec,
 332                                  const char *module)
 333 {
 334         unsigned int index;
 335         int list;
 336
 337         for (list = 0; list < SIGNAL_LISTS; list++) {
 338                 if (rec->modulelist[list] == NULL)
 339                         continue;
 340
 341                 for (index = rec->modulelist[list]->len; index > 0; index--)
 342                         if (g_strcasecmp(g_ptr_array_index(rec->modulelist[list], index-1), module) == 0)
 343                                 signal_remove_from_list(rec, list, index-1);
 344         }
 345 }
 346
 347 static void signal_foreach_ref(void *signal, SIGNAL_REC *rec)
 348 {
 349         signal_ref(rec);
 350 }
 351
 352 static int signal_foreach_unref(void *signal, SIGNAL_REC *rec)
 353 {
 354         return signal_unref_full(rec, FALSE);
 355 }
 356
 357 /* remove all signals that belong to `module' */
 358 void signals_remove_module(const char *module)
 359 {
 360         g_return_if_fail(module != NULL);
 361
 362         g_hash_table_foreach(signals, (GHFunc) signal_foreach_ref, NULL);
 363         g_hash_table_foreach(signals, (GHFunc) signal_remove_module, (void *) module);
 364         g_hash_table_foreach_remove(signals, (GHRFunc) signal_foreach_unref, NULL);
 365 }
 366
 367 void signals_init(void)
 368 {
 369         signals_chunk = g_mem_chunk_new("signals", sizeof(SIGNAL_REC),
 370                                         sizeof(SIGNAL_REC)*200, G_ALLOC_AND_FREE);
 371         signals = g_hash_table_new((GHashFunc) g_direct_hash, (GCompareFunc) g_direct_equal);
 372 }
 373
 374 static void signal_free(void *key, SIGNAL_REC *rec)
 375 {
 376         int n;
 377
 378         signal_ref(rec);
 379
 380         for (n = 0; n < SIGNAL_LISTS; n++) {
 381                 if (rec->siglist[n] != NULL) {
 382                         signal_unref_count(rec, rec->siglist[n]->len);
 383                         signal_list_free(rec, n);
 384                 }
 385         }
 386
 387         if (!signal_unref_full(rec, FALSE)) {
 388                 g_error("signal_free(%s) : BUG - signal still has %d references",
 389                         signal_get_id_str(rec->id), rec->refcount);
 390         }
 391 }
 392
 393 void signals_deinit(void)
 394 {
 395         g_hash_table_foreach(signals, (GHFunc) signal_free, NULL);
 396         g_hash_table_destroy(signals);
 397
 398         module_uniq_destroy("signals");
 399         g_mem_chunk_destroy(signals_chunk);
 400 }