gobject-introspection 3.3.8 → 3.3.9

Sign up to get free protection for your applications and to get access to all the features.
Files changed (33) hide show
  1. checksums.yaml +4 -4
  2. data/ext/gobject-introspection/extconf.rb +4 -4
  3. data/ext/gobject-introspection/gobject_introspection.def +2 -1
  4. data/ext/gobject-introspection/rb-gi-arg-info.c +33 -1
  5. data/ext/gobject-introspection/rb-gi-argument.c +384 -3291
  6. data/ext/gobject-introspection/rb-gi-arguments-in.c +2229 -0
  7. data/ext/gobject-introspection/rb-gi-arguments-out.c +929 -0
  8. data/ext/gobject-introspection/rb-gi-arguments.c +850 -0
  9. data/ext/gobject-introspection/rb-gi-array-type.c +54 -0
  10. data/ext/gobject-introspection/rb-gi-callback.c +242 -0
  11. data/ext/gobject-introspection/rb-gi-conversions.h +0 -43
  12. data/ext/gobject-introspection/rb-gi-direction.c +36 -0
  13. data/ext/gobject-introspection/rb-gi-field-info.c +172 -81
  14. data/ext/gobject-introspection/rb-gi-function-info.c +15 -1404
  15. data/ext/gobject-introspection/rb-gi-private-arg-info.h +24 -0
  16. data/ext/gobject-introspection/rb-gi-private-arguments-in.h +26 -0
  17. data/ext/gobject-introspection/rb-gi-private-arguments-out.h +28 -0
  18. data/ext/gobject-introspection/rb-gi-private-arguments.h +107 -0
  19. data/ext/gobject-introspection/rb-gi-private-array-type.h +26 -0
  20. data/ext/gobject-introspection/rb-gi-private-callback.h +41 -0
  21. data/ext/gobject-introspection/rb-gi-private-direction.h +24 -0
  22. data/ext/gobject-introspection/rb-gi-private-transfer.h +24 -0
  23. data/ext/gobject-introspection/rb-gi-private.h +11 -5
  24. data/ext/gobject-introspection/rb-gi-struct-info.c +2 -0
  25. data/ext/gobject-introspection/rb-gi-transfer.c +36 -0
  26. data/ext/gobject-introspection/rb-gi-type-info.c +1 -13
  27. data/ext/gobject-introspection/rb-gobject-introspection.c +4 -1
  28. data/ext/gobject-introspection/rb-gobject-introspection.h +5 -23
  29. data/lib/gobject-introspection/arg-info.rb +2 -0
  30. data/lib/gobject-introspection/callable-info.rb +1 -1
  31. data/lib/gobject-introspection/loader.rb +0 -39
  32. data/lib/gobject-introspection/type-tag.rb +39 -2
  33. metadata +21 -5
