1 /* -*- Mode: C; c-basic-offset: 4 -*-
2 * vim: tabstop=4 shiftwidth=4 expandtab
4 * Copyright (C) 2005-2009 Johan Dahlin <johan@gnome.org>
5 * Copyright (C) 2011 John (J5) Palimier <johnp@redhat.com>
7 * pygi-invoke.c: main invocation function
9 * This library is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU Lesser General Public
11 * License as published by the Free Software Foundation; either
12 * version 2.1 of the License, or (at your option) any later version.
14 * This library is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * Lesser General Public License for more details.
19 * You should have received a copy of the GNU Lesser General Public
20 * License along with this library; if not, see <http://www.gnu.org/licenses/>.
24 #include "pygi-invoke.h"
25 #include "pygi-marshal-cleanup.h"
26 #include "pygi-error.h"
27 #include "pygi-resulttuple.h"
28 #include "pygi-foreign.h"
29 #include "pygi-boxed.h"
31 extern PyObject
*_PyGIDefaultArgPlaceholder
;
34 _check_for_unexpected_kwargs (PyGICallableCache
*cache
,
35 GHashTable
*arg_name_hash
,
38 PyObject
*dict_key
, *dict_value
;
39 Py_ssize_t dict_iter_pos
= 0;
41 while (PyDict_Next (py_kwargs
, &dict_iter_pos
, &dict_key
, &dict_value
)) {
44 #if PY_VERSION_HEX < 0x03000000
45 if (PyString_Check (dict_key
)) {
51 key
= PyUnicode_AsUTF8String (dict_key
);
57 /* Use extended lookup because it returns whether or not the key actually
58 * exists in the hash table. g_hash_table_lookup returns NULL for keys not
59 * found which maps to index 0 for our hash lookup.
61 if (!g_hash_table_lookup_extended (arg_name_hash
, PyBytes_AsString(key
), NULL
, NULL
)) {
62 char *full_name
= pygi_callable_cache_get_full_name (cache
);
63 PyErr_Format (PyExc_TypeError
,
64 "%.200s() got an unexpected keyword argument '%.400s'",
66 PyBytes_AsString (key
));
78 * _py_args_combine_and_check_length:
79 * @cache: PyGICallableCache
80 * @py_args: the tuple of positional arguments.
81 * @py_kwargs: the dict of keyword arguments to be merged with py_args.
83 * Returns: New value reference to the combined py_args and py_kwargs.
86 _py_args_combine_and_check_length (PyGICallableCache
*cache
,
90 PyObject
*combined_py_args
= NULL
;
91 Py_ssize_t n_py_args
, n_py_kwargs
, i
;
92 gssize n_expected_args
= cache
->n_py_args
;
95 n_py_args
= PyTuple_GET_SIZE (py_args
);
96 if (py_kwargs
== NULL
)
99 n_py_kwargs
= PyDict_Size (py_kwargs
);
101 /* Fast path, we already have the exact number of args and not kwargs. */
102 if (n_py_kwargs
== 0 && n_py_args
== n_expected_args
&& cache
->user_data_varargs_index
< 0) {
107 if (cache
->user_data_varargs_index
< 0 && n_expected_args
< n_py_args
) {
108 char *full_name
= pygi_callable_cache_get_full_name (cache
);
109 PyErr_Format (PyExc_TypeError
,
110 "%.200s() takes exactly %zd %sargument%s (%zd given)",
113 n_py_kwargs
> 0 ? "non-keyword " : "",
114 n_expected_args
== 1 ? "" : "s",
120 if (cache
->user_data_varargs_index
>= 0 && n_py_kwargs
> 0 && n_expected_args
< n_py_args
) {
121 char *full_name
= pygi_callable_cache_get_full_name (cache
);
122 PyErr_Format (PyExc_TypeError
,
123 "%.200s() cannot use variable user data arguments with keyword arguments",
129 if (n_py_kwargs
> 0 && !_check_for_unexpected_kwargs (cache
,
130 cache
->arg_name_hash
,
135 /* will hold arguments from both py_args and py_kwargs
136 * when they are combined into a single tuple */
137 combined_py_args
= PyTuple_New (n_expected_args
);
139 for (i
= 0, l
= cache
->arg_name_list
; i
< n_expected_args
&& l
; i
++, l
= l
->next
) {
140 PyObject
*py_arg_item
= NULL
;
141 PyObject
*kw_arg_item
= NULL
;
142 const gchar
*arg_name
= l
->data
;
143 int arg_cache_index
= -1;
144 gboolean is_varargs_user_data
= FALSE
;
146 if (arg_name
!= NULL
)
147 arg_cache_index
= GPOINTER_TO_INT (g_hash_table_lookup (cache
->arg_name_hash
, arg_name
));
149 is_varargs_user_data
= cache
->user_data_varargs_index
>= 0 &&
150 arg_cache_index
== cache
->user_data_varargs_index
;
152 if (n_py_kwargs
> 0 && arg_name
!= NULL
) {
153 /* NULL means this argument has no keyword name */
154 /* ex. the first argument to a method or constructor */
155 kw_arg_item
= PyDict_GetItemString (py_kwargs
, arg_name
);
158 /* use a bounded retrieval of the original input */
160 py_arg_item
= PyTuple_GET_ITEM (py_args
, i
);
162 if (kw_arg_item
== NULL
&& py_arg_item
!= NULL
) {
163 if (is_varargs_user_data
) {
164 /* For tail end user_data varargs, pull a slice off and we are done. */
165 PyObject
*user_data
= PyTuple_GetSlice (py_args
, i
, PY_SSIZE_T_MAX
);
166 PyTuple_SET_ITEM (combined_py_args
, i
, user_data
);
167 return combined_py_args
;
169 Py_INCREF (py_arg_item
);
170 PyTuple_SET_ITEM (combined_py_args
, i
, py_arg_item
);
172 } else if (kw_arg_item
!= NULL
&& py_arg_item
== NULL
) {
173 if (is_varargs_user_data
) {
174 /* Special case where user_data is passed as a keyword argument (user_data=foo)
175 * Wrap the value in a tuple to represent variable args for marshaling later on.
177 PyObject
*user_data
= Py_BuildValue("(O)", kw_arg_item
, NULL
);
178 PyTuple_SET_ITEM (combined_py_args
, i
, user_data
);
180 Py_INCREF (kw_arg_item
);
181 PyTuple_SET_ITEM (combined_py_args
, i
, kw_arg_item
);
184 } else if (kw_arg_item
== NULL
&& py_arg_item
== NULL
) {
185 if (is_varargs_user_data
) {
186 /* For varargs user_data, pass an empty tuple when nothing is given. */
187 PyTuple_SET_ITEM (combined_py_args
, i
, PyTuple_New (0));
188 } else if (arg_cache_index
>= 0 && _pygi_callable_cache_get_arg (cache
, arg_cache_index
)->has_default
) {
189 /* If the argument supports a default, use a place holder in the
190 * argument tuple, this will be checked later during marshaling.
192 Py_INCREF (_PyGIDefaultArgPlaceholder
);
193 PyTuple_SET_ITEM (combined_py_args
, i
, _PyGIDefaultArgPlaceholder
);
195 char *full_name
= pygi_callable_cache_get_full_name (cache
);
196 PyErr_Format (PyExc_TypeError
,
197 "%.200s() takes exactly %zd %sargument%s (%zd given)",
200 n_py_kwargs
> 0 ? "non-keyword " : "",
201 n_expected_args
== 1 ? "" : "s",
205 Py_DECREF (combined_py_args
);
208 } else if (kw_arg_item
!= NULL
&& py_arg_item
!= NULL
) {
209 char *full_name
= pygi_callable_cache_get_full_name (cache
);
210 PyErr_Format (PyExc_TypeError
,
211 "%.200s() got multiple values for keyword argument '%.200s'",
215 Py_DECREF (combined_py_args
);
221 return combined_py_args
;
224 /* To reduce calls to g_slice_*() we (1) allocate all the memory depended on
225 * the argument count in one go and (2) keep one version per argument count
226 * around for faster reuse.
229 #define PyGI_INVOKE_ARG_STATE_SIZE(n) (n * (sizeof (PyGIInvokeArgState) + sizeof (GIArgument *)))
230 #define PyGI_INVOKE_ARG_STATE_N_MAX 10
231 static gpointer free_arg_state
[PyGI_INVOKE_ARG_STATE_N_MAX
];
234 * _pygi_invoke_arg_state_init:
235 * Sets PyGIInvokeState.args and PyGIInvokeState.ffi_args.
236 * On error returns FALSE and sets an exception.
239 _pygi_invoke_arg_state_init (PyGIInvokeState
*state
) {
243 if (state
->n_args
< PyGI_INVOKE_ARG_STATE_N_MAX
&& (mem
= free_arg_state
[state
->n_args
]) != NULL
) {
244 free_arg_state
[state
->n_args
] = NULL
;
245 memset (mem
, 0, PyGI_INVOKE_ARG_STATE_SIZE (state
->n_args
));
247 mem
= g_slice_alloc0 (PyGI_INVOKE_ARG_STATE_SIZE (state
->n_args
));
250 if (mem
== NULL
&& state
->n_args
!= 0) {
257 state
->ffi_args
= (gpointer
)((gchar
*)mem
+ state
->n_args
* sizeof (PyGIInvokeArgState
));
264 * _pygi_invoke_arg_state_free:
265 * Frees PyGIInvokeState.args and PyGIInvokeState.ffi_args
268 _pygi_invoke_arg_state_free(PyGIInvokeState
*state
) {
269 if (state
->n_args
< PyGI_INVOKE_ARG_STATE_N_MAX
&& free_arg_state
[state
->n_args
] == NULL
) {
270 free_arg_state
[state
->n_args
] = state
->args
;
274 g_slice_free1 (PyGI_INVOKE_ARG_STATE_SIZE (state
->n_args
), state
->args
);
278 _invoke_state_init_from_cache (PyGIInvokeState
*state
,
279 PyGIFunctionCache
*function_cache
,
283 PyGICallableCache
*cache
= (PyGICallableCache
*) function_cache
;
285 state
->n_args
= _pygi_callable_cache_args_len (cache
);
291 /* Copy the function pointer to the state for the normal case. For vfuncs,
292 * this has already been filled out based on the implementor's GType.
294 if (state
->function_ptr
== NULL
)
295 state
->function_ptr
= function_cache
->invoker
.native_address
;
297 state
->py_in_args
= _py_args_combine_and_check_length (cache
,
301 if (state
->py_in_args
== NULL
) {
304 state
->n_py_in_args
= PyTuple_Size (state
->py_in_args
);
306 if (!_pygi_invoke_arg_state_init (state
)) {
313 gssize error_index
= state
->n_args
- 1;
314 /* The ffi argument for GError needs to be a triple pointer. */
315 state
->args
[error_index
].arg_pointer
.v_pointer
= &state
->error
;
316 state
->ffi_args
[error_index
] = &(state
->args
[error_index
].arg_pointer
);
323 _invoke_state_clear (PyGIInvokeState
*state
, PyGIFunctionCache
*function_cache
)
325 _pygi_invoke_arg_state_free (state
);
326 Py_XDECREF (state
->py_in_args
);
330 _caller_alloc (PyGIArgCache
*arg_cache
, GIArgument
*arg
)
332 if (arg_cache
->type_tag
== GI_TYPE_TAG_INTERFACE
) {
333 PyGIInterfaceCache
*iface_cache
= (PyGIInterfaceCache
*)arg_cache
;
335 arg
->v_pointer
= NULL
;
336 if (g_type_is_a (iface_cache
->g_type
, G_TYPE_BOXED
)) {
338 _pygi_boxed_alloc (iface_cache
->interface_info
, NULL
);
339 } else if (iface_cache
->g_type
== G_TYPE_VALUE
) {
340 arg
->v_pointer
= g_slice_new0 (GValue
);
341 } else if (iface_cache
->is_foreign
) {
342 PyObject
*foreign_struct
=
343 pygi_struct_foreign_convert_from_g_argument (
344 iface_cache
->interface_info
,
348 pygi_struct_foreign_convert_to_g_argument (foreign_struct
,
349 iface_cache
->interface_info
,
350 GI_TRANSFER_EVERYTHING
,
353 gssize size
= g_struct_info_get_size(
354 (GIStructInfo
*)iface_cache
->interface_info
);
355 arg
->v_pointer
= g_malloc0 (size
);
357 } else if (arg_cache
->type_tag
== GI_TYPE_TAG_ARRAY
) {
358 PyGIArgGArray
*array_cache
= (PyGIArgGArray
*)arg_cache
;
360 arg
->v_pointer
= g_array_new (TRUE
, TRUE
, array_cache
->item_size
);
365 if (arg
->v_pointer
== NULL
)
372 /* pygi_invoke_marshal_in_args:
374 * Fills out the state struct argument lists. arg_values will always hold
375 * actual values marshaled either to or from Python and C. arg_pointers will
376 * hold pointers (via v_pointer) to auxilary value storage. This will normally
377 * point to values stored in arg_values. In the case of caller allocated
378 * out args, arg_pointers[x].v_pointer will point to newly allocated memory.
379 * arg_pointers inserts a level of pointer indirection between arg_values
380 * and the argument list ffi receives when dealing with non-caller allocated
385 * void callee (int *i, int j) { *i = 50 - j; }
391 * args[0] == &arg_pointers[0];
392 * arg_pointers[0].v_pointer == &arg_values[0];
393 * arg_values[0].v_int == 42;
395 * args[1] == &arg_values[1];
396 * arg_values[1].v_int == 8;
401 _invoke_marshal_in_args (PyGIInvokeState
*state
, PyGIFunctionCache
*function_cache
)
403 PyGICallableCache
*cache
= (PyGICallableCache
*) function_cache
;
406 if (state
->n_py_in_args
> cache
->n_py_args
) {
407 char *full_name
= pygi_callable_cache_get_full_name (cache
);
408 PyErr_Format (PyExc_TypeError
,
409 "%s() takes exactly %zd argument(s) (%zd given)",
412 state
->n_py_in_args
);
417 for (i
= 0; (gsize
)i
< _pygi_callable_cache_args_len (cache
); i
++) {
418 GIArgument
*c_arg
= &state
->args
[i
].arg_value
;
419 PyGIArgCache
*arg_cache
= g_ptr_array_index (cache
->args_cache
, i
);
420 PyObject
*py_arg
= NULL
;
422 switch (arg_cache
->direction
) {
423 case PYGI_DIRECTION_FROM_PYTHON
:
424 /* The ffi argument points directly at memory in arg_values. */
425 state
->ffi_args
[i
] = c_arg
;
427 if (arg_cache
->meta_type
== PYGI_META_ARG_TYPE_CLOSURE
) {
428 state
->ffi_args
[i
]->v_pointer
= state
->user_data
;
430 } else if (arg_cache
->meta_type
!= PYGI_META_ARG_TYPE_PARENT
)
433 if (arg_cache
->py_arg_index
>= state
->n_py_in_args
) {
434 char *full_name
= pygi_callable_cache_get_full_name (cache
);
435 PyErr_Format (PyExc_TypeError
,
436 "%s() takes exactly %zd argument(s) (%zd given)",
439 state
->n_py_in_args
);
442 /* clean up all of the args we have already marshalled,
443 * since invoke will not be called
445 pygi_marshal_cleanup_args_from_py_parameter_fail (state
,
452 PyTuple_GET_ITEM (state
->py_in_args
,
453 arg_cache
->py_arg_index
);
456 case PYGI_DIRECTION_BIDIRECTIONAL
:
457 if (arg_cache
->meta_type
!= PYGI_META_ARG_TYPE_CHILD
) {
458 if (arg_cache
->py_arg_index
>= state
->n_py_in_args
) {
459 char *full_name
= pygi_callable_cache_get_full_name (cache
);
460 PyErr_Format (PyExc_TypeError
,
461 "%s() takes exactly %zd argument(s) (%zd given)",
464 state
->n_py_in_args
);
466 pygi_marshal_cleanup_args_from_py_parameter_fail (state
,
473 PyTuple_GET_ITEM (state
->py_in_args
,
474 arg_cache
->py_arg_index
);
478 case PYGI_DIRECTION_TO_PYTHON
:
479 /* arg_pointers always stores a pointer to the data to be marshaled "to python"
480 * even in cases where arg_pointers is not being used as indirection between
481 * ffi and arg_values. This gives a guarantee that out argument marshaling
482 * (_invoke_marshal_out_args) can always rely on arg_pointers pointing to
483 * the correct chunk of memory to marshal.
485 state
->args
[i
].arg_pointer
.v_pointer
= c_arg
;
487 if (arg_cache
->is_caller_allocates
) {
488 /* In the case of caller allocated out args, we don't use
489 * an extra level of indirection and state->args will point
490 * directly at the data to be marshaled. However, as noted
491 * above, arg_pointers will also point to this caller allocated
492 * chunk of memory used by out argument marshaling.
494 state
->ffi_args
[i
] = c_arg
;
496 if (!_caller_alloc (arg_cache
, c_arg
)) {
497 char *full_name
= pygi_callable_cache_get_full_name (cache
);
498 PyErr_Format (PyExc_TypeError
,
499 "Could not caller allocate argument %zd of callable %s",
502 pygi_marshal_cleanup_args_from_py_parameter_fail (state
,
508 /* Non-caller allocated out args will use arg_pointers as an
509 * extra level of indirection */
510 state
->ffi_args
[i
] = &state
->args
[i
].arg_pointer
;
515 g_assert_not_reached();
519 if (py_arg
== _PyGIDefaultArgPlaceholder
) {
520 *c_arg
= arg_cache
->default_value
;
521 } else if (arg_cache
->from_py_marshaller
!= NULL
&&
522 arg_cache
->meta_type
!= PYGI_META_ARG_TYPE_CHILD
) {
524 gpointer cleanup_data
= NULL
;
526 if (!arg_cache
->allow_none
&& py_arg
== Py_None
) {
527 PyErr_Format (PyExc_TypeError
,
528 "Argument %zd does not allow None as a value",
531 pygi_marshal_cleanup_args_from_py_parameter_fail (state
,
536 success
= arg_cache
->from_py_marshaller (state
,
542 state
->args
[i
].arg_cleanup_data
= cleanup_data
;
545 pygi_marshal_cleanup_args_from_py_parameter_fail (state
,
559 _invoke_marshal_out_args (PyGIInvokeState
*state
, PyGIFunctionCache
*function_cache
)
561 PyGICallableCache
*cache
= (PyGICallableCache
*) function_cache
;
562 PyObject
*py_out
= NULL
;
563 PyObject
*py_return
= NULL
;
564 gssize n_out_args
= cache
->n_to_py_args
- cache
->n_to_py_child_args
;
566 if (cache
->return_cache
) {
567 if (!cache
->return_cache
->is_skipped
) {
568 py_return
= cache
->return_cache
->to_py_marshaller ( state
,
572 if (py_return
== NULL
) {
573 pygi_marshal_cleanup_args_return_fail (state
,
578 if (cache
->return_cache
->transfer
== GI_TRANSFER_EVERYTHING
) {
579 PyGIMarshalCleanupFunc to_py_cleanup
=
580 cache
->return_cache
->to_py_cleanup
;
582 if (to_py_cleanup
!= NULL
)
583 to_py_cleanup ( state
,
592 if (n_out_args
== 0) {
593 if (cache
->return_cache
->is_skipped
&& state
->error
== NULL
) {
594 /* we skip the return value and have no (out) arguments to return,
595 * so py_return should be NULL. But we must not return NULL,
596 * otherwise Python will expect an exception.
598 g_assert (py_return
== NULL
);
604 } else if (!cache
->has_return
&& n_out_args
== 1) {
605 /* if we get here there is one out arg an no return */
606 PyGIArgCache
*arg_cache
= (PyGIArgCache
*)cache
->to_py_args
->data
;
607 py_out
= arg_cache
->to_py_marshaller (state
,
610 state
->args
[arg_cache
->c_arg_index
].arg_pointer
.v_pointer
);
611 if (py_out
== NULL
) {
612 pygi_marshal_cleanup_args_to_py_parameter_fail (state
,
620 gssize py_arg_index
= 0;
621 GSList
*cache_item
= cache
->to_py_args
;
622 gssize tuple_len
= cache
->has_return
+ n_out_args
;
624 py_out
= pygi_resulttuple_new (cache
->resulttuple_type
, tuple_len
);
626 if (py_out
== NULL
) {
627 pygi_marshal_cleanup_args_to_py_parameter_fail (state
,
633 if (cache
->has_return
) {
634 PyTuple_SET_ITEM (py_out
, py_arg_index
, py_return
);
638 for (; py_arg_index
< tuple_len
; py_arg_index
++) {
639 PyGIArgCache
*arg_cache
= (PyGIArgCache
*)cache_item
->data
;
640 PyObject
*py_obj
= arg_cache
->to_py_marshaller (state
,
643 state
->args
[arg_cache
->c_arg_index
].arg_pointer
.v_pointer
);
645 if (py_obj
== NULL
) {
646 if (cache
->has_return
)
649 pygi_marshal_cleanup_args_to_py_parameter_fail (state
,
656 PyTuple_SET_ITEM (py_out
, py_arg_index
, py_obj
);
657 cache_item
= cache_item
->next
;
664 pygi_invoke_c_callable (PyGIFunctionCache
*function_cache
,
665 PyGIInvokeState
*state
,
669 PyGICallableCache
*cache
= (PyGICallableCache
*) function_cache
;
670 GIFFIReturnValue ffi_return_value
= {0};
671 PyObject
*ret
= NULL
;
673 if (!_invoke_state_init_from_cache (state
, function_cache
,
677 if (!_invoke_marshal_in_args (state
, function_cache
))
680 Py_BEGIN_ALLOW_THREADS
;
682 ffi_call (&function_cache
->invoker
.cif
,
684 (void *) &ffi_return_value
,
685 (void **) state
->ffi_args
);
687 Py_END_ALLOW_THREADS
;
689 /* If the callable throws, the address of state->error will be bound into
690 * the state->args as the last value. When the callee sets an error using
691 * the state->args passed, it will have the side effect of setting
692 * state->error allowing for easy checking here.
694 if (state
->error
!= NULL
) {
695 if (pygi_error_check (&state
->error
)) {
696 /* even though we errored out, the call itself was successful,
697 so we assume the call processed all of the parameters */
698 pygi_marshal_cleanup_args_from_py_marshal_success (state
, cache
);
703 if (cache
->return_cache
) {
704 gi_type_info_extract_ffi_return_value (cache
->return_cache
->type_info
,
709 ret
= _invoke_marshal_out_args (state
, function_cache
);
710 pygi_marshal_cleanup_args_from_py_marshal_success (state
, cache
);
713 pygi_marshal_cleanup_args_to_py_marshal_success (state
, cache
);
716 _invoke_state_clear (state
, function_cache
);
721 pygi_callable_info_invoke (GIBaseInfo
*info
, PyObject
*py_args
,
722 PyObject
*kwargs
, PyGICallableCache
*cache
,
725 return pygi_function_cache_invoke ((PyGIFunctionCache
*) cache
,
730 _wrap_g_callable_info_invoke (PyGIBaseInfo
*self
, PyObject
*py_args
,
733 if (self
->cache
== NULL
) {
734 PyGIFunctionCache
*function_cache
;
735 GIInfoType type
= g_base_info_get_type (self
->info
);
737 if (type
== GI_INFO_TYPE_FUNCTION
) {
738 GIFunctionInfoFlags flags
;
740 flags
= g_function_info_get_flags ( (GIFunctionInfo
*)self
->info
);
742 if (flags
& GI_FUNCTION_IS_CONSTRUCTOR
) {
743 function_cache
= pygi_constructor_cache_new (self
->info
);
744 } else if (flags
& GI_FUNCTION_IS_METHOD
) {
745 function_cache
= pygi_method_cache_new (self
->info
);
747 function_cache
= pygi_function_cache_new (self
->info
);
749 } else if (type
== GI_INFO_TYPE_VFUNC
) {
750 function_cache
= pygi_vfunc_cache_new (self
->info
);
751 } else if (type
== GI_INFO_TYPE_CALLBACK
) {
752 g_error ("Cannot invoke callback types");
754 function_cache
= pygi_method_cache_new (self
->info
);
757 self
->cache
= (PyGICallableCache
*)function_cache
;
758 if (self
->cache
== NULL
)
762 return pygi_callable_info_invoke (self
->info
, py_args
, kwargs
, self
->cache
, NULL
);