1 /* -*- Mode: C; c-basic-offset: 4 -*-
2 * vim: tabstop=4 shiftwidth=4 expandtab
4 * Copyright (C) 2005-2009 Johan Dahlin <johan@gnome.org>
6 * pygi-argument.c: GIArgument - PyObject conversion functions.
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with this library; if not, see <http://www.gnu.org/licenses/>.
27 #include "pygobject-internal.h"
32 #include "pygi-python-compat.h"
33 #include "pygi-argument.h"
34 #include "pygi-info.h"
35 #include "pygi-value.h"
36 #include "pygi-basictype.h"
37 #include "pygi-object.h"
38 #include "pygi-struct-marshal.h"
39 #include "pygi-error.h"
40 #include "pygi-foreign.h"
41 #include "pygi-type.h"
42 #include "pygi-util.h"
46 pygi_argument_to_gssize (GIArgument
*arg_in
,
51 case GI_TYPE_TAG_INT8
:
52 *gssize_out
= arg_in
->v_int8
;
54 case GI_TYPE_TAG_UINT8
:
55 *gssize_out
= arg_in
->v_uint8
;
57 case GI_TYPE_TAG_INT16
:
58 *gssize_out
= arg_in
->v_int16
;
60 case GI_TYPE_TAG_UINT16
:
61 *gssize_out
= arg_in
->v_uint16
;
63 case GI_TYPE_TAG_INT32
:
64 *gssize_out
= arg_in
->v_int32
;
66 case GI_TYPE_TAG_UINT32
:
67 *gssize_out
= arg_in
->v_uint32
;
69 case GI_TYPE_TAG_INT64
:
70 if (arg_in
->v_int64
> G_MAXSSIZE
|| arg_in
->v_int64
< G_MINSSIZE
) {
71 PyErr_Format (PyExc_TypeError
,
72 "Unable to marshal %s to gssize",
73 g_type_tag_to_string(type_tag
));
76 *gssize_out
= (gssize
)arg_in
->v_int64
;
78 case GI_TYPE_TAG_UINT64
:
79 if (arg_in
->v_uint64
> G_MAXSSIZE
) {
80 PyErr_Format (PyExc_TypeError
,
81 "Unable to marshal %s to gssize",
82 g_type_tag_to_string(type_tag
));
85 *gssize_out
= (gssize
)arg_in
->v_uint64
;
88 PyErr_Format (PyExc_TypeError
,
89 "Unable to marshal %s to gssize",
90 g_type_tag_to_string(type_tag
));
96 _pygi_get_storage_type (GITypeInfo
*type_info
)
98 GITypeTag type_tag
= g_type_info_get_tag (type_info
);
100 if (type_tag
== GI_TYPE_TAG_INTERFACE
) {
101 GIBaseInfo
*interface
= g_type_info_get_interface (type_info
);
102 switch (g_base_info_get_type (interface
)) {
103 case GI_INFO_TYPE_ENUM
:
104 case GI_INFO_TYPE_FLAGS
:
105 type_tag
= g_enum_info_get_storage_type ((GIEnumInfo
*)interface
);
108 /* FIXME: we might have something to do for other types */
111 g_base_info_unref (interface
);
117 _pygi_hash_pointer_to_arg (GIArgument
*arg
,
118 GITypeInfo
*type_info
)
120 GITypeTag type_tag
= _pygi_get_storage_type (type_info
);
123 case GI_TYPE_TAG_INT8
:
124 arg
->v_int8
= (gint8
)GPOINTER_TO_INT (arg
->v_pointer
);
126 case GI_TYPE_TAG_INT16
:
127 arg
->v_int16
= (gint16
)GPOINTER_TO_INT (arg
->v_pointer
);
129 case GI_TYPE_TAG_INT32
:
130 arg
->v_int32
= (gint32
)GPOINTER_TO_INT (arg
->v_pointer
);
132 case GI_TYPE_TAG_UINT8
:
133 arg
->v_uint8
= (guint8
)GPOINTER_TO_UINT (arg
->v_pointer
);
135 case GI_TYPE_TAG_UINT16
:
136 arg
->v_uint16
= (guint16
)GPOINTER_TO_UINT (arg
->v_pointer
);
138 case GI_TYPE_TAG_UINT32
:
139 arg
->v_uint32
= (guint32
)GPOINTER_TO_UINT (arg
->v_pointer
);
141 case GI_TYPE_TAG_GTYPE
:
142 arg
->v_size
= GPOINTER_TO_SIZE (arg
->v_pointer
);
144 case GI_TYPE_TAG_UTF8
:
145 case GI_TYPE_TAG_FILENAME
:
146 case GI_TYPE_TAG_INTERFACE
:
147 case GI_TYPE_TAG_ARRAY
:
150 g_critical ("Unsupported type %s", g_type_tag_to_string(type_tag
));
155 _pygi_arg_to_hash_pointer (const GIArgument
*arg
,
156 GITypeInfo
*type_info
)
158 GITypeTag type_tag
= _pygi_get_storage_type (type_info
);
161 case GI_TYPE_TAG_INT8
:
162 return GINT_TO_POINTER (arg
->v_int8
);
163 case GI_TYPE_TAG_UINT8
:
164 return GINT_TO_POINTER (arg
->v_uint8
);
165 case GI_TYPE_TAG_INT16
:
166 return GINT_TO_POINTER (arg
->v_int16
);
167 case GI_TYPE_TAG_UINT16
:
168 return GINT_TO_POINTER (arg
->v_uint16
);
169 case GI_TYPE_TAG_INT32
:
170 return GINT_TO_POINTER (arg
->v_int32
);
171 case GI_TYPE_TAG_UINT32
:
172 return GINT_TO_POINTER (arg
->v_uint32
);
173 case GI_TYPE_TAG_GTYPE
:
174 return GSIZE_TO_POINTER (arg
->v_size
);
175 case GI_TYPE_TAG_UTF8
:
176 case GI_TYPE_TAG_FILENAME
:
177 case GI_TYPE_TAG_INTERFACE
:
178 case GI_TYPE_TAG_ARRAY
:
179 return arg
->v_pointer
;
181 g_critical ("Unsupported type %s", g_type_tag_to_string(type_tag
));
182 return arg
->v_pointer
;
188 * _pygi_argument_array_length_marshal:
189 * @length_arg_index: Index of length argument in the callables args list.
190 * @user_data1: (type Array(GValue)): Array of GValue arguments to retrieve length
191 * @user_data2: (type GICallableInfo): Callable info to get the argument from.
193 * Generic marshalling policy for array length arguments in callables.
195 * Returns: The length of the array or -1 on failure.
198 _pygi_argument_array_length_marshal (gsize length_arg_index
,
202 GIArgInfo length_arg_info
;
203 GITypeInfo length_type_info
;
204 GIArgument length_arg
;
205 gssize array_len
= -1;
206 GValue
*values
= (GValue
*)user_data1
;
207 GICallableInfo
*callable_info
= (GICallableInfo
*)user_data2
;
209 g_callable_info_load_arg (callable_info
, (gint
)length_arg_index
, &length_arg_info
);
210 g_arg_info_load_type (&length_arg_info
, &length_type_info
);
212 length_arg
= _pygi_argument_from_g_value (&(values
[length_arg_index
]),
214 if (!pygi_argument_to_gssize (&length_arg
,
215 g_type_info_get_tag (&length_type_info
),
224 * _pygi_argument_to_array
225 * @arg: The argument to convert
226 * @array_length_policy: Closure for marshalling the array length argument when needed.
227 * @user_data1: Generic user data passed to the array_length_policy.
228 * @user_data2: Generic user data passed to the array_length_policy.
229 * @type_info: The type info for @arg
230 * @out_free_array: A return location for a gboolean that indicates whether
231 * or not the wrapped GArray should be freed
233 * Make sure an array type argument is wrapped in a GArray.
235 * Note: This method can *not* be folded into _pygi_argument_to_object() because
236 * arrays are special in the sense that they might require access to @args in
237 * order to get the length.
239 * Returns: A GArray wrapping @arg. If @out_free_array has been set to TRUE then
240 * free the array with g_array_free() without freeing the data members.
241 * Otherwise don't free the array.
244 _pygi_argument_to_array (GIArgument
*arg
,
245 PyGIArgArrayLengthPolicy array_length_policy
,
248 GITypeInfo
*type_info
,
249 gboolean
*out_free_array
)
251 GITypeInfo
*item_type_info
;
252 gboolean is_zero_terminated
;
257 g_return_val_if_fail (g_type_info_get_tag (type_info
) == GI_TYPE_TAG_ARRAY
, NULL
);
259 if (arg
->v_pointer
== NULL
) {
263 switch (g_type_info_get_array_type (type_info
)) {
264 case GI_ARRAY_TYPE_C
:
265 is_zero_terminated
= g_type_info_is_zero_terminated (type_info
);
266 item_type_info
= g_type_info_get_param_type (type_info
, 0);
268 item_size
= _pygi_g_type_info_size (item_type_info
);
270 g_base_info_unref ( (GIBaseInfo
*) item_type_info
);
272 if (is_zero_terminated
) {
273 length
= g_strv_length (arg
->v_pointer
);
275 length
= g_type_info_get_array_fixed_size (type_info
);
279 if (G_UNLIKELY (array_length_policy
== NULL
)) {
280 g_critical ("Unable to determine array length for %p",
282 g_array
= g_array_new (is_zero_terminated
, FALSE
, (guint
)item_size
);
283 *out_free_array
= TRUE
;
287 length_arg_pos
= g_type_info_get_array_length (type_info
);
288 g_assert (length_arg_pos
>= 0);
290 length
= array_length_policy (length_arg_pos
, user_data1
, user_data2
);
297 g_assert (length
>= 0);
299 g_array
= g_array_new (is_zero_terminated
, FALSE
, (guint
)item_size
);
301 g_free (g_array
->data
);
302 g_array
->data
= arg
->v_pointer
;
303 g_array
->len
= (guint
)length
;
304 *out_free_array
= TRUE
;
306 case GI_ARRAY_TYPE_ARRAY
:
307 case GI_ARRAY_TYPE_BYTE_ARRAY
:
308 /* Note: GByteArray is really just a GArray */
309 g_array
= arg
->v_pointer
;
310 *out_free_array
= FALSE
;
312 case GI_ARRAY_TYPE_PTR_ARRAY
:
314 GPtrArray
*ptr_array
= (GPtrArray
*) arg
->v_pointer
;
315 g_array
= g_array_sized_new (FALSE
, FALSE
,
318 g_array
->data
= (char*) ptr_array
->pdata
;
319 g_array
->len
= ptr_array
->len
;
320 *out_free_array
= TRUE
;
324 g_critical ("Unexpected array type %u",
325 g_type_info_get_array_type (type_info
));
334 _pygi_argument_from_object (PyObject
*object
,
335 GITypeInfo
*type_info
,
340 gpointer cleanup_data
= NULL
;
342 memset(&arg
, 0, sizeof(GIArgument
));
343 type_tag
= g_type_info_get_tag (type_info
);
346 case GI_TYPE_TAG_ARRAY
:
348 Py_ssize_t py_length
;
350 gboolean is_zero_terminated
;
351 GITypeInfo
*item_type_info
;
354 GITransfer item_transfer
;
356 if (object
== Py_None
) {
357 arg
.v_pointer
= NULL
;
361 /* Note, strings are sequences, but we cannot accept them here */
362 if (!PySequence_Check (object
) ||
363 #if PY_VERSION_HEX < 0x03000000
364 PyString_Check (object
) ||
366 PyUnicode_Check (object
)) {
367 PyErr_SetString (PyExc_TypeError
, "expected sequence");
371 py_length
= PySequence_Length (object
);
375 if (!pygi_guint_from_pyssize (py_length
, &length
))
378 is_zero_terminated
= g_type_info_is_zero_terminated (type_info
);
379 item_type_info
= g_type_info_get_param_type (type_info
, 0);
381 /* we handle arrays that are really strings specially, see below */
382 if (g_type_info_get_tag (item_type_info
) == GI_TYPE_TAG_UINT8
)
385 item_size
= sizeof (GIArgument
);
387 array
= g_array_sized_new (is_zero_terminated
, FALSE
, (guint
)item_size
, length
);
389 g_base_info_unref ( (GIBaseInfo
*) item_type_info
);
394 if (g_type_info_get_tag (item_type_info
) == GI_TYPE_TAG_UINT8
&&
395 PYGLIB_PyBytes_Check(object
)) {
397 memcpy(array
->data
, PYGLIB_PyBytes_AsString(object
), length
);
403 item_transfer
= transfer
== GI_TRANSFER_CONTAINER
? GI_TRANSFER_NOTHING
: transfer
;
405 for (i
= 0; i
< length
; i
++) {
409 py_item
= PySequence_GetItem (object
, i
);
410 if (py_item
== NULL
) {
411 goto array_item_error
;
414 item
= _pygi_argument_from_object (py_item
, item_type_info
, item_transfer
);
418 if (PyErr_Occurred()) {
419 goto array_item_error
;
422 g_array_insert_val (array
, i
, item
);
426 /* Free everything we have converted so far. */
427 _pygi_argument_release ( (GIArgument
*) &array
, type_info
,
428 GI_TRANSFER_NOTHING
, GI_DIRECTION_IN
);
431 _PyGI_ERROR_PREFIX ("Item %u: ", i
);
436 arg
.v_pointer
= array
;
438 g_base_info_unref ( (GIBaseInfo
*) item_type_info
);
441 case GI_TYPE_TAG_INTERFACE
:
444 GIInfoType info_type
;
446 info
= g_type_info_get_interface (type_info
);
447 info_type
= g_base_info_get_type (info
);
450 case GI_INFO_TYPE_CALLBACK
:
451 /* This should be handled in invoke() */
452 g_assert_not_reached();
454 case GI_INFO_TYPE_BOXED
:
455 case GI_INFO_TYPE_STRUCT
:
456 case GI_INFO_TYPE_UNION
:
460 gboolean is_foreign
= (info_type
== GI_INFO_TYPE_STRUCT
) &&
461 (g_struct_info_is_foreign ((GIStructInfo
*) info
));
463 g_type
= g_registered_type_info_get_g_type ( (GIRegisteredTypeInfo
*) info
);
464 py_type
= pygi_type_import_by_gi_info ( (GIBaseInfo
*) info
);
466 /* Note for G_TYPE_VALUE g_type:
467 * This will currently leak the GValue that is allocated and
468 * stashed in arg.v_pointer. Out argument marshaling for caller
469 * allocated GValues already pass in memory for the GValue.
470 * Further re-factoring is needed to fix this leak.
471 * See: https://bugzilla.gnome.org/show_bug.cgi?id=693405
473 pygi_arg_struct_from_py_marshal (object
,
476 info
, /*interface_info*/
480 FALSE
, /*copy_reference*/
482 g_type_info_is_pointer (type_info
));
487 case GI_INFO_TYPE_ENUM
:
488 case GI_INFO_TYPE_FLAGS
:
490 if (!pygi_gint_from_py (object
, &arg
.v_int
))
495 case GI_INFO_TYPE_INTERFACE
:
496 case GI_INFO_TYPE_OBJECT
:
497 /* An error within this call will result in a NULL arg */
498 pygi_arg_gobject_out_arg_from_py (object
, &arg
, transfer
);
502 g_assert_not_reached();
504 g_base_info_unref (info
);
507 case GI_TYPE_TAG_GLIST
:
508 case GI_TYPE_TAG_GSLIST
:
511 GITypeInfo
*item_type_info
;
513 GITransfer item_transfer
;
516 if (object
== Py_None
) {
517 arg
.v_pointer
= NULL
;
521 length
= PySequence_Length (object
);
526 item_type_info
= g_type_info_get_param_type (type_info
, 0);
527 g_assert (item_type_info
!= NULL
);
529 item_transfer
= transfer
== GI_TRANSFER_CONTAINER
? GI_TRANSFER_NOTHING
: transfer
;
531 for (i
= length
- 1; i
>= 0; i
--) {
535 py_item
= PySequence_GetItem (object
, i
);
536 if (py_item
== NULL
) {
537 goto list_item_error
;
540 item
= _pygi_argument_from_object (py_item
, item_type_info
, item_transfer
);
544 if (PyErr_Occurred()) {
545 goto list_item_error
;
548 if (type_tag
== GI_TYPE_TAG_GLIST
) {
549 list
= (GSList
*) g_list_prepend ( (GList
*) list
, item
.v_pointer
);
551 list
= g_slist_prepend (list
, item
.v_pointer
);
557 /* Free everything we have converted so far. */
558 _pygi_argument_release ( (GIArgument
*) &list
, type_info
,
559 GI_TRANSFER_NOTHING
, GI_DIRECTION_IN
);
562 _PyGI_ERROR_PREFIX ("Item %zd: ", i
);
566 arg
.v_pointer
= list
;
568 g_base_info_unref ( (GIBaseInfo
*) item_type_info
);
572 case GI_TYPE_TAG_GHASH
:
577 GITypeInfo
*key_type_info
;
578 GITypeInfo
*value_type_info
;
579 GITypeTag key_type_tag
;
581 GEqualFunc equal_func
;
582 GHashTable
*hash_table
;
583 GITransfer item_transfer
;
587 if (object
== Py_None
) {
588 arg
.v_pointer
= NULL
;
592 length
= PyMapping_Length (object
);
597 keys
= PyMapping_Keys (object
);
602 values
= PyMapping_Values (object
);
603 if (values
== NULL
) {
608 key_type_info
= g_type_info_get_param_type (type_info
, 0);
609 g_assert (key_type_info
!= NULL
);
611 value_type_info
= g_type_info_get_param_type (type_info
, 1);
612 g_assert (value_type_info
!= NULL
);
614 key_type_tag
= g_type_info_get_tag (key_type_info
);
616 switch (key_type_tag
) {
617 case GI_TYPE_TAG_UTF8
:
618 case GI_TYPE_TAG_FILENAME
:
619 hash_func
= g_str_hash
;
620 equal_func
= g_str_equal
;
627 hash_table
= g_hash_table_new (hash_func
, equal_func
);
628 if (hash_table
== NULL
) {
630 goto hash_table_release
;
633 item_transfer
= transfer
== GI_TRANSFER_CONTAINER
? GI_TRANSFER_NOTHING
: transfer
;
635 for (i
= 0; i
< length
; i
++) {
641 py_key
= PyList_GET_ITEM (keys
, i
);
642 py_value
= PyList_GET_ITEM (values
, i
);
644 key
= _pygi_argument_from_object (py_key
, key_type_info
, item_transfer
);
645 if (PyErr_Occurred()) {
646 goto hash_table_item_error
;
649 value
= _pygi_argument_from_object (py_value
, value_type_info
, item_transfer
);
650 if (PyErr_Occurred()) {
651 _pygi_argument_release (&key
, type_info
, GI_TRANSFER_NOTHING
, GI_DIRECTION_IN
);
652 goto hash_table_item_error
;
655 g_hash_table_insert (hash_table
, key
.v_pointer
,
656 _pygi_arg_to_hash_pointer (&value
, value_type_info
));
659 hash_table_item_error
:
660 /* Free everything we have converted so far. */
661 _pygi_argument_release ( (GIArgument
*) &hash_table
, type_info
,
662 GI_TRANSFER_NOTHING
, GI_DIRECTION_IN
);
665 _PyGI_ERROR_PREFIX ("Item %zd: ", i
);
669 arg
.v_pointer
= hash_table
;
672 g_base_info_unref ( (GIBaseInfo
*) key_type_info
);
673 g_base_info_unref ( (GIBaseInfo
*) value_type_info
);
678 case GI_TYPE_TAG_ERROR
:
679 PyErr_SetString (PyExc_NotImplementedError
, "error marshalling is not supported yet");
683 /* Ignores cleanup data for now. */
684 pygi_marshal_from_py_basic_type (object
, &arg
, type_tag
, transfer
, &cleanup_data
);
692 * _pygi_argument_to_object:
693 * @arg: The argument to convert to an object.
694 * @type_info: Type info for @arg
697 * If the argument is of type array, it must be encoded in a GArray, by calling
698 * _pygi_argument_to_array(). This logic can not be folded into this method
699 * as determining array lengths may require access to method call arguments.
701 * Returns: A PyObject representing @arg
704 _pygi_argument_to_object (GIArgument
*arg
,
705 GITypeInfo
*type_info
,
709 PyObject
*object
= NULL
;
711 type_tag
= g_type_info_get_tag (type_info
);
714 case GI_TYPE_TAG_VOID
:
716 if (g_type_info_is_pointer (type_info
)) {
717 g_warn_if_fail (transfer
== GI_TRANSFER_NOTHING
);
718 object
= PyLong_FromVoidPtr (arg
->v_pointer
);
722 case GI_TYPE_TAG_ARRAY
:
724 /* Arrays are assumed to be packed in a GArray */
726 GITypeInfo
*item_type_info
;
727 GITypeTag item_type_tag
;
728 GITransfer item_transfer
;
731 if (arg
->v_pointer
== NULL
)
732 return PyList_New (0);
734 item_type_info
= g_type_info_get_param_type (type_info
, 0);
735 g_assert (item_type_info
!= NULL
);
737 item_type_tag
= g_type_info_get_tag (item_type_info
);
738 item_transfer
= transfer
== GI_TRANSFER_CONTAINER
? GI_TRANSFER_NOTHING
: transfer
;
740 array
= arg
->v_pointer
;
741 item_size
= g_array_get_element_size (array
);
743 if (G_UNLIKELY (item_size
> sizeof(GIArgument
))) {
744 g_critical ("Stack overflow protection. "
745 "Can't copy array element into GIArgument.");
746 return PyList_New (0);
749 if (item_type_tag
== GI_TYPE_TAG_UINT8
) {
750 /* Return as a byte array */
751 object
= PYGLIB_PyBytes_FromStringAndSize (array
->data
, array
->len
);
753 object
= PyList_New (array
->len
);
754 if (object
== NULL
) {
755 g_critical ("Failure to allocate array for %u items", array
->len
);
756 g_base_info_unref ( (GIBaseInfo
*) item_type_info
);
760 for (i
= 0; i
< array
->len
; i
++) {
761 GIArgument item
= { 0 };
764 memcpy (&item
, array
->data
+ i
* item_size
, item_size
);
766 py_item
= _pygi_argument_to_object (&item
, item_type_info
, item_transfer
);
767 if (py_item
== NULL
) {
769 _PyGI_ERROR_PREFIX ("Item %zu: ", i
);
773 PyList_SET_ITEM (object
, i
, py_item
);
777 g_base_info_unref ( (GIBaseInfo
*) item_type_info
);
780 case GI_TYPE_TAG_INTERFACE
:
783 GIInfoType info_type
;
785 info
= g_type_info_get_interface (type_info
);
786 info_type
= g_base_info_get_type (info
);
789 case GI_INFO_TYPE_CALLBACK
:
791 g_assert_not_reached();
793 case GI_INFO_TYPE_BOXED
:
794 case GI_INFO_TYPE_STRUCT
:
795 case GI_INFO_TYPE_UNION
:
798 GType g_type
= g_registered_type_info_get_g_type ( (GIRegisteredTypeInfo
*) info
);
799 gboolean is_foreign
= (info_type
== GI_INFO_TYPE_STRUCT
) &&
800 (g_struct_info_is_foreign ((GIStructInfo
*) info
));
802 /* Special case variant and none to force loading from py module. */
803 if (g_type
== G_TYPE_VARIANT
|| g_type
== G_TYPE_NONE
) {
804 py_type
= pygi_type_import_by_gi_info (info
);
806 py_type
= pygi_type_get_from_g_type (g_type
);
809 object
= pygi_arg_struct_to_py_marshal (arg
,
810 info
, /*interface_info*/
814 FALSE
, /*is_allocated*/
817 Py_XDECREF (py_type
);
820 case GI_INFO_TYPE_ENUM
:
821 case GI_INFO_TYPE_FLAGS
:
825 type
= g_registered_type_info_get_g_type ( (GIRegisteredTypeInfo
*) info
);
827 if (type
== G_TYPE_NONE
) {
828 /* An enum with a GType of None is an enum without GType */
829 PyObject
*py_type
= pygi_type_import_by_gi_info (info
);
830 PyObject
*py_args
= NULL
;
835 py_args
= PyTuple_New (1);
836 if (PyTuple_SetItem (py_args
, 0, pygi_gint_to_py (arg
->v_int
)) != 0) {
842 object
= PyObject_CallFunction (py_type
, "i", arg
->v_int
);
847 } else if (info_type
== GI_INFO_TYPE_ENUM
) {
848 object
= pyg_enum_from_gtype (type
, arg
->v_int
);
850 object
= pyg_flags_from_gtype (type
, arg
->v_uint
);
855 case GI_INFO_TYPE_INTERFACE
:
856 case GI_INFO_TYPE_OBJECT
:
857 object
= pygi_arg_gobject_to_py_called_from_c (arg
, transfer
);
861 g_assert_not_reached();
864 g_base_info_unref (info
);
867 case GI_TYPE_TAG_GLIST
:
868 case GI_TYPE_TAG_GSLIST
:
872 GITypeInfo
*item_type_info
;
873 GITransfer item_transfer
;
876 list
= arg
->v_pointer
;
877 length
= g_slist_length (list
);
879 object
= PyList_New (length
);
880 if (object
== NULL
) {
884 item_type_info
= g_type_info_get_param_type (type_info
, 0);
885 g_assert (item_type_info
!= NULL
);
887 item_transfer
= transfer
== GI_TRANSFER_CONTAINER
? GI_TRANSFER_NOTHING
: transfer
;
889 for (i
= 0; list
!= NULL
; list
= g_slist_next (list
), i
++) {
893 item
.v_pointer
= list
->data
;
895 py_item
= _pygi_argument_to_object (&item
, item_type_info
, item_transfer
);
896 if (py_item
== NULL
) {
898 _PyGI_ERROR_PREFIX ("Item %zu: ", i
);
902 PyList_SET_ITEM (object
, i
, py_item
);
905 g_base_info_unref ( (GIBaseInfo
*) item_type_info
);
908 case GI_TYPE_TAG_GHASH
:
910 GITypeInfo
*key_type_info
;
911 GITypeInfo
*value_type_info
;
912 GITransfer item_transfer
;
913 GHashTableIter hash_table_iter
;
917 if (arg
->v_pointer
== NULL
) {
923 object
= PyDict_New();
924 if (object
== NULL
) {
928 key_type_info
= g_type_info_get_param_type (type_info
, 0);
929 g_assert (key_type_info
!= NULL
);
930 g_assert (g_type_info_get_tag (key_type_info
) != GI_TYPE_TAG_VOID
);
932 value_type_info
= g_type_info_get_param_type (type_info
, 1);
933 g_assert (value_type_info
!= NULL
);
934 g_assert (g_type_info_get_tag (value_type_info
) != GI_TYPE_TAG_VOID
);
936 item_transfer
= transfer
== GI_TRANSFER_CONTAINER
? GI_TRANSFER_NOTHING
: transfer
;
938 g_hash_table_iter_init (&hash_table_iter
, (GHashTable
*) arg
->v_pointer
);
939 while (g_hash_table_iter_next (&hash_table_iter
, &key
.v_pointer
, &value
.v_pointer
)) {
944 py_key
= _pygi_argument_to_object (&key
, key_type_info
, item_transfer
);
945 if (py_key
== NULL
) {
949 _pygi_hash_pointer_to_arg (&value
, value_type_info
);
950 py_value
= _pygi_argument_to_object (&value
, value_type_info
, item_transfer
);
951 if (py_value
== NULL
) {
956 retval
= PyDict_SetItem (object
, py_key
, py_value
);
959 Py_DECREF (py_value
);
967 g_base_info_unref ( (GIBaseInfo
*) key_type_info
);
968 g_base_info_unref ( (GIBaseInfo
*) value_type_info
);
971 case GI_TYPE_TAG_ERROR
:
973 GError
*error
= (GError
*) arg
->v_pointer
;
974 if (error
!= NULL
&& transfer
== GI_TRANSFER_NOTHING
) {
975 /* If we have not been transferred the ownership we must copy
976 * the error, because pygi_error_check() is going to free it.
978 error
= g_error_copy (error
);
981 if (pygi_error_check (&error
)) {
985 PyErr_Fetch (&err_type
, &err_value
, &err_trace
);
986 Py_XDECREF (err_type
);
987 Py_XDECREF (err_trace
);
998 object
= pygi_marshal_to_py_basic_type (arg
, type_tag
, transfer
);
1006 _pygi_argument_release (GIArgument
*arg
,
1007 GITypeInfo
*type_info
,
1008 GITransfer transfer
,
1009 GIDirection direction
)
1012 gboolean is_out
= (direction
== GI_DIRECTION_OUT
|| direction
== GI_DIRECTION_INOUT
);
1014 type_tag
= g_type_info_get_tag (type_info
);
1017 case GI_TYPE_TAG_VOID
:
1018 /* Don't do anything, it's transparent to the C side */
1020 case GI_TYPE_TAG_BOOLEAN
:
1021 case GI_TYPE_TAG_INT8
:
1022 case GI_TYPE_TAG_UINT8
:
1023 case GI_TYPE_TAG_INT16
:
1024 case GI_TYPE_TAG_UINT16
:
1025 case GI_TYPE_TAG_INT32
:
1026 case GI_TYPE_TAG_UINT32
:
1027 case GI_TYPE_TAG_INT64
:
1028 case GI_TYPE_TAG_UINT64
:
1029 case GI_TYPE_TAG_FLOAT
:
1030 case GI_TYPE_TAG_DOUBLE
:
1031 case GI_TYPE_TAG_GTYPE
:
1032 case GI_TYPE_TAG_UNICHAR
:
1034 case GI_TYPE_TAG_FILENAME
:
1035 case GI_TYPE_TAG_UTF8
:
1036 /* With allow-none support the string could be NULL */
1037 if ((arg
->v_string
!= NULL
&&
1038 (direction
== GI_DIRECTION_IN
&& transfer
== GI_TRANSFER_NOTHING
))
1039 || (direction
== GI_DIRECTION_OUT
&& transfer
== GI_TRANSFER_EVERYTHING
)) {
1040 g_free (arg
->v_string
);
1043 case GI_TYPE_TAG_ARRAY
:
1048 if (arg
->v_pointer
== NULL
) {
1052 array
= arg
->v_pointer
;
1054 if ( (direction
== GI_DIRECTION_IN
&& transfer
!= GI_TRANSFER_EVERYTHING
)
1055 || (direction
== GI_DIRECTION_OUT
&& transfer
== GI_TRANSFER_EVERYTHING
)) {
1056 GITypeInfo
*item_type_info
;
1057 GITransfer item_transfer
;
1059 item_type_info
= g_type_info_get_param_type (type_info
, 0);
1061 item_transfer
= direction
== GI_DIRECTION_IN
? GI_TRANSFER_NOTHING
: GI_TRANSFER_EVERYTHING
;
1063 /* Free the items */
1064 for (i
= 0; i
< array
->len
; i
++) {
1066 memcpy (&item
, array
->data
+ (g_array_get_element_size (array
) * i
), sizeof (GIArgument
));
1067 _pygi_argument_release (&item
, item_type_info
, item_transfer
, direction
);
1070 g_base_info_unref ( (GIBaseInfo
*) item_type_info
);
1073 if ( (direction
== GI_DIRECTION_IN
&& transfer
== GI_TRANSFER_NOTHING
)
1074 || (direction
== GI_DIRECTION_OUT
&& transfer
!= GI_TRANSFER_NOTHING
)) {
1075 g_array_free (array
, TRUE
);
1080 case GI_TYPE_TAG_INTERFACE
:
1083 GIInfoType info_type
;
1085 info
= g_type_info_get_interface (type_info
);
1086 info_type
= g_base_info_get_type (info
);
1088 switch (info_type
) {
1089 case GI_INFO_TYPE_CALLBACK
:
1092 case GI_INFO_TYPE_BOXED
:
1093 case GI_INFO_TYPE_STRUCT
:
1094 case GI_INFO_TYPE_UNION
:
1098 if (arg
->v_pointer
== NULL
) {
1102 type
= g_registered_type_info_get_g_type ( (GIRegisteredTypeInfo
*) info
);
1104 if (g_type_is_a (type
, G_TYPE_VALUE
)) {
1107 value
= arg
->v_pointer
;
1109 if ( (direction
== GI_DIRECTION_IN
&& transfer
!= GI_TRANSFER_EVERYTHING
)
1110 || (direction
== GI_DIRECTION_OUT
&& transfer
== GI_TRANSFER_EVERYTHING
)) {
1111 g_value_unset (value
);
1114 if ( (direction
== GI_DIRECTION_IN
&& transfer
== GI_TRANSFER_NOTHING
)
1115 || (direction
== GI_DIRECTION_OUT
&& transfer
!= GI_TRANSFER_NOTHING
)) {
1116 g_slice_free (GValue
, value
);
1118 } else if (g_type_is_a (type
, G_TYPE_CLOSURE
)) {
1119 if (direction
== GI_DIRECTION_IN
&& transfer
== GI_TRANSFER_NOTHING
) {
1120 g_closure_unref (arg
->v_pointer
);
1122 } else if (info_type
== GI_INFO_TYPE_STRUCT
&&
1123 g_struct_info_is_foreign ((GIStructInfo
*) info
)) {
1124 if (direction
== GI_DIRECTION_OUT
&& transfer
== GI_TRANSFER_EVERYTHING
) {
1125 pygi_struct_foreign_release (info
, arg
->v_pointer
);
1127 } else if (g_type_is_a (type
, G_TYPE_BOXED
)) {
1128 } else if (g_type_is_a (type
, G_TYPE_POINTER
) || type
== G_TYPE_NONE
) {
1129 g_warn_if_fail (!g_type_info_is_pointer (type_info
) || transfer
== GI_TRANSFER_NOTHING
);
1134 case GI_INFO_TYPE_ENUM
:
1135 case GI_INFO_TYPE_FLAGS
:
1137 case GI_INFO_TYPE_INTERFACE
:
1138 case GI_INFO_TYPE_OBJECT
:
1139 if (arg
->v_pointer
== NULL
) {
1142 if (is_out
&& transfer
== GI_TRANSFER_EVERYTHING
) {
1143 g_object_unref (arg
->v_pointer
);
1147 g_assert_not_reached();
1150 g_base_info_unref (info
);
1153 case GI_TYPE_TAG_GLIST
:
1154 case GI_TYPE_TAG_GSLIST
:
1158 if (arg
->v_pointer
== NULL
) {
1162 list
= arg
->v_pointer
;
1164 if ( (direction
== GI_DIRECTION_IN
&& transfer
!= GI_TRANSFER_EVERYTHING
)
1165 || (direction
== GI_DIRECTION_OUT
&& transfer
== GI_TRANSFER_EVERYTHING
)) {
1166 GITypeInfo
*item_type_info
;
1167 GITransfer item_transfer
;
1170 item_type_info
= g_type_info_get_param_type (type_info
, 0);
1171 g_assert (item_type_info
!= NULL
);
1173 item_transfer
= direction
== GI_DIRECTION_IN
? GI_TRANSFER_NOTHING
: GI_TRANSFER_EVERYTHING
;
1175 /* Free the items */
1176 for (item
= list
; item
!= NULL
; item
= g_slist_next (item
)) {
1177 _pygi_argument_release ( (GIArgument
*) &item
->data
, item_type_info
,
1178 item_transfer
, direction
);
1181 g_base_info_unref ( (GIBaseInfo
*) item_type_info
);
1184 if ( (direction
== GI_DIRECTION_IN
&& transfer
== GI_TRANSFER_NOTHING
)
1185 || (direction
== GI_DIRECTION_OUT
&& transfer
!= GI_TRANSFER_NOTHING
)) {
1186 if (type_tag
== GI_TYPE_TAG_GLIST
) {
1187 g_list_free ( (GList
*) list
);
1189 /* type_tag == GI_TYPE_TAG_GSLIST */
1190 g_slist_free (list
);
1196 case GI_TYPE_TAG_GHASH
:
1198 GHashTable
*hash_table
;
1200 if (arg
->v_pointer
== NULL
) {
1204 hash_table
= arg
->v_pointer
;
1206 if (direction
== GI_DIRECTION_IN
&& transfer
!= GI_TRANSFER_EVERYTHING
) {
1207 /* We created the table without a destroy function, so keys and
1208 * values need to be released. */
1209 GITypeInfo
*key_type_info
;
1210 GITypeInfo
*value_type_info
;
1211 GITransfer item_transfer
;
1212 GHashTableIter hash_table_iter
;
1216 key_type_info
= g_type_info_get_param_type (type_info
, 0);
1217 g_assert (key_type_info
!= NULL
);
1219 value_type_info
= g_type_info_get_param_type (type_info
, 1);
1220 g_assert (value_type_info
!= NULL
);
1222 if (direction
== GI_DIRECTION_IN
) {
1223 item_transfer
= GI_TRANSFER_NOTHING
;
1225 item_transfer
= GI_TRANSFER_EVERYTHING
;
1228 g_hash_table_iter_init (&hash_table_iter
, hash_table
);
1229 while (g_hash_table_iter_next (&hash_table_iter
, &key
, &value
)) {
1230 _pygi_argument_release ( (GIArgument
*) &key
, key_type_info
,
1231 item_transfer
, direction
);
1232 _pygi_argument_release ( (GIArgument
*) &value
, value_type_info
,
1233 item_transfer
, direction
);
1236 g_base_info_unref ( (GIBaseInfo
*) key_type_info
);
1237 g_base_info_unref ( (GIBaseInfo
*) value_type_info
);
1238 } else if (direction
== GI_DIRECTION_OUT
&& transfer
== GI_TRANSFER_CONTAINER
) {
1239 /* Be careful to avoid keys and values being freed if the
1240 * callee gave a destroy function. */
1241 g_hash_table_steal_all (hash_table
);
1244 if ( (direction
== GI_DIRECTION_IN
&& transfer
== GI_TRANSFER_NOTHING
)
1245 || (direction
== GI_DIRECTION_OUT
&& transfer
!= GI_TRANSFER_NOTHING
)) {
1246 g_hash_table_unref (hash_table
);
1251 case GI_TYPE_TAG_ERROR
:
1255 if (arg
->v_pointer
== NULL
) {
1259 error
= * (GError
**) arg
->v_pointer
;
1261 if (error
!= NULL
) {
1262 g_error_free (error
);
1265 g_slice_free (GError
*, arg
->v_pointer
);