data/ext/gobject-introspection/rb-gi-arguments-out.c ADDED
@@ -0,0 +1,929 @@
1
+ /* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
2
+ /*
3
+ * Copyright (C) 2012-2019 Ruby-GNOME Project Team
4
+ *
5
+ * This library is free software; you can redistribute it and/or
6
+ * modify it under the terms of the GNU Lesser General Public
7
+ * License as published by the Free Software Foundation; either
8
+ * version 2.1 of the License, or (at your option) any later version.
9
+ *
10
+ * This library is distributed in the hope that it will be useful,
11
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
12
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13
+ * Lesser General Public License for more details.
14
+ *
15
+ * You should have received a copy of the GNU Lesser General Public
16
+ * License along with this library; if not, write to the Free Software
17
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
18
+ * MA 02110-1301 USA
19
+ */
20
+
21
+ #include "rb-gi-private.h"
22
+
23
+ static void
24
+ rb_gi_arguments_out_free_immediate_value(RBGIArguments *args,
25
+ RBGIArgMetadata *metadata,
26
+ gpointer user_data)
27
+ {
28
+ xfree(metadata->out_arg->v_pointer);
29
+ }
30
+
31
+ static void
32
+ rb_gi_arguments_out_free_string(RBGIArguments *args,
33
+ RBGIArgMetadata *metadata,
34
+ gpointer user_data)
35
+ {
36
+ gchar **target = metadata->out_arg->v_pointer;
37
+ if (metadata->transfer != GI_TRANSFER_NOTHING) {
38
+ g_free(*target);
39
+ }
40
+ xfree(target);
41
+ }
42
+
43
+ static void
44
+ rb_gi_arguments_out_free_array_c_uint8(RBGIArguments *args,
45
+ RBGIArgMetadata *metadata,
46
+ gpointer user_data)
47
+ {
48
+ guint8 **target = metadata->out_arg->v_pointer;
49
+ switch (metadata->transfer) {
50
+ case GI_TRANSFER_NOTHING:
51
+ break;
52
+ case GI_TRANSFER_CONTAINER:
53
+ case GI_TRANSFER_EVERYTHING:
54
+ g_free(*target);
55
+ break;
56
+ default:
57
+ rb_raise(rb_eNotImpError,
58
+ "TODO: [%s] %s free GIArgument(%s)[%s]",
59
+ metadata->name,
60
+ rb_gi_direction_to_string(metadata->direction),
61
+ g_type_tag_to_string(metadata->type.tag),
62
+ rb_gi_transfer_to_string(metadata->transfer));
63
+ }
64
+ xfree(target);
65
+ }
66
+
67
+ static void
68
+ rb_gi_arguments_out_free_array_c_string(RBGIArguments *args,
69
+ RBGIArgMetadata *metadata,
70
+ gpointer user_data)
71
+ {
72
+ gchar ***target = metadata->out_arg->v_pointer;
73
+ switch (metadata->transfer) {
74
+ case GI_TRANSFER_NOTHING:
75
+ break;
76
+ case GI_TRANSFER_CONTAINER:
77
+ g_free(*target);
78
+ break;
79
+ case GI_TRANSFER_EVERYTHING:
80
+ g_strfreev(*target);
81
+ break;
82
+ default:
83
+ rb_raise(rb_eNotImpError,
84
+ "TODO: [%s] %s free GIArgument(%s)[%s]",
85
+ metadata->name,
86
+ rb_gi_direction_to_string(metadata->direction),
87
+ g_type_tag_to_string(metadata->type.tag),
88
+ rb_gi_transfer_to_string(metadata->transfer));
89
+ }
90
+ xfree(target);
91
+ }
92
+
93
+ static void
94
+ rb_gi_arguments_out_free_array_c_interface(RBGIArguments *args,
95
+ RBGIArgMetadata *metadata,
96
+ gpointer user_data)
97
+ {
98
+ gpointer **target = metadata->out_arg->v_pointer;
99
+ switch (metadata->transfer) {
100
+ case GI_TRANSFER_NOTHING:
101
+ break;
102
+ case GI_TRANSFER_CONTAINER:
103
+ g_free(*target);
104
+ break;
105
+ case GI_TRANSFER_EVERYTHING:
106
+ default:
107
+ rb_raise(rb_eNotImpError,
108
+ "TODO: [%s] %s free GIArgument(%s)[%s]",
109
+ metadata->name,
110
+ rb_gi_direction_to_string(metadata->direction),
111
+ g_type_tag_to_string(metadata->type.tag),
112
+ rb_gi_transfer_to_string(metadata->transfer));
113
+ }
114
+ xfree(target);
115
+ }
116
+
117
+ static void
118
+ rb_gi_arguments_out_free_array_array_interface_struct(RBGIArguments *args,
119
+ RBGIArgMetadata *metadata,
120
+ gpointer user_data)
121
+ {
122
+ GArray *target = metadata->out_arg->v_pointer;
123
+ switch (metadata->transfer) {
124
+ case GI_TRANSFER_NOTHING:
125
+ break;
126
+ case GI_TRANSFER_CONTAINER:
127
+ case GI_TRANSFER_EVERYTHING:
128
+ default:
129
+ rb_raise(rb_eNotImpError,
130
+ "TODO: [%s] %s free GIArgument(%s)[%s]",
131
+ metadata->name,
132
+ rb_gi_direction_to_string(metadata->direction),
133
+ g_type_tag_to_string(metadata->type.tag),
134
+ rb_gi_transfer_to_string(metadata->transfer));
135
+ }
136
+ g_array_free(target, TRUE);
137
+ }
138
+
139
+ static void
140
+ rb_gi_arguments_out_free_interface_struct(RBGIArguments *args,
141
+ RBGIArgMetadata *metadata,
142
+ gpointer user_data)
143
+ {
144
+ gpointer *target = metadata->out_arg->v_pointer;
145
+ GType gtype = metadata->type.interface_gtype;
146
+ switch (metadata->transfer) {
147
+ case GI_TRANSFER_NOTHING:
148
+ break;
149
+ case GI_TRANSFER_CONTAINER:
150
+ case GI_TRANSFER_EVERYTHING:
151
+ if (gtype == G_TYPE_VALUE) {
152
+ g_value_unset((GValue *)target);
153
+ break;
154
+ } else if (G_TYPE_IS_BOXED(gtype)) {
155
+ if (*target) {
156
+ g_boxed_free(gtype, *target);
157
+ }
158
+ break;
159
+ }
160
+ default:
161
+ rb_raise(rb_eNotImpError,
162
+ "TODO: [%s] %s free GIArgument(%s)[%s]",
163
+ metadata->name,
164
+ rb_gi_direction_to_string(metadata->direction),
165
+ g_type_tag_to_string(metadata->type.tag),
166
+ rb_gi_transfer_to_string(metadata->transfer));
167
+ break;
168
+ }
169
+ xfree(target);
170
+ }
171
+
172
+ static void
173
+ rb_gi_arguments_out_free_interface_object(RBGIArguments *args,
174
+ RBGIArgMetadata *metadata,
175
+ gpointer user_data)
176
+ {
177
+ GObject **target = metadata->out_arg->v_pointer;
178
+ switch (metadata->transfer) {
179
+ case GI_TRANSFER_NOTHING:
180
+ break;
181
+ case GI_TRANSFER_CONTAINER:
182
+ case GI_TRANSFER_EVERYTHING:
183
+ if (*target) {
184
+ g_object_unref(*target);
185
+ }
186
+ break;
187
+ default:
188
+ rb_raise(rb_eNotImpError,
189
+ "TODO: [%s] %s free GIArgument(%s)[%s]",
190
+ metadata->name,
191
+ rb_gi_direction_to_string(metadata->direction),
192
+ g_type_tag_to_string(metadata->type.tag),
193
+ rb_gi_transfer_to_string(metadata->transfer));
194
+ }
195
+ xfree(target);
196
+ }
197
+
198
+ static void
199
+ rb_gi_arguments_out_free_list(RBGIArguments *args,
200
+ RBGIArgMetadata *metadata,
201
+ gpointer user_data)
202
+ {
203
+ gpointer *target = metadata->out_arg->v_pointer;
204
+ switch (metadata->transfer) {
205
+ case GI_TRANSFER_NOTHING:
206
+ break;
207
+ case GI_TRANSFER_CONTAINER:
208
+ if (metadata->type.tag == GI_TYPE_TAG_GLIST) {
209
+ g_list_free(*((GList **)target));
210
+ } else {
211
+ g_slist_free(*((GSList **)target));
212
+ }
213
+ break;
214
+ default:
215
+ rb_raise(rb_eNotImpError,
216
+ "TODO: [%s] %s free GIArgument(%s)[%s]",
217
+ metadata->name,
218
+ rb_gi_direction_to_string(metadata->direction),
219
+ g_type_tag_to_string(metadata->type.tag),
220
+ rb_gi_transfer_to_string(metadata->transfer));
221
+ break;
222
+ }
223
+ xfree(target);
224
+ }
225
+
226
+ static void
227
+ rb_gi_arguments_out_free_hash(RBGIArguments *args,
228
+ RBGIArgMetadata *metadata,
229
+ gpointer user_data)
230
+ {
231
+ GHashTable *target = metadata->out_arg->v_pointer;
232
+ if (metadata->transfer != GI_TRANSFER_NOTHING) {
233
+ rb_raise(rb_eNotImpError,
234
+ "TODO: [%s] %s free GIArgument(%s)[%s]",
235
+ metadata->name,
236
+ rb_gi_direction_to_string(metadata->direction),
237
+ g_type_tag_to_string(metadata->type.tag),
238
+ rb_gi_transfer_to_string(metadata->transfer));
239
+ }
240
+ xfree(target);
241
+ }
242
+
243
+ static void
244
+ rb_gi_arguments_out_free_error(RBGIArguments *args,
245
+ RBGIArgMetadata *metadata,
246
+ gpointer user_data)
247
+ {
248
+ GError **target = metadata->out_arg->v_pointer;
249
+ if (metadata->transfer != GI_TRANSFER_NOTHING) {
250
+ rb_raise(rb_eNotImpError,
251
+ "TODO: [%s] %s free GIArgument(%s)[%s]",
252
+ metadata->name,
253
+ rb_gi_direction_to_string(metadata->direction),
254
+ g_type_tag_to_string(metadata->type.tag),
255
+ rb_gi_transfer_to_string(metadata->transfer));
256
+ }
257
+ xfree(target);
258
+ }
259
+
260
+ static void
261
+ rb_gi_arguments_out_init_arg_array_c(RBGIArguments *args,
262
+ RBGIArgMetadata *metadata)
263
+ {
264
+ GIArgument *argument = metadata->out_arg;
265
+ switch (metadata->element_type.tag) {
266
+ case GI_TYPE_TAG_VOID:
267
+ case GI_TYPE_TAG_BOOLEAN:
268
+ case GI_TYPE_TAG_INT8:
269
+ rb_raise(rb_eNotImpError,
270
+ "TODO: [%s] %s allocates GIArgument(array)[c][%s]",
271
+ metadata->name,
272
+ rb_gi_direction_to_string(metadata->direction),
273
+ g_type_tag_to_string(metadata->element_type.tag));
274
+ break;
275
+ case GI_TYPE_TAG_UINT8:
276
+ if (metadata->output_buffer_p) {
277
+ if (!rb_type_p(metadata->rb_arg, RUBY_T_STRING)) {
278
+ rb_raise(rb_eNotImpError,
279
+ "[%s::%s] %s allocates GIArgument(%s)[%s]: "
280
+ "output buffer isn't String: <%" PRIsVALUE ">",
281
+ args->name,
282
+ metadata->name,
283
+ rb_gi_direction_to_string(metadata->direction),
284
+ g_type_tag_to_string(metadata->type.tag),
285
+ rb_gi_transfer_to_string(metadata->transfer),
286
+ metadata->rb_arg);
287
+ }
288
+ RBGIArgMetadata *length_metadata = metadata->array_length_metadata;
289
+ if (!length_metadata) {
290
+ rb_raise(rb_eNotImpError,
291
+ "TODO: [%s::%s] %s allocates GIArgument(%s)[%s]: "
292
+ "output buffer without length",
293
+ args->name,
294
+ metadata->name,
295
+ rb_gi_direction_to_string(metadata->direction),
296
+ g_type_tag_to_string(metadata->type.tag),
297
+ rb_gi_transfer_to_string(metadata->transfer));
298
+ }
299
+ argument->v_pointer = RSTRING_PTR(metadata->rb_arg);
300
+ length_metadata->out_arg->v_size = RSTRING_LEN(metadata->rb_arg);
301
+ } else {
302
+ argument->v_pointer = ALLOC(guint8 *);
303
+ metadata->free_func = rb_gi_arguments_out_free_array_c_uint8;
304
+ }
305
+ break;
306
+ case GI_TYPE_TAG_INT16:
307
+ case GI_TYPE_TAG_UINT16:
308
+ case GI_TYPE_TAG_INT32:
309
+ case GI_TYPE_TAG_UINT32:
310
+ case GI_TYPE_TAG_INT64:
311
+ case GI_TYPE_TAG_UINT64:
312
+ case GI_TYPE_TAG_FLOAT:
313
+ case GI_TYPE_TAG_DOUBLE:
314
+ case GI_TYPE_TAG_GTYPE:
315
+ rb_raise(rb_eNotImpError,
316
+ "TODO: [%s] %s allocates GIArgument(array)[c][%s]",
317
+ metadata->name,
318
+ rb_gi_direction_to_string(metadata->direction),
319
+ g_type_tag_to_string(metadata->element_type.tag));
320
+ break;
321
+ case GI_TYPE_TAG_UTF8:
322
+ argument->v_pointer = ALLOC(gchar **);
323
+ metadata->free_func = rb_gi_arguments_out_free_array_c_string;
324
+ break;
325
+ case GI_TYPE_TAG_FILENAME:
326
+ case GI_TYPE_TAG_ARRAY:
327
+ rb_raise(rb_eNotImpError,
328
+ "TODO: [%s] %s allocates GIArgument(array)[c][%s]",
329
+ metadata->name,
330
+ rb_gi_direction_to_string(metadata->direction),
331
+ g_type_tag_to_string(metadata->element_type.tag));
332
+ break;
333
+ case GI_TYPE_TAG_INTERFACE:
334
+ argument->v_pointer = ALLOC(gpointer *);
335
+ metadata->free_func = rb_gi_arguments_out_free_array_c_interface;
336
+ break;
337
+ case GI_TYPE_TAG_GLIST:
338
+ case GI_TYPE_TAG_GSLIST:
339
+ case GI_TYPE_TAG_GHASH:
340
+ case GI_TYPE_TAG_ERROR:
341
+ case GI_TYPE_TAG_UNICHAR:
342
+ rb_raise(rb_eNotImpError,
343
+ "TODO: [%s] %s allocates GIArgument(array)[c][%s]",
344
+ metadata->name,
345
+ rb_gi_direction_to_string(metadata->direction),
346
+ g_type_tag_to_string(metadata->element_type.tag));
347
+ break;
348
+ default:
349
+ g_assert_not_reached();
350
+ break;
351
+ }
352
+ }
353
+
354
+ static void
355
+ rb_gi_arguments_out_init_arg_array_array_interface(RBGIArguments *args,
356
+ RBGIArgMetadata *metadata)
357
+ {
358
+ GIArgument *argument = metadata->out_arg;
359
+ switch (metadata->element_type.interface_type) {
360
+ case GI_INFO_TYPE_INVALID:
361
+ case GI_INFO_TYPE_FUNCTION:
362
+ case GI_INFO_TYPE_CALLBACK:
363
+ rb_raise(rb_eNotImpError,
364
+ "TODO: [%s] %s allocates "
365
+ "GIArgument(array)[array][interface(%s)](%s)",
366
+ metadata->name,
367
+ rb_gi_direction_to_string(metadata->direction),
368
+ g_info_type_to_string(metadata->element_type.interface_type),
369
+ g_type_name(metadata->element_type.interface_gtype));
370
+ break;
371
+ case GI_INFO_TYPE_STRUCT:
372
+ {
373
+ gsize raw_struct_size;
374
+ guint struct_size;
375
+
376
+ raw_struct_size =
377
+ g_struct_info_get_size(metadata->element_type.interface_info);
378
+ struct_size = (guint)raw_struct_size;
379
+ argument->v_pointer = g_array_new(metadata->zero_terminated_p,
380
+ TRUE,
381
+ struct_size);
382
+ metadata->free_func =
383
+ rb_gi_arguments_out_free_array_array_interface_struct;
384
+ }
385
+ break;
386
+ case GI_INFO_TYPE_BOXED:
387
+ case GI_INFO_TYPE_ENUM:
388
+ case GI_INFO_TYPE_FLAGS:
389
+ case GI_INFO_TYPE_OBJECT:
390
+ case GI_INFO_TYPE_INTERFACE:
391
+ case GI_INFO_TYPE_CONSTANT:
392
+ case GI_INFO_TYPE_INVALID_0:
393
+ case GI_INFO_TYPE_UNION:
394
+ case GI_INFO_TYPE_VALUE:
395
+ case GI_INFO_TYPE_SIGNAL:
396
+ case GI_INFO_TYPE_VFUNC:
397
+ case GI_INFO_TYPE_PROPERTY:
398
+ case GI_INFO_TYPE_FIELD:
399
+ case GI_INFO_TYPE_ARG:
400
+ case GI_INFO_TYPE_TYPE:
401
+ case GI_INFO_TYPE_UNRESOLVED:
402
+ rb_raise(rb_eNotImpError,
403
+ "TODO: [%s] %s allocates "
404
+ "GIArgument(array)[array][interface(%s)](%s)",
405
+ metadata->name,
406
+ rb_gi_direction_to_string(metadata->direction),
407
+ g_info_type_to_string(metadata->element_type.interface_type),
408
+ g_type_name(metadata->element_type.interface_gtype));
409
+ break;
410
+ default:
411
+ g_assert_not_reached();
412
+ break;
413
+ }
414
+ }
415
+
416
+ static void
417
+ rb_gi_arguments_out_init_arg_array_array(RBGIArguments *args,
418
+ RBGIArgMetadata *metadata)
419
+ {
420
+ switch (metadata->element_type.tag) {
421
+ case GI_TYPE_TAG_VOID:
422
+ case GI_TYPE_TAG_BOOLEAN:
423
+ case GI_TYPE_TAG_INT8:
424
+ case GI_TYPE_TAG_UINT8:
425
+ case GI_TYPE_TAG_INT16:
426
+ case GI_TYPE_TAG_UINT16:
427
+ case GI_TYPE_TAG_INT32:
428
+ case GI_TYPE_TAG_UINT32:
429
+ case GI_TYPE_TAG_INT64:
430
+ case GI_TYPE_TAG_UINT64:
431
+ case GI_TYPE_TAG_FLOAT:
432
+ case GI_TYPE_TAG_DOUBLE:
433
+ case GI_TYPE_TAG_GTYPE:
434
+ case GI_TYPE_TAG_UTF8:
435
+ case GI_TYPE_TAG_FILENAME:
436
+ case GI_TYPE_TAG_ARRAY:
437
+ rb_raise(rb_eNotImpError,
438
+ "TODO: [%s] %s allocates GIArgument(array)[array][%s]",
439
+ metadata->name,
440
+ rb_gi_direction_to_string(metadata->direction),
441
+ g_type_tag_to_string(metadata->element_type.tag));
442
+ break;
443
+ case GI_TYPE_TAG_INTERFACE:
444
+ rb_gi_arguments_out_init_arg_array_array_interface(args, metadata);
445
+ break;
446
+ case GI_TYPE_TAG_GLIST:
447
+ case GI_TYPE_TAG_GSLIST:
448
+ case GI_TYPE_TAG_GHASH:
449
+ case GI_TYPE_TAG_ERROR:
450
+ case GI_TYPE_TAG_UNICHAR:
451
+ rb_raise(rb_eNotImpError,
452
+ "TODO: [%s] %s allocates GIArgument(array)[array][%s]",
453
+ metadata->name,
454
+ rb_gi_direction_to_string(metadata->direction),
455
+ g_type_tag_to_string(metadata->element_type.tag));
456
+ break;
457
+ default:
458
+ g_assert_not_reached();
459
+ break;
460
+ }
461
+ }
462
+
463
+ static void
464
+ rb_gi_arguments_out_init_arg_array(RBGIArguments *args,
465
+ RBGIArgMetadata *metadata)
466
+ {
467
+ switch (metadata->array_type) {
468
+ case GI_ARRAY_TYPE_C:
469
+ rb_gi_arguments_out_init_arg_array_c(args, metadata);
470
+ break;
471
+ case GI_ARRAY_TYPE_ARRAY:
472
+ rb_gi_arguments_out_init_arg_array_array(args, metadata);
473
+ break;
474
+ case GI_ARRAY_TYPE_PTR_ARRAY:
475
+ rb_raise(rb_eNotImpError,
476
+ "TODO: [%s] %s allocates GIArgument(array)[ptr-array][%s]",
477
+ metadata->name,
478
+ rb_gi_direction_to_string(metadata->direction),
479
+ g_type_tag_to_string(metadata->element_type.tag));
480
+ break;
481
+ case GI_ARRAY_TYPE_BYTE_ARRAY:
482
+ rb_raise(rb_eNotImpError,
483
+ "TODO: [%s] %s allocates GIArgument(array)[byte-array][%s]",
484
+ metadata->name,
485
+ rb_gi_direction_to_string(metadata->direction),
486
+ g_type_tag_to_string(metadata->element_type.tag));
487
+ break;
488
+ default:
489
+ g_assert_not_reached();
490
+ break;
491
+ }
492
+ }
493
+
494
+ static void
495
+ rb_gi_arguments_out_init_arg_interface(RBGIArguments *args,
496
+ RBGIArgMetadata *metadata)
497
+ {
498
+ GIArgument *argument = metadata->out_arg;
499
+ switch (metadata->type.interface_type) {
500
+ case GI_INFO_TYPE_INVALID:
501
+ case GI_INFO_TYPE_FUNCTION:
502
+ case GI_INFO_TYPE_CALLBACK:
503
+ rb_raise(rb_eNotImpError,
504
+ "TODO: allocates GIArgument(interface)[%s] for output",
505
+ g_info_type_to_string(metadata->type.interface_type));
506
+ break;
507
+ case GI_INFO_TYPE_STRUCT:
508
+ {
509
+ gsize struct_size;
510
+
511
+ /* Should we care gtype?
512
+ Related: rb_gi_arguments_out_arg_clear_interface() */
513
+ struct_size = g_struct_info_get_size(metadata->type.interface_info);
514
+ argument->v_pointer = xmalloc(struct_size);
515
+ memset(argument->v_pointer, 0, struct_size);
516
+ metadata->free_func = rb_gi_arguments_out_free_interface_struct;
517
+ }
518
+ break;
519
+ case GI_INFO_TYPE_BOXED:
520
+ rb_raise(rb_eNotImpError,
521
+ "TODO: allocates GIArgument(interface)[%s] for output",
522
+ g_info_type_to_string(metadata->type.interface_type));
523
+ break;
524
+ case GI_INFO_TYPE_ENUM:
525
+ {
526
+ gint *pointer = ALLOC(gint);
527
+ *pointer = 0;
528
+ argument->v_pointer = pointer;
529
+ metadata->free_func = rb_gi_arguments_out_free_immediate_value;
530
+ }
531
+ break;
532
+ case GI_INFO_TYPE_FLAGS:
533
+ {
534
+ guint *pointer = ALLOC(guint);
535
+ *pointer = 0;
536
+ argument->v_pointer = pointer;
537
+ metadata->free_func = rb_gi_arguments_out_free_immediate_value;
538
+ }
539
+ break;
540
+ case GI_INFO_TYPE_OBJECT:
541
+ case GI_INFO_TYPE_INTERFACE:
542
+ {
543
+ gpointer *pointer = ALLOC(gpointer);
544
+ *pointer = NULL;
545
+ argument->v_pointer = pointer;
546
+ metadata->free_func = rb_gi_arguments_out_free_interface_object;
547
+ }
548
+ break;
549
+ case GI_INFO_TYPE_CONSTANT:
550
+ case GI_INFO_TYPE_INVALID_0:
551
+ case GI_INFO_TYPE_UNION:
552
+ case GI_INFO_TYPE_VALUE:
553
+ case GI_INFO_TYPE_SIGNAL:
554
+ case GI_INFO_TYPE_VFUNC:
555
+ case GI_INFO_TYPE_PROPERTY:
556
+ case GI_INFO_TYPE_FIELD:
557
+ case GI_INFO_TYPE_ARG:
558
+ case GI_INFO_TYPE_TYPE:
559
+ case GI_INFO_TYPE_UNRESOLVED:
560
+ rb_raise(rb_eNotImpError,
561
+ "TODO: [%s] %s allocates GIArgument(interface)[%s]",
562
+ metadata->name,
563
+ rb_gi_direction_to_string(metadata->direction),
564
+ g_info_type_to_string(metadata->type.interface_type));
565
+ break;
566
+ default:
567
+ g_assert_not_reached();
568
+ break;
569
+ }
570
+ }
571
+
572
+ static void
573
+ rb_gi_arguments_out_init_arg(RBGIArguments *args,
574
+ RBGIArgMetadata *metadata)
575
+ {
576
+ GIArgument *argument = metadata->out_arg;
577
+
578
+ if (metadata->array_length_p &&
579
+ metadata->array_metadata &&
580
+ metadata->array_metadata->output_buffer_p) {
581
+ return;
582
+ }
583
+
584
+ memset(argument, 0, sizeof(GIArgument));
585
+ switch (metadata->type.tag) {
586
+ case GI_TYPE_TAG_VOID:
587
+ if (metadata->pointer_p) {
588
+ gpointer *pointer = ALLOC(gpointer);
589
+ *pointer = NULL;
590
+ argument->v_pointer = pointer;
591
+ metadata->free_func = rb_gi_arguments_out_free_immediate_value;
592
+ }
593
+ break;
594
+ case GI_TYPE_TAG_BOOLEAN:
595
+ {
596
+ gboolean *pointer = ALLOC(gboolean);
597
+ *pointer = FALSE;
598
+ argument->v_pointer = pointer;
599
+ metadata->free_func = rb_gi_arguments_out_free_immediate_value;
600
+ }
601
+ break;
602
+ case GI_TYPE_TAG_INT8:
603
+ {
604
+ gint8 *pointer = ALLOC(gint8);
605
+ *pointer = 0;
606
+ argument->v_pointer = pointer;
607
+ metadata->free_func = rb_gi_arguments_out_free_immediate_value;
608
+ }
609
+ break;
610
+ case GI_TYPE_TAG_UINT8:
611
+ {
612
+ guint8 *pointer = ALLOC(guint8);
613
+ *pointer = 0;
614
+ argument->v_pointer = pointer;
615
+ metadata->free_func = rb_gi_arguments_out_free_immediate_value;
616
+ }
617
+ break;
618
+ case GI_TYPE_TAG_INT16:
619
+ {
620
+ gint16 *pointer = ALLOC(gint16);
621
+ *pointer = 0;
622
+ argument->v_pointer = pointer;
623
+ metadata->free_func = rb_gi_arguments_out_free_immediate_value;
624
+ }
625
+ break;
626
+ case GI_TYPE_TAG_UINT16:
627
+ {
628
+ guint16 *pointer = ALLOC(guint16);
629
+ *pointer = 0;
630
+ argument->v_pointer = pointer;
631
+ metadata->free_func = rb_gi_arguments_out_free_immediate_value;
632
+ }
633
+ break;
634
+ case GI_TYPE_TAG_INT32:
635
+ {
636
+ gint32 *pointer = ALLOC(gint32);
637
+ *pointer = 0;
638
+ argument->v_pointer = pointer;
639
+ metadata->free_func = rb_gi_arguments_out_free_immediate_value;
640
+ }
641
+ break;
642
+ case GI_TYPE_TAG_UINT32:
643
+ {
644
+ guint32 *pointer = ALLOC(guint32);
645
+ *pointer = 0;
646
+ argument->v_pointer = pointer;
647
+ metadata->free_func = rb_gi_arguments_out_free_immediate_value;
648
+ }
649
+ break;
650
+ case GI_TYPE_TAG_INT64:
651
+ {
652
+ gint64 *pointer = ALLOC(gint64);
653
+ *pointer = 0;
654
+ argument->v_pointer = pointer;
655
+ metadata->free_func = rb_gi_arguments_out_free_immediate_value;
656
+ }
657
+ break;
658
+ case GI_TYPE_TAG_UINT64:
659
+ {
660
+ guint64 *pointer = ALLOC(guint64);
661
+ *pointer = 0;
662
+ argument->v_pointer = pointer;
663
+ metadata->free_func = rb_gi_arguments_out_free_immediate_value;
664
+ }
665
+ break;
666
+ case GI_TYPE_TAG_FLOAT:
667
+ {
668
+ gfloat *pointer = ALLOC(gfloat);
669
+ *pointer = 0.0;
670
+ argument->v_pointer = pointer;
671
+ metadata->free_func = rb_gi_arguments_out_free_immediate_value;
672
+ }
673
+ break;
674
+ case GI_TYPE_TAG_DOUBLE:
675
+ {
676
+ gdouble *pointer = ALLOC(gdouble);
677
+ *pointer = 0.0;
678
+ argument->v_pointer = pointer;
679
+ metadata->free_func = rb_gi_arguments_out_free_immediate_value;
680
+ }
681
+ break;
682
+ case GI_TYPE_TAG_GTYPE:
683
+ {
684
+ GType *pointer = ALLOC(GType);
685
+ *pointer = G_TYPE_INVALID;
686
+ argument->v_pointer = pointer;
687
+ metadata->free_func = rb_gi_arguments_out_free_immediate_value;
688
+ }
689
+ break;
690
+ case GI_TYPE_TAG_UTF8:
691
+ case GI_TYPE_TAG_FILENAME:
692
+ {
693
+ gchar **pointer = ALLOC(gchar *);
694
+ *pointer = NULL;
695
+ argument->v_pointer = pointer;
696
+ metadata->free_func = rb_gi_arguments_out_free_string;
697
+ }
698
+ break;
699
+ case GI_TYPE_TAG_ARRAY:
700
+ rb_gi_arguments_out_init_arg_array(args, metadata);
701
+ break;
702
+ case GI_TYPE_TAG_INTERFACE:
703
+ rb_gi_arguments_out_init_arg_interface(args, metadata);
704
+ break;
705
+ case GI_TYPE_TAG_GLIST:
706
+ case GI_TYPE_TAG_GSLIST:
707
+ {
708
+ gpointer *pointer = ALLOC(gpointer);
709
+ *pointer = NULL;
710
+ argument->v_pointer = pointer;
711
+ metadata->free_func = rb_gi_arguments_out_free_list;
712
+ }
713
+ break;
714
+ case GI_TYPE_TAG_GHASH:
715
+ {
716
+ gpointer *pointer = ALLOC(gpointer);
717
+ *pointer = NULL;
718
+ argument->v_pointer = pointer;
719
+ metadata->free_func = rb_gi_arguments_out_free_hash;
720
+ }
721
+ break;
722
+ case GI_TYPE_TAG_ERROR:
723
+ {
724
+ GError **pointer = ALLOC(GError *);
725
+ *pointer = NULL;
726
+ argument->v_pointer = pointer;
727
+ metadata->free_func = rb_gi_arguments_out_free_error;
728
+ }
729
+ break;
730
+ case GI_TYPE_TAG_UNICHAR:
731
+ {
732
+ gunichar *pointer = ALLOC(gunichar);
733
+ *pointer = 0;
734
+ argument->v_pointer = pointer;
735
+ metadata->free_func = rb_gi_arguments_out_free_immediate_value;
736
+ }
737
+ break;
738
+ default:
739
+ g_assert_not_reached();
740
+ break;
741
+ }
742
+ }
743
+
744
+ void
745
+ rb_gi_arguments_out_init(RBGIArguments *args)
746
+ {
747
+ guint i;
748
+
749
+ for (i = 0; i < args->metadata->len; i++) {
750
+ RBGIArgMetadata *metadata;
751
+
752
+ metadata = g_ptr_array_index(args->metadata, i);
753
+ if (metadata->direction != GI_DIRECTION_OUT) {
754
+ continue;
755
+ }
756
+
757
+ if (args->rb_mode_p) {
758
+ rb_gi_arguments_out_init_arg(args, metadata);
759
+ } else {
760
+ GIArgument *argument = &(g_array_index(args->out_args,
761
+ GIArgument,
762
+ metadata->out_arg_index));
763
+ argument->v_pointer = *((gpointer *)(args->raw_args[i]));
764
+ }
765
+ }
766
+ }
767
+
768
+ void
769
+ rb_gi_arguments_out_clear(RBGIArguments *args)
770
+ {
771
+ guint i;
772
+
773
+ for (i = 0; i < args->metadata->len; i++) {
774
+ RBGIArgMetadata *metadata;
775
+
776
+ metadata = g_ptr_array_index(args->metadata, i);
777
+ if (metadata->direction != GI_DIRECTION_OUT) {
778
+ continue;
779
+ }
780
+
781
+ if (metadata->free_func) {
782
+ metadata->free_func(args, metadata, metadata->free_func_data);
783
+ }
784
+ }
785
+ }
786
+
787
+ static VALUE
788
+ rb_gi_arguments_out_to_ruby_arg(RBGIArguments *args,
789
+ RBGIArgMetadata *metadata,
790
+ GIArgument *argument)
791
+ {
792
+ /* TODO */
793
+ if (metadata->output_buffer_p) {
794
+ return metadata->rb_arg;
795
+ }
796
+
797
+ GIArgument normalized_argument;
798
+ gboolean duplicate = FALSE;
799
+
800
+ memset(&normalized_argument, 0, sizeof(GIArgument));
801
+ switch (metadata->type.tag) {
802
+ case GI_TYPE_TAG_VOID:
803
+ if (metadata->pointer_p) {
804
+ normalized_argument.v_pointer = *((gpointer *)(argument->v_pointer));
805
+ }
806
+ break;
807
+ case GI_TYPE_TAG_BOOLEAN:
808
+ normalized_argument.v_boolean = *((gboolean *)(argument->v_pointer));
809
+ break;
810
+ case GI_TYPE_TAG_INT8:
811
+ normalized_argument.v_int8 = *((gint8 *)(argument->v_pointer));
812
+ break;
813
+ case GI_TYPE_TAG_UINT8:
814
+ normalized_argument.v_uint8 = *((guint8 *)(argument->v_pointer));
815
+ break;
816
+ case GI_TYPE_TAG_INT16:
817
+ normalized_argument.v_int16 = *((gint16 *)(argument->v_pointer));
818
+ break;
819
+ case GI_TYPE_TAG_UINT16:
820
+ normalized_argument.v_uint16 = *((guint16 *)(argument->v_pointer));
821
+ break;
822
+ case GI_TYPE_TAG_INT32:
823
+ normalized_argument.v_int32 = *((gint32 *)(argument->v_pointer));
824
+ break;
825
+ case GI_TYPE_TAG_UINT32:
826
+ normalized_argument.v_uint32 = *((guint32 *)(argument->v_pointer));
827
+ break;
828
+ case GI_TYPE_TAG_INT64:
829
+ normalized_argument.v_int64 = *((gint64 *)(argument->v_pointer));
830
+ break;
831
+ case GI_TYPE_TAG_UINT64:
832
+ normalized_argument.v_uint64 = *((guint64 *)(argument->v_pointer));
833
+ break;
834
+ case GI_TYPE_TAG_FLOAT:
835
+ normalized_argument.v_float = *((gfloat *)(argument->v_pointer));
836
+ break;
837
+ case GI_TYPE_TAG_DOUBLE:
838
+ normalized_argument.v_double = *((gdouble *)(argument->v_pointer));
839
+ break;
840
+ case GI_TYPE_TAG_GTYPE:
841
+ normalized_argument.v_size = *((GType *)(argument->v_pointer));
842
+ break;
843
+ case GI_TYPE_TAG_UTF8:
844
+ case GI_TYPE_TAG_FILENAME:
845
+ normalized_argument.v_string = *((gchar **)(argument->v_pointer));
846
+ break;
847
+ case GI_TYPE_TAG_ARRAY:
848
+ case GI_TYPE_TAG_INTERFACE:
849
+ case GI_TYPE_TAG_GLIST:
850
+ case GI_TYPE_TAG_GSLIST:
851
+ case GI_TYPE_TAG_GHASH:
852
+ if (metadata->caller_allocates_p) {
853
+ duplicate = TRUE;
854
+ normalized_argument.v_pointer = argument->v_pointer;
855
+ } else {
856
+ normalized_argument.v_pointer = *((gpointer *)(argument->v_pointer));
857
+ }
858
+ break;
859
+ case GI_TYPE_TAG_ERROR:
860
+ normalized_argument.v_pointer = *((GError **)(argument->v_pointer));
861
+ break;
862
+ case GI_TYPE_TAG_UNICHAR:
863
+ normalized_argument.v_uint32 = *((guint32 *)(argument->v_pointer));
864
+ break;
865
+ default:
866
+ g_assert_not_reached();
867
+ break;
868
+ }
869
+
870
+ return rb_gi_argument_to_ruby(&normalized_argument,
871
+ duplicate,
872
+ metadata->type.info,
873
+ args->in_args,
874
+ args->out_args,
875
+ args->metadata);
876
+ }
877
+
878
+ VALUE
879
+ rb_gi_arguments_out_to_ruby(RBGIArguments *args)
880
+ {
881
+ gint i, n_args;
882
+ VALUE rb_out_args;
883
+
884
+ rb_out_args = rb_ary_new();
885
+ n_args = g_callable_info_get_n_args(args->info);
886
+ for (i = 0; i < n_args; i++) {
887
+ RBGIArgMetadata *metadata;
888
+ GIArgument *argument = NULL;
889
+ VALUE rb_argument;
890
+
891
+ metadata = g_ptr_array_index(args->metadata, i);
892
+ if (metadata->array_length_p) {
893
+ continue;
894
+ }
895
+
896
+ switch (metadata->direction) {
897
+ case GI_DIRECTION_IN:
898
+ break;
899
+ case GI_DIRECTION_OUT:
900
+ argument = &g_array_index(args->out_args,
901
+ GIArgument,
902
+ metadata->out_arg_index);
903
+ break;
904
+ case GI_DIRECTION_INOUT:
905
+ argument = &g_array_index(args->in_args,
906
+ GIArgument,
907
+ metadata->in_arg_index);
908
+ break;
909
+ default:
910
+ g_assert_not_reached();
911
+ break;
912
+ }
913
+
914
+ if (!argument) {
915
+ continue;
916
+ }
917
+
918
+ rb_argument = rb_gi_arguments_out_to_ruby_arg(args,
919
+ metadata,
920
+ argument);
921
+ rb_ary_push(rb_out_args, rb_argument);
922
+ }
923
+
924
+ if (RARRAY_LEN(rb_out_args) == 0) {
925
+ return Qnil;
926
+ } else {
927
+ return rb_out_args;
928
+ }
929
+ }