static inline void
_cleanup_caller_allocates (PyGIInvokeState *state,
PyGIArgCache *cache,
PyObject *py_obj,
gpointer data,
gboolean was_processed)
{
PyGIInterfaceCache *iface_cache = (PyGIInterfaceCache *)cache;
/* check GValue first because GValue is also a boxed sub-type */
if (g_type_is_a (iface_cache->g_type, G_TYPE_VALUE)) {
if (was_processed)
g_value_unset (data);
g_slice_free (GValue, data);
} else if (g_type_is_a (iface_cache->g_type, G_TYPE_BOXED)) {
gsize size;
if (was_processed)
return; /* will be cleaned up at deallocation */
size = g_struct_info_get_size (iface_cache->interface_info);
g_slice_free1 (size, data);
} else if (iface_cache->is_foreign) {
if (was_processed)
return; /* will be cleaned up at deallocation */
pygi_struct_foreign_release ((GIBaseInfo *)iface_cache->interface_info,
data);
} else {
if (was_processed)
return; /* will be cleaned up at deallocation */
g_free (data);
}
}
static void
struct_dealloc (PyGIStruct *self)
{
GIBaseInfo *info;
PyObject *error_type, *error_value, *error_traceback;
gboolean have_error = !!PyErr_Occurred ();
if (have_error)
PyErr_Fetch (&error_type, &error_value, &error_traceback);
info = struct_get_info (Py_TYPE (self));
if (info != NULL && g_struct_info_is_foreign ( (GIStructInfo *) info)) {
pygi_struct_foreign_release (info, pyg_pointer_get_ptr (self));
} else if (self->free_on_dealloc) {
g_free (pyg_pointer_get_ptr (self));
}
if (info != NULL) {
g_base_info_unref (info);
}
if (have_error)
PyErr_Restore (error_type, error_value, error_traceback);
Py_TYPE (self)->tp_free ((PyObject *)self);
}
void
_pygi_marshal_cleanup_to_py_interface_struct_foreign (PyGIInvokeState *state,
PyGIArgCache *arg_cache,
PyObject *dummy,
gpointer data,
gboolean was_processed)
{
if (!was_processed && arg_cache->transfer == GI_TRANSFER_EVERYTHING)
pygi_struct_foreign_release (
( (PyGIInterfaceCache *)arg_cache)->interface_info,
data);
}
void
_pygi_marshal_cleanup_from_py_interface_struct_foreign (PyGIInvokeState *state,
PyGIArgCache *arg_cache,
PyObject *py_arg,
gpointer data,
gboolean was_processed)
{
if (state->failed && was_processed)
pygi_struct_foreign_release (
( (PyGIInterfaceCache *)arg_cache)->interface_info,
data);
}
static void
_struct_dealloc (PyGIStruct *self)
{
GIBaseInfo *info = _pygi_object_get_gi_info (
(PyObject *) self,
&PyGIStructInfo_Type);
if (info != NULL && g_struct_info_is_foreign ( (GIStructInfo *) info)) {
pygi_struct_foreign_release (info, ( (PyGPointer *) self)->pointer);
} else if (self->free_on_dealloc) {
g_free ( ( (PyGPointer *) self)->pointer);
}
g_base_info_unref (info);
Py_TYPE( (PyGPointer *) self )->tp_free ( (PyObject *) self);
}
void
_pygi_argument_release (GIArgument *arg,
GITypeInfo *type_info,
GITransfer transfer,
GIDirection direction)
{
GITypeTag type_tag;
gboolean is_out = (direction == GI_DIRECTION_OUT || direction == GI_DIRECTION_INOUT);
type_tag = g_type_info_get_tag (type_info);
switch (type_tag) {
case GI_TYPE_TAG_VOID:
/* Don't do anything, it's transparent to the C side */
break;
case GI_TYPE_TAG_BOOLEAN:
case GI_TYPE_TAG_INT8:
case GI_TYPE_TAG_UINT8:
case GI_TYPE_TAG_INT16:
case GI_TYPE_TAG_UINT16:
case GI_TYPE_TAG_INT32:
case GI_TYPE_TAG_UINT32:
case GI_TYPE_TAG_INT64:
case GI_TYPE_TAG_UINT64:
case GI_TYPE_TAG_FLOAT:
case GI_TYPE_TAG_DOUBLE:
case GI_TYPE_TAG_GTYPE:
case GI_TYPE_TAG_UNICHAR:
break;
case GI_TYPE_TAG_FILENAME:
case GI_TYPE_TAG_UTF8:
/* With allow-none support the string could be NULL */
if ((arg->v_string != NULL &&
(direction == GI_DIRECTION_IN && transfer == GI_TRANSFER_NOTHING))
|| (direction == GI_DIRECTION_OUT && transfer == GI_TRANSFER_EVERYTHING)) {
g_free (arg->v_string);
}
break;
case GI_TYPE_TAG_ARRAY:
{
GArray *array;
gsize i;
if (arg->v_pointer == NULL) {
return;
}
array = arg->v_pointer;
if ( (direction == GI_DIRECTION_IN && transfer != GI_TRANSFER_EVERYTHING)
|| (direction == GI_DIRECTION_OUT && transfer == GI_TRANSFER_EVERYTHING)) {
GITypeInfo *item_type_info;
GITransfer item_transfer;
item_type_info = g_type_info_get_param_type (type_info, 0);
item_transfer = direction == GI_DIRECTION_IN ? GI_TRANSFER_NOTHING : GI_TRANSFER_EVERYTHING;
/* Free the items */
for (i = 0; i < array->len; i++) {
GIArgument *item;
item = &_g_array_index (array, GIArgument, i);
_pygi_argument_release (item, item_type_info, item_transfer, direction);
}
g_base_info_unref ( (GIBaseInfo *) item_type_info);
}
if ( (direction == GI_DIRECTION_IN && transfer == GI_TRANSFER_NOTHING)
|| (direction == GI_DIRECTION_OUT && transfer != GI_TRANSFER_NOTHING)) {
g_array_free (array, TRUE);
}
break;
}
case GI_TYPE_TAG_INTERFACE:
{
GIBaseInfo *info;
GIInfoType info_type;
info = g_type_info_get_interface (type_info);
info_type = g_base_info_get_type (info);
switch (info_type) {
case GI_INFO_TYPE_CALLBACK:
/* TODO */
break;
case GI_INFO_TYPE_BOXED:
case GI_INFO_TYPE_STRUCT:
case GI_INFO_TYPE_UNION:
{
GType type;
if (arg->v_pointer == NULL) {
return;
}
type = g_registered_type_info_get_g_type ( (GIRegisteredTypeInfo *) info);
if (g_type_is_a (type, G_TYPE_VALUE)) {
GValue *value;
value = arg->v_pointer;
if ( (direction == GI_DIRECTION_IN && transfer != GI_TRANSFER_EVERYTHING)
|| (direction == GI_DIRECTION_OUT && transfer == GI_TRANSFER_EVERYTHING)) {
g_value_unset (value);
}
if ( (direction == GI_DIRECTION_IN && transfer == GI_TRANSFER_NOTHING)
|| (direction == GI_DIRECTION_OUT && transfer != GI_TRANSFER_NOTHING)) {
g_slice_free (GValue, value);
}
} else if (g_type_is_a (type, G_TYPE_CLOSURE)) {
if (direction == GI_DIRECTION_IN && transfer == GI_TRANSFER_NOTHING) {
g_closure_unref (arg->v_pointer);
}
} else if (info_type == GI_INFO_TYPE_STRUCT &&
g_struct_info_is_foreign ((GIStructInfo*) info)) {
if (direction == GI_DIRECTION_OUT && transfer == GI_TRANSFER_EVERYTHING) {
pygi_struct_foreign_release (info, arg->v_pointer);
}
} else if (g_type_is_a (type, G_TYPE_BOXED)) {
} else if (g_type_is_a (type, G_TYPE_POINTER) || type == G_TYPE_NONE) {
g_warn_if_fail (!g_type_info_is_pointer (type_info) || transfer == GI_TRANSFER_NOTHING);
}
break;
}
case GI_INFO_TYPE_ENUM:
case GI_INFO_TYPE_FLAGS:
break;
case GI_INFO_TYPE_INTERFACE:
case GI_INFO_TYPE_OBJECT:
if (arg->v_pointer == NULL) {
return;
}
if (is_out && transfer == GI_TRANSFER_EVERYTHING) {
g_object_unref (arg->v_pointer);
}
break;
default:
g_assert_not_reached();
}
g_base_info_unref (info);
break;
}
case GI_TYPE_TAG_GLIST:
case GI_TYPE_TAG_GSLIST:
{
GSList *list;
if (arg->v_pointer == NULL) {
return;
}
list = arg->v_pointer;
if ( (direction == GI_DIRECTION_IN && transfer != GI_TRANSFER_EVERYTHING)
|| (direction == GI_DIRECTION_OUT && transfer == GI_TRANSFER_EVERYTHING)) {
GITypeInfo *item_type_info;
GITransfer item_transfer;
GSList *item;
item_type_info = g_type_info_get_param_type (type_info, 0);
g_assert (item_type_info != NULL);
item_transfer = direction == GI_DIRECTION_IN ? GI_TRANSFER_NOTHING : GI_TRANSFER_EVERYTHING;
/* Free the items */
for (item = list; item != NULL; item = g_slist_next (item)) {
_pygi_argument_release ( (GIArgument *) &item->data, item_type_info,
item_transfer, direction);
}
g_base_info_unref ( (GIBaseInfo *) item_type_info);
}
if ( (direction == GI_DIRECTION_IN && transfer == GI_TRANSFER_NOTHING)
|| (direction == GI_DIRECTION_OUT && transfer != GI_TRANSFER_NOTHING)) {
if (type_tag == GI_TYPE_TAG_GLIST) {
g_list_free ( (GList *) list);
} else {
/* type_tag == GI_TYPE_TAG_GSLIST */
g_slist_free (list);
}
}
break;
}
case GI_TYPE_TAG_GHASH:
{
GHashTable *hash_table;
if (arg->v_pointer == NULL) {
return;
}
hash_table = arg->v_pointer;
if (direction == GI_DIRECTION_IN && transfer != GI_TRANSFER_EVERYTHING) {
/* We created the table without a destroy function, so keys and
* values need to be released. */
GITypeInfo *key_type_info;
GITypeInfo *value_type_info;
GITransfer item_transfer;
GHashTableIter hash_table_iter;
gpointer key;
gpointer value;
key_type_info = g_type_info_get_param_type (type_info, 0);
g_assert (key_type_info != NULL);
value_type_info = g_type_info_get_param_type (type_info, 1);
g_assert (value_type_info != NULL);
if (direction == GI_DIRECTION_IN) {
item_transfer = GI_TRANSFER_NOTHING;
} else {
item_transfer = GI_TRANSFER_EVERYTHING;
}
g_hash_table_iter_init (&hash_table_iter, hash_table);
while (g_hash_table_iter_next (&hash_table_iter, &key, &value)) {
_pygi_argument_release ( (GIArgument *) &key, key_type_info,
item_transfer, direction);
_pygi_argument_release ( (GIArgument *) &value, value_type_info,
item_transfer, direction);
}
g_base_info_unref ( (GIBaseInfo *) key_type_info);
g_base_info_unref ( (GIBaseInfo *) value_type_info);
} else if (direction == GI_DIRECTION_OUT && transfer == GI_TRANSFER_CONTAINER) {
/* Be careful to avoid keys and values being freed if the
* callee gave a destroy function. */
g_hash_table_steal_all (hash_table);
}
if ( (direction == GI_DIRECTION_IN && transfer == GI_TRANSFER_NOTHING)
|| (direction == GI_DIRECTION_OUT && transfer != GI_TRANSFER_NOTHING)) {
g_hash_table_unref (hash_table);
}
break;
}
case GI_TYPE_TAG_ERROR:
{
GError *error;
if (arg->v_pointer == NULL) {
return;
}
error = * (GError **) arg->v_pointer;
if (error != NULL) {
g_error_free (error);
}
g_slice_free (GError *, arg->v_pointer);
break;
}
}
}