Branch data Line data Source code
1 : : /* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*-
2 : : * GObject introspection: Callable implementation
3 : : *
4 : : * Copyright (C) 2005 Matthias Clasen
5 : : * Copyright (C) 2008,2009 Red Hat, Inc.
6 : : *
7 : : * SPDX-License-Identifier: LGPL-2.1-or-later
8 : : *
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 of the License, or (at your option) any later version.
13 : : *
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.
18 : : *
19 : : * You should have received a copy of the GNU Lesser General Public
20 : : * License along with this library; if not, write to the
21 : : * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
22 : : * Boston, MA 02111-1307, USA.
23 : : */
24 : :
25 : : #include "config.h"
26 : :
27 : : #include <stdlib.h>
28 : :
29 : : #include <glib.h>
30 : :
31 : : #include <girepository/girepository.h>
32 : : #include "gibaseinfo-private.h"
33 : : #include "girepository-private.h"
34 : : #include "gitypelib-internal.h"
35 : : #include "girffi.h"
36 : : #include "gicallableinfo.h"
37 : :
38 : : #define GET_BLOB(Type, rinfo) ((Type *) &rinfo->typelib->data[rinfo->offset])
39 : :
40 : : /* GICallableInfo functions */
41 : :
42 : : /**
43 : : * GICallableInfo:
44 : : *
45 : : * `GICallableInfo` represents an entity which is callable.
46 : : *
47 : : * Examples of callable are:
48 : : *
49 : : * - functions ([class@GIRepository.FunctionInfo])
50 : : * - virtual functions ([class@GIRepository.VFuncInfo])
51 : : * - callbacks ([class@GIRepository.CallbackInfo]).
52 : : *
53 : : * A callable has a list of arguments ([class@GIRepository.ArgInfo]), a return
54 : : * type, direction and a flag which decides if it returns `NULL`.
55 : : *
56 : : * Since: 2.80
57 : : */
58 : :
59 : : static uint32_t
60 : 47 : signature_offset (GICallableInfo *info)
61 : : {
62 : 47 : GIRealInfo *rinfo = (GIRealInfo*)info;
63 : 47 : int sigoff = -1;
64 : :
65 : 47 : switch (gi_base_info_get_info_type ((GIBaseInfo *) info))
66 : : {
67 : 41 : case GI_INFO_TYPE_FUNCTION:
68 : 41 : sigoff = G_STRUCT_OFFSET (FunctionBlob, signature);
69 : 41 : break;
70 : 2 : case GI_INFO_TYPE_VFUNC:
71 : 2 : sigoff = G_STRUCT_OFFSET (VFuncBlob, signature);
72 : 2 : break;
73 : 1 : case GI_INFO_TYPE_CALLBACK:
74 : 1 : sigoff = G_STRUCT_OFFSET (CallbackBlob, signature);
75 : 1 : break;
76 : 3 : case GI_INFO_TYPE_SIGNAL:
77 : 3 : sigoff = G_STRUCT_OFFSET (SignalBlob, signature);
78 : 3 : break;
79 : 0 : default:
80 : : g_assert_not_reached ();
81 : : }
82 : 47 : if (sigoff >= 0)
83 : 47 : return *(uint32_t *)&rinfo->typelib->data[rinfo->offset + sigoff];
84 : 0 : return 0;
85 : : }
86 : :
87 : : /**
88 : : * gi_callable_info_can_throw_gerror:
89 : : * @info: a #GICallableInfo
90 : : *
91 : : * Whether the callable can throw a [type@GLib.Error]
92 : : *
93 : : * Returns: `TRUE` if this `GICallableInfo` can throw a [type@GLib.Error]
94 : : * Since: 2.80
95 : : */
96 : : gboolean
97 : 8 : gi_callable_info_can_throw_gerror (GICallableInfo *info)
98 : : {
99 : 8 : GIRealInfo *rinfo = (GIRealInfo*)info;
100 : : SignatureBlob *signature;
101 : :
102 : 8 : signature = (SignatureBlob *)&rinfo->typelib->data[signature_offset (info)];
103 : 8 : if (signature->throws)
104 : 6 : return TRUE;
105 : :
106 : : /* Functions and VFuncs store "throws" in their own blobs.
107 : : * This info was additionally added to the SignatureBlob
108 : : * to support the other callables. For Functions and VFuncs,
109 : : * also check their legacy flag for compatibility.
110 : : */
111 : 2 : switch (gi_base_info_get_info_type ((GIBaseInfo *) info)) {
112 : 2 : case GI_INFO_TYPE_FUNCTION:
113 : : {
114 : : FunctionBlob *blob;
115 : 2 : blob = (FunctionBlob *)&rinfo->typelib->data[rinfo->offset];
116 : 2 : return blob->throws;
117 : : }
118 : 0 : case GI_INFO_TYPE_VFUNC:
119 : : {
120 : : VFuncBlob *blob;
121 : 0 : blob = (VFuncBlob *)&rinfo->typelib->data[rinfo->offset];
122 : 0 : return blob->throws;
123 : : }
124 : 0 : case GI_INFO_TYPE_CALLBACK:
125 : : case GI_INFO_TYPE_SIGNAL:
126 : 0 : return FALSE;
127 : 0 : default:
128 : : g_assert_not_reached ();
129 : : }
130 : : }
131 : :
132 : : /**
133 : : * gi_callable_info_is_method:
134 : : * @info: a #GICallableInfo
135 : : *
136 : : * Determines if the callable info is a method.
137 : : *
138 : : * For [class@GIRepository.VFuncInfo]s, [class@GIRepository.CallbackInfo]s, and
139 : : * [class@GIRepository.SignalInfo]s, this is always true. Otherwise, this looks
140 : : * at the `GI_FUNCTION_IS_METHOD` flag on the [class@GIRepository.FunctionInfo].
141 : : *
142 : : * Concretely, this function returns whether
143 : : * [method@GIRepository.CallableInfo.get_n_args] matches the number of arguments
144 : : * in the raw C method. For methods, there is one more C argument than is
145 : : * exposed by introspection: the `self` or `this` object.
146 : : *
147 : : * Returns: `TRUE` if @info is a method, `FALSE` otherwise
148 : : * Since: 2.80
149 : : */
150 : : gboolean
151 : 6 : gi_callable_info_is_method (GICallableInfo *info)
152 : : {
153 : 6 : GIRealInfo *rinfo = (GIRealInfo*)info;
154 : 6 : switch (gi_base_info_get_info_type ((GIBaseInfo *) info)) {
155 : 6 : case GI_INFO_TYPE_FUNCTION:
156 : : {
157 : : FunctionBlob *blob;
158 : 6 : blob = (FunctionBlob *)&rinfo->typelib->data[rinfo->offset];
159 : 6 : return (!blob->constructor && !blob->is_static);
160 : : }
161 : 0 : case GI_INFO_TYPE_VFUNC:
162 : : case GI_INFO_TYPE_SIGNAL:
163 : 0 : return TRUE;
164 : 0 : case GI_INFO_TYPE_CALLBACK:
165 : 0 : return FALSE;
166 : 0 : default:
167 : : g_assert_not_reached ();
168 : : }
169 : : }
170 : :
171 : : /**
172 : : * gi_callable_info_get_return_type:
173 : : * @info: a #GICallableInfo
174 : : *
175 : : * Obtain the return type of a callable item as a [class@GIRepository.TypeInfo].
176 : : *
177 : : * If the callable doesn’t return anything, a [class@GIRepository.TypeInfo] of
178 : : * type [enum@GIRepository.TypeTag.VOID] will be returned.
179 : : *
180 : : * Returns: (transfer full): the [class@GIRepository.TypeInfo]. Free the struct
181 : : * by calling [method@GIRepository.BaseInfo.unref] when done.
182 : : * Since: 2.80
183 : : */
184 : : GITypeInfo *
185 : 8 : gi_callable_info_get_return_type (GICallableInfo *info)
186 : : {
187 : 8 : GIRealInfo *rinfo = (GIRealInfo *)info;
188 : : uint32_t offset;
189 : :
190 : 8 : g_return_val_if_fail (info != NULL, NULL);
191 : 8 : g_return_val_if_fail (GI_IS_CALLABLE_INFO (info), NULL);
192 : :
193 : 8 : offset = signature_offset (info);
194 : :
195 : 8 : return gi_type_info_new ((GIBaseInfo*)info, rinfo->typelib, offset);
196 : : }
197 : :
198 : : /**
199 : : * gi_callable_info_load_return_type:
200 : : * @info: a #GICallableInfo
201 : : * @type: (out caller-allocates): Initialized with return type of @info
202 : : *
203 : : * Obtain information about a return value of callable; this
204 : : * function is a variant of [method@GIRepository.CallableInfo.get_return_type]
205 : : * designed for stack allocation.
206 : : *
207 : : * The initialized @type must not be referenced after @info is deallocated.
208 : : *
209 : : * Once you are done with @type, it must be cleared using
210 : : * [method@GIRepository.BaseInfo.clear].
211 : : *
212 : : * Since: 2.80
213 : : */
214 : : void
215 : 1 : gi_callable_info_load_return_type (GICallableInfo *info,
216 : : GITypeInfo *type)
217 : : {
218 : 1 : GIRealInfo *rinfo = (GIRealInfo *)info;
219 : : uint32_t offset;
220 : :
221 : 1 : g_return_if_fail (info != NULL);
222 : 1 : g_return_if_fail (GI_IS_CALLABLE_INFO (info));
223 : :
224 : 1 : offset = signature_offset (info);
225 : :
226 : 1 : gi_type_info_init (type, (GIBaseInfo*)info, rinfo->typelib, offset);
227 : : }
228 : :
229 : : /**
230 : : * gi_callable_info_may_return_null:
231 : : * @info: a #GICallableInfo
232 : : *
233 : : * See if a callable could return `NULL`.
234 : : *
235 : : * Returns: `TRUE` if callable could return `NULL`
236 : : * Since: 2.80
237 : : */
238 : : gboolean
239 : 1 : gi_callable_info_may_return_null (GICallableInfo *info)
240 : : {
241 : 1 : GIRealInfo *rinfo = (GIRealInfo *)info;
242 : : SignatureBlob *blob;
243 : :
244 : 1 : g_return_val_if_fail (info != NULL, FALSE);
245 : 1 : g_return_val_if_fail (GI_IS_CALLABLE_INFO (info), FALSE);
246 : :
247 : 1 : blob = (SignatureBlob *)&rinfo->typelib->data[signature_offset (info)];
248 : :
249 : 1 : return blob->may_return_null;
250 : : }
251 : :
252 : : /**
253 : : * gi_callable_info_skip_return:
254 : : * @info: a #GICallableInfo
255 : : *
256 : : * See if a callable’s return value is only useful in C.
257 : : *
258 : : * Returns: `TRUE` if return value is only useful in C.
259 : : * Since: 2.80
260 : : */
261 : : gboolean
262 : 1 : gi_callable_info_skip_return (GICallableInfo *info)
263 : : {
264 : 1 : GIRealInfo *rinfo = (GIRealInfo *)info;
265 : : SignatureBlob *blob;
266 : :
267 : 1 : g_return_val_if_fail (info != NULL, FALSE);
268 : 1 : g_return_val_if_fail (GI_IS_CALLABLE_INFO (info), FALSE);
269 : :
270 : 1 : blob = (SignatureBlob *)&rinfo->typelib->data[signature_offset (info)];
271 : :
272 : 1 : return blob->skip_return;
273 : : }
274 : :
275 : : /**
276 : : * gi_callable_info_get_caller_owns:
277 : : * @info: a #GICallableInfo
278 : : *
279 : : * See whether the caller owns the return value of this callable.
280 : : *
281 : : * [type@GIRepository.Transfer] contains a list of possible transfer values.
282 : : *
283 : : * Returns: the transfer mode for the return value of the callable
284 : : * Since: 2.80
285 : : */
286 : : GITransfer
287 : 1 : gi_callable_info_get_caller_owns (GICallableInfo *info)
288 : : {
289 : 1 : GIRealInfo *rinfo = (GIRealInfo*) info;
290 : : SignatureBlob *blob;
291 : :
292 : 1 : g_return_val_if_fail (info != NULL, -1);
293 : 1 : g_return_val_if_fail (GI_IS_CALLABLE_INFO (info), -1);
294 : :
295 : 1 : blob = (SignatureBlob *)&rinfo->typelib->data[signature_offset (info)];
296 : :
297 : 1 : if (blob->caller_owns_return_value)
298 : 0 : return GI_TRANSFER_EVERYTHING;
299 : 1 : else if (blob->caller_owns_return_container)
300 : 0 : return GI_TRANSFER_CONTAINER;
301 : : else
302 : 1 : return GI_TRANSFER_NOTHING;
303 : : }
304 : :
305 : : /**
306 : : * gi_callable_info_get_instance_ownership_transfer:
307 : : * @info: a #GICallableInfo
308 : : *
309 : : * Obtains the ownership transfer for the instance argument.
310 : : *
311 : : * [type@GIRepository.Transfer] contains a list of possible transfer values.
312 : : *
313 : : * Returns: the transfer mode of the instance argument
314 : : * Since: 2.80
315 : : */
316 : : GITransfer
317 : 3 : gi_callable_info_get_instance_ownership_transfer (GICallableInfo *info)
318 : : {
319 : 3 : GIRealInfo *rinfo = (GIRealInfo*) info;
320 : : SignatureBlob *blob;
321 : :
322 : 3 : g_return_val_if_fail (info != NULL, -1);
323 : 3 : g_return_val_if_fail (GI_IS_CALLABLE_INFO (info), -1);
324 : :
325 : 3 : blob = (SignatureBlob *)&rinfo->typelib->data[signature_offset (info)];
326 : :
327 : 3 : if (blob->instance_transfer_ownership)
328 : 1 : return GI_TRANSFER_EVERYTHING;
329 : : else
330 : 2 : return GI_TRANSFER_NOTHING;
331 : : }
332 : :
333 : : /**
334 : : * gi_callable_info_get_n_args:
335 : : * @info: a #GICallableInfo
336 : : *
337 : : * Obtain the number of arguments (both ‘in’ and ‘out’) for this callable.
338 : : *
339 : : * Returns: The number of arguments this callable expects.
340 : : * Since: 2.80
341 : : */
342 : : unsigned int
343 : 7 : gi_callable_info_get_n_args (GICallableInfo *info)
344 : : {
345 : 7 : GIRealInfo *rinfo = (GIRealInfo *)info;
346 : : uint32_t offset;
347 : : SignatureBlob *blob;
348 : :
349 : 7 : g_return_val_if_fail (info != NULL, -1);
350 : 7 : g_return_val_if_fail (GI_IS_CALLABLE_INFO (info), -1);
351 : :
352 : 7 : offset = signature_offset (info);
353 : 7 : blob = (SignatureBlob *)&rinfo->typelib->data[offset];
354 : :
355 : 7 : return blob->n_arguments;
356 : : }
357 : :
358 : : /**
359 : : * gi_callable_info_get_arg:
360 : : * @info: a #GICallableInfo
361 : : * @n: the argument index to fetch
362 : : *
363 : : * Obtain information about a particular argument of this callable.
364 : : *
365 : : * Returns: (transfer full): the [class@GIRepository.ArgInfo]. Free it with
366 : : * [method@GIRepository.BaseInfo.unref] when done.
367 : : * Since: 2.80
368 : : */
369 : : GIArgInfo *
370 : 10 : gi_callable_info_get_arg (GICallableInfo *info,
371 : : unsigned int n)
372 : : {
373 : 10 : GIRealInfo *rinfo = (GIRealInfo *)info;
374 : : Header *header;
375 : : uint32_t offset;
376 : :
377 : 10 : g_return_val_if_fail (info != NULL, NULL);
378 : 10 : g_return_val_if_fail (GI_IS_CALLABLE_INFO (info), NULL);
379 : 10 : g_return_val_if_fail (n <= G_MAXUINT16, NULL);
380 : :
381 : 10 : offset = signature_offset (info);
382 : 10 : header = (Header *)rinfo->typelib->data;
383 : :
384 : 10 : return (GIArgInfo *) gi_base_info_new (GI_INFO_TYPE_ARG, (GIBaseInfo*)info, rinfo->typelib,
385 : 10 : offset + header->signature_blob_size + n * header->arg_blob_size);
386 : : }
387 : :
388 : : /**
389 : : * gi_callable_info_load_arg:
390 : : * @info: a #GICallableInfo
391 : : * @n: the argument index to fetch
392 : : * @arg: (out caller-allocates): Initialize with argument number @n
393 : : *
394 : : * Obtain information about a particular argument of this callable; this
395 : : * function is a variant of [method@GIRepository.CallableInfo.get_arg] designed
396 : : * for stack allocation.
397 : : *
398 : : * The initialized @arg must not be referenced after @info is deallocated.
399 : : *
400 : : * Once you are done with @arg, it must be cleared using
401 : : * [method@GIRepository.BaseInfo.clear].
402 : : *
403 : : * Since: 2.80
404 : : */
405 : : void
406 : 5 : gi_callable_info_load_arg (GICallableInfo *info,
407 : : unsigned int n,
408 : : GIArgInfo *arg)
409 : : {
410 : 5 : GIRealInfo *rinfo = (GIRealInfo *)info;
411 : : Header *header;
412 : : uint32_t offset;
413 : :
414 : 5 : g_return_if_fail (info != NULL);
415 : 5 : g_return_if_fail (GI_IS_CALLABLE_INFO (info));
416 : 5 : g_return_if_fail (n <= G_MAXUINT16);
417 : :
418 : 5 : offset = signature_offset (info);
419 : 5 : header = (Header *)rinfo->typelib->data;
420 : :
421 : 5 : gi_info_init ((GIRealInfo*)arg, GI_TYPE_ARG_INFO, rinfo->repository, (GIBaseInfo*)info, rinfo->typelib,
422 : 5 : offset + header->signature_blob_size + n * header->arg_blob_size);
423 : : }
424 : :
425 : : /**
426 : : * gi_callable_info_get_return_attribute:
427 : : * @info: a #GICallableInfo
428 : : * @name: a freeform string naming an attribute
429 : : *
430 : : * Retrieve an arbitrary attribute associated with the return value.
431 : : *
432 : : * Returns: (nullable): The value of the attribute, or `NULL` if no such
433 : : * attribute exists
434 : : * Since: 2.80
435 : : */
436 : : const char *
437 : 1 : gi_callable_info_get_return_attribute (GICallableInfo *info,
438 : : const char *name)
439 : : {
440 : 1 : GIAttributeIter iter = GI_ATTRIBUTE_ITER_INIT;
441 : : const char *curname, *curvalue;
442 : 1 : while (gi_callable_info_iterate_return_attributes (info, &iter, &curname, &curvalue))
443 : : {
444 : 0 : if (g_strcmp0 (name, curname) == 0)
445 : 0 : return (const char*) curvalue;
446 : : }
447 : :
448 : 1 : return NULL;
449 : : }
450 : :
451 : : /**
452 : : * gi_callable_info_iterate_return_attributes:
453 : : * @info: a #GICallableInfo
454 : : * @iterator: (inout): a [type@GIRepository.AttributeIter] structure, must be
455 : : * initialized; see below
456 : : * @name: (out) (transfer none): Returned name, must not be freed
457 : : * @value: (out) (transfer none): Returned name, must not be freed
458 : : *
459 : : * Iterate over all attributes associated with the return value.
460 : : *
461 : : * The iterator structure is typically stack allocated, and must have its
462 : : * first member initialized to `NULL`.
463 : : *
464 : : * Both the @name and @value should be treated as constants
465 : : * and must not be freed.
466 : : *
467 : : * See [method@GIRepository.BaseInfo.iterate_attributes] for an example of how
468 : : * to use a similar API.
469 : : *
470 : : * Returns: `TRUE` if there are more attributes
471 : : * Since: 2.80
472 : : */
473 : : gboolean
474 : 2 : gi_callable_info_iterate_return_attributes (GICallableInfo *info,
475 : : GIAttributeIter *iterator,
476 : : const char **name,
477 : : const char **value)
478 : : {
479 : 2 : GIRealInfo *rinfo = (GIRealInfo *)info;
480 : 2 : Header *header = (Header *)rinfo->typelib->data;
481 : : AttributeBlob *next, *after;
482 : : uint32_t blob_offset;
483 : :
484 : 2 : after = (AttributeBlob *) &rinfo->typelib->data[header->attributes +
485 : 2 : header->n_attributes * header->attribute_blob_size];
486 : :
487 : 2 : blob_offset = signature_offset (info);
488 : :
489 : 2 : if (iterator->data != NULL)
490 : 0 : next = (AttributeBlob *) iterator->data;
491 : : else
492 : 2 : next = _attribute_blob_find_first ((GIBaseInfo *) info, blob_offset);
493 : :
494 : 2 : if (next == NULL || next->offset != blob_offset || next >= after)
495 : 2 : return FALSE;
496 : :
497 : 0 : *name = gi_typelib_get_string (rinfo->typelib, next->name);
498 : 0 : *value = gi_typelib_get_string (rinfo->typelib, next->value);
499 : 0 : iterator->data = next + 1;
500 : :
501 : 0 : return TRUE;
502 : : }
503 : :
504 : : /**
505 : : * gi_type_tag_extract_ffi_return_value:
506 : : * @return_tag: [type@GIRepository.TypeTag] of the return value
507 : : * @interface_type: [type@GObject.Type] of the underlying interface type
508 : : * @ffi_value: pointer to [type@GIRepository.FFIReturnValue] union containing
509 : : * the return value from `ffi_call()`
510 : : * @arg: (out caller-allocates): pointer to an allocated
511 : : * [class@GIRepository.Argument]
512 : : *
513 : : * Extract the correct bits from an `ffi_arg` return value into
514 : : * [class@GIRepository.Argument].
515 : : *
516 : : * See: https://bugzilla.gnome.org/show_bug.cgi?id=665152
517 : : *
518 : : * Also see [`ffi_call()`](man:ffi_call(3)): the storage requirements for return
519 : : * values are ‘special’.
520 : : *
521 : : * The @interface_type argument only applies if @return_tag is
522 : : * `GI_TYPE_TAG_INTERFACE`. Otherwise it is ignored.
523 : : *
524 : : * Since: 2.80
525 : : */
526 : : void
527 : 0 : gi_type_tag_extract_ffi_return_value (GITypeTag return_tag,
528 : : GType interface_type,
529 : : GIFFIReturnValue *ffi_value,
530 : : GIArgument *arg)
531 : : {
532 : 0 : switch (return_tag) {
533 : 0 : case GI_TYPE_TAG_INT8:
534 : 0 : arg->v_int8 = (int8_t) ffi_value->v_long;
535 : 0 : break;
536 : 0 : case GI_TYPE_TAG_UINT8:
537 : 0 : arg->v_uint8 = (uint8_t) ffi_value->v_ulong;
538 : 0 : break;
539 : 0 : case GI_TYPE_TAG_INT16:
540 : 0 : arg->v_int16 = (int16_t) ffi_value->v_long;
541 : 0 : break;
542 : 0 : case GI_TYPE_TAG_UINT16:
543 : 0 : arg->v_uint16 = (uint16_t) ffi_value->v_ulong;
544 : 0 : break;
545 : 0 : case GI_TYPE_TAG_INT32:
546 : 0 : arg->v_int32 = (int32_t) ffi_value->v_long;
547 : 0 : break;
548 : 0 : case GI_TYPE_TAG_UINT32:
549 : : case GI_TYPE_TAG_BOOLEAN:
550 : : case GI_TYPE_TAG_UNICHAR:
551 : 0 : arg->v_uint32 = (uint32_t) ffi_value->v_ulong;
552 : 0 : break;
553 : 0 : case GI_TYPE_TAG_INT64:
554 : 0 : arg->v_int64 = (int64_t) ffi_value->v_int64;
555 : 0 : break;
556 : 0 : case GI_TYPE_TAG_UINT64:
557 : 0 : arg->v_uint64 = (uint64_t) ffi_value->v_uint64;
558 : 0 : break;
559 : 0 : case GI_TYPE_TAG_FLOAT:
560 : 0 : arg->v_float = ffi_value->v_float;
561 : 0 : break;
562 : 0 : case GI_TYPE_TAG_DOUBLE:
563 : 0 : arg->v_double = ffi_value->v_double;
564 : 0 : break;
565 : 0 : case GI_TYPE_TAG_INTERFACE:
566 : 0 : if (interface_type == GI_TYPE_ENUM_INFO ||
567 : 0 : interface_type == GI_TYPE_FLAGS_INFO)
568 : 0 : arg->v_int32 = (int32_t) ffi_value->v_long;
569 : : else
570 : 0 : arg->v_pointer = (void *) ffi_value->v_pointer;
571 : 0 : break;
572 : 0 : default:
573 : 0 : arg->v_pointer = (void *) ffi_value->v_pointer;
574 : 0 : break;
575 : : }
576 : 0 : }
577 : :
578 : : /**
579 : : * gi_type_info_extract_ffi_return_value:
580 : : * @return_info: [type@GIRepository.TypeInfo] describing the return type
581 : : * @ffi_value: pointer to [type@GIRepository.FFIReturnValue] union containing
582 : : * the return value from `ffi_call()`
583 : : * @arg: (out caller-allocates): pointer to an allocated
584 : : * [class@GIRepository.Argument]
585 : : *
586 : : * Extract the correct bits from an `ffi_arg` return value into
587 : : * [class@GIRepository.Argument].
588 : : *
589 : : * See: https://bugzilla.gnome.org/show_bug.cgi?id=665152
590 : : *
591 : : * Also see [`ffi_call()`](man:ffi_call(3)): the storage requirements for return
592 : : * values are ‘special’.
593 : : *
594 : : * Since: 2.80
595 : : */
596 : : void
597 : 0 : gi_type_info_extract_ffi_return_value (GITypeInfo *return_info,
598 : : GIFFIReturnValue *ffi_value,
599 : : GIArgument *arg)
600 : : {
601 : 0 : GITypeTag return_tag = gi_type_info_get_tag (return_info);
602 : 0 : GType interface_type = G_TYPE_INVALID;
603 : :
604 : 0 : if (return_tag == GI_TYPE_TAG_INTERFACE)
605 : : {
606 : 0 : GIBaseInfo *interface_info = gi_type_info_get_interface (return_info);
607 : 0 : interface_type = G_TYPE_FROM_INSTANCE (interface_info);
608 : 0 : gi_base_info_unref (interface_info);
609 : : }
610 : :
611 : 0 : gi_type_tag_extract_ffi_return_value (return_tag, interface_type,
612 : : ffi_value, arg);
613 : 0 : }
614 : :
615 : : /**
616 : : * gi_callable_info_invoke:
617 : : * @info: a #GICallableInfo
618 : : * @function: function pointer to call
619 : : * @in_args: (array length=n_in_args): array of ‘in’ arguments
620 : : * @n_in_args: number of arguments in @in_args
621 : : * @out_args: (array length=n_out_args): array of ‘out’ arguments allocated by
622 : : * the caller, to be populated with outputted values
623 : : * @n_out_args: number of arguments in @out_args
624 : : * @return_value: (out caller-allocates) (not optional) (nullable): return
625 : : * location for the return value from the callable; `NULL` may be returned if
626 : : * the callable returns that
627 : : * @error: return location for a [type@GLib.Error], or `NULL`
628 : : *
629 : : * Invoke the given `GICallableInfo` by calling the given @function pointer.
630 : : *
631 : : * The set of arguments passed to @function will be constructed according to the
632 : : * introspected type of the `GICallableInfo`, using @in_args, @out_args
633 : : * and @error.
634 : : *
635 : : * Returns: `TRUE` if the callable was executed successfully and didn’t throw
636 : : * a [type@GLib.Error]; `FALSE` if @error is set
637 : : * Since: 2.80
638 : : */
639 : : gboolean
640 : 1 : gi_callable_info_invoke (GICallableInfo *info,
641 : : void *function,
642 : : const GIArgument *in_args,
643 : : size_t n_in_args,
644 : : GIArgument *out_args,
645 : : size_t n_out_args,
646 : : GIArgument *return_value,
647 : : GError **error)
648 : : {
649 : : ffi_cif cif;
650 : : ffi_type *rtype;
651 : : ffi_type **atypes;
652 : : GITypeInfo *tinfo;
653 : : GITypeInfo *rinfo;
654 : : GITypeTag rtag;
655 : : GIArgInfo *ainfo;
656 : : unsigned int n_args, n_invoke_args, in_pos, out_pos, i;
657 : : void **args;
658 : 1 : gboolean success = FALSE;
659 : 1 : GError *local_error = NULL;
660 : 1 : void *error_address = &local_error;
661 : : GIFFIReturnValue ffi_return_value;
662 : : void *return_value_p; /* Will point inside the union return_value */
663 : : gboolean is_method, throws;
664 : :
665 : 1 : rinfo = gi_callable_info_get_return_type ((GICallableInfo *)info);
666 : 1 : rtype = gi_type_info_get_ffi_type (rinfo);
667 : 1 : rtag = gi_type_info_get_tag(rinfo);
668 : 1 : is_method = gi_callable_info_is_method (info);
669 : 1 : throws = gi_callable_info_can_throw_gerror (info);
670 : :
671 : 1 : in_pos = 0;
672 : 1 : out_pos = 0;
673 : :
674 : 1 : n_args = gi_callable_info_get_n_args ((GICallableInfo *)info);
675 : 1 : if (is_method)
676 : : {
677 : 0 : if (n_in_args == 0)
678 : : {
679 : 0 : g_set_error (error,
680 : : GI_INVOKE_ERROR,
681 : : GI_INVOKE_ERROR_ARGUMENT_MISMATCH,
682 : : "Too few \"in\" arguments (handling this)");
683 : 0 : goto out;
684 : : }
685 : 0 : n_invoke_args = n_args+1;
686 : 0 : in_pos++;
687 : : }
688 : : else
689 : 1 : n_invoke_args = n_args;
690 : :
691 : 1 : if (throws)
692 : : /* Add an argument for the GError */
693 : 1 : n_invoke_args ++;
694 : :
695 : 1 : atypes = g_alloca (sizeof (ffi_type*) * n_invoke_args);
696 : 1 : args = g_alloca (sizeof (void *) * n_invoke_args);
697 : :
698 : 1 : if (is_method)
699 : : {
700 : 0 : atypes[0] = &ffi_type_pointer;
701 : 0 : args[0] = (void *) &in_args[0];
702 : : }
703 : 2 : for (i = 0; i < n_args; i++)
704 : : {
705 : 1 : int offset = (is_method ? 1 : 0);
706 : 1 : ainfo = gi_callable_info_get_arg ((GICallableInfo *)info, i);
707 : 1 : switch (gi_arg_info_get_direction (ainfo))
708 : : {
709 : 1 : case GI_DIRECTION_IN:
710 : 1 : tinfo = gi_arg_info_get_type_info (ainfo);
711 : 1 : atypes[i+offset] = gi_type_info_get_ffi_type (tinfo);
712 : 1 : gi_base_info_unref ((GIBaseInfo *)ainfo);
713 : 1 : gi_base_info_unref ((GIBaseInfo *)tinfo);
714 : :
715 : 1 : if (in_pos >= n_in_args)
716 : : {
717 : 0 : g_set_error (error,
718 : : GI_INVOKE_ERROR,
719 : : GI_INVOKE_ERROR_ARGUMENT_MISMATCH,
720 : : "Too few \"in\" arguments (handling in)");
721 : 0 : goto out;
722 : : }
723 : :
724 : 1 : args[i+offset] = (void *)&in_args[in_pos];
725 : 1 : in_pos++;
726 : :
727 : 1 : break;
728 : 0 : case GI_DIRECTION_OUT:
729 : 0 : atypes[i+offset] = &ffi_type_pointer;
730 : 0 : gi_base_info_unref ((GIBaseInfo *)ainfo);
731 : :
732 : 0 : if (out_pos >= n_out_args)
733 : : {
734 : 0 : g_set_error (error,
735 : : GI_INVOKE_ERROR,
736 : : GI_INVOKE_ERROR_ARGUMENT_MISMATCH,
737 : : "Too few \"out\" arguments (handling out)");
738 : 0 : goto out;
739 : : }
740 : :
741 : 0 : args[i+offset] = (void *)&out_args[out_pos];
742 : 0 : out_pos++;
743 : 0 : break;
744 : 0 : case GI_DIRECTION_INOUT:
745 : 0 : atypes[i+offset] = &ffi_type_pointer;
746 : 0 : gi_base_info_unref ((GIBaseInfo *)ainfo);
747 : :
748 : 0 : if (in_pos >= n_in_args)
749 : : {
750 : 0 : g_set_error (error,
751 : : GI_INVOKE_ERROR,
752 : : GI_INVOKE_ERROR_ARGUMENT_MISMATCH,
753 : : "Too few \"in\" arguments (handling inout)");
754 : 0 : goto out;
755 : : }
756 : :
757 : 0 : if (out_pos >= n_out_args)
758 : : {
759 : 0 : g_set_error (error,
760 : : GI_INVOKE_ERROR,
761 : : GI_INVOKE_ERROR_ARGUMENT_MISMATCH,
762 : : "Too few \"out\" arguments (handling inout)");
763 : 0 : goto out;
764 : : }
765 : :
766 : 0 : args[i+offset] = (void *)&in_args[in_pos];
767 : 0 : in_pos++;
768 : 0 : out_pos++;
769 : 0 : break;
770 : 0 : default:
771 : 0 : gi_base_info_unref ((GIBaseInfo *)ainfo);
772 : : g_assert_not_reached ();
773 : : }
774 : : }
775 : :
776 : 1 : if (throws)
777 : : {
778 : 1 : args[n_invoke_args - 1] = &error_address;
779 : 1 : atypes[n_invoke_args - 1] = &ffi_type_pointer;
780 : : }
781 : :
782 : 1 : if (in_pos < n_in_args)
783 : : {
784 : 0 : g_set_error (error,
785 : : GI_INVOKE_ERROR,
786 : : GI_INVOKE_ERROR_ARGUMENT_MISMATCH,
787 : : "Too many \"in\" arguments (at end)");
788 : 0 : goto out;
789 : : }
790 : 1 : if (out_pos < n_out_args)
791 : : {
792 : 0 : g_set_error (error,
793 : : GI_INVOKE_ERROR,
794 : : GI_INVOKE_ERROR_ARGUMENT_MISMATCH,
795 : : "Too many \"out\" arguments (at end)");
796 : 0 : goto out;
797 : : }
798 : :
799 : 1 : if (ffi_prep_cif (&cif, FFI_DEFAULT_ABI, n_invoke_args, rtype, atypes) != FFI_OK)
800 : 0 : goto out;
801 : :
802 : 1 : g_return_val_if_fail (return_value, FALSE);
803 : : /* See comment for GIFFIReturnValue above */
804 : 1 : switch (rtag)
805 : : {
806 : 0 : case GI_TYPE_TAG_FLOAT:
807 : 0 : return_value_p = &ffi_return_value.v_float;
808 : 0 : break;
809 : 0 : case GI_TYPE_TAG_DOUBLE:
810 : 0 : return_value_p = &ffi_return_value.v_double;
811 : 0 : break;
812 : 0 : case GI_TYPE_TAG_INT64:
813 : : case GI_TYPE_TAG_UINT64:
814 : 0 : return_value_p = &ffi_return_value.v_uint64;
815 : 0 : break;
816 : 1 : default:
817 : 1 : return_value_p = &ffi_return_value.v_long;
818 : : }
819 : 1 : ffi_call (&cif, function, return_value_p, args);
820 : :
821 : 1 : if (local_error)
822 : : {
823 : 1 : g_propagate_error (error, local_error);
824 : 1 : success = FALSE;
825 : : }
826 : : else
827 : : {
828 : 0 : gi_type_info_extract_ffi_return_value (rinfo, &ffi_return_value, return_value);
829 : 0 : success = TRUE;
830 : : }
831 : 1 : out:
832 : 1 : gi_base_info_unref ((GIBaseInfo *)rinfo);
833 : 1 : return success;
834 : : }
835 : :
836 : : void
837 : 8 : gi_callable_info_class_init (gpointer g_class,
838 : : gpointer class_data)
839 : : {
840 : 8 : GIBaseInfoClass *info_class = g_class;
841 : :
842 : 8 : info_class->info_type = GI_INFO_TYPE_CALLABLE;
843 : 8 : }
844 : :
845 : : static GICallableInfo *
846 : 9 : get_method_callable_info_for_index (GIBaseInfo *rinfo,
847 : : unsigned int index)
848 : : {
849 : 9 : GIBaseInfo *container = rinfo->container;
850 : :
851 : 9 : g_assert (container);
852 : :
853 : 9 : if (GI_IS_OBJECT_INFO (container))
854 : 0 : return (GICallableInfo *) gi_object_info_get_method ((GIObjectInfo *) container, index);
855 : :
856 : 9 : if (GI_IS_INTERFACE_INFO (container))
857 : 9 : return (GICallableInfo *) gi_interface_info_get_method ((GIInterfaceInfo *) container,
858 : : index);
859 : :
860 : 0 : return NULL;
861 : : }
862 : :
863 : : static GICallableInfo *
864 : 9 : get_callable_info_for_index (GIBaseInfo *rinfo,
865 : : unsigned int index)
866 : : {
867 : 9 : if (!rinfo->container)
868 : : {
869 : 0 : GIBaseInfo *info = gi_info_from_entry (rinfo->repository, rinfo->typelib, index);
870 : :
871 : 0 : g_assert (GI_IS_CALLABLE_INFO (info));
872 : :
873 : 0 : return (GICallableInfo *) info;
874 : : }
875 : :
876 : 9 : return get_method_callable_info_for_index (rinfo, index);
877 : : }
878 : :
879 : : /**
880 : : * gi_callable_info_get_async_function
881 : : * @info: a callable info structure
882 : : *
883 : : * Gets the callable info for the callable's asynchronous version
884 : : *
885 : : * Returns: (transfer full) (nullable): a [class@GIRepository.CallableInfo] for the
886 : : * async function or `NULL` if not defined.
887 : : * Since: 2.84
888 : : */
889 : : GICallableInfo *
890 : 5 : gi_callable_info_get_async_function (GICallableInfo *info)
891 : : {
892 : 5 : GIBaseInfo *rinfo = (GIBaseInfo *) info;
893 : :
894 : 5 : switch (gi_base_info_get_info_type (rinfo))
895 : : {
896 : 5 : case GI_INFO_TYPE_FUNCTION:
897 : : {
898 : 5 : FunctionBlob *blob = GET_BLOB (FunctionBlob, rinfo);
899 : 5 : if (blob->is_async || blob->sync_or_async == ASYNC_SENTINEL)
900 : 1 : return NULL;
901 : :
902 : 4 : return get_callable_info_for_index (rinfo, blob->sync_or_async);
903 : : }
904 : 0 : case GI_INFO_TYPE_VFUNC:
905 : : {
906 : 0 : VFuncBlob *blob = GET_BLOB (VFuncBlob, rinfo);
907 : 0 : if (blob->is_async || blob->sync_or_async == ASYNC_SENTINEL)
908 : 0 : return NULL;
909 : :
910 : 0 : return get_method_callable_info_for_index (rinfo, blob->sync_or_async);
911 : : }
912 : 0 : case GI_INFO_TYPE_CALLBACK:
913 : : case GI_INFO_TYPE_SIGNAL:
914 : 0 : return NULL;
915 : 0 : default:
916 : : g_assert_not_reached ();
917 : : }
918 : : }
919 : :
920 : : /**
921 : : * gi_callable_info_get_sync_function
922 : : * @info: a callable info structure
923 : : *
924 : : * Gets the callable info for the callable's synchronous version
925 : : *
926 : : * Returns: (transfer full) (nullable): a [class@GIRepository.CallableInfo] for the
927 : : * sync function or `NULL` if not defined.
928 : : * Since: 2.84
929 : : */
930 : : GICallableInfo *
931 : 5 : gi_callable_info_get_sync_function (GICallableInfo *info)
932 : : {
933 : 5 : GIBaseInfo *rinfo = (GIBaseInfo *) info;
934 : :
935 : 5 : switch (gi_base_info_get_info_type (rinfo))
936 : : {
937 : 5 : case GI_INFO_TYPE_FUNCTION:
938 : : {
939 : 5 : FunctionBlob *blob = GET_BLOB (FunctionBlob, rinfo);
940 : 5 : if (!blob->is_async || blob->sync_or_async == ASYNC_SENTINEL)
941 : 2 : return NULL;
942 : :
943 : 3 : return get_callable_info_for_index (rinfo, blob->sync_or_async);
944 : : }
945 : 0 : case GI_INFO_TYPE_VFUNC:
946 : : {
947 : 0 : VFuncBlob *blob = GET_BLOB (VFuncBlob, rinfo);
948 : 0 : if (!blob->is_async || blob->sync_or_async == ASYNC_SENTINEL)
949 : 0 : return NULL;
950 : :
951 : 0 : return get_method_callable_info_for_index (rinfo, blob->sync_or_async);
952 : : }
953 : 0 : case GI_INFO_TYPE_CALLBACK:
954 : : case GI_INFO_TYPE_SIGNAL:
955 : 0 : return NULL;
956 : 0 : default:
957 : : g_assert_not_reached ();
958 : : }
959 : : }
960 : :
961 : : /**
962 : : * gi_callable_info_get_finish_function
963 : : * @info: a callable info structure
964 : : *
965 : : * Gets the info for an async function's corresponding finish function
966 : : *
967 : : * Returns: (transfer full) (nullable): a [class@GIRepository.CallableInfo] for the
968 : : * finish function or `NULL` if not defined.
969 : : * Since: 2.84
970 : : */
971 : : GICallableInfo *
972 : 4 : gi_callable_info_get_finish_function (GICallableInfo *info)
973 : : {
974 : 4 : GIBaseInfo *rinfo = (GIBaseInfo *) info;
975 : :
976 : 4 : switch (gi_base_info_get_info_type (rinfo))
977 : : {
978 : 4 : case GI_INFO_TYPE_FUNCTION:
979 : : {
980 : 4 : FunctionBlob *blob = GET_BLOB (FunctionBlob, rinfo);
981 : 4 : if (!blob->is_async || blob->finish == ASYNC_SENTINEL)
982 : 2 : return NULL;
983 : :
984 : 2 : return get_callable_info_for_index (rinfo, blob->finish);
985 : : }
986 : 0 : case GI_INFO_TYPE_VFUNC:
987 : : {
988 : 0 : VFuncBlob *blob = GET_BLOB (VFuncBlob, rinfo);
989 : 0 : if (!blob->is_async || blob->finish == ASYNC_SENTINEL)
990 : 0 : return NULL;
991 : :
992 : 0 : return get_method_callable_info_for_index (rinfo, blob->finish);
993 : : }
994 : 0 : case GI_INFO_TYPE_CALLBACK:
995 : : case GI_INFO_TYPE_SIGNAL:
996 : 0 : return NULL;
997 : 0 : default:
998 : : g_assert_not_reached ();
999 : : }
1000 : : }
1001 : :
1002 : : /**
1003 : : * gi_callable_info_is_async
1004 : : * @info: a callable info structure
1005 : : *
1006 : : * Gets whether a callable is ‘async’. Async callables have a
1007 : : * [type@Gio.AsyncReadyCallback] parameter and user data.
1008 : : *
1009 : : * Returns: true if the callable is async
1010 : : * Since: 2.84
1011 : : */
1012 : : gboolean
1013 : 1 : gi_callable_info_is_async (GICallableInfo *callable_info)
1014 : : {
1015 : 1 : GIBaseInfo *info = (GIBaseInfo *) callable_info;
1016 : 1 : switch (gi_base_info_get_info_type ((GIBaseInfo *) callable_info))
1017 : : {
1018 : 1 : case GI_INFO_TYPE_FUNCTION:
1019 : : {
1020 : 1 : return GET_BLOB (FunctionBlob, info)->is_async;
1021 : : }
1022 : 0 : case GI_INFO_TYPE_VFUNC:
1023 : : {
1024 : 0 : return GET_BLOB (VFuncBlob, info)->is_async;
1025 : : }
1026 : 0 : case GI_INFO_TYPE_CALLBACK:
1027 : : case GI_INFO_TYPE_SIGNAL:
1028 : 0 : return FALSE;
1029 : 0 : default:
1030 : : g_assert_not_reached ();
1031 : : }
1032 : : }
1033 : :
|
