libpurple/signals.c

   1 /* purple
   2  *
   3  * Purple is the legal property of its developers, whose names are too numerous
   4  * to list here.  Please refer to the COPYRIGHT file distributed with this
   5  * source distribution.
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 2 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA
  20  */
  21 #include "internal.h"
  22
  23 #include "debug.h"
  24 #include "signals.h"
  25
  26 /* must include this to use G_VA_COPY */
  27 #include <string.h>
  28
  29 typedef struct
  30 {
  31         void *instance;
  32
  33         GHashTable *signals;
  34         size_t signal_count;
  35
  36         gulong next_signal_id;
  37
  38 } PurpleInstanceData;
  39
  40 typedef struct
  41 {
  42         gulong id;
  43
  44         PurpleSignalMarshalFunc marshal;
  45
  46         int num_values;
  47         GType *value_types;
  48         GType ret_type;
  49
  50         GList *handlers;
  51         size_t handler_count;
  52
  53         gulong next_handler_id;
  54 } PurpleSignalData;
  55
  56 typedef struct
  57 {
  58         gulong id;
  59         PurpleCallback cb;
  60         void *handle;
  61         void *data;
  62         gboolean use_vargs;
  63         int priority;
  64
  65 } PurpleSignalHandlerData;
  66
  67 static GHashTable *instance_table = NULL;
  68
  69 static void
  70 destroy_instance_data(PurpleInstanceData *instance_data)
  71 {
  72         g_hash_table_destroy(instance_data->signals);
  73
  74         g_free(instance_data);
  75 }
  76
  77 static void
  78 destroy_signal_data(PurpleSignalData *signal_data)
  79 {
  80         g_list_free_full(signal_data->handlers, g_free);
  81         g_free(signal_data->value_types);
  82         g_free(signal_data);
  83 }
  84
  85 gulong
  86 purple_signal_register(void *instance, const char *signal,
  87                                          PurpleSignalMarshalFunc marshal,
  88                                          GType ret_type, int num_values, ...)
  89 {
  90         PurpleInstanceData *instance_data;
  91         PurpleSignalData *signal_data;
  92         va_list args;
  93
  94         g_return_val_if_fail(instance != NULL, 0);
  95         g_return_val_if_fail(signal   != NULL, 0);
  96         g_return_val_if_fail(marshal  != NULL, 0);
  97
  98         instance_data =
  99                 (PurpleInstanceData *)g_hash_table_lookup(instance_table, instance);
 100
 101         if (instance_data == NULL)
 102         {
 103                 instance_data = g_new0(PurpleInstanceData, 1);
 104
 105                 instance_data->instance = instance;
 106                 instance_data->next_signal_id = 1;
 107
 108                 instance_data->signals =
 109                         g_hash_table_new_full(g_str_hash, g_str_equal, g_free,
 110                                                                   (GDestroyNotify)destroy_signal_data);
 111
 112                 g_hash_table_insert(instance_table, instance, instance_data);
 113         }
 114
 115         signal_data = g_new0(PurpleSignalData, 1);
 116         signal_data->id              = instance_data->next_signal_id;
 117         signal_data->marshal         = marshal;
 118         signal_data->next_handler_id = 1;
 119         signal_data->ret_type        = ret_type;
 120         signal_data->num_values      = num_values;
 121
 122         if (num_values > 0)
 123         {
 124                 int i;
 125
 126                 signal_data->value_types = g_new0(GType, num_values);
 127
 128                 va_start(args, num_values);
 129
 130                 for (i = 0; i < num_values; i++)
 131                         signal_data->value_types[i] = va_arg(args, GType);
 132
 133                 va_end(args);
 134         }
 135
 136         g_hash_table_insert(instance_data->signals,
 137                                                 g_strdup(signal), signal_data);
 138
 139         instance_data->next_signal_id++;
 140         instance_data->signal_count++;
 141
 142         return signal_data->id;
 143 }
 144
 145 void
 146 purple_signal_unregister(void *instance, const char *signal)
 147 {
 148         PurpleInstanceData *instance_data;
 149
 150         g_return_if_fail(instance != NULL);
 151         g_return_if_fail(signal   != NULL);
 152
 153         instance_data =
 154                 (PurpleInstanceData *)g_hash_table_lookup(instance_table, instance);
 155
 156         g_return_if_fail(instance_data != NULL);
 157
 158         g_hash_table_remove(instance_data->signals, signal);
 159
 160         instance_data->signal_count--;
 161
 162         if (instance_data->signal_count == 0)
 163         {
 164                 /* Unregister the instance. */
 165                 g_hash_table_remove(instance_table, instance);
 166         }
 167 }
 168
 169 void
 170 purple_signals_unregister_by_instance(void *instance)
 171 {
 172         g_return_if_fail(instance != NULL);
 173
 174         g_hash_table_remove(instance_table, instance);
 175
 176         /*
 177          * Makes things easier (more annoying?) for developers who don't have
 178          * things registering and unregistering in the right order :)
 179          */
 180         /* g_return_if_fail(found); */
 181 }
 182
 183 void
 184 purple_signal_get_types(void *instance, const char *signal,
 185                                            GType *ret_type,
 186                                            int *num_values, GType **value_types)
 187 {
 188         PurpleInstanceData *instance_data;
 189         PurpleSignalData *signal_data;
 190
 191         g_return_if_fail(instance    != NULL);
 192         g_return_if_fail(signal      != NULL);
 193         g_return_if_fail(num_values  != NULL);
 194         g_return_if_fail(value_types != NULL);
 195
 196         /* Get the instance data */
 197         instance_data =
 198                 (PurpleInstanceData *)g_hash_table_lookup(instance_table, instance);
 199
 200         g_return_if_fail(instance_data != NULL);
 201
 202         /* Get the signal data */
 203         signal_data =
 204                 (PurpleSignalData *)g_hash_table_lookup(instance_data->signals, signal);
 205
 206         g_return_if_fail(signal_data != NULL);
 207
 208         *num_values  = signal_data->num_values;
 209         *value_types = signal_data->value_types;
 210
 211         if (ret_type != NULL)
 212                 *ret_type = signal_data->ret_type;
 213 }
 214
 215 static gint handler_priority(void * a, void * b) {
 216         PurpleSignalHandlerData *ah = (PurpleSignalHandlerData*)a;
 217         PurpleSignalHandlerData *bh = (PurpleSignalHandlerData*)b;
 218         if (ah->priority > bh->priority) return 1;
 219         if (ah->priority < bh->priority) return -1;
 220         return 0;
 221 }
 222
 223 static gulong
 224 signal_connect_common(void *instance, const char *signal, void *handle,
 225                                           PurpleCallback func, void *data, int priority, gboolean use_vargs)
 226 {
 227         PurpleInstanceData *instance_data;
 228         PurpleSignalData *signal_data;
 229         PurpleSignalHandlerData *handler_data;
 230
 231         g_return_val_if_fail(instance != NULL, 0);
 232         g_return_val_if_fail(signal   != NULL, 0);
 233         g_return_val_if_fail(handle   != NULL, 0);
 234         g_return_val_if_fail(func     != NULL, 0);
 235
 236         /* Get the instance data */
 237         instance_data =
 238                 (PurpleInstanceData *)g_hash_table_lookup(instance_table, instance);
 239
 240         if (instance_data == NULL)
 241         {
 242                 purple_debug_warning("signals", "Something tried to register a callback "
 243                                 "for the '%s' signal, but we do not have any signals "
 244                                 "registered with the given handle\n", signal);
 245                 g_return_val_if_reached(0);
 246         }
 247
 248         /* Get the signal data */
 249         signal_data =
 250                 (PurpleSignalData *)g_hash_table_lookup(instance_data->signals, signal);
 251
 252         if (signal_data == NULL)
 253         {
 254                 purple_debug(PURPLE_DEBUG_ERROR, "signals",
 255                                    "Signal data for %s not found!\n", signal);
 256                 return 0;
 257         }
 258
 259         /* Create the signal handler data */
 260         handler_data = g_new0(PurpleSignalHandlerData, 1);
 261         handler_data->id        = signal_data->next_handler_id;
 262         handler_data->cb        = func;
 263         handler_data->handle    = handle;
 264         handler_data->data      = data;
 265         handler_data->use_vargs = use_vargs;
 266         handler_data->priority = priority;
 267
 268         signal_data->handlers = g_list_insert_sorted(signal_data->handlers, handler_data, (GCompareFunc)handler_priority);
 269         signal_data->handler_count++;
 270         signal_data->next_handler_id++;
 271
 272         return handler_data->id;
 273 }
 274
 275 gulong
 276 purple_signal_connect_priority(void *instance, const char *signal, void *handle,
 277                                         PurpleCallback func, void *data, int priority)
 278 {
 279         return signal_connect_common(instance, signal, handle, func, data, priority, FALSE);
 280 }
 281
 282 gulong
 283 purple_signal_connect(void *instance, const char *signal, void *handle,
 284                                         PurpleCallback func, void *data)
 285 {
 286         return signal_connect_common(instance, signal, handle, func, data, PURPLE_SIGNAL_PRIORITY_DEFAULT, FALSE);
 287 }
 288
 289 gulong
 290 purple_signal_connect_priority_vargs(void *instance, const char *signal, void *handle,
 291                                                   PurpleCallback func, void *data, int priority)
 292 {
 293         return signal_connect_common(instance, signal, handle, func, data, priority, TRUE);
 294 }
 295
 296 gulong
 297 purple_signal_connect_vargs(void *instance, const char *signal, void *handle,
 298                                                   PurpleCallback func, void *data)
 299 {
 300         return signal_connect_common(instance, signal, handle, func, data, PURPLE_SIGNAL_PRIORITY_DEFAULT, TRUE);
 301 }
 302
 303 void
 304 purple_signal_disconnect(void *instance, const char *signal,
 305                                            void *handle, PurpleCallback func)
 306 {
 307         PurpleInstanceData *instance_data;
 308         PurpleSignalData *signal_data;
 309         PurpleSignalHandlerData *handler_data;
 310         GList *l;
 311         gboolean found = FALSE;
 312
 313         g_return_if_fail(instance != NULL);
 314         g_return_if_fail(signal   != NULL);
 315         g_return_if_fail(handle   != NULL);
 316         g_return_if_fail(func     != NULL);
 317
 318         /* Get the instance data */
 319         instance_data =
 320                 (PurpleInstanceData *)g_hash_table_lookup(instance_table, instance);
 321
 322         g_return_if_fail(instance_data != NULL);
 323
 324         /* Get the signal data */
 325         signal_data =
 326                 (PurpleSignalData *)g_hash_table_lookup(instance_data->signals, signal);
 327
 328         if (signal_data == NULL)
 329         {
 330                 purple_debug(PURPLE_DEBUG_ERROR, "signals",
 331                                    "Signal data for %s not found!\n", signal);
 332                 return;
 333         }
 334
 335         /* Find the handler data. */
 336         for (l = signal_data->handlers; l != NULL; l = l->next)
 337         {
 338                 handler_data = (PurpleSignalHandlerData *)l->data;
 339
 340                 if (handler_data->handle == handle && handler_data->cb == func)
 341                 {
 342                         g_free(handler_data);
 343
 344                         signal_data->handlers = g_list_delete_link(signal_data->handlers,
 345                                                                                                        l);
 346                         signal_data->handler_count--;
 347
 348                         found = TRUE;
 349
 350                         break;
 351                 }
 352         }
 353
 354         /* See note somewhere about this actually helping developers.. */
 355         g_return_if_fail(found);
 356 }
 357
 358 /*
 359  * TODO: Make this all more efficient by storing a list of handlers, keyed
 360  *       to a handle.
 361  */
 362 static void
 363 disconnect_handle_from_signals(const char *signal,
 364                                                            PurpleSignalData *signal_data, void *handle)
 365 {
 366         GList *l, *l_next;
 367         PurpleSignalHandlerData *handler_data;
 368
 369         for (l = signal_data->handlers; l != NULL; l = l_next)
 370         {
 371                 handler_data = (PurpleSignalHandlerData *)l->data;
 372                 l_next = l->next;
 373
 374                 if (handler_data->handle == handle)
 375                 {
 376                         g_free(handler_data);
 377
 378                         signal_data->handler_count--;
 379                         signal_data->handlers = g_list_delete_link(signal_data->handlers,
 380                                                                    l);
 381                 }
 382         }
 383 }
 384
 385 static void
 386 disconnect_handle_from_instance(void *instance,
 387                                                                 PurpleInstanceData *instance_data,
 388                                                                 void *handle)
 389 {
 390         g_hash_table_foreach(instance_data->signals,
 391                                                  (GHFunc)disconnect_handle_from_signals, handle);
 392 }
 393
 394 void
 395 purple_signals_disconnect_by_handle(void *handle)
 396 {
 397         g_return_if_fail(handle != NULL);
 398
 399         g_hash_table_foreach(instance_table,
 400                                                  (GHFunc)disconnect_handle_from_instance, handle);
 401 }
 402
 403 void
 404 purple_signal_emit(void *instance, const char *signal, ...)
 405 {
 406         va_list args;
 407
 408         g_return_if_fail(instance != NULL);
 409         g_return_if_fail(signal   != NULL);
 410
 411         va_start(args, signal);
 412         purple_signal_emit_vargs(instance, signal, args);
 413         va_end(args);
 414 }
 415
 416 void
 417 purple_signal_emit_vargs(void *instance, const char *signal, va_list args)
 418 {
 419         PurpleInstanceData *instance_data;
 420         PurpleSignalData *signal_data;
 421         PurpleSignalHandlerData *handler_data;
 422         GList *l, *l_next;
 423         va_list tmp;
 424
 425         g_return_if_fail(instance != NULL);
 426         g_return_if_fail(signal   != NULL);
 427
 428         instance_data =
 429                 (PurpleInstanceData *)g_hash_table_lookup(instance_table, instance);
 430
 431         g_return_if_fail(instance_data != NULL);
 432
 433         signal_data =
 434                 (PurpleSignalData *)g_hash_table_lookup(instance_data->signals, signal);
 435
 436         if (signal_data == NULL)
 437         {
 438                 purple_debug(PURPLE_DEBUG_ERROR, "signals",
 439                                    "Signal data for %s not found!\n", signal);
 440                 return;
 441         }
 442
 443         for (l = signal_data->handlers; l != NULL; l = l_next)
 444         {
 445                 l_next = l->next;
 446
 447                 handler_data = (PurpleSignalHandlerData *)l->data;
 448
 449                 /* This is necessary because a va_list may only be
 450                  * evaluated once */
 451                 G_VA_COPY(tmp, args);
 452
 453                 if (handler_data->use_vargs)
 454                 {
 455                         ((void (*)(va_list, void *))handler_data->cb)(tmp,
 456                                                                                                                   handler_data->data);
 457                 }
 458                 else
 459                 {
 460                         signal_data->marshal(handler_data->cb, tmp,
 461                                                                  handler_data->data, NULL);
 462                 }
 463
 464                 va_end(tmp);
 465         }
 466 }
 467
 468 void *
 469 purple_signal_emit_return_1(void *instance, const char *signal, ...)
 470 {
 471         void *ret_val;
 472         va_list args;
 473
 474         g_return_val_if_fail(instance != NULL, NULL);
 475         g_return_val_if_fail(signal   != NULL, NULL);
 476
 477         va_start(args, signal);
 478         ret_val = purple_signal_emit_vargs_return_1(instance, signal, args);
 479         va_end(args);
 480
 481         return ret_val;
 482 }
 483
 484 void *
 485 purple_signal_emit_vargs_return_1(void *instance, const char *signal,
 486                                                                 va_list args)
 487 {
 488         PurpleInstanceData *instance_data;
 489         PurpleSignalData *signal_data;
 490         PurpleSignalHandlerData *handler_data;
 491         GList *l, *l_next;
 492         va_list tmp;
 493
 494         g_return_val_if_fail(instance != NULL, NULL);
 495         g_return_val_if_fail(signal   != NULL, NULL);
 496
 497         instance_data =
 498                 (PurpleInstanceData *)g_hash_table_lookup(instance_table, instance);
 499
 500         g_return_val_if_fail(instance_data != NULL, NULL);
 501
 502         signal_data =
 503                 (PurpleSignalData *)g_hash_table_lookup(instance_data->signals, signal);
 504
 505         if (signal_data == NULL)
 506         {
 507                 purple_debug(PURPLE_DEBUG_ERROR, "signals",
 508                                    "Signal data for %s not found!\n", signal);
 509                 return 0;
 510         }
 511
 512         for (l = signal_data->handlers; l != NULL; l = l_next)
 513         {
 514                 void *ret_val = NULL;
 515
 516                 l_next = l->next;
 517
 518                 handler_data = (PurpleSignalHandlerData *)l->data;
 519
 520                 G_VA_COPY(tmp, args);
 521                 if (handler_data->use_vargs)
 522                 {
 523                         ret_val = ((void *(*)(va_list, void *))handler_data->cb)(
 524                                 tmp, handler_data->data);
 525                 }
 526                 else
 527                 {
 528                         signal_data->marshal(handler_data->cb, tmp,
 529                                                                  handler_data->data, &ret_val);
 530                 }
 531                 va_end(tmp);
 532
 533                 if (ret_val != NULL)
 534                         return ret_val;
 535         }
 536
 537         return NULL;
 538 }
 539
 540 void
 541 purple_signals_init()
 542 {
 543         g_return_if_fail(instance_table == NULL);
 544
 545         instance_table =
 546                 g_hash_table_new_full(g_direct_hash, g_direct_equal,
 547                                                           NULL, (GDestroyNotify)destroy_instance_data);
 548 }
 549
 550 void
 551 purple_signals_uninit()
 552 {
 553         g_return_if_fail(instance_table != NULL);
 554
 555         g_hash_table_destroy(instance_table);
 556         instance_table = NULL;
 557 }
 558
 559 /**************************************************************************
 560  * Marshallers
 561  **************************************************************************/
 562 void
 563 purple_marshal_VOID(PurpleCallback cb, va_list args, void *data,
 564                                   void **return_val)
 565 {
 566         ((void (*)(void *))cb)(data);
 567 }
 568
 569 void
 570 purple_marshal_VOID__INT(PurpleCallback cb, va_list args, void *data,
 571                                            void **return_val)
 572 {
 573         gint arg1 = va_arg(args, gint);
 574
 575         ((void (*)(gint, void *))cb)(arg1, data);
 576 }
 577
 578 void
 579 purple_marshal_VOID__INT_INT(PurpleCallback cb, va_list args, void *data,
 580                                                    void **return_val)
 581 {
 582         gint arg1 = va_arg(args, gint);
 583         gint arg2 = va_arg(args, gint);
 584
 585         ((void (*)(gint, gint, void *))cb)(arg1, arg2, data);
 586 }
 587
 588 void
 589 purple_marshal_VOID__POINTER(PurpleCallback cb, va_list args, void *data,
 590                                                    void **return_val)
 591 {
 592         void *arg1 = va_arg(args, void *);
 593
 594         ((void (*)(void *, void *))cb)(arg1, data);
 595 }
 596
 597 void
 598 purple_marshal_VOID__POINTER_UINT(PurpleCallback cb, va_list args,
 599                                                                                 void *data, void **return_val)
 600 {
 601         void *arg1 = va_arg(args, void *);
 602         guint arg2 = va_arg(args, guint);
 603
 604         ((void (*)(void *, guint, void *))cb)(arg1, arg2, data);
 605 }
 606
 607 void purple_marshal_VOID__POINTER_INT_INT(PurpleCallback cb, va_list args,
 608                                         void *data, void **return_val)
 609 {
 610         void *arg1 = va_arg(args, void *);
 611         gint arg2 = va_arg(args, gint);
 612         gint arg3 = va_arg(args, gint);
 613
 614         ((void (*)(void *, gint, gint, void *))cb)(arg1, arg2, arg3, data);
 615 }
 616
 617 void purple_marshal_VOID__POINTER_INT_POINTER(PurpleCallback cb, va_list args,
 618                                               void *data, void **return_val)
 619 {
 620         void *arg1 = va_arg(args, void *);
 621         gint arg2 = va_arg(args, gint);
 622         void *arg3 = va_arg(args, void *);
 623
 624         ((void (*)(void *, gint, void *, void *))cb)(arg1, arg2, arg3, data);
 625 }
 626
 627 void
 628 purple_marshal_VOID__POINTER_POINTER(PurpleCallback cb, va_list args,
 629                                                                    void *data, void **return_val)
 630 {
 631         void *arg1 = va_arg(args, void *);
 632         void *arg2 = va_arg(args, void *);
 633
 634         ((void (*)(void *, void *, void *))cb)(arg1, arg2, data);
 635 }
 636
 637 void
 638 purple_marshal_VOID__POINTER_POINTER_UINT(PurpleCallback cb, va_list args,
 639                                                                                 void *data, void **return_val)
 640 {
 641         void *arg1 = va_arg(args, void *);
 642         void *arg2 = va_arg(args, void *);
 643         guint arg3 = va_arg(args, guint);
 644
 645         ((void (*)(void *, void *, guint, void *))cb)(arg1, arg2, arg3, data);
 646 }
 647
 648 void
 649 purple_marshal_VOID__POINTER_POINTER_UINT_UINT(PurpleCallback cb, va_list args,
 650                                                                                      void *data, void **return_val)
 651 {
 652         void *arg1 = va_arg(args, void *);
 653         void *arg2 = va_arg(args, void *);
 654         guint arg3 = va_arg(args, guint);
 655         guint arg4 = va_arg(args, guint);
 656
 657         ((void (*)(void *, void *, guint, guint, void *))cb)(arg1, arg2, arg3, arg4, data);
 658 }
 659
 660 void
 661 purple_marshal_VOID__POINTER_UINT_UINT(PurpleCallback cb, va_list args,
 662                                                                                      void *data, void **return_val)
 663 {
 664         void *arg1 = va_arg(args, void *);
 665         guint arg2 = va_arg(args, guint);
 666         guint arg3 = va_arg(args, guint);
 667
 668         ((void (*)(void *, guint, guint, void *))cb)(arg1, arg2, arg3, data);
 669 }
 670
 671 void
 672 purple_marshal_VOID__POINTER_POINTER_POINTER(PurpleCallback cb, va_list args,
 673                                                                                    void *data, void **return_val)
 674 {
 675         void *arg1 = va_arg(args, void *);
 676         void *arg2 = va_arg(args, void *);
 677         void *arg3 = va_arg(args, void *);
 678
 679         ((void (*)(void *, void *, void *, void *))cb)(arg1, arg2, arg3, data);
 680 }
 681
 682 void
 683 purple_marshal_VOID__POINTER_POINTER_POINTER_POINTER(PurpleCallback cb,
 684                                                                                                    va_list args,
 685                                                                                                    void *data,
 686                                                                                                    void **return_val)
 687 {
 688         void *arg1 = va_arg(args, void *);
 689         void *arg2 = va_arg(args, void *);
 690         void *arg3 = va_arg(args, void *);
 691         void *arg4 = va_arg(args, void *);
 692
 693         ((void (*)(void *, void *, void *, void *, void *))cb)(arg1, arg2, arg3, arg4, data);
 694 }
 695
 696 void
 697 purple_marshal_VOID__POINTER_POINTER_POINTER_POINTER_POINTER(PurpleCallback cb,
 698                                                                                                                    va_list args,
 699                                                                                                                    void *data,
 700                                                                                                                    void **return_val)
 701 {
 702         void *arg1 = va_arg(args, void *);
 703         void *arg2 = va_arg(args, void *);
 704         void *arg3 = va_arg(args, void *);
 705         void *arg4 = va_arg(args, void *);
 706         void *arg5 = va_arg(args, void *);
 707
 708         ((void (*)(void *, void *, void *, void *, void *, void *))cb)(arg1, arg2, arg3, arg4, arg5, data);
 709 }
 710
 711 void
 712 purple_marshal_VOID__POINTER_POINTER_POINTER_UINT(PurpleCallback cb,
 713                                                                                                    va_list args,
 714                                                                                                    void *data,
 715                                                                                                    void **return_val)
 716 {
 717         void *arg1 = va_arg(args, void *);
 718         void *arg2 = va_arg(args, void *);
 719         void *arg3 = va_arg(args, void *);
 720         guint arg4 = va_arg(args, guint);
 721
 722         ((void (*)(void *, void *, void *, guint, void *))cb)(arg1, arg2, arg3, arg4, data);
 723 }
 724
 725 void
 726 purple_marshal_VOID__POINTER_POINTER_POINTER_POINTER_UINT(PurpleCallback cb,
 727                                                                                                             va_list args,
 728                                                                                                             void *data,
 729                                                                                                             void **return_val)
 730 {
 731         void *arg1 = va_arg(args, void *);
 732         void *arg2 = va_arg(args, void *);
 733         void *arg3 = va_arg(args, void *);
 734         void *arg4 = va_arg(args, void *);
 735         guint arg5 = va_arg(args, guint);
 736
 737         ((void (*)(void *, void *, void *, void *, guint, void *))cb)(arg1, arg2, arg3, arg4, arg5, data);
 738 }
 739
 740 void
 741 purple_marshal_VOID__POINTER_POINTER_POINTER_UINT_UINT(PurpleCallback cb,
 742                                                                                                          va_list args,
 743                                                                                                          void *data,
 744                                                                                                          void **return_val)
 745 {
 746         void *arg1 = va_arg(args, void *);
 747         void *arg2 = va_arg(args, void *);
 748         void *arg3 = va_arg(args, void *);
 749         guint arg4 = va_arg(args, guint);
 750         guint arg5 = va_arg(args, guint);
 751
 752         ((void (*)(void *, void *, void *, guint, guint, void *))cb)(
 753                         arg1, arg2, arg3, arg4, arg5, data);
 754 }
 755
 756 void
 757 purple_marshal_INT__INT(PurpleCallback cb, va_list args, void *data,
 758                                           void **return_val)
 759 {
 760         gint ret_val;
 761         gint arg1 = va_arg(args, gint);
 762
 763         ret_val = ((gint (*)(gint, void *))cb)(arg1, data);
 764
 765         if (return_val != NULL)
 766                 *return_val = GINT_TO_POINTER(ret_val);
 767 }
 768
 769 void
 770 purple_marshal_INT__INT_INT(PurpleCallback cb, va_list args, void *data,
 771                                                   void **return_val)
 772 {
 773         gint ret_val;
 774         gint arg1 = va_arg(args, gint);
 775         gint arg2 = va_arg(args, gint);
 776
 777         ret_val = ((gint (*)(gint, gint, void *))cb)(arg1, arg2, data);
 778
 779         if (return_val != NULL)
 780                 *return_val = GINT_TO_POINTER(ret_val);
 781 }
 782
 783 void
 784 purple_marshal_INT__POINTER_POINTER(PurpleCallback cb, va_list args, void *data,
 785                                       void **return_val)
 786 {
 787         gint ret_val;
 788         void *arg1 = va_arg(args, void *);
 789         void *arg2 = va_arg(args, void *);
 790
 791         ret_val = ((gint (*)(void *, void *, void *))cb)(arg1, arg2, data);
 792
 793         if (return_val != NULL)
 794                 *return_val = GINT_TO_POINTER(ret_val);
 795 }
 796
 797         void
 798 purple_marshal_INT__POINTER_POINTER_POINTER(
 799                 PurpleCallback cb, va_list args, void *data, void **return_val)
 800 {
 801         gint ret_val;
 802         void *arg1 = va_arg(args, void *);
 803         void *arg2 = va_arg(args, void *);
 804         void *arg3 = va_arg(args, void *);
 805
 806         ret_val = ((gint (*)(void *, void *, void *, void *))cb)(arg1, arg2, arg3, data);
 807
 808         if (return_val != NULL)
 809                 *return_val = GINT_TO_POINTER(ret_val);
 810 }
 811
 812 void
 813 purple_marshal_INT__POINTER_POINTER_POINTER_POINTER_POINTER(
 814                 PurpleCallback cb, va_list args, void *data, void **return_val)
 815 {
 816         gint ret_val;
 817         void *arg1 = va_arg(args, void *);
 818         void *arg2 = va_arg(args, void *);
 819         void *arg3 = va_arg(args, void *);
 820         void *arg4 = va_arg(args, void *);
 821         void *arg5 = va_arg(args, void *);
 822
 823         ret_val =
 824                 ((gint (*)(void *, void *, void *, void *, void *, void *))cb)(
 825                         arg1, arg2, arg3, arg4, arg5, data);
 826
 827         if (return_val != NULL)
 828                 *return_val = GINT_TO_POINTER(ret_val);
 829 }
 830
 831 void
 832 purple_marshal_BOOLEAN__POINTER(PurpleCallback cb, va_list args, void *data,
 833                                                           void **return_val)
 834 {
 835         gboolean ret_val;
 836         void *arg1 = va_arg(args, void *);
 837
 838         ret_val = ((gboolean (*)(void *, void *))cb)(arg1, data);
 839
 840         if (return_val != NULL)
 841                 *return_val = GINT_TO_POINTER(ret_val);
 842 }
 843
 844 void
 845 purple_marshal_BOOLEAN__POINTER_POINTER(PurpleCallback cb, va_list args,
 846                                                                           void *data, void **return_val)
 847 {
 848         gboolean ret_val;
 849         void *arg1 = va_arg(args, void *);
 850         void *arg2 = va_arg(args, void *);
 851
 852         ret_val = ((gboolean (*)(void *, void *, void *))cb)(arg1, arg2, data);
 853
 854         if (return_val != NULL)
 855                 *return_val = GINT_TO_POINTER(ret_val);
 856 }
 857
 858 void
 859 purple_marshal_BOOLEAN__POINTER_BOOLEAN(PurpleCallback cb, va_list args,
 860                                                                           void *data, void **return_val)
 861 {
 862         gboolean ret_val;
 863         void *arg1 = va_arg(args, void *);
 864         gboolean arg2 = va_arg(args, gboolean);
 865
 866         ret_val = ((gboolean (*)(void *, gboolean, void *))cb)(arg1, arg2, data);
 867
 868         if (return_val != NULL)
 869                 *return_val = GINT_TO_POINTER(ret_val);
 870 }
 871
 872 void
 873 purple_marshal_BOOLEAN__POINTER_POINTER_POINTER(PurpleCallback cb, va_list args,
 874                                                                                           void *data, void **return_val)
 875 {
 876         gboolean ret_val;
 877         void *arg1 = va_arg(args, void *);
 878         void *arg2 = va_arg(args, void *);
 879         void *arg3 = va_arg(args, void *);
 880
 881         ret_val = ((gboolean (*)(void *, void *, void *, void *))cb)(arg1, arg2,
 882                                                                                                                                  arg3, data);
 883
 884         if (return_val != NULL)
 885                 *return_val = GINT_TO_POINTER(ret_val);
 886 }
 887
 888 void
 889 purple_marshal_BOOLEAN__POINTER_POINTER_UINT(PurpleCallback cb,
 890                                                                                                    va_list args,
 891                                                                                                    void *data,
 892                                                                                                    void **return_val)
 893 {
 894         gboolean ret_val;
 895         void *arg1 = va_arg(args, void *);
 896         void *arg2 = va_arg(args, void *);
 897         guint arg3 = va_arg(args, guint);
 898
 899         ret_val = ((gboolean (*)(void *, void *, guint, void *))cb)(
 900                         arg1, arg2, arg3, data);
 901
 902         if (return_val != NULL)
 903                 *return_val = GINT_TO_POINTER(ret_val);
 904 }
 905
 906 void
 907 purple_marshal_BOOLEAN__POINTER_POINTER_POINTER_UINT(PurpleCallback cb,
 908                                                                                                    va_list args,
 909                                                                                                    void *data,
 910                                                                                                    void **return_val)
 911 {
 912         gboolean ret_val;
 913         void *arg1 = va_arg(args, void *);
 914         void *arg2 = va_arg(args, void *);
 915         void *arg3 = va_arg(args, void *);
 916         guint arg4 = va_arg(args, guint);
 917
 918         ret_val = ((gboolean (*)(void *, void *, void *, guint, void *))cb)(
 919                         arg1, arg2, arg3, arg4, data);
 920
 921         if (return_val != NULL)
 922                 *return_val = GINT_TO_POINTER(ret_val);
 923 }
 924
 925 void
 926 purple_marshal_BOOLEAN__POINTER_POINTER_POINTER_POINTER(PurpleCallback cb,
 927                                                                                                           va_list args,
 928                                                                                                           void *data,
 929                                                                                                           void **return_val)
 930 {
 931         gboolean ret_val;
 932         void *arg1 = va_arg(args, void *);
 933         void *arg2 = va_arg(args, void *);
 934         void *arg3 = va_arg(args, void *);
 935         void *arg4 = va_arg(args, void *);
 936
 937         ret_val = ((gboolean (*)(void *, void *, void *, void *, void *))cb)(
 938                         arg1, arg2, arg3, arg4, data);
 939
 940         if (return_val != NULL)
 941                 *return_val = GINT_TO_POINTER(ret_val);
 942 }
 943
 944 void
 945 purple_marshal_BOOLEAN__POINTER_POINTER_POINTER_POINTER_POINTER(
 946                 PurpleCallback cb, va_list args, void *data, void **return_val)
 947 {
 948         gboolean ret_val;
 949         void *arg1 = va_arg(args, void *);
 950         void *arg2 = va_arg(args, void *);
 951         void *arg3 = va_arg(args, void *);
 952         void *arg4 = va_arg(args, void *);
 953         void *arg5 = va_arg(args, void *);
 954
 955         ret_val =
 956                 ((gboolean (*)(void *, void *, void *, void *, void *, void *))cb)(
 957                         arg1, arg2, arg3, arg4, arg5, data);
 958
 959         if (return_val != NULL)
 960                 *return_val = GINT_TO_POINTER(ret_val);
 961 }
 962
 963 void
 964 purple_marshal_BOOLEAN__POINTER_POINTER_POINTER_POINTER_UINT(
 965                 PurpleCallback cb, va_list args, void *data, void **return_val)
 966 {
 967         gboolean ret_val;
 968         void *arg1 = va_arg(args, void *);
 969         void *arg2 = va_arg(args, void *);
 970         void *arg3 = va_arg(args, void *);
 971         void *arg4 = va_arg(args, void *);
 972         guint arg5 = va_arg(args, guint);
 973
 974         ret_val =
 975                 ((gboolean (*)(void *, void *, void *, void *, guint, void *))cb)(
 976                         arg1, arg2, arg3, arg4, arg5, data);
 977
 978         if (return_val != NULL)
 979                 *return_val = GINT_TO_POINTER(ret_val);
 980 }
 981
 982 void
 983 purple_marshal_BOOLEAN__POINTER_POINTER_POINTER_POINTER_POINTER_POINTER(
 984                 PurpleCallback cb, va_list args, void *data, void **return_val)
 985 {
 986         gboolean ret_val;
 987         void *arg1 = va_arg(args, void *);
 988         void *arg2 = va_arg(args, void *);
 989         void *arg3 = va_arg(args, void *);
 990         void *arg4 = va_arg(args, void *);
 991         void *arg5 = va_arg(args, void *);
 992         void *arg6 = va_arg(args, void *);
 993
 994         ret_val =
 995                 ((gboolean (*)(void *, void *, void *, void *, void *, void *, void *))cb)(
 996                         arg1, arg2, arg3, arg4, arg5, arg6, data);
 997
 998         if (return_val != NULL)
 999                 *return_val = GINT_TO_POINTER(ret_val);
1000 }
1001
1002 void
1003 purple_marshal_BOOLEAN__INT_POINTER(PurpleCallback cb, va_list args, void *data,
1004                                   void **return_val)
1005 {
1006         gboolean ret_val;
1007         gint arg1 = va_arg(args, gint);
1008         void *arg2 = va_arg(args, void *);
1009
1010         ret_val = ((gboolean (*)(gint, void *, void *))cb)(arg1, arg2, data);
1011
1012         if (return_val != NULL)
1013                 *return_val = GINT_TO_POINTER(ret_val);
1014 }
1015
1016 void
1017 purple_marshal_POINTER__POINTER(
1018                                     PurpleCallback cb, va_list args, void *data,
1019                                     void **return_val)
1020 {
1021         gpointer ret_val;
1022         void *arg1 = va_arg(args, void *);
1023
1024         ret_val = ((gpointer(*)(void *, void *))cb)(arg1, data);
1025
1026         if (return_val != NULL)
1027                 *return_val = ret_val;
1028 }
1029
1030
1031 void
1032 purple_marshal_POINTER__POINTER_INT(
1033                                     PurpleCallback cb, va_list args, void *data,
1034                                     void **return_val)
1035 {
1036         gpointer ret_val;
1037         void *arg1 = va_arg(args, void *);
1038         gint arg2 = va_arg(args, gint);
1039
1040         ret_val = ((gpointer(*)(void *, gint, void *))cb)(arg1, arg2, data);
1041
1042         if (return_val != NULL)
1043                 *return_val = ret_val;
1044 }
1045
1046 void
1047 purple_marshal_POINTER__POINTER_INT64(
1048                                     PurpleCallback cb, va_list args, void *data,
1049                                     void **return_val)
1050 {
1051         gpointer ret_val;
1052         void *arg1 = va_arg(args, void *);
1053         gint64 arg2 = va_arg(args, gint64);
1054
1055         ret_val = ((gpointer(*)(void *, gint64, void *))cb)(arg1, arg2, data);
1056
1057         if (return_val != NULL)
1058                 *return_val = ret_val;
1059 }
1060
1061 void
1062 purple_marshal_POINTER__POINTER_INT_BOOLEAN(
1063                                     PurpleCallback cb, va_list args, void *data,
1064                                     void **return_val)
1065 {
1066         gpointer ret_val;
1067         void *arg1 = va_arg(args, void *);
1068         gint arg2 = va_arg(args, gint);
1069         gboolean arg3 = va_arg(args, gboolean);
1070
1071         ret_val = ((gpointer(*)(void *, gint, gboolean, void *))cb)(arg1, arg2, arg3, data);
1072
1073         if (return_val != NULL)
1074                 *return_val = ret_val;
1075 }
1076
1077 void
1078 purple_marshal_POINTER__POINTER_INT64_BOOLEAN(
1079                                     PurpleCallback cb, va_list args, void *data,
1080                                     void **return_val)
1081 {
1082         gpointer ret_val;
1083         void *arg1 = va_arg(args, void *);
1084         gint64 arg2 = va_arg(args, gint64);
1085         gboolean arg3 = va_arg(args, gboolean);
1086
1087         ret_val = ((gpointer(*)(void *, gint64, gboolean, void *))cb)(arg1, arg2, arg3, data);
1088
1089         if (return_val != NULL)
1090                 *return_val = ret_val;
1091 }
1092
1093 void
1094 purple_marshal_POINTER__POINTER_POINTER_BOOLEAN(
1095                                     PurpleCallback cb, va_list args, void *data,
1096                                     void **return_val)
1097 {
1098         gpointer ret_val;
1099         void *arg1 = va_arg(args, void *);
1100         void *arg2 = va_arg(args, void *);
1101         gboolean arg3 = va_arg(args, gboolean);
1102
1103         ret_val = ((gpointer(*)(void *, void *, gboolean, void *))cb)(arg1, arg2, arg3, data);
1104
1105         if (return_val != NULL)
1106                 *return_val = ret_val;
1107 }
1108
1109 void
1110 purple_marshal_POINTER__POINTER_POINTER(PurpleCallback cb, va_list args, void *data,
1111                                       void **return_val)
1112 {
1113         gpointer ret_val;
1114         void *arg1 = va_arg(args, void *);
1115         void *arg2 = va_arg(args, void *);
1116
1117         ret_val = ((gpointer (*)(void *, void *, void *))cb)(arg1, arg2, data);
1118
1119         if (return_val != NULL)
1120                 *return_val = ret_val;
1121 }