apps/irssi/src/core/expandos.c

   1 /*
   2  expandos.c : irssi
   3
   4     Copyright (C) 2000 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 "core.h"
  22 #include "module.h"
  23 #include "modules.h"
  24 #include "signals.h"
  25 #include "expandos.h"
  26 #include "settings.h"
  27 #include "commands.h"
  28 #include "misc.h"
  29 #include "irssi-version.h"
  30
  31 #include "servers.h"
  32 #include "channels.h"
  33 #include "queries.h"
  34 #include "window-item-def.h"
  35
  36 #ifdef HAVE_SYS_UTSNAME_H
  37 #  include <sys/utsname.h>
  38 #endif
  39
  40 #define MAX_EXPANDO_SIGNALS 10
  41
  42 typedef struct {
  43         EXPANDO_FUNC func;
  44
  45         int signals;
  46         int signal_ids[MAX_EXPANDO_SIGNALS];
  47         int signal_args[MAX_EXPANDO_SIGNALS];
  48 } EXPANDO_REC;
  49
  50 const char *current_expando = NULL;
  51
  52 static int timer_tag;
  53
  54 static EXPANDO_REC *char_expandos[255];
  55 static GHashTable *expandos;
  56 static char *last_sent_msg, *last_sent_msg_body;
  57 static char *last_privmsg_from, *last_public_from;
  58 static char *sysname, *sysrelease, *sysarch;
  59
  60 static const char *timestamp_format;
  61 static int timestamp_seconds;
  62 static time_t last_timestamp;
  63
  64 #define CHAR_EXPANDO(chr) \
  65         (char_expandos[(int) (unsigned char) chr])
  66
  67 /* Create expando - overrides any existing ones. */
  68 void expando_create(const char *key, EXPANDO_FUNC func, ...)
  69 {
  70         EXPANDO_REC *rec;
  71         const char *signal;
  72         va_list va;
  73
  74         g_return_if_fail(key != NULL || *key == '\0');
  75         g_return_if_fail(func != NULL);
  76
  77         if (key[1] != '\0')
  78                 rec = g_hash_table_lookup(expandos, key);
  79         else {
  80                 /* single character expando */
  81                 rec = CHAR_EXPANDO(*key);
  82         }
  83
  84         if (rec != NULL)
  85                 rec->signals = 0;
  86         else {
  87                 rec = g_new0(EXPANDO_REC, 1);
  88                 if (key[1] != '\0')
  89                         g_hash_table_insert(expandos, g_strdup(key), rec);
  90                 else
  91                         char_expandos[(int) (unsigned char) *key] = rec;
  92         }
  93
  94         rec->func = func;
  95
  96         va_start(va, func);
  97         while ((signal = (const char *) va_arg(va, const char *)) != NULL)
  98                expando_add_signal(key, signal, (int) va_arg(va, int));
  99         va_end(va);
 100 }
 101
 102 static EXPANDO_REC *expando_find(const char *key)
 103 {
 104         if (key[1] != '\0')
 105                 return g_hash_table_lookup(expandos, key);
 106         else
 107                 return CHAR_EXPANDO(*key);
 108 }
 109
 110 /* Add new signal to expando */
 111 void expando_add_signal(const char *key, const char *signal, ExpandoArg arg)
 112 {
 113         EXPANDO_REC *rec;
 114
 115         g_return_if_fail(key != NULL);
 116         g_return_if_fail(signal != NULL);
 117
 118         rec = expando_find(key);
 119         g_return_if_fail(rec != NULL);
 120
 121         if (arg == EXPANDO_NEVER) {
 122                 /* expando changes never */
 123                 rec->signals = -1;
 124         } else if (rec->signals < MAX_EXPANDO_SIGNALS) {
 125                 g_return_if_fail(rec->signals != -1);
 126
 127                 rec->signal_ids[rec->signals] = signal_get_uniq_id(signal);
 128                 rec->signal_args[rec->signals] = arg;
 129                 rec->signals++;
 130         }
 131 }
 132
 133 /* Destroy expando */
 134 void expando_destroy(const char *key, EXPANDO_FUNC func)
 135 {
 136         gpointer origkey, value;
 137         EXPANDO_REC *rec;
 138
 139         g_return_if_fail(key != NULL || *key == '\0');
 140         g_return_if_fail(func != NULL);
 141
 142         if (key[1] == '\0') {
 143                 /* single character expando */
 144                 rec = CHAR_EXPANDO(*key);
 145                 if (rec != NULL && rec->func == func) {
 146                         char_expandos[(int) (unsigned char) *key] = NULL;
 147                         g_free(rec);
 148                 }
 149         } else if (g_hash_table_lookup_extended(expandos, key,
 150                                                 &origkey, &value)) {
 151                 rec = value;
 152                 if (rec->func == func) {
 153                         g_hash_table_remove(expandos, key);
 154                         g_free(origkey);
 155                         g_free(rec);
 156                 }
 157         }
 158 }
 159
 160 void expando_bind(const char *key, int funccount, SIGNAL_FUNC *funcs)
 161 {
 162         SIGNAL_FUNC func;
 163         EXPANDO_REC *rec;
 164         int n, arg;
 165
 166         g_return_if_fail(key != NULL);
 167         g_return_if_fail(funccount >= 1);
 168         g_return_if_fail(funcs != NULL);
 169         g_return_if_fail(funcs[0] != NULL);
 170
 171         rec = expando_find(key);
 172         g_return_if_fail(rec != NULL);
 173
 174         if (rec->signals == 0) {
 175                 /* it's unknown when this expando changes..
 176                    check it once in a second */
 177                 signal_add("expando timer", funcs[EXPANDO_ARG_NONE]);
 178         }
 179
 180         for (n = 0; n < rec->signals; n++) {
 181                 arg = rec->signal_args[n];
 182                 func = arg < funccount ? funcs[arg] : NULL;
 183                 if (func == NULL) func = funcs[EXPANDO_ARG_NONE];
 184
 185                 signal_add_full_id(MODULE_NAME, SIGNAL_PRIORITY_DEFAULT,
 186                                    rec->signal_ids[n], func, NULL);
 187         }
 188 }
 189
 190 void expando_unbind(const char *key, int funccount, SIGNAL_FUNC *funcs)
 191 {
 192         SIGNAL_FUNC func;
 193         EXPANDO_REC *rec;
 194         int n, arg;
 195
 196         g_return_if_fail(key != NULL);
 197         g_return_if_fail(funccount >= 1);
 198         g_return_if_fail(funcs != NULL);
 199         g_return_if_fail(funcs[0] != NULL);
 200
 201         rec = expando_find(key);
 202         g_return_if_fail(rec != NULL);
 203
 204         if (rec->signals == 0) {
 205                 /* it's unknown when this expando changes..
 206                    check it once in a second */
 207                 signal_remove("expando timer", funcs[EXPANDO_ARG_NONE]);
 208         }
 209
 210         for (n = 0; n < rec->signals; n++) {
 211                 arg = rec->signal_args[n];
 212                 func = arg < funccount ? funcs[arg] : NULL;
 213                 if (func == NULL) func = funcs[EXPANDO_ARG_NONE];
 214
 215                 signal_remove_id(rec->signal_ids[n], func, NULL);
 216         }
 217 }
 218
 219 /* Returns [<signal id>, EXPANDO_ARG_xxx, <signal id>, ..., -1] */
 220 int *expando_get_signals(const char *key)
 221 {
 222         EXPANDO_REC *rec;
 223         int *signals;
 224         int n;
 225
 226         g_return_val_if_fail(key != NULL, NULL);
 227
 228         rec = expando_find(key);
 229         if (rec == NULL || rec->signals < 0)
 230                 return NULL;
 231
 232         if (rec->signals == 0) {
 233                 /* it's unknown when this expando changes..
 234                    check it once in a second */
 235                 signals = g_new(int, 3);
 236                 signals[0] = signal_get_uniq_id("expando timer");
 237                 signals[1] = EXPANDO_ARG_NONE;
 238                 signals[2] = -1;
 239                 return signals;
 240         }
 241
 242         signals = g_new(int, rec->signals*2+1);
 243         for (n = 0; n < rec->signals; n++) {
 244                 signals[n*2] = rec->signal_ids[n];
 245                 signals[n*2+1] = rec->signal_args[n];
 246         }
 247         signals[rec->signals*2] = -1;
 248         return signals;
 249 }
 250
 251 EXPANDO_FUNC expando_find_char(char chr)
 252 {
 253         return CHAR_EXPANDO(chr) == NULL ? NULL :
 254                 CHAR_EXPANDO(chr)->func;
 255 }
 256
 257 EXPANDO_FUNC expando_find_long(const char *key)
 258 {
 259         EXPANDO_REC *rec = g_hash_table_lookup(expandos, key);
 260         return rec == NULL ? NULL : rec->func;
 261 }
 262
 263 static gboolean free_expando(gpointer key, gpointer value, gpointer user_data)
 264 {
 265         g_free(key);
 266         g_free(value);
 267         return TRUE;
 268 }
 269
 270 /* last person who sent you a MSG */
 271 static char *expando_lastmsg(SERVER_REC *server, void *item, int *free_ret)
 272 {
 273         return last_privmsg_from;
 274 }
 275
 276 /* last person to whom you sent a MSG */
 277 static char *expando_lastmymsg(SERVER_REC *server, void *item, int *free_ret)
 278 {
 279         return last_sent_msg;
 280 }
 281
 282 /* last person to send a public message to a channel you are on */
 283 static char *expando_lastpublic(SERVER_REC *server, void *item, int *free_ret)
 284 {
 285         return last_public_from;
 286 }
 287
 288 /* text of your AWAY message, if any */
 289 static char *expando_awaymsg(SERVER_REC *server, void *item, int *free_ret)
 290 {
 291         return server == NULL ? "" : server->away_reason;
 292 }
 293
 294 /* body of last MSG you sent */
 295 static char *expando_lastmymsg_body(SERVER_REC *server, void *item, int *free_ret)
 296 {
 297         return last_sent_msg_body;
 298 }
 299
 300 /* current channel */
 301 static char *expando_channel(SERVER_REC *server, void *item, int *free_ret)
 302 {
 303         return !IS_CHANNEL(item) ? NULL : CHANNEL(item)->name;
 304 }
 305
 306 /* time client was started, $time() format */
 307 static char *expando_clientstarted(SERVER_REC *server, void *item, int *free_ret)
 308 {
 309         *free_ret = TRUE;
 310         return g_strdup_printf("%ld", (long) client_start_time);
 311 }
 312
 313 /* channel you were last INVITEd to */
 314 static char *expando_last_invite(SERVER_REC *server, void *item, int *free_ret)
 315 {
 316         return server == NULL ? "" : server->last_invite;
 317 }
 318
 319 /* client version text string */
 320 static char *expando_version(SERVER_REC *server, void *item, int *free_ret)
 321 {
 322         return IRSSI_VERSION;
 323 }
 324
 325 /* current value of CMDCHARS */
 326 static char *expando_cmdchars(SERVER_REC *server, void *item, int *free_ret)
 327 {
 328         return (char *) settings_get_str("cmdchars");
 329 }
 330
 331 /* first CMDCHAR */
 332 static char *expando_cmdchar(SERVER_REC *server, void *item, int *free_ret)
 333 {
 334         char str[2] = { 0, 0 };
 335
 336         str[0] = *settings_get_str("cmdchars");
 337
 338         *free_ret = TRUE;
 339         return g_strdup(str);
 340 }
 341
 342 /* modes of current channel, if any */
 343 static char *expando_chanmode(SERVER_REC *server, void *item, int *free_ret)
 344 {
 345         char *cmode;
 346
 347         *free_ret = FALSE;
 348
 349         if (!IS_CHANNEL(item))
 350                 return NULL;
 351
 352         if (!settings_get_bool("chanmode_expando_strip"))
 353                 return CHANNEL(item)->mode;
 354
 355         *free_ret = TRUE;
 356         cmode = g_strdup(CHANNEL(item)->mode);
 357         if (strchr(cmode, ' ') != NULL)
 358                 *(strchr(cmode, ' ')) = 0;
 359
 360         return cmode;
 361 }
 362
 363 /* current nickname */
 364 static char *expando_nick(SERVER_REC *server, void *item, int *free_ret)
 365 {
 366         return server == NULL ? "" : server->nick;
 367 }
 368
 369 /* value of STATUS_OPER if you are an irc operator */
 370 static char *expando_statusoper(SERVER_REC *server, void *item, int *free_ret)
 371 {
 372         return server == NULL || !server->server_operator ? "" :
 373                 (char *) settings_get_str("STATUS_OPER");
 374 }
 375
 376 /* if you are a channel operator in $C, expands to a '@' */
 377 static char *expando_chanop(SERVER_REC *server, void *item, int *free_ret)
 378 {
 379         return IS_CHANNEL(item) && CHANNEL(item)->chanop ? "@" : "";
 380 }
 381
 382 /* nickname of whomever you are QUERYing */
 383 static char *expando_query(SERVER_REC *server, void *item, int *free_ret)
 384 {
 385         return !IS_QUERY(item) ? "" : QUERY(item)->name;
 386 }
 387
 388 /* version of current server */
 389 static char *expando_serverversion(SERVER_REC *server, void *item, int *free_ret)
 390 {
 391         return server == NULL ? "" : server->version;
 392 }
 393
 394 /* target of current input (channel or QUERY nickname) */
 395 static char *expando_target(SERVER_REC *server, void *item, int *free_ret)
 396 {
 397         return item == NULL ? "" :
 398                 (char *) window_item_get_target((WI_ITEM_REC *) item);
 399 }
 400
 401 /* client release date (in YYYYMMDD format) */
 402 static char *expando_releasedate(SERVER_REC *server, void *item, int *free_ret)
 403 {
 404         *free_ret = TRUE;
 405         return g_strdup_printf("%d", IRSSI_VERSION_DATE);
 406 }
 407
 408 /* client release time (in HHMM format) */
 409 static char *expando_releasetime(SERVER_REC *server, void *item, int *free_ret)
 410 {
 411         *free_ret = TRUE;
 412         return g_strdup_printf("%04d", IRSSI_VERSION_TIME);
 413 }
 414
 415 /* current working directory */
 416 static char *expando_workdir(SERVER_REC *server, void *item, int *free_ret)
 417 {
 418         *free_ret = TRUE;
 419         return g_get_current_dir();
 420 }
 421
 422 /* value of REALNAME */
 423 static char *expando_realname(SERVER_REC *server, void *item, int *free_ret)
 424 {
 425         return server == NULL ? "" : server->connrec->realname;
 426 }
 427
 428 /* time of day (hh:mm) */
 429 static char *expando_time(SERVER_REC *server, void *item, int *free_ret)
 430 {
 431         time_t now;
 432         struct tm *tm;
 433         char str[256];
 434
 435         now = time(NULL);
 436         tm = localtime(&now);
 437
 438         if (strftime(str, sizeof(str), timestamp_format, tm) == 0)
 439                 return "";
 440
 441         *free_ret = TRUE;
 442         return g_strdup(str);
 443 }
 444
 445 /* a literal '$' */
 446 static char *expando_dollar(SERVER_REC *server, void *item, int *free_ret)
 447 {
 448         return "$";
 449 }
 450
 451 /* system name */
 452 static char *expando_sysname(SERVER_REC *server, void *item, int *free_ret)
 453 {
 454         return sysname;
 455 }
 456
 457 /* system release */
 458 static char *expando_sysrelease(SERVER_REC *server, void *item, int *free_ret)
 459 {
 460         return sysrelease;
 461 }
 462
 463 /* system architecture */
 464 static char *expando_sysarch(SERVER_REC *server, void *item, int *free_ret)
 465 {
 466         return sysarch;
 467 }
 468
 469 /* Topic of active channel (or address of queried nick) */
 470 static char *expando_topic(SERVER_REC *server, void *item, int *free_ret)
 471 {
 472         if (IS_CHANNEL(item))
 473                 return CHANNEL(item)->topic;
 474         if (IS_QUERY(item)) {
 475                 QUERY_REC *query = QUERY(item);
 476
 477                 if (query->server_tag == NULL)
 478                         return "";
 479
 480                 *free_ret = TRUE;
 481                 return query->address == NULL ?
 482                         g_strdup_printf("(%s)", query->server_tag) :
 483                         g_strdup_printf("%s (%s)", query->address,
 484                                         query->server_tag);
 485         }
 486         return "";
 487 }
 488
 489 /* Server tag */
 490 static char *expando_servertag(SERVER_REC *server, void *item, int *free_ret)
 491 {
 492         return server == NULL ? "" : server->tag;
 493 }
 494
 495 /* Server chatnet */
 496 static char *expando_chatnet(SERVER_REC *server, void *item, int *free_ret)
 497 {
 498         return server == NULL ? "" : server->connrec->chatnet;
 499 }
 500
 501 /* visible_name of current window item */
 502 static char *expando_itemname(SERVER_REC *server, void *item, int *free_ret)
 503 {
 504         return item == NULL ? "" : ((WI_ITEM_REC *) item)->visible_name;
 505 }
 506
 507 static void sig_message_public(SERVER_REC *server, const char *msg,
 508                                const char *nick, const char *address,
 509                                const char *target)
 510 {
 511         g_free_not_null(last_public_from);
 512         last_public_from = g_strdup(nick);
 513 }
 514
 515 static void sig_message_private(SERVER_REC *server, const char *msg,
 516                                 const char *nick, const char *address)
 517 {
 518         g_free_not_null(last_privmsg_from);
 519         last_privmsg_from = g_strdup(nick);
 520 }
 521
 522 static void sig_message_own_private(SERVER_REC *server, const char *msg,
 523                                     const char *target, const char *origtarget)
 524 {
 525         g_return_if_fail(server != NULL);
 526         g_return_if_fail(msg != NULL);
 527
 528         if (target != NULL) {
 529                 if (target != last_sent_msg) {
 530                         g_free_not_null(last_sent_msg);
 531                         last_sent_msg = g_strdup(target);
 532                 }
 533                 g_free_not_null(last_sent_msg_body);
 534                 last_sent_msg_body = g_strdup(msg);
 535         }
 536 }
 537
 538 static int sig_timer(void)
 539 {
 540         time_t now;
 541         struct tm *tm;
 542         int last_min;
 543
 544         signal_emit("expando timer", 0);
 545
 546         /* check if $Z has changed */
 547         now = time(NULL);
 548         if (last_timestamp != now) {
 549                 if (!timestamp_seconds && last_timestamp != 0) {
 550                         /* assume it changes every minute */
 551                         tm = localtime(&last_timestamp);
 552                         last_min = tm->tm_min;
 553
 554                         tm = localtime(&now);
 555                         if (tm->tm_min == last_min)
 556                                 return 1;
 557                 }
 558
 559                 signal_emit("time changed", 0);
 560                 last_timestamp = now;
 561         }
 562
 563         return 1;
 564 }
 565
 566 static void read_settings(void)
 567 {
 568         timestamp_format = settings_get_str("timestamp_format");
 569         timestamp_seconds =
 570                 strstr(timestamp_format, "%r") != NULL ||
 571                 strstr(timestamp_format, "%s") != NULL ||
 572                 strstr(timestamp_format, "%S") != NULL ||
 573                 strstr(timestamp_format, "%X") != NULL ||
 574                 strstr(timestamp_format, "%T") != NULL;
 575
 576 }
 577
 578 void expandos_init(void)
 579 {
 580 #ifdef HAVE_SYS_UTSNAME_H
 581         struct utsname un;
 582 #endif
 583         settings_add_str("misc", "STATUS_OPER", "*");
 584         settings_add_str("lookandfeel", "timestamp_format", "%H:%M");
 585         settings_add_bool("lookandfeel", "chanmode_expando_strip", FALSE);
 586
 587         last_sent_msg = NULL; last_sent_msg_body = NULL;
 588         last_privmsg_from = NULL; last_public_from = NULL;
 589         last_timestamp = 0;
 590
 591         sysname = sysrelease = sysarch = NULL;
 592 #ifdef HAVE_SYS_UTSNAME_H
 593         if (uname(&un) >= 0) {
 594                 sysname = g_strdup(un.sysname);
 595                 sysrelease = g_strdup(un.release);
 596                 sysarch = g_strdup(un.machine);
 597         }
 598 #endif
 599
 600         memset(char_expandos, 0, sizeof(char_expandos));
 601         expandos = g_hash_table_new((GHashFunc) g_str_hash,
 602                                     (GCompareFunc) g_str_equal);
 603
 604         expando_create(",", expando_lastmsg,
 605                        "message private", EXPANDO_ARG_SERVER, NULL);
 606         expando_create(".", expando_lastmymsg,
 607                        "command msg", EXPANDO_ARG_NONE, NULL);
 608         expando_create(";", expando_lastpublic,
 609                        "message public", EXPANDO_ARG_SERVER, NULL);
 610         expando_create("A", expando_awaymsg,
 611                        "away mode changed", EXPANDO_ARG_NONE, NULL);
 612         expando_create("B", expando_lastmymsg_body,
 613                        "command msg", EXPANDO_ARG_NONE, NULL);
 614         expando_create("C", expando_channel,
 615                        "window changed", EXPANDO_ARG_NONE,
 616                        "window item changed", EXPANDO_ARG_WINDOW, NULL);
 617         expando_create("F", expando_clientstarted,
 618                        "", EXPANDO_NEVER, NULL);
 619         expando_create("I", expando_last_invite, NULL);
 620         expando_create("J", expando_version,
 621                        "", EXPANDO_NEVER, NULL);
 622         expando_create("K", expando_cmdchars,
 623                        "setup changed", EXPANDO_ARG_NONE, NULL);
 624         expando_create("k", expando_cmdchar,
 625                        "setup changed", EXPANDO_ARG_NONE, NULL);
 626         expando_create("M", expando_chanmode,
 627                        "window changed", EXPANDO_ARG_NONE,
 628                        "window item changed", EXPANDO_ARG_WINDOW,
 629                        "channel mode changed", EXPANDO_ARG_WINDOW_ITEM, NULL);
 630         expando_create("N", expando_nick,
 631                        "window changed", EXPANDO_ARG_NONE,
 632                        "window connect changed", EXPANDO_ARG_WINDOW,
 633                        "window server changed", EXPANDO_ARG_WINDOW,
 634                        "server nick changed", EXPANDO_ARG_SERVER, NULL);
 635         expando_create("O", expando_statusoper,
 636                        "setup changed", EXPANDO_ARG_NONE,
 637                        "window changed", EXPANDO_ARG_NONE,
 638                        "window server changed", EXPANDO_ARG_WINDOW,
 639                        "user mode changed", EXPANDO_ARG_WINDOW, NULL);
 640         expando_create("P", expando_chanop,
 641                        "window changed", EXPANDO_ARG_NONE,
 642                        "window item changed", EXPANDO_ARG_WINDOW,
 643                        "nick mode changed", EXPANDO_ARG_WINDOW_ITEM, NULL);
 644         expando_create("Q", expando_query,
 645                        "window changed", EXPANDO_ARG_NONE,
 646                        "window item changed", EXPANDO_ARG_WINDOW, NULL);
 647         expando_create("R", expando_serverversion,
 648                        "window changed", EXPANDO_ARG_NONE,
 649                        "window server changed", EXPANDO_ARG_WINDOW, NULL);
 650         expando_create("T", expando_target,
 651                        "window changed", EXPANDO_ARG_NONE,
 652                        "window item changed", EXPANDO_ARG_WINDOW, NULL);
 653         expando_create("V", expando_releasedate,
 654                        "", EXPANDO_NEVER, NULL);
 655         expando_create("versiontime", expando_releasetime,
 656                        "", EXPANDO_NEVER, NULL);
 657         expando_create("W", expando_workdir, NULL);
 658         expando_create("Y", expando_realname,
 659                        "window changed", EXPANDO_ARG_NONE,
 660                        "window connect changed", EXPANDO_ARG_WINDOW,
 661                        "window server changed", EXPANDO_ARG_WINDOW, NULL);
 662         expando_create("Z", expando_time,
 663                        "time changed", EXPANDO_ARG_NONE, NULL);
 664         expando_create("$", expando_dollar,
 665                        "", EXPANDO_NEVER, NULL);
 666
 667         expando_create("sysname", expando_sysname,
 668                        "", EXPANDO_NEVER, NULL);
 669         expando_create("sysrelease", expando_sysrelease,
 670                        "", EXPANDO_NEVER, NULL);
 671         expando_create("sysarch", expando_sysarch,
 672                        "", EXPANDO_NEVER, NULL);
 673         expando_create("topic", expando_topic,
 674                        "window changed", EXPANDO_ARG_NONE,
 675                        "window item changed", EXPANDO_ARG_WINDOW,
 676                        "channel topic changed", EXPANDO_ARG_WINDOW_ITEM,
 677                        "query address changed", EXPANDO_ARG_WINDOW_ITEM, NULL);
 678         expando_create("tag", expando_servertag,
 679                        "window changed", EXPANDO_ARG_NONE,
 680                        "window connect changed", EXPANDO_ARG_WINDOW,
 681                        "window server changed", EXPANDO_ARG_WINDOW, NULL);
 682         expando_create("chatnet", expando_chatnet,
 683                        "window changed", EXPANDO_ARG_NONE,
 684                        "window connect changed", EXPANDO_ARG_WINDOW,
 685                        "window server changed", EXPANDO_ARG_WINDOW, NULL);
 686         expando_create("itemname", expando_itemname,
 687                        "window changed", EXPANDO_ARG_NONE,
 688                        "window item changed", EXPANDO_ARG_WINDOW,
 689                        "window item name changed", EXPANDO_ARG_WINDOW_ITEM,
 690                        NULL);
 691
 692         read_settings();
 693
 694         timer_tag = g_timeout_add(500, (GSourceFunc) sig_timer, NULL);
 695         signal_add("message public", (SIGNAL_FUNC) sig_message_public);
 696         signal_add("message private", (SIGNAL_FUNC) sig_message_private);
 697         signal_add("message own_private", (SIGNAL_FUNC) sig_message_own_private);
 698         signal_add_first("setup changed", (SIGNAL_FUNC) read_settings);
 699 }
 700
 701 void expandos_deinit(void)
 702 {
 703         int n;
 704
 705         for (n = 0; n < sizeof(char_expandos)/sizeof(char_expandos[0]); n++)
 706                 g_free_not_null(char_expandos[n]);
 707
 708         g_hash_table_foreach_remove(expandos, free_expando, NULL);
 709         g_hash_table_destroy(expandos);
 710
 711         g_free_not_null(last_sent_msg); g_free_not_null(last_sent_msg_body);
 712         g_free_not_null(last_privmsg_from); g_free_not_null(last_public_from);
 713         g_free_not_null(sysname); g_free_not_null(sysrelease);
 714         g_free_not_null(sysarch);
 715
 716         g_source_remove(timer_tag);
 717         signal_remove("message public", (SIGNAL_FUNC) sig_message_public);
 718         signal_remove("message private", (SIGNAL_FUNC) sig_message_private);
 719         signal_remove("message own_private", (SIGNAL_FUNC) sig_message_own_private);
 720         signal_remove("setup changed", (SIGNAL_FUNC) read_settings);
 721 }