pidgin/pidgin

Make it possible so that libpurple plugins can use functions defined in libpurple/glibcompat.h

4 months ago, Gary Kramlich
797f5a0f602c
Make it possible so that libpurple plugins can use functions defined in libpurple/glibcompat.h

Testing Done:
Compiled on linux and raspberry pi os which fixes that build.

Reviewed at https://reviews.imfreedom.org/r/169/
/* purple
*
* Purple is the legal property of its developers, whose names are too numerous
* to list here. Please refer to the COPYRIGHT file distributed with this
* source distribution.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
*/
#include "internal.h"
#include "debug.h"
#include "signals.h"
/* must include this to use G_VA_COPY */
#include <string.h>
typedef struct
{
void *instance;
GHashTable *signals;
size_t signal_count;
gulong next_signal_id;
} PurpleInstanceData;
typedef struct
{
gulong id;
PurpleSignalMarshalFunc marshal;
int num_values;
GType *value_types;
GType ret_type;
GList *handlers;
size_t handler_count;
gulong next_handler_id;
} PurpleSignalData;
typedef struct
{
gulong id;
PurpleCallback cb;
void *handle;
void *data;
gboolean use_vargs;
int priority;
} PurpleSignalHandlerData;
static GHashTable *instance_table = NULL;
static void
destroy_instance_data(PurpleInstanceData *instance_data)
{
g_hash_table_destroy(instance_data->signals);
g_free(instance_data);
}
static void
destroy_signal_data(PurpleSignalData *signal_data)
{
g_list_free_full(signal_data->handlers, g_free);
g_free(signal_data->value_types);
g_free(signal_data);
}
gulong
purple_signal_register(void *instance, const char *signal,
PurpleSignalMarshalFunc marshal,
GType ret_type, int num_values, ...)
{
PurpleInstanceData *instance_data;
PurpleSignalData *signal_data;
va_list args;
g_return_val_if_fail(instance != NULL, 0);
g_return_val_if_fail(signal != NULL, 0);
g_return_val_if_fail(marshal != NULL, 0);
instance_data =
(PurpleInstanceData *)g_hash_table_lookup(instance_table, instance);
if (instance_data == NULL)
{
instance_data = g_new0(PurpleInstanceData, 1);
instance_data->instance = instance;
instance_data->next_signal_id = 1;
instance_data->signals =
g_hash_table_new_full(g_str_hash, g_str_equal, g_free,
(GDestroyNotify)destroy_signal_data);
g_hash_table_insert(instance_table, instance, instance_data);
}
signal_data = g_new0(PurpleSignalData, 1);
signal_data->id = instance_data->next_signal_id;
signal_data->marshal = marshal;
signal_data->next_handler_id = 1;
signal_data->ret_type = ret_type;
signal_data->num_values = num_values;
if (num_values > 0)
{
int i;
signal_data->value_types = g_new0(GType, num_values);
va_start(args, num_values);
for (i = 0; i < num_values; i++)
signal_data->value_types[i] = va_arg(args, GType);
va_end(args);
}
g_hash_table_insert(instance_data->signals,
g_strdup(signal), signal_data);
instance_data->next_signal_id++;
instance_data->signal_count++;
return signal_data->id;
}
void
purple_signal_unregister(void *instance, const char *signal)
{
PurpleInstanceData *instance_data;
g_return_if_fail(instance != NULL);
g_return_if_fail(signal != NULL);
instance_data =
(PurpleInstanceData *)g_hash_table_lookup(instance_table, instance);
g_return_if_fail(instance_data != NULL);
g_hash_table_remove(instance_data->signals, signal);
instance_data->signal_count--;
if (instance_data->signal_count == 0)
{
/* Unregister the instance. */
g_hash_table_remove(instance_table, instance);
}
}
void
purple_signals_unregister_by_instance(void *instance)
{
g_return_if_fail(instance != NULL);
g_hash_table_remove(instance_table, instance);
/*
* Makes things easier (more annoying?) for developers who don't have
* things registering and unregistering in the right order :)
*/
/* g_return_if_fail(found); */
}
void
purple_signal_get_types(void *instance, const char *signal,
GType *ret_type,
int *num_values, GType **value_types)
{
PurpleInstanceData *instance_data;
PurpleSignalData *signal_data;
g_return_if_fail(instance != NULL);
g_return_if_fail(signal != NULL);
g_return_if_fail(num_values != NULL);
g_return_if_fail(value_types != NULL);
/* Get the instance data */
instance_data =
(PurpleInstanceData *)g_hash_table_lookup(instance_table, instance);
g_return_if_fail(instance_data != NULL);
/* Get the signal data */
signal_data =
(PurpleSignalData *)g_hash_table_lookup(instance_data->signals, signal);
g_return_if_fail(signal_data != NULL);
*num_values = signal_data->num_values;
*value_types = signal_data->value_types;
if (ret_type != NULL)
*ret_type = signal_data->ret_type;
}
static gint handler_priority(void * a, void * b) {
PurpleSignalHandlerData *ah = (PurpleSignalHandlerData*)a;
PurpleSignalHandlerData *bh = (PurpleSignalHandlerData*)b;
if (ah->priority > bh->priority) return 1;
if (ah->priority < bh->priority) return -1;
return 0;
}
static gulong
signal_connect_common(void *instance, const char *signal, void *handle,
PurpleCallback func, void *data, int priority, gboolean use_vargs)
{
PurpleInstanceData *instance_data;
PurpleSignalData *signal_data;
PurpleSignalHandlerData *handler_data;
g_return_val_if_fail(instance != NULL, 0);
g_return_val_if_fail(signal != NULL, 0);
g_return_val_if_fail(handle != NULL, 0);
g_return_val_if_fail(func != NULL, 0);
/* Get the instance data */
instance_data =
(PurpleInstanceData *)g_hash_table_lookup(instance_table, instance);
if (instance_data == NULL)
{
purple_debug_warning("signals", "Something tried to register a callback "
"for the '%s' signal, but we do not have any signals "
"registered with the given handle\n", signal);
g_return_val_if_reached(0);
}
/* Get the signal data */
signal_data =
(PurpleSignalData *)g_hash_table_lookup(instance_data->signals, signal);
if (signal_data == NULL)
{
purple_debug(PURPLE_DEBUG_ERROR, "signals",
"Signal data for %s not found!\n", signal);
return 0;
}
/* Create the signal handler data */
handler_data = g_new0(PurpleSignalHandlerData, 1);
handler_data->id = signal_data->next_handler_id;
handler_data->cb = func;
handler_data->handle = handle;
handler_data->data = data;
handler_data->use_vargs = use_vargs;
handler_data->priority = priority;
signal_data->handlers = g_list_insert_sorted(signal_data->handlers, handler_data, (GCompareFunc)handler_priority);
signal_data->handler_count++;
signal_data->next_handler_id++;
return handler_data->id;
}
gulong
purple_signal_connect_priority(void *instance, const char *signal, void *handle,
PurpleCallback func, void *data, int priority)
{
return signal_connect_common(instance, signal, handle, func, data, priority, FALSE);
}
gulong
purple_signal_connect(void *instance, const char *signal, void *handle,
PurpleCallback func, void *data)
{
return signal_connect_common(instance, signal, handle, func, data, PURPLE_SIGNAL_PRIORITY_DEFAULT, FALSE);
}
gulong
purple_signal_connect_priority_vargs(void *instance, const char *signal, void *handle,
PurpleCallback func, void *data, int priority)
{
return signal_connect_common(instance, signal, handle, func, data, priority, TRUE);
}
gulong
purple_signal_connect_vargs(void *instance, const char *signal, void *handle,
PurpleCallback func, void *data)
{
return signal_connect_common(instance, signal, handle, func, data, PURPLE_SIGNAL_PRIORITY_DEFAULT, TRUE);
}
void
purple_signal_disconnect(void *instance, const char *signal,
void *handle, PurpleCallback func)
{
PurpleInstanceData *instance_data;
PurpleSignalData *signal_data;
PurpleSignalHandlerData *handler_data;
GList *l;
gboolean found = FALSE;
g_return_if_fail(instance != NULL);
g_return_if_fail(signal != NULL);
g_return_if_fail(handle != NULL);
g_return_if_fail(func != NULL);
/* Get the instance data */
instance_data =
(PurpleInstanceData *)g_hash_table_lookup(instance_table, instance);
g_return_if_fail(instance_data != NULL);
/* Get the signal data */
signal_data =
(PurpleSignalData *)g_hash_table_lookup(instance_data->signals, signal);
if (signal_data == NULL)
{
purple_debug(PURPLE_DEBUG_ERROR, "signals",
"Signal data for %s not found!\n", signal);
return;
}
/* Find the handler data. */
for (l = signal_data->handlers; l != NULL; l = l->next)
{
handler_data = (PurpleSignalHandlerData *)l->data;
if (handler_data->handle == handle && handler_data->cb == func)
{
g_free(handler_data);
signal_data->handlers = g_list_delete_link(signal_data->handlers,
l);
signal_data->handler_count--;
found = TRUE;
break;
}
}
/* See note somewhere about this actually helping developers.. */
g_return_if_fail(found);
}
/*
* TODO: Make this all more efficient by storing a list of handlers, keyed
* to a handle.
*/
static void
disconnect_handle_from_signals(const char *signal,
PurpleSignalData *signal_data, void *handle)
{
GList *l, *l_next;
PurpleSignalHandlerData *handler_data;
for (l = signal_data->handlers; l != NULL; l = l_next)
{
handler_data = (PurpleSignalHandlerData *)l->data;
l_next = l->next;
if (handler_data->handle == handle)
{
g_free(handler_data);
signal_data->handler_count--;
signal_data->handlers = g_list_delete_link(signal_data->handlers,
l);
}
}
}
static void
disconnect_handle_from_instance(void *instance,
PurpleInstanceData *instance_data,
void *handle)
{
g_hash_table_foreach(instance_data->signals,
(GHFunc)disconnect_handle_from_signals, handle);
}
void
purple_signals_disconnect_by_handle(void *handle)
{
g_return_if_fail(handle != NULL);
g_hash_table_foreach(instance_table,
(GHFunc)disconnect_handle_from_instance, handle);
}
void
purple_signal_emit(void *instance, const char *signal, ...)
{
va_list args;
g_return_if_fail(instance != NULL);
g_return_if_fail(signal != NULL);
va_start(args, signal);
purple_signal_emit_vargs(instance, signal, args);
va_end(args);
}
void
purple_signal_emit_vargs(void *instance, const char *signal, va_list args)
{
PurpleInstanceData *instance_data;
PurpleSignalData *signal_data;
PurpleSignalHandlerData *handler_data;
GList *l, *l_next;
va_list tmp;
g_return_if_fail(instance != NULL);
g_return_if_fail(signal != NULL);
instance_data =
(PurpleInstanceData *)g_hash_table_lookup(instance_table, instance);
g_return_if_fail(instance_data != NULL);
signal_data =
(PurpleSignalData *)g_hash_table_lookup(instance_data->signals, signal);
if (signal_data == NULL)
{
purple_debug(PURPLE_DEBUG_ERROR, "signals",
"Signal data for %s not found!\n", signal);
return;
}
for (l = signal_data->handlers; l != NULL; l = l_next)
{
l_next = l->next;
handler_data = (PurpleSignalHandlerData *)l->data;
/* This is necessary because a va_list may only be
* evaluated once */
G_VA_COPY(tmp, args);
if (handler_data->use_vargs)
{
((void (*)(va_list, void *))handler_data->cb)(tmp,
handler_data->data);
}
else
{
signal_data->marshal(handler_data->cb, tmp,
handler_data->data, NULL);
}
va_end(tmp);
}
}
void *
purple_signal_emit_return_1(void *instance, const char *signal, ...)
{
void *ret_val;
va_list args;
g_return_val_if_fail(instance != NULL, NULL);
g_return_val_if_fail(signal != NULL, NULL);
va_start(args, signal);
ret_val = purple_signal_emit_vargs_return_1(instance, signal, args);
va_end(args);
return ret_val;
}
void *
purple_signal_emit_vargs_return_1(void *instance, const char *signal,
va_list args)
{
PurpleInstanceData *instance_data;
PurpleSignalData *signal_data;
PurpleSignalHandlerData *handler_data;
GList *l, *l_next;
va_list tmp;
g_return_val_if_fail(instance != NULL, NULL);
g_return_val_if_fail(signal != NULL, NULL);
instance_data =
(PurpleInstanceData *)g_hash_table_lookup(instance_table, instance);
g_return_val_if_fail(instance_data != NULL, NULL);
signal_data =
(PurpleSignalData *)g_hash_table_lookup(instance_data->signals, signal);
if (signal_data == NULL)
{
purple_debug(PURPLE_DEBUG_ERROR, "signals",
"Signal data for %s not found!\n", signal);
return 0;
}
for (l = signal_data->handlers; l != NULL; l = l_next)
{
void *ret_val = NULL;
l_next = l->next;
handler_data = (PurpleSignalHandlerData *)l->data;
G_VA_COPY(tmp, args);
if (handler_data->use_vargs)
{
ret_val = ((void *(*)(va_list, void *))handler_data->cb)(
tmp, handler_data->data);
}
else
{
signal_data->marshal(handler_data->cb, tmp,
handler_data->data, &ret_val);
}
va_end(tmp);
if (ret_val != NULL)
return ret_val;
}
return NULL;
}
void
purple_signals_init()
{
g_return_if_fail(instance_table == NULL);
instance_table =
g_hash_table_new_full(g_direct_hash, g_direct_equal,
NULL, (GDestroyNotify)destroy_instance_data);
}
void
purple_signals_uninit()
{
g_return_if_fail(instance_table != NULL);
g_hash_table_destroy(instance_table);
instance_table = NULL;
}
/**************************************************************************
* Marshallers
**************************************************************************/
void
purple_marshal_VOID(PurpleCallback cb, va_list args, void *data,
void **return_val)
{
((void (*)(void *))cb)(data);
}
void
purple_marshal_VOID__INT(PurpleCallback cb, va_list args, void *data,
void **return_val)
{
gint arg1 = va_arg(args, gint);
((void (*)(gint, void *))cb)(arg1, data);
}
void
purple_marshal_VOID__INT_INT(PurpleCallback cb, va_list args, void *data,
void **return_val)
{
gint arg1 = va_arg(args, gint);
gint arg2 = va_arg(args, gint);
((void (*)(gint, gint, void *))cb)(arg1, arg2, data);
}
void
purple_marshal_VOID__POINTER(PurpleCallback cb, va_list args, void *data,
void **return_val)
{
void *arg1 = va_arg(args, void *);
((void (*)(void *, void *))cb)(arg1, data);
}
void
purple_marshal_VOID__POINTER_UINT(PurpleCallback cb, va_list args,
void *data, void **return_val)
{
void *arg1 = va_arg(args, void *);
guint arg2 = va_arg(args, guint);
((void (*)(void *, guint, void *))cb)(arg1, arg2, data);
}
void purple_marshal_VOID__POINTER_INT_INT(PurpleCallback cb, va_list args,
void *data, void **return_val)
{
void *arg1 = va_arg(args, void *);
gint arg2 = va_arg(args, gint);
gint arg3 = va_arg(args, gint);
((void (*)(void *, gint, gint, void *))cb)(arg1, arg2, arg3, data);
}
void purple_marshal_VOID__POINTER_INT_POINTER(PurpleCallback cb, va_list args,
void *data, void **return_val)
{
void *arg1 = va_arg(args, void *);
gint arg2 = va_arg(args, gint);
void *arg3 = va_arg(args, void *);
((void (*)(void *, gint, void *, void *))cb)(arg1, arg2, arg3, data);
}
void
purple_marshal_VOID__POINTER_POINTER(PurpleCallback cb, va_list args,
void *data, void **return_val)
{
void *arg1 = va_arg(args, void *);
void *arg2 = va_arg(args, void *);
((void (*)(void *, void *, void *))cb)(arg1, arg2, data);
}
void
purple_marshal_VOID__POINTER_POINTER_UINT(PurpleCallback cb, va_list args,
void *data, void **return_val)
{
void *arg1 = va_arg(args, void *);
void *arg2 = va_arg(args, void *);
guint arg3 = va_arg(args, guint);
((void (*)(void *, void *, guint, void *))cb)(arg1, arg2, arg3, data);
}
void
purple_marshal_VOID__POINTER_POINTER_UINT_UINT(PurpleCallback cb, va_list args,
void *data, void **return_val)
{
void *arg1 = va_arg(args, void *);
void *arg2 = va_arg(args, void *);
guint arg3 = va_arg(args, guint);
guint arg4 = va_arg(args, guint);
((void (*)(void *, void *, guint, guint, void *))cb)(arg1, arg2, arg3, arg4, data);
}
void
purple_marshal_VOID__POINTER_UINT_UINT(PurpleCallback cb, va_list args,
void *data, void **return_val)
{
void *arg1 = va_arg(args, void *);
guint arg2 = va_arg(args, guint);
guint arg3 = va_arg(args, guint);
((void (*)(void *, guint, guint, void *))cb)(arg1, arg2, arg3, data);
}
void
purple_marshal_VOID__POINTER_POINTER_POINTER(PurpleCallback cb, va_list args,
void *data, void **return_val)
{
void *arg1 = va_arg(args, void *);
void *arg2 = va_arg(args, void *);
void *arg3 = va_arg(args, void *);
((void (*)(void *, void *, void *, void *))cb)(arg1, arg2, arg3, data);
}
void
purple_marshal_VOID__POINTER_POINTER_POINTER_POINTER(PurpleCallback cb,
va_list args,
void *data,
void **return_val)
{
void *arg1 = va_arg(args, void *);
void *arg2 = va_arg(args, void *);
void *arg3 = va_arg(args, void *);
void *arg4 = va_arg(args, void *);
((void (*)(void *, void *, void *, void *, void *))cb)(arg1, arg2, arg3, arg4, data);
}
void
purple_marshal_VOID__POINTER_POINTER_POINTER_POINTER_POINTER(PurpleCallback cb,
va_list args,
void *data,
void **return_val)
{
void *arg1 = va_arg(args, void *);
void *arg2 = va_arg(args, void *);
void *arg3 = va_arg(args, void *);
void *arg4 = va_arg(args, void *);
void *arg5 = va_arg(args, void *);
((void (*)(void *, void *, void *, void *, void *, void *))cb)(arg1, arg2, arg3, arg4, arg5, data);
}
void
purple_marshal_VOID__POINTER_POINTER_POINTER_UINT(PurpleCallback cb,
va_list args,
void *data,
void **return_val)
{
void *arg1 = va_arg(args, void *);
void *arg2 = va_arg(args, void *);
void *arg3 = va_arg(args, void *);
guint arg4 = va_arg(args, guint);
((void (*)(void *, void *, void *, guint, void *))cb)(arg1, arg2, arg3, arg4, data);
}
void
purple_marshal_VOID__POINTER_POINTER_POINTER_POINTER_UINT(PurpleCallback cb,
va_list args,
void *data,
void **return_val)
{
void *arg1 = va_arg(args, void *);
void *arg2 = va_arg(args, void *);
void *arg3 = va_arg(args, void *);
void *arg4 = va_arg(args, void *);
guint arg5 = va_arg(args, guint);
((void (*)(void *, void *, void *, void *, guint, void *))cb)(arg1, arg2, arg3, arg4, arg5, data);
}
void
purple_marshal_VOID__POINTER_POINTER_POINTER_UINT_UINT(PurpleCallback cb,
va_list args,
void *data,
void **return_val)
{
void *arg1 = va_arg(args, void *);
void *arg2 = va_arg(args, void *);
void *arg3 = va_arg(args, void *);
guint arg4 = va_arg(args, guint);
guint arg5 = va_arg(args, guint);
((void (*)(void *, void *, void *, guint, guint, void *))cb)(
arg1, arg2, arg3, arg4, arg5, data);
}
void
purple_marshal_INT__INT(PurpleCallback cb, va_list args, void *data,
void **return_val)
{
gint ret_val;
gint arg1 = va_arg(args, gint);
ret_val = ((gint (*)(gint, void *))cb)(arg1, data);
if (return_val != NULL)
*return_val = GINT_TO_POINTER(ret_val);
}
void
purple_marshal_INT__INT_INT(PurpleCallback cb, va_list args, void *data,
void **return_val)
{
gint ret_val;
gint arg1 = va_arg(args, gint);
gint arg2 = va_arg(args, gint);
ret_val = ((gint (*)(gint, gint, void *))cb)(arg1, arg2, data);
if (return_val != NULL)
*return_val = GINT_TO_POINTER(ret_val);
}
void
purple_marshal_INT__POINTER_POINTER(PurpleCallback cb, va_list args, void *data,
void **return_val)
{
gint ret_val;
void *arg1 = va_arg(args, void *);
void *arg2 = va_arg(args, void *);
ret_val = ((gint (*)(void *, void *, void *))cb)(arg1, arg2, data);
if (return_val != NULL)
*return_val = GINT_TO_POINTER(ret_val);
}
void
purple_marshal_INT__POINTER_POINTER_POINTER(
PurpleCallback cb, va_list args, void *data, void **return_val)
{
gint ret_val;
void *arg1 = va_arg(args, void *);
void *arg2 = va_arg(args, void *);
void *arg3 = va_arg(args, void *);
ret_val = ((gint (*)(void *, void *, void *, void *))cb)(arg1, arg2, arg3, data);
if (return_val != NULL)
*return_val = GINT_TO_POINTER(ret_val);
}
void
purple_marshal_INT__POINTER_POINTER_POINTER_POINTER_POINTER(
PurpleCallback cb, va_list args, void *data, void **return_val)
{
gint ret_val;
void *arg1 = va_arg(args, void *);
void *arg2 = va_arg(args, void *);
void *arg3 = va_arg(args, void *);
void *arg4 = va_arg(args, void *);
void *arg5 = va_arg(args, void *);
ret_val =
((gint (*)(void *, void *, void *, void *, void *, void *))cb)(
arg1, arg2, arg3, arg4, arg5, data);
if (return_val != NULL)
*return_val = GINT_TO_POINTER(ret_val);
}
void
purple_marshal_BOOLEAN__POINTER(PurpleCallback cb, va_list args, void *data,
void **return_val)
{
gboolean ret_val;
void *arg1 = va_arg(args, void *);
ret_val = ((gboolean (*)(void *, void *))cb)(arg1, data);
if (return_val != NULL)
*return_val = GINT_TO_POINTER(ret_val);
}
void
purple_marshal_BOOLEAN__POINTER_POINTER(PurpleCallback cb, va_list args,
void *data, void **return_val)
{
gboolean ret_val;
void *arg1 = va_arg(args, void *);
void *arg2 = va_arg(args, void *);
ret_val = ((gboolean (*)(void *, void *, void *))cb)(arg1, arg2, data);
if (return_val != NULL)
*return_val = GINT_TO_POINTER(ret_val);
}
void
purple_marshal_BOOLEAN__POINTER_BOOLEAN(PurpleCallback cb, va_list args,
void *data, void **return_val)
{
gboolean ret_val;
void *arg1 = va_arg(args, void *);
gboolean arg2 = va_arg(args, gboolean);
ret_val = ((gboolean (*)(void *, gboolean, void *))cb)(arg1, arg2, data);
if (return_val != NULL)
*return_val = GINT_TO_POINTER(ret_val);
}
void
purple_marshal_BOOLEAN__POINTER_POINTER_POINTER(PurpleCallback cb, va_list args,
void *data, void **return_val)
{
gboolean ret_val;
void *arg1 = va_arg(args, void *);
void *arg2 = va_arg(args, void *);
void *arg3 = va_arg(args, void *);
ret_val = ((gboolean (*)(void *, void *, void *, void *))cb)(arg1, arg2,
arg3, data);
if (return_val != NULL)
*return_val = GINT_TO_POINTER(ret_val);
}
void
purple_marshal_BOOLEAN__POINTER_POINTER_UINT(PurpleCallback cb,
va_list args,
void *data,
void **return_val)
{
gboolean ret_val;
void *arg1 = va_arg(args, void *);
void *arg2 = va_arg(args, void *);
guint arg3 = va_arg(args, guint);
ret_val = ((gboolean (*)(void *, void *, guint, void *))cb)(
arg1, arg2, arg3, data);
if (return_val != NULL)
*return_val = GINT_TO_POINTER(ret_val);
}
void
purple_marshal_BOOLEAN__POINTER_POINTER_POINTER_UINT(PurpleCallback cb,
va_list args,
void *data,
void **return_val)
{
gboolean ret_val;
void *arg1 = va_arg(args, void *);
void *arg2 = va_arg(args, void *);
void *arg3 = va_arg(args, void *);
guint arg4 = va_arg(args, guint);
ret_val = ((gboolean (*)(void *, void *, void *, guint, void *))cb)(
arg1, arg2, arg3, arg4, data);
if (return_val != NULL)
*return_val = GINT_TO_POINTER(ret_val);
}
void
purple_marshal_BOOLEAN__POINTER_POINTER_POINTER_POINTER(PurpleCallback cb,
va_list args,
void *data,
void **return_val)
{
gboolean ret_val;
void *arg1 = va_arg(args, void *);
void *arg2 = va_arg(args, void *);
void *arg3 = va_arg(args, void *);
void *arg4 = va_arg(args, void *);
ret_val = ((gboolean (*)(void *, void *, void *, void *, void *))cb)(
arg1, arg2, arg3, arg4, data);
if (return_val != NULL)
*return_val = GINT_TO_POINTER(ret_val);
}
void
purple_marshal_BOOLEAN__POINTER_POINTER_POINTER_POINTER_POINTER(
PurpleCallback cb, va_list args, void *data, void **return_val)
{
gboolean ret_val;
void *arg1 = va_arg(args, void *);
void *arg2 = va_arg(args, void *);
void *arg3 = va_arg(args, void *);
void *arg4 = va_arg(args, void *);
void *arg5 = va_arg(args, void *);
ret_val =
((gboolean (*)(void *, void *, void *, void *, void *, void *))cb)(
arg1, arg2, arg3, arg4, arg5, data);
if (return_val != NULL)
*return_val = GINT_TO_POINTER(ret_val);
}
void
purple_marshal_BOOLEAN__POINTER_POINTER_POINTER_POINTER_UINT(
PurpleCallback cb, va_list args, void *data, void **return_val)
{
gboolean ret_val;
void *arg1 = va_arg(args, void *);
void *arg2 = va_arg(args, void *);
void *arg3 = va_arg(args, void *);
void *arg4 = va_arg(args, void *);
guint arg5 = va_arg(args, guint);
ret_val =
((gboolean (*)(void *, void *, void *, void *, guint, void *))cb)(
arg1, arg2, arg3, arg4, arg5, data);
if (return_val != NULL)
*return_val = GINT_TO_POINTER(ret_val);
}
void
purple_marshal_BOOLEAN__POINTER_POINTER_POINTER_POINTER_POINTER_POINTER(
PurpleCallback cb, va_list args, void *data, void **return_val)
{
gboolean ret_val;
void *arg1 = va_arg(args, void *);
void *arg2 = va_arg(args, void *);
void *arg3 = va_arg(args, void *);
void *arg4 = va_arg(args, void *);
void *arg5 = va_arg(args, void *);
void *arg6 = va_arg(args, void *);
ret_val =
((gboolean (*)(void *, void *, void *, void *, void *, void *, void *))cb)(
arg1, arg2, arg3, arg4, arg5, arg6, data);
if (return_val != NULL)
*return_val = GINT_TO_POINTER(ret_val);
}
void
purple_marshal_BOOLEAN__INT_POINTER(PurpleCallback cb, va_list args, void *data,
void **return_val)
{
gboolean ret_val;
gint arg1 = va_arg(args, gint);
void *arg2 = va_arg(args, void *);
ret_val = ((gboolean (*)(gint, void *, void *))cb)(arg1, arg2, data);
if (return_val != NULL)
*return_val = GINT_TO_POINTER(ret_val);
}
void
purple_marshal_POINTER__POINTER(
PurpleCallback cb, va_list args, void *data,
void **return_val)
{
gpointer ret_val;
void *arg1 = va_arg(args, void *);
ret_val = ((gpointer(*)(void *, void *))cb)(arg1, data);
if (return_val != NULL)
*return_val = ret_val;
}
void
purple_marshal_POINTER__POINTER_INT(
PurpleCallback cb, va_list args, void *data,
void **return_val)
{
gpointer ret_val;
void *arg1 = va_arg(args, void *);
gint arg2 = va_arg(args, gint);
ret_val = ((gpointer(*)(void *, gint, void *))cb)(arg1, arg2, data);
if (return_val != NULL)
*return_val = ret_val;
}
void
purple_marshal_POINTER__POINTER_INT64(
PurpleCallback cb, va_list args, void *data,
void **return_val)
{
gpointer ret_val;
void *arg1 = va_arg(args, void *);
gint64 arg2 = va_arg(args, gint64);
ret_val = ((gpointer(*)(void *, gint64, void *))cb)(arg1, arg2, data);
if (return_val != NULL)
*return_val = ret_val;
}
void
purple_marshal_POINTER__POINTER_INT_BOOLEAN(
PurpleCallback cb, va_list args, void *data,
void **return_val)
{
gpointer ret_val;
void *arg1 = va_arg(args, void *);
gint arg2 = va_arg(args, gint);
gboolean arg3 = va_arg(args, gboolean);
ret_val = ((gpointer(*)(void *, gint, gboolean, void *))cb)(arg1, arg2, arg3, data);
if (return_val != NULL)
*return_val = ret_val;
}
void
purple_marshal_POINTER__POINTER_INT64_BOOLEAN(
PurpleCallback cb, va_list args, void *data,
void **return_val)
{
gpointer ret_val;
void *arg1 = va_arg(args, void *);
gint64 arg2 = va_arg(args, gint64);
gboolean arg3 = va_arg(args, gboolean);
ret_val = ((gpointer(*)(void *, gint64, gboolean, void *))cb)(arg1, arg2, arg3, data);
if (return_val != NULL)
*return_val = ret_val;
}
void
purple_marshal_POINTER__POINTER_POINTER_BOOLEAN(
PurpleCallback cb, va_list args, void *data,
void **return_val)
{
gpointer ret_val;
void *arg1 = va_arg(args, void *);
void *arg2 = va_arg(args, void *);
gboolean arg3 = va_arg(args, gboolean);
ret_val = ((gpointer(*)(void *, void *, gboolean, void *))cb)(arg1, arg2, arg3, data);
if (return_val != NULL)
*return_val = ret_val;
}
void
purple_marshal_POINTER__POINTER_POINTER(PurpleCallback cb, va_list args, void *data,
void **return_val)
{
gpointer ret_val;
void *arg1 = va_arg(args, void *);
void *arg2 = va_arg(args, void *);
ret_val = ((gpointer (*)(void *, void *, void *))cb)(arg1, arg2, data);
if (return_val != NULL)
*return_val = ret_val;
}