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
  30         int emitting; /* signal is being emitted */
  31         int altered; /* some signal functions are marked as NULL */
  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 void signal_add_to(const char *module, int pos,
  47                    const char *signal, SIGNAL_FUNC func)
  48 {
  49         g_return_if_fail(signal != NULL);
  50
  51         signal_add_to_id(module, pos, signal_get_uniq_id(signal), func);
  52 }
  53
  54 /* bind a signal */
  55 void signal_add_to_id(const char *module, int pos,
  56                       int signal_id, SIGNAL_FUNC func)
  57 {
  58         SIGNAL_REC *rec;
  59
  60         g_return_if_fail(signal_id >= 0);
  61         g_return_if_fail(func != NULL);
  62         g_return_if_fail(pos >= 0 && pos < SIGNAL_LISTS);
  63
  64         rec = g_hash_table_lookup(signals, GINT_TO_POINTER(signal_id));
  65         if (rec == NULL) {
  66                 rec = g_mem_chunk_alloc0(signals_chunk);
  67                 rec->id = signal_id;
  68                 g_hash_table_insert(signals, GINT_TO_POINTER(signal_id), rec);
  69         }
  70
  71         if (rec->siglist[pos] == NULL) {
  72                 rec->siglist[pos] = g_ptr_array_new();
  73                 rec->modulelist[pos] = g_ptr_array_new();
  74         }
  75
  76         g_ptr_array_add(rec->siglist[pos], (void *) func);
  77         g_ptr_array_add(rec->modulelist[pos], (void *) module);
  78 }
  79
  80 /* Destroy the whole signal */
  81 static void signal_destroy(int signal_id)
  82 {
  83         SIGNAL_REC *rec;
  84
  85         rec = g_hash_table_lookup(signals, GINT_TO_POINTER(signal_id));
  86         if (rec != NULL) {
  87                 /* remove whole signal from memory */
  88                 g_hash_table_remove(signals, GINT_TO_POINTER(signal_id));
  89                 g_free(rec);
  90         }
  91 }
  92
  93 static int signal_list_find(GPtrArray *array, void *data)
  94 {
  95         unsigned int n;
  96
  97         for (n = 0; n < array->len; n++) {
  98                 if (g_ptr_array_index(array, n) == data)
  99                         return n;
 100         }
 101
 102         return -1;
 103 }
 104
 105 static void signal_remove_from_list(SIGNAL_REC *rec, int signal_id,
 106                                     int list, int index)
 107 {
 108         if (rec->emitting) {
 109                 g_ptr_array_index(rec->siglist[list], index) = NULL;
 110                 rec->altered = TRUE;
 111         } else {
 112                 g_ptr_array_remove_index(rec->siglist[list], index);
 113                 g_ptr_array_remove_index(rec->modulelist[list], index);
 114                 if (signal_is_emitlist_empty(rec))
 115                         signal_destroy(signal_id);
 116         }
 117 }
 118
 119 /* Remove signal from emit lists */
 120 static int signal_remove_from_lists(SIGNAL_REC *rec, int signal_id,
 121                                     SIGNAL_FUNC func)
 122 {
 123         int n, index;
 124
 125         for (n = 0; n < SIGNAL_LISTS; n++) {
 126                 if (rec->siglist[n] == NULL)
 127                         continue;
 128
 129                 index = signal_list_find(rec->siglist[n], (void *) func);
 130                 if (index != -1) {
 131                         /* remove the function from emit list */
 132                         signal_remove_from_list(rec, signal_id, n, index);
 133                         return 1;
 134                 }
 135         }
 136
 137         return 0;
 138 }
 139
 140 void signal_remove_id(int signal_id, SIGNAL_FUNC func)
 141 {
 142         SIGNAL_REC *rec;
 143
 144         g_return_if_fail(signal_id >= 0);
 145         g_return_if_fail(func != NULL);
 146
 147         rec = g_hash_table_lookup(signals, GINT_TO_POINTER(signal_id));
 148         if (rec != NULL)
 149                 signal_remove_from_lists(rec, signal_id, func);
 150 }
 151
 152 /* unbind signal */
 153 void signal_remove(const char *signal, SIGNAL_FUNC func)
 154 {
 155         g_return_if_fail(signal != NULL);
 156
 157         signal_remove_id(signal_get_uniq_id(signal), func);
 158 }
 159
 160 /* Remove all NULL functions from signal list */
 161 static void signal_list_clean(SIGNAL_REC *rec)
 162 {
 163         int n, index;
 164
 165         for (n = 0; n < SIGNAL_LISTS; n++) {
 166                 if (rec->siglist[n] == NULL)
 167                         continue;
 168
 169                 for (index = rec->siglist[n]->len-1; index >= 0; index--) {
 170                         if (g_ptr_array_index(rec->siglist[n], index) == NULL) {
 171                                 g_ptr_array_remove_index(rec->siglist[n], index);
 172                                 g_ptr_array_remove_index(rec->modulelist[n], index);
 173                         }
 174                 }
 175         }
 176 }
 177
 178 static int signal_emit_real(SIGNAL_REC *rec, gconstpointer *arglist)
 179 {
 180         SIGNAL_REC *prev_emitted_signal;
 181         SIGNAL_FUNC func;
 182         int n, index, stopped, stop_emit_count;
 183
 184         /* signal_stop_by_name("signal"); signal_emit("signal", ...);
 185            fails if we compare rec->stop_emit against 0. */
 186         stop_emit_count = rec->stop_emit;
 187
 188         stopped = FALSE;
 189         rec->emitting++;
 190         for (n = 0; n < SIGNAL_LISTS; n++) {
 191                 /* run signals in emit lists */
 192                 if (rec->siglist[n] == NULL)
 193                         continue;
 194
 195                 for (index = rec->siglist[n]->len-1; index >= 0; index--) {
 196                         func = (SIGNAL_FUNC) g_ptr_array_index(rec->siglist[n], index);
 197
 198                         if (func != NULL) {
 199                                 prev_emitted_signal = current_emitted_signal;
 200                                 current_emitted_signal = rec;
 201 #if SIGNAL_MAX_ARGUMENTS != 6
 202 #  error SIGNAL_MAX_ARGS changed - update code
 203 #endif
 204                                 func(arglist[0], arglist[1], arglist[2], arglist[3], arglist[4], arglist[5]);
 205                                 current_emitted_signal = prev_emitted_signal;
 206                         }
 207
 208                         if (rec->stop_emit != stop_emit_count) {
 209                                 stopped = TRUE;
 210                                 rec->stop_emit--;
 211                                 n = SIGNAL_LISTS;
 212                                 break;
 213                         }
 214                 }
 215         }
 216         rec->emitting--;
 217
 218         if (!rec->emitting) {
 219                 if (rec->stop_emit != 0) {
 220                         /* signal_stop() used too many times */
 221                         rec->stop_emit = 0;
 222                 }
 223                 if (rec->altered) {
 224                         signal_list_clean(rec);
 225                         rec->altered = FALSE;
 226                 }
 227         }
 228
 229         return stopped;
 230 }
 231
 232 static int signal_emitv_id(int signal_id, int params, va_list va)
 233 {
 234         gconstpointer arglist[SIGNAL_MAX_ARGUMENTS];
 235         SIGNAL_REC *rec;
 236         int n;
 237
 238         g_return_val_if_fail(signal_id >= 0, FALSE);
 239         g_return_val_if_fail(params >= 0 && params <= SIGNAL_MAX_ARGUMENTS, FALSE);
 240
 241         for (n = 0; n < SIGNAL_MAX_ARGUMENTS; n++)
 242                 arglist[n] = n >= params ? NULL : va_arg(va, gconstpointer);
 243
 244         rec = g_hash_table_lookup(signals, GINT_TO_POINTER(signal_id));
 245         if (rec != NULL && signal_emit_real(rec, arglist))
 246                 return TRUE;
 247
 248         return rec != NULL;
 249 }
 250
 251 int signal_emit(const char *signal, int params, ...)
 252 {
 253         va_list va;
 254         int signal_id, ret;
 255
 256         /* get arguments */
 257         signal_id = signal_get_uniq_id(signal);
 258
 259         va_start(va, params);
 260         ret = signal_emitv_id(signal_id, params, va);
 261         va_end(va);
 262
 263         return ret;
 264 }
 265
 266 int signal_emit_id(int signal_id, int params, ...)
 267 {
 268         va_list va;
 269         int ret;
 270
 271         /* get arguments */
 272         va_start(va, params);
 273         ret = signal_emitv_id(signal_id, params, va);
 274         va_end(va);
 275
 276         return ret;
 277 }
 278
 279 /* stop the current ongoing signal emission */
 280 void signal_stop(void)
 281 {
 282         SIGNAL_REC *rec;
 283
 284         rec = current_emitted_signal;
 285         if (rec == NULL)
 286                 g_warning("signal_stop() : no signals are being emitted currently");
 287         else if (rec->emitting > rec->stop_emit)
 288                 rec->stop_emit++;
 289 }
 290
 291 /* stop ongoing signal emission by signal name */
 292 void signal_stop_by_name(const char *signal)
 293 {
 294         SIGNAL_REC *rec;
 295         int signal_id;
 296
 297         signal_id = signal_get_uniq_id(signal);
 298         rec = g_hash_table_lookup(signals, GINT_TO_POINTER(signal_id));
 299         if (rec == NULL)
 300                 g_warning("signal_stop_by_name() : unknown signal \"%s\"", signal);
 301         else if (rec->emitting > rec->stop_emit)
 302                 rec->stop_emit++;
 303 }
 304
 305 /* return the name of the signal that is currently being emitted */
 306 const char *signal_get_emitted(void)
 307 {
 308         return signal_get_id_str(signal_get_emitted_id());
 309 }
 310
 311 /* return the ID of the signal that is currently being emitted */
 312 int signal_get_emitted_id(void)
 313 {
 314         SIGNAL_REC *rec;
 315
 316         rec = current_emitted_signal;
 317         g_return_val_if_fail(rec != NULL, -1);
 318         return rec->id;
 319 }
 320
 321 /* return TRUE if specified signal was stopped */
 322 int signal_is_stopped(int signal_id)
 323 {
 324         SIGNAL_REC *rec;
 325
 326         rec = g_hash_table_lookup(signals, GINT_TO_POINTER(signal_id));
 327         g_return_val_if_fail(rec != NULL, FALSE);
 328
 329         return rec->emitting <= rec->stop_emit;
 330 }
 331
 332 static void signal_remove_module(void *signal, SIGNAL_REC *rec,
 333                                  const char *module)
 334 {
 335         unsigned int index;
 336         int signal_id, list;
 337
 338         signal_id = GPOINTER_TO_INT(signal);
 339
 340         for (list = 0; list < SIGNAL_LISTS; list++) {
 341                 if (rec->modulelist[list] == NULL)
 342                         continue;
 343
 344                 for (index = 0; index < rec->modulelist[list]->len; index++) {
 345                         if (g_strcasecmp(g_ptr_array_index(rec->modulelist[list], index), module) == 0)
 346                                 signal_remove_from_list(rec, signal_id, list, index);
 347                 }
 348         }
 349 }
 350
 351 /* remove all signals that belong to `module' */
 352 void signals_remove_module(const char *module)
 353 {
 354         g_return_if_fail(module != NULL);
 355
 356         g_hash_table_foreach(signals, (GHFunc) signal_remove_module, (void *) module);
 357 }
 358
 359 void signals_init(void)
 360 {
 361         signals_chunk = g_mem_chunk_new("signals", sizeof(SIGNAL_REC),
 362                                         sizeof(SIGNAL_REC)*200, G_ALLOC_AND_FREE);
 363         signals = g_hash_table_new((GHashFunc) g_direct_hash, (GCompareFunc) g_direct_equal);
 364 }
 365
 366 static void signal_free(void *key, SIGNAL_REC *rec)
 367 {
 368         int n;
 369
 370         for (n = 0; n < SIGNAL_LISTS; n++) {
 371                 if (rec->siglist[n] != NULL) {
 372                         g_ptr_array_free(rec->siglist[n], TRUE);
 373                         g_ptr_array_free(rec->modulelist[n], TRUE);
 374                 }
 375         }
 376
 377         g_mem_chunk_free(signals_chunk, rec);
 378         current_emitted_signal = NULL;
 379 }
 380
 381 void signals_deinit(void)
 382 {
 383         g_hash_table_foreach(signals, (GHFunc) signal_free, NULL);
 384         g_hash_table_destroy(signals);
 385
 386         module_uniq_destroy("signals");
 387         g_mem_chunk_destroy(signals_chunk);
 388 }