gobject-introspection 3.4.6 → 3.5.0

Sign up to get free protection for your applications and to get access to all the features.
Files changed (21) hide show
  1. checksums.yaml +4 -4
  2. data/ext/gobject-introspection/rb-gi-arg-info.c +44 -1
  3. data/ext/gobject-introspection/rb-gi-arguments-in.c +23 -20
  4. data/ext/gobject-introspection/rb-gi-arguments-out.c +17 -17
  5. data/ext/gobject-introspection/rb-gi-arguments.c +2013 -130
  6. data/ext/gobject-introspection/rb-gi-callback.c +8 -2
  7. data/ext/gobject-introspection/rb-gi-constant-info.c +14 -10
  8. data/ext/gobject-introspection/rb-gi-conversions.h +1 -23
  9. data/ext/gobject-introspection/rb-gi-field-info.c +77 -76
  10. data/ext/gobject-introspection/rb-gi-function-info.c +57 -16
  11. data/ext/gobject-introspection/rb-gi-loader.c +2 -2
  12. data/ext/gobject-introspection/rb-gi-private-arg-info.h +3 -1
  13. data/ext/gobject-introspection/rb-gi-private-arguments.h +19 -3
  14. data/ext/gobject-introspection/rb-gi-private.h +6 -3
  15. data/ext/gobject-introspection/rb-gobject-introspection.c +5 -225
  16. data/lib/gobject-introspection/function-info.rb +2 -2
  17. data/lib/gobject-introspection/loader.rb +144 -73
  18. data/lib/gobject-introspection/type-tag.rb +115 -123
  19. data/test/test-loader.rb +14 -0
  20. metadata +5 -6
  21. data/ext/gobject-introspection/rb-gi-argument.c +0 -2051
data/ext/gobject-introspection/rb-gi-argument.c DELETED
@@ -1,2051 +0,0 @@
1
- /* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
2
- /*
3
- * Copyright (C) 2012-2021 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 VALUE rb_cGLibBoxed = Qnil;
24
- static VALUE rb_cGLibBytes = Qnil;
25
- static VALUE rb_cGLibObject = Qnil;
26
- static VALUE rb_cGLibValue = Qnil;
27
-
28
- static void
29
- array_c_to_ruby_sized_interface(gconstpointer *elements,
30
- gint64 n_elements,
31
- GITypeInfo *element_type_info,
32
- VALUE rb_array)
33
- {
34
- gint64 i;
35
- GIBaseInfo *interface_info;
36
- GIInfoType interface_type;
37
- GType gtype;
38
- const char *interface_name;
39
-
40
- interface_info = g_type_info_get_interface(element_type_info);
41
- interface_type = g_base_info_get_type(interface_info);
42
- gtype = g_registered_type_info_get_g_type(interface_info);
43
-
44
- switch (interface_type) {
45
- case GI_INFO_TYPE_INVALID:
46
- case GI_INFO_TYPE_FUNCTION:
47
- case GI_INFO_TYPE_CALLBACK:
48
- interface_name = g_info_type_to_string(interface_type);
49
- g_base_info_unref(interface_info);
50
- g_base_info_unref(element_type_info);
51
- rb_raise(rb_eNotImpError,
52
- "TODO: GIArgument(array)[c][interface(%s)](%s) -> Ruby",
53
- interface_name,
54
- g_type_name(gtype));
55
- break;
56
- case GI_INFO_TYPE_STRUCT:
57
- if (gtype == G_TYPE_NONE) {
58
- for (i = 0; i < n_elements; i++) {
59
- rb_ary_push(rb_array,
60
- rb_gi_struct_info_to_ruby(interface_info,
61
- (gpointer)elements[i],
62
- TRUE));
63
- }
64
- g_base_info_unref(interface_info);
65
- g_base_info_unref(element_type_info);
66
- } else {
67
- /* TODO: Should we check caller_allocates? */
68
- gsize struct_size = g_struct_info_get_size(interface_info);
69
- for (i = 0; i < n_elements; i++) {
70
- gpointer element = ((gchar *)elements) + struct_size * i;
71
- rb_ary_push(rb_array, BOXED2RVAL(element, gtype));
72
- }
73
- g_base_info_unref(interface_info);
74
- g_base_info_unref(element_type_info);
75
- }
76
- break;
77
- case GI_INFO_TYPE_BOXED:
78
- case GI_INFO_TYPE_ENUM:
79
- case GI_INFO_TYPE_FLAGS:
80
- interface_name = g_info_type_to_string(interface_type);
81
- g_base_info_unref(interface_info);
82
- g_base_info_unref(element_type_info);
83
- rb_raise(rb_eNotImpError,
84
- "TODO: GIArgument(array)[c][interface(%s)](%s) -> Ruby",
85
- interface_name,
86
- g_type_name(gtype));
87
- break;
88
- case GI_INFO_TYPE_OBJECT:
89
- for (i = 0; i < n_elements; i++) {
90
- rb_ary_push(rb_array, GOBJ2RVAL((GObject *)(elements[i])));
91
- }
92
- g_base_info_unref(interface_info);
93
- g_base_info_unref(element_type_info);
94
- break;
95
- case GI_INFO_TYPE_INTERFACE:
96
- case GI_INFO_TYPE_CONSTANT:
97
- case GI_INFO_TYPE_INVALID_0:
98
- case GI_INFO_TYPE_UNION:
99
- case GI_INFO_TYPE_VALUE:
100
- case GI_INFO_TYPE_SIGNAL:
101
- case GI_INFO_TYPE_VFUNC:
102
- case GI_INFO_TYPE_PROPERTY:
103
- case GI_INFO_TYPE_FIELD:
104
- case GI_INFO_TYPE_ARG:
105
- case GI_INFO_TYPE_TYPE:
106
- case GI_INFO_TYPE_UNRESOLVED:
107
- interface_name = g_info_type_to_string(interface_type);
108
- g_base_info_unref(interface_info);
109
- g_base_info_unref(element_type_info);
110
- rb_raise(rb_eNotImpError,
111
- "TODO: GIArgument(array)[c][interface(%s)](%s) -> Ruby",
112
- interface_name,
113
- g_type_name(gtype));
114
- break;
115
- default:
116
- g_base_info_unref(interface_info);
117
- g_base_info_unref(element_type_info);
118
- g_assert_not_reached();
119
- break;
120
- }
121
- }
122
-
123
- static void
124
- array_c_to_ruby_sized(gconstpointer *elements,
125
- gint64 n_elements,
126
- GITypeInfo *type_info,
127
- VALUE rb_array)
128
- {
129
- gint64 i;
130
- GITypeInfo *element_type_info;
131
- GITypeTag element_type_tag;
132
-
133
- element_type_info = g_type_info_get_param_type(type_info, 0);
134
- element_type_tag = g_type_info_get_tag(element_type_info);
135
-
136
- switch (element_type_tag) {
137
- case GI_TYPE_TAG_VOID:
138
- g_base_info_unref(element_type_info);
139
- rb_raise(rb_eNotImpError,
140
- "TODO: GIArgument(array)[c][%s] -> Ruby",
141
- g_type_tag_to_string(element_type_tag));
142
- break;
143
- case GI_TYPE_TAG_BOOLEAN:
144
- g_base_info_unref(element_type_info);
145
- {
146
- const gboolean *booleans = (const gboolean *)elements;
147
- for (i = 0; i < n_elements; i++) {
148
- rb_ary_push(rb_array, CBOOL2RVAL(booleans[i]));
149
- }
150
- }
151
- break;
152
- case GI_TYPE_TAG_INT8:
153
- g_base_info_unref(element_type_info);
154
- {
155
- const gint8 *numbers = (const gint8 *)elements;
156
- for (i = 0; i < n_elements; i++) {
157
- rb_ary_push(rb_array, INT2NUM(numbers[i]));
158
- }
159
- }
160
- break;
161
- case GI_TYPE_TAG_UINT8:
162
- g_base_info_unref(element_type_info);
163
- {
164
- const guint8 *numbers = (const guint8 *)elements;
165
- for (i = 0; i < n_elements; i++) {
166
- rb_ary_push(rb_array, UINT2NUM(numbers[i]));
167
- }
168
- }
169
- break;
170
- case GI_TYPE_TAG_INT16:
171
- g_base_info_unref(element_type_info);
172
- {
173
- const gint16 *numbers = (const gint16 *)elements;
174
- for (i = 0; i < n_elements; i++) {
175
- rb_ary_push(rb_array, INT2NUM(numbers[i]));
176
- }
177
- }
178
- break;
179
- case GI_TYPE_TAG_UINT16:
180
- g_base_info_unref(element_type_info);
181
- {
182
- const guint16 *numbers = (const guint16 *)elements;
183
- for (i = 0; i < n_elements; i++) {
184
- rb_ary_push(rb_array, UINT2NUM(numbers[i]));
185
- }
186
- }
187
- break;
188
- case GI_TYPE_TAG_INT32:
189
- g_base_info_unref(element_type_info);
190
- {
191
- const gint32 *numbers = (const gint32 *)elements;
192
- for (i = 0; i < n_elements; i++) {
193
- rb_ary_push(rb_array, INT2NUM(numbers[i]));
194
- }
195
- }
196
- break;
197
- case GI_TYPE_TAG_UINT32:
198
- g_base_info_unref(element_type_info);
199
- {
200
- const guint32 *numbers = (const guint32 *)elements;
201
- for (i = 0; i < n_elements; i++) {
202
- rb_ary_push(rb_array, UINT2NUM(numbers[i]));
203
- }
204
- }
205
- break;
206
- case GI_TYPE_TAG_INT64:
207
- g_base_info_unref(element_type_info);
208
- {
209
- const gint64 *numbers = (const gint64 *)elements;
210
- for (i = 0; i < n_elements; i++) {
211
- rb_ary_push(rb_array, LL2NUM(numbers[i]));
212
- }
213
- }
214
- break;
215
- case GI_TYPE_TAG_UINT64:
216
- g_base_info_unref(element_type_info);
217
- {
218
- const guint64 *numbers = (const guint64 *)elements;
219
- for (i = 0; i < n_elements; i++) {
220
- rb_ary_push(rb_array, ULL2NUM(numbers[i]));
221
- }
222
- }
223
- break;
224
- case GI_TYPE_TAG_FLOAT:
225
- g_base_info_unref(element_type_info);
226
- {
227
- const gfloat *numbers = (const gfloat *)elements;
228
- for (i = 0; i < n_elements; i++) {
229
- rb_ary_push(rb_array, rb_float_new(numbers[i]));
230
- }
231
- }
232
- break;
233
- case GI_TYPE_TAG_DOUBLE:
234
- g_base_info_unref(element_type_info);
235
- {
236
- const gdouble *numbers = (const gdouble *)elements;
237
- for (i = 0; i < n_elements; i++) {
238
- rb_ary_push(rb_array, rb_float_new(numbers[i]));
239
- }
240
- }
241
- break;
242
- case GI_TYPE_TAG_GTYPE:
243
- g_base_info_unref(element_type_info);
244
- rb_raise(rb_eNotImpError,
245
- "TODO: GIArgument(array)[c][%s] -> Ruby",
246
- g_type_tag_to_string(element_type_tag));
247
- break;
248
- case GI_TYPE_TAG_UTF8:
249
- g_base_info_unref(element_type_info);
250
- {
251
- const gchar **strings = (const gchar **)elements;
252
- for (i = 0; i < n_elements; i++) {
253
- rb_ary_push(rb_array, CSTR2RVAL(strings[i]));
254
- }
255
- }
256
- break;
257
- case GI_TYPE_TAG_FILENAME:
258
- g_base_info_unref(element_type_info);
259
- {
260
- const gchar **filenames = (const gchar **)elements;
261
- for (i = 0; i < n_elements; i++) {
262
- rb_ary_push(rb_array, CSTRFILENAME2RVAL(filenames[i]));
263
- }
264
- }
265
- break;
266
- case GI_TYPE_TAG_ARRAY:
267
- g_base_info_unref(element_type_info);
268
- rb_raise(rb_eNotImpError,
269
- "TODO: GIArgument(array)[c][%s] -> Ruby",
270
- g_type_tag_to_string(element_type_tag));
271
- break;
272
- case GI_TYPE_TAG_INTERFACE:
273
- array_c_to_ruby_sized_interface(elements, n_elements, element_type_info,
274
- rb_array);
275
- break;
276
- case GI_TYPE_TAG_GLIST:
277
- case GI_TYPE_TAG_GSLIST:
278
- case GI_TYPE_TAG_GHASH:
279
- case GI_TYPE_TAG_ERROR:
280
- case GI_TYPE_TAG_UNICHAR:
281
- g_base_info_unref(element_type_info);
282
- rb_raise(rb_eNotImpError,
283
- "TODO: GIArgument(array)[c][%s] -> Ruby",
284
- g_type_tag_to_string(element_type_tag));
285
- break;
286
- default:
287
- g_base_info_unref(element_type_info);
288
- g_assert_not_reached();
289
- break;
290
- }
291
- }
292
-
293
- static void
294
- array_c_to_ruby(GIArgument *array, GITypeInfo *type_info, gint64 n_elements,
295
- VALUE rb_array)
296
- {
297
- gconstpointer *elements;
298
- gint fixed_size;
299
- gboolean zero_terminated_p;
300
-
301
- elements = array->v_pointer;
302
- if (!elements) {
303
- return;
304
- }
305
-
306
- fixed_size = g_type_info_get_array_fixed_size(type_info);
307
- zero_terminated_p = g_type_info_is_zero_terminated(type_info);
308
-
309
- if (n_elements != -1) {
310
- array_c_to_ruby_sized(elements, n_elements, type_info, rb_array);
311
- } else if (zero_terminated_p) {
312
- const gchar **strings = (const gchar **)elements;
313
- for (; *strings; strings++) {
314
- rb_ary_push(rb_array, CSTR2RVAL(*strings));
315
- }
316
- } else {
317
- rb_raise(rb_eNotImpError,
318
- "TODO: GIArgument(array)[c] -> Ruby: "
319
- "zero-terminated: %s "
320
- "fixed-size: %d "
321
- "length: %" G_GINT64_FORMAT,
322
- zero_terminated_p ? "true" : "false",
323
- fixed_size,
324
- n_elements);
325
- }
326
- }
327
-
328
- static void
329
- array_array_interface_to_ruby(GIArgument *array,
330
- G_GNUC_UNUSED GITypeInfo *array_type_info,
331
- GITypeInfo *element_type_info,
332
- VALUE rb_array)
333
- {
334
- GArray *elements;
335
- GIBaseInfo *interface_info;
336
- GIInfoType interface_type;
337
- GType gtype;
338
- const char *interface_name;
339
-
340
- elements = array->v_pointer;
341
-
342
- interface_info = g_type_info_get_interface(element_type_info);
343
- interface_type = g_base_info_get_type(interface_info);
344
- gtype = g_registered_type_info_get_g_type(interface_info);
345
-
346
- switch (interface_type) {
347
- case GI_INFO_TYPE_INVALID:
348
- case GI_INFO_TYPE_FUNCTION:
349
- case GI_INFO_TYPE_CALLBACK:
350
- interface_name = g_info_type_to_string(interface_type);
351
- g_base_info_unref(interface_info);
352
- g_base_info_unref(element_type_info);
353
- rb_raise(rb_eNotImpError,
354
- "TODO: GIArgument(array)[array][interface(%s)](%s) -> Ruby",
355
- interface_name,
356
- g_type_name(gtype));
357
- break;
358
- case GI_INFO_TYPE_STRUCT:
359
- if (gtype == G_TYPE_NONE) {
360
- guint i;
361
- guint element_size;
362
-
363
- element_size = g_array_get_element_size(elements);
364
- for (i = 0; i < elements->len; i++) {
365
- gpointer element;
366
- element = elements->data + (element_size * i);
367
- rb_ary_push(rb_array,
368
- rb_gi_struct_info_to_ruby(interface_info,
369
- element,
370
- FALSE));
371
- }
372
- } else {
373
- interface_name = g_info_type_to_string(interface_type);
374
- g_base_info_unref(interface_info);
375
- g_base_info_unref(element_type_info);
376
- rb_raise(rb_eNotImpError,
377
- "TODO: GIArgument(array)[array][interface(%s)](%s) -> Ruby",
378
- interface_name,
379
- g_type_name(gtype));
380
- }
381
- break;
382
- case GI_INFO_TYPE_BOXED:
383
- case GI_INFO_TYPE_ENUM:
384
- case GI_INFO_TYPE_FLAGS:
385
- case GI_INFO_TYPE_OBJECT:
386
- case GI_INFO_TYPE_INTERFACE:
387
- case GI_INFO_TYPE_CONSTANT:
388
- case GI_INFO_TYPE_INVALID_0:
389
- case GI_INFO_TYPE_UNION:
390
- case GI_INFO_TYPE_VALUE:
391
- case GI_INFO_TYPE_SIGNAL:
392
- case GI_INFO_TYPE_VFUNC:
393
- case GI_INFO_TYPE_PROPERTY:
394
- case GI_INFO_TYPE_FIELD:
395
- case GI_INFO_TYPE_ARG:
396
- case GI_INFO_TYPE_TYPE:
397
- case GI_INFO_TYPE_UNRESOLVED:
398
- interface_name = g_info_type_to_string(interface_type);
399
- g_base_info_unref(interface_info);
400
- g_base_info_unref(element_type_info);
401
- rb_raise(rb_eNotImpError,
402
- "TODO: GIArgument(array)[array][interface(%s)](%s) -> Ruby",
403
- interface_name,
404
- g_type_name(gtype));
405
- break;
406
- default:
407
- g_base_info_unref(interface_info);
408
- g_base_info_unref(element_type_info);
409
- g_assert_not_reached();
410
- break;
411
- }
412
-
413
- g_base_info_unref(interface_info);
414
- }
415
-
416
- static void
417
- array_array_to_ruby(GIArgument *array,
418
- GITypeInfo *array_type_info,
419
- VALUE rb_array)
420
- {
421
- GITypeInfo *element_type_info;
422
- GITypeTag element_type_tag;
423
- GArray *elements;
424
-
425
- elements = array->v_pointer;
426
- if (!elements) {
427
- return;
428
- }
429
-
430
- element_type_info = g_type_info_get_param_type(array_type_info, 0);
431
- element_type_tag = g_type_info_get_tag(element_type_info);
432
-
433
- switch (element_type_tag) {
434
- case GI_TYPE_TAG_VOID:
435
- case GI_TYPE_TAG_BOOLEAN:
436
- case GI_TYPE_TAG_INT8:
437
- case GI_TYPE_TAG_UINT8:
438
- case GI_TYPE_TAG_INT16:
439
- case GI_TYPE_TAG_UINT16:
440
- case GI_TYPE_TAG_INT32:
441
- case GI_TYPE_TAG_UINT32:
442
- case GI_TYPE_TAG_INT64:
443
- case GI_TYPE_TAG_UINT64:
444
- case GI_TYPE_TAG_FLOAT:
445
- case GI_TYPE_TAG_DOUBLE:
446
- case GI_TYPE_TAG_GTYPE:
447
- case GI_TYPE_TAG_UTF8:
448
- case GI_TYPE_TAG_FILENAME:
449
- case GI_TYPE_TAG_ARRAY:
450
- g_base_info_unref(element_type_info);
451
- rb_raise(rb_eNotImpError,
452
- "TODO: GIArgument(array)[array][%s] -> Ruby",
453
- g_type_tag_to_string(element_type_tag));
454
- break;
455
- case GI_TYPE_TAG_INTERFACE:
456
- array_array_interface_to_ruby(array,
457
- array_type_info,
458
- element_type_info,
459
- rb_array);
460
- break;
461
- case GI_TYPE_TAG_GLIST:
462
- case GI_TYPE_TAG_GSLIST:
463
- case GI_TYPE_TAG_GHASH:
464
- case GI_TYPE_TAG_ERROR:
465
- case GI_TYPE_TAG_UNICHAR:
466
- g_base_info_unref(element_type_info);
467
- rb_raise(rb_eNotImpError,
468
- "TODO: GIArgument(array)[array][%s] -> Ruby",
469
- g_type_tag_to_string(element_type_tag));
470
- break;
471
- default:
472
- g_base_info_unref(element_type_info);
473
- g_assert_not_reached();
474
- break;
475
- }
476
-
477
- g_base_info_unref(element_type_info);
478
- }
479
-
480
- static gint64
481
- get_array_length(GIArgument *argument, GITypeInfo *type_info)
482
- {
483
- GITypeTag type_tag;
484
- gint64 length = -1;
485
-
486
- if (!argument) {
487
- return length;
488
- }
489
-
490
- type_tag = g_type_info_get_tag(type_info);
491
- switch (type_tag) {
492
- case GI_TYPE_TAG_VOID:
493
- case GI_TYPE_TAG_BOOLEAN:
494
- rb_raise(rb_eNotImpError,
495
- "TODO: invalid array length argument?: <%s>",
496
- g_type_tag_to_string(type_tag));
497
- break;
498
- case GI_TYPE_TAG_INT8:
499
- length = argument->v_int8;
500
- break;
501
- case GI_TYPE_TAG_UINT8:
502
- length = argument->v_uint8;
503
- break;
504
- case GI_TYPE_TAG_INT16:
505
- length = argument->v_int16;
506
- break;
507
- case GI_TYPE_TAG_UINT16:
508
- length = argument->v_uint16;
509
- break;
510
- case GI_TYPE_TAG_INT32:
511
- length = argument->v_int32;
512
- break;
513
- case GI_TYPE_TAG_UINT32:
514
- length = argument->v_uint32;
515
- break;
516
- case GI_TYPE_TAG_INT64:
517
- length = argument->v_int64;
518
- break;
519
- case GI_TYPE_TAG_UINT64:
520
- length = argument->v_uint64;
521
- break;
522
- case GI_TYPE_TAG_FLOAT:
523
- case GI_TYPE_TAG_DOUBLE:
524
- case GI_TYPE_TAG_GTYPE:
525
- case GI_TYPE_TAG_UTF8:
526
- case GI_TYPE_TAG_FILENAME:
527
- case GI_TYPE_TAG_ARRAY:
528
- case GI_TYPE_TAG_INTERFACE:
529
- case GI_TYPE_TAG_GLIST:
530
- case GI_TYPE_TAG_GSLIST:
531
- case GI_TYPE_TAG_GHASH:
532
- case GI_TYPE_TAG_ERROR:
533
- case GI_TYPE_TAG_UNICHAR:
534
- rb_raise(rb_eNotImpError,
535
- "TODO: invalid array length argument?: <%s>",
536
- g_type_tag_to_string(type_tag));
537
- break;
538
- default:
539
- g_assert_not_reached();
540
- break;
541
- }
542
-
543
- return length;
544
- }
545
-
546
- static VALUE
547
- rb_gi_array_argument_to_ruby(GIArgument *array_argument,
548
- GIArgument *length_argument,
549
- GITypeInfo *array_type_info,
550
- GITypeInfo *length_type_info)
551
- {
552
- VALUE rb_array;
553
- GIArrayType array_type;
554
- gint64 n_elements;
555
-
556
- array_type = g_type_info_get_array_type(array_type_info);
557
- n_elements = get_array_length(length_argument, length_type_info);
558
- if (n_elements == -1) {
559
- rb_array = rb_ary_new();
560
- } else {
561
- rb_array = rb_ary_new2(n_elements);
562
- }
563
- switch (array_type) {
564
- case GI_ARRAY_TYPE_C:
565
- array_c_to_ruby(array_argument, array_type_info, n_elements, rb_array);
566
- break;
567
- case GI_ARRAY_TYPE_ARRAY:
568
- array_array_to_ruby(array_argument, array_type_info, rb_array);
569
- break;
570
- case GI_ARRAY_TYPE_PTR_ARRAY:
571
- rb_raise(rb_eNotImpError, "TODO: GIArgument(array)[ptr-array] -> Ruby");
572
- break;
573
- case GI_ARRAY_TYPE_BYTE_ARRAY:
574
- rb_raise(rb_eNotImpError, "TODO: GIArgument(array)[byte-array] -> Ruby");
575
- break;
576
- default:
577
- g_assert_not_reached();
578
- break;
579
- }
580
-
581
- return rb_array;
582
- }
583
-
584
- static VALUE
585
- rb_gi_argument_to_ruby_interface(GIArgument *argument,
586
- gboolean duplicate,
587
- GITypeInfo *type_info)
588
- {
589
- VALUE rb_interface;
590
- GIBaseInfo *interface_info;
591
- GIInfoType interface_type;
592
- GType gtype;
593
-
594
- interface_info = g_type_info_get_interface(type_info);
595
- interface_type = g_base_info_get_type(interface_info);
596
-
597
- gtype = g_registered_type_info_get_g_type(interface_info);
598
- switch (interface_type) {
599
- case GI_INFO_TYPE_INVALID:
600
- rb_raise(rb_eNotImpError,
601
- "TODO: GIArgument(interface)[invalid] -> Ruby");
602
- break;
603
- case GI_INFO_TYPE_FUNCTION:
604
- rb_raise(rb_eNotImpError,
605
- "TODO: GIArgument(interface)[function] -> Ruby");
606
- break;
607
- case GI_INFO_TYPE_CALLBACK:
608
- rb_raise(rb_eNotImpError,
609
- "TODO: GIArgument(interface)[callback] -> Ruby");
610
- break;
611
- case GI_INFO_TYPE_STRUCT:
612
- rb_interface = rb_gi_struct_info_to_ruby(interface_info,
613
- argument->v_pointer,
614
- !duplicate);
615
- break;
616
- case GI_INFO_TYPE_BOXED:
617
- rb_raise(rb_eNotImpError,
618
- "TODO: GIArgument(interface)[boxed] -> Ruby");
619
- break;
620
- case GI_INFO_TYPE_ENUM:
621
- if (gtype == G_TYPE_NONE) {
622
- rb_interface = INT2NUM(argument->v_int32);
623
- } else {
624
- rb_interface = GENUM2RVAL(argument->v_int32, gtype);
625
- }
626
- break;
627
- case GI_INFO_TYPE_FLAGS:
628
- if (gtype == G_TYPE_NONE) {
629
- rb_interface = INT2NUM(argument->v_int32);
630
- } else {
631
- rb_interface = GFLAGS2RVAL(argument->v_int32, gtype);
632
- }
633
- break;
634
- case GI_INFO_TYPE_OBJECT:
635
- rb_interface = GOBJ2RVAL(argument->v_pointer);
636
- break;
637
- case GI_INFO_TYPE_INTERFACE:
638
- rb_interface = GOBJ2RVAL(argument->v_pointer);
639
- break;
640
- case GI_INFO_TYPE_CONSTANT:
641
- rb_raise(rb_eNotImpError,
642
- "TODO: GIArgument(interface)[constant] -> Ruby");
643
- break;
644
- case GI_INFO_TYPE_INVALID_0:
645
- g_assert_not_reached();
646
- break;
647
- case GI_INFO_TYPE_UNION:
648
- rb_interface = BOXED2RVAL(argument->v_pointer, gtype);
649
- break;
650
- case GI_INFO_TYPE_VALUE:
651
- rb_raise(rb_eNotImpError,
652
- "TODO: GIArgument(interface)[value] -> Ruby");
653
- break;
654
- case GI_INFO_TYPE_SIGNAL:
655
- rb_raise(rb_eNotImpError,
656
- "TODO: GIArgument(interface)[signal] -> Ruby");
657
- break;
658
- case GI_INFO_TYPE_VFUNC:
659
- rb_raise(rb_eNotImpError,
660
- "TODO: GIArgument(interface)[vfunc] -> Ruby");
661
- break;
662
- case GI_INFO_TYPE_PROPERTY:
663
- rb_raise(rb_eNotImpError,
664
- "TODO: GIArgument(interface)[property] -> Ruby");
665
- break;
666
- case GI_INFO_TYPE_FIELD:
667
- rb_raise(rb_eNotImpError,
668
- "TODO: GIArgument(interface)[field] -> Ruby");
669
- break;
670
- case GI_INFO_TYPE_ARG:
671
- rb_raise(rb_eNotImpError,
672
- "TODO: GIArgument(interface)[arg] -> Ruby");
673
- break;
674
- case GI_INFO_TYPE_TYPE:
675
- rb_raise(rb_eNotImpError,
676
- "TODO: GIArgument(interface)[type] -> Ruby");
677
- break;
678
- case GI_INFO_TYPE_UNRESOLVED:
679
- rb_raise(rb_eNotImpError,
680
- "TODO: GIArgument(interface)[unresolved] -> Ruby");
681
- break;
682
- default:
683
- g_assert_not_reached();
684
- break;
685
- }
686
-
687
- g_base_info_unref(interface_info);
688
-
689
- return rb_interface;
690
- }
691
-
692
- static void
693
- normalize_out_array_length(GIArgument *normalized_argument,
694
- GIArgument *argument,
695
- RBGIArgMetadata *metadata)
696
- {
697
- switch (metadata->type.tag) {
698
- case GI_TYPE_TAG_VOID:
699
- case GI_TYPE_TAG_BOOLEAN:
700
- rb_raise(rb_eNotImpError,
701
- "TODO: invalid out array length argument?: <%s>",
702
- g_type_tag_to_string(metadata->type.tag));
703
- break;
704
- case GI_TYPE_TAG_INT8:
705
- normalized_argument->v_int8 = *((gint8 *)argument->v_pointer);
706
- break;
707
- case GI_TYPE_TAG_UINT8:
708
- normalized_argument->v_uint8 = *((guint8 *)argument->v_pointer);
709
- break;
710
- case GI_TYPE_TAG_INT16:
711
- normalized_argument->v_int16 = *((gint16 *)argument->v_pointer);
712
- break;
713
- case GI_TYPE_TAG_UINT16:
714
- normalized_argument->v_uint16 = *((guint16 *)argument->v_pointer);
715
- break;
716
- case GI_TYPE_TAG_INT32:
717
- normalized_argument->v_int32 = *((gint32 *)argument->v_pointer);
718
- break;
719
- case GI_TYPE_TAG_UINT32:
720
- normalized_argument->v_uint32 = *((guint32 *)argument->v_pointer);
721
- break;
722
- case GI_TYPE_TAG_INT64:
723
- normalized_argument->v_int64 = *((gint64 *)argument->v_pointer);
724
- break;
725
- case GI_TYPE_TAG_UINT64:
726
- normalized_argument->v_uint64 = *((guint64 *)argument->v_pointer);
727
- break;
728
- case GI_TYPE_TAG_FLOAT:
729
- case GI_TYPE_TAG_DOUBLE:
730
- case GI_TYPE_TAG_GTYPE:
731
- case GI_TYPE_TAG_UTF8:
732
- case GI_TYPE_TAG_FILENAME:
733
- case GI_TYPE_TAG_ARRAY:
734
- case GI_TYPE_TAG_INTERFACE:
735
- case GI_TYPE_TAG_GLIST:
736
- case GI_TYPE_TAG_GSLIST:
737
- case GI_TYPE_TAG_GHASH:
738
- case GI_TYPE_TAG_ERROR:
739
- case GI_TYPE_TAG_UNICHAR:
740
- rb_raise(rb_eNotImpError,
741
- "TODO: invalid out array length argument?: <%s>",
742
- g_type_tag_to_string(metadata->type.tag));
743
- break;
744
- default:
745
- g_assert_not_reached();
746
- break;
747
- }
748
- }
749
-
750
- static VALUE
751
- rb_gi_argument_to_ruby_array(GIArgument *array_argument,
752
- GITypeInfo *array_type_info,
753
- GArray *in_args,
754
- GArray *out_args,
755
- GPtrArray *args_metadata)
756
- {
757
- VALUE rb_array;
758
- gint length_index;
759
- GIArgument *length_argument = NULL;
760
- GIArgument normalized_length_argument;
761
- GITypeInfo *length_type_info = NULL;
762
-
763
- length_index = g_type_info_get_array_length(array_type_info);
764
- if (length_index != -1) {
765
- RBGIArgMetadata *length_metadata;
766
- GIArgument *raw_length_argument = NULL;
767
-
768
- length_metadata = g_ptr_array_index(args_metadata, length_index);
769
- length_type_info = length_metadata->type.info;
770
- if (length_metadata->direction == GI_DIRECTION_OUT) {
771
- raw_length_argument = &g_array_index(out_args, GIArgument,
772
- length_metadata->out_arg_index);
773
- } else if (length_metadata->direction == GI_DIRECTION_INOUT) {
774
- raw_length_argument = &g_array_index(in_args, GIArgument,
775
- length_metadata->in_arg_index);
776
- }
777
-
778
- if (raw_length_argument) {
779
- if (length_metadata->array_metadata &&
780
- length_metadata->array_metadata->output_buffer_p) {
781
- length_argument = raw_length_argument;
782
- } else {
783
- normalize_out_array_length(&normalized_length_argument,
784
- raw_length_argument,
785
- length_metadata);
786
- length_argument = &normalized_length_argument;
787
- }
788
- } else {
789
- length_argument = &g_array_index(in_args, GIArgument,
790
- length_metadata->in_arg_index);
791
- }
792
- }
793
-
794
- rb_array = rb_gi_array_argument_to_ruby(array_argument,
795
- length_argument,
796
- array_type_info,
797
- length_type_info);
798
-
799
- return rb_array;
800
- }
801
-
802
- static VALUE
803
- rb_gi_argument_to_ruby_glist_interface(GIArgument *argument,
804
- G_GNUC_UNUSED GITypeInfo *type_info,
805
- GITypeInfo *element_type_info)
806
- {
807
- VALUE rb_argument = Qnil;
808
- GIBaseInfo *interface_info;
809
- GIInfoType interface_type;
810
- const gchar *interface_name;
811
- GType gtype;
812
-
813
- interface_info = g_type_info_get_interface(element_type_info);
814
- interface_type = g_base_info_get_type(interface_info);
815
- interface_name = g_info_type_to_string(interface_type);
816
- gtype = g_registered_type_info_get_g_type(interface_info);
817
-
818
- switch (interface_type) {
819
- case GI_INFO_TYPE_INVALID:
820
- case GI_INFO_TYPE_FUNCTION:
821
- case GI_INFO_TYPE_CALLBACK:
822
- g_base_info_unref(interface_info);
823
- g_base_info_unref(element_type_info);
824
- rb_raise(rb_eNotImpError,
825
- "TODO: GIArgument(GList)[interface(%s)](%s) -> Ruby",
826
- interface_name,
827
- g_type_name(gtype));
828
- break;
829
- case GI_INFO_TYPE_STRUCT:
830
- if (gtype == G_TYPE_NONE) {
831
- GList *node;
832
- rb_argument = rb_ary_new();
833
- for (node = argument->v_pointer; node; node = g_list_next(node)) {
834
- rb_ary_push(rb_argument,
835
- rb_gi_struct_info_to_ruby(interface_info,
836
- node->data,
837
- TRUE));
838
- }
839
- } else {
840
- rb_argument = BOXEDGLIST2RVAL(argument->v_pointer, gtype);
841
- }
842
- break;
843
- case GI_INFO_TYPE_BOXED:
844
- rb_argument = BOXEDGLIST2RVAL(argument->v_pointer, gtype);
845
- break;
846
- case GI_INFO_TYPE_ENUM:
847
- case GI_INFO_TYPE_FLAGS:
848
- g_base_info_unref(interface_info);
849
- g_base_info_unref(element_type_info);
850
- rb_raise(rb_eNotImpError,
851
- "TODO: GIArgument(GList)[interface(%s)](%s) -> Ruby",
852
- interface_name,
853
- g_type_name(gtype));
854
- break;
855
- case GI_INFO_TYPE_OBJECT:
856
- case GI_INFO_TYPE_INTERFACE:
857
- rb_argument = GOBJGLIST2RVAL(argument->v_pointer);
858
- break;
859
- case GI_INFO_TYPE_CONSTANT:
860
- case GI_INFO_TYPE_INVALID_0:
861
- case GI_INFO_TYPE_UNION:
862
- case GI_INFO_TYPE_VALUE:
863
- case GI_INFO_TYPE_SIGNAL:
864
- case GI_INFO_TYPE_VFUNC:
865
- case GI_INFO_TYPE_PROPERTY:
866
- case GI_INFO_TYPE_FIELD:
867
- case GI_INFO_TYPE_ARG:
868
- case GI_INFO_TYPE_TYPE:
869
- case GI_INFO_TYPE_UNRESOLVED:
870
- g_base_info_unref(interface_info);
871
- g_base_info_unref(element_type_info);
872
- rb_raise(rb_eNotImpError,
873
- "TODO: GIArgument(GList)[interface(%s)](%s) -> Ruby",
874
- interface_name,
875
- g_type_name(gtype));
876
- break;
877
- default:
878
- g_assert_not_reached();
879
- break;
880
- }
881
-
882
- g_base_info_unref(interface_info);
883
- g_base_info_unref(element_type_info);
884
-
885
- return rb_argument;
886
- }
887
-
888
- static VALUE
889
- rb_gi_argument_to_ruby_glist(GIArgument *argument, GITypeInfo *type_info)
890
- {
891
- VALUE rb_argument;
892
- GITypeInfo *element_type_info;
893
- GITypeTag element_type_tag;
894
-
895
- element_type_info = g_type_info_get_param_type(type_info, 0);
896
- element_type_tag = g_type_info_get_tag(element_type_info);
897
-
898
- switch (element_type_tag) {
899
- case GI_TYPE_TAG_VOID:
900
- case GI_TYPE_TAG_BOOLEAN:
901
- case GI_TYPE_TAG_INT8:
902
- case GI_TYPE_TAG_UINT8:
903
- case GI_TYPE_TAG_INT16:
904
- case GI_TYPE_TAG_UINT16:
905
- case GI_TYPE_TAG_INT32:
906
- case GI_TYPE_TAG_UINT32:
907
- case GI_TYPE_TAG_INT64:
908
- case GI_TYPE_TAG_UINT64:
909
- case GI_TYPE_TAG_FLOAT:
910
- case GI_TYPE_TAG_DOUBLE:
911
- case GI_TYPE_TAG_GTYPE:
912
- g_base_info_unref(element_type_info);
913
- rb_raise(rb_eNotImpError,
914
- "TODO: GIArgument(GList)[%s] -> Ruby",
915
- g_type_tag_to_string(element_type_tag));
916
- break;
917
- case GI_TYPE_TAG_UTF8:
918
- g_base_info_unref(element_type_info);
919
- rb_argument = CSTRGLIST2RVAL(argument->v_pointer);
920
- break;
921
- case GI_TYPE_TAG_FILENAME:
922
- case GI_TYPE_TAG_ARRAY:
923
- g_base_info_unref(element_type_info);
924
- rb_raise(rb_eNotImpError,
925
- "TODO: GIArgument(GList)[%s] -> Ruby",
926
- g_type_tag_to_string(element_type_tag));
927
- break;
928
- case GI_TYPE_TAG_INTERFACE:
929
- rb_argument = rb_gi_argument_to_ruby_glist_interface(argument,
930
- type_info,
931
- element_type_info);
932
- break;
933
- case GI_TYPE_TAG_GLIST:
934
- case GI_TYPE_TAG_GSLIST:
935
- case GI_TYPE_TAG_GHASH:
936
- case GI_TYPE_TAG_ERROR:
937
- case GI_TYPE_TAG_UNICHAR:
938
- g_base_info_unref(element_type_info);
939
- rb_raise(rb_eNotImpError,
940
- "TODO: GIArgument(GList)[%s] -> Ruby",
941
- g_type_tag_to_string(element_type_tag));
942
- break;
943
- default:
944
- g_base_info_unref(element_type_info);
945
- g_assert_not_reached();
946
- break;
947
- }
948
-
949
- return rb_argument;
950
- }
951
-
952
- static VALUE
953
- rb_gi_argument_to_ruby_gslist_interface(GIArgument *argument,
954
- G_GNUC_UNUSED GITypeInfo *type_info,
955
- GITypeInfo *element_type_info)
956
- {
957
- VALUE rb_argument = Qnil;
958
- GIBaseInfo *interface_info;
959
- GIInfoType interface_type;
960
- const gchar *interface_name;
961
- GType gtype;
962
-
963
- interface_info = g_type_info_get_interface(element_type_info);
964
- interface_type = g_base_info_get_type(interface_info);
965
- interface_name = g_info_type_to_string(interface_type);
966
- gtype = g_registered_type_info_get_g_type(interface_info);
967
-
968
- switch (interface_type) {
969
- case GI_INFO_TYPE_INVALID:
970
- case GI_INFO_TYPE_FUNCTION:
971
- case GI_INFO_TYPE_CALLBACK:
972
- g_base_info_unref(interface_info);
973
- g_base_info_unref(element_type_info);
974
- rb_raise(rb_eNotImpError,
975
- "TODO: GIArgument(GSList)[interface(%s)](%s) -> Ruby",
976
- interface_name,
977
- g_type_name(gtype));
978
- break;
979
- case GI_INFO_TYPE_STRUCT:
980
- if (gtype == G_TYPE_NONE) {
981
- GSList *node;
982
- rb_argument = rb_ary_new();
983
- for (node = argument->v_pointer; node; node = g_slist_next(node)) {
984
- rb_ary_push(rb_argument,
985
- rb_gi_struct_info_to_ruby(interface_info,
986
- node->data,
987
- TRUE));
988
- }
989
- } else {
990
- rb_argument = BOXEDGLIST2RVAL(argument->v_pointer, gtype);
991
- }
992
- break;
993
- case GI_INFO_TYPE_BOXED:
994
- rb_argument = BOXEDGLIST2RVAL(argument->v_pointer, gtype);
995
- break;
996
- case GI_INFO_TYPE_ENUM:
997
- case GI_INFO_TYPE_FLAGS:
998
- case GI_INFO_TYPE_OBJECT:
999
- case GI_INFO_TYPE_INTERFACE:
1000
- rb_argument = GOBJGLIST2RVAL(argument->v_pointer);
1001
- break;
1002
- case GI_INFO_TYPE_CONSTANT:
1003
- case GI_INFO_TYPE_INVALID_0:
1004
- case GI_INFO_TYPE_UNION:
1005
- case GI_INFO_TYPE_VALUE:
1006
- case GI_INFO_TYPE_SIGNAL:
1007
- case GI_INFO_TYPE_VFUNC:
1008
- case GI_INFO_TYPE_PROPERTY:
1009
- case GI_INFO_TYPE_FIELD:
1010
- case GI_INFO_TYPE_ARG:
1011
- case GI_INFO_TYPE_TYPE:
1012
- case GI_INFO_TYPE_UNRESOLVED:
1013
- g_base_info_unref(interface_info);
1014
- g_base_info_unref(element_type_info);
1015
- rb_raise(rb_eNotImpError,
1016
- "TODO: GIArgument(GSList)[interface(%s)](%s) -> Ruby",
1017
- interface_name,
1018
- g_type_name(gtype));
1019
- break;
1020
- default:
1021
- g_assert_not_reached();
1022
- break;
1023
- }
1024
-
1025
- g_base_info_unref(interface_info);
1026
- g_base_info_unref(element_type_info);
1027
-
1028
- return rb_argument;
1029
- }
1030
-
1031
- static VALUE
1032
- rb_gi_argument_to_ruby_gslist(GIArgument *argument, GITypeInfo *type_info)
1033
- {
1034
- VALUE rb_argument;
1035
- GITypeInfo *element_type_info;
1036
- GITypeTag element_type_tag;
1037
-
1038
- element_type_info = g_type_info_get_param_type(type_info, 0);
1039
- element_type_tag = g_type_info_get_tag(element_type_info);
1040
-
1041
- switch (element_type_tag) {
1042
- case GI_TYPE_TAG_VOID:
1043
- case GI_TYPE_TAG_BOOLEAN:
1044
- case GI_TYPE_TAG_INT8:
1045
- case GI_TYPE_TAG_UINT8:
1046
- case GI_TYPE_TAG_INT16:
1047
- case GI_TYPE_TAG_UINT16:
1048
- case GI_TYPE_TAG_INT32:
1049
- case GI_TYPE_TAG_UINT32:
1050
- case GI_TYPE_TAG_INT64:
1051
- case GI_TYPE_TAG_UINT64:
1052
- case GI_TYPE_TAG_FLOAT:
1053
- case GI_TYPE_TAG_DOUBLE:
1054
- case GI_TYPE_TAG_GTYPE:
1055
- g_base_info_unref(element_type_info);
1056
- rb_raise(rb_eNotImpError,
1057
- "TODO: GIArgument(GSList)[%s] -> Ruby",
1058
- g_type_tag_to_string(element_type_tag));
1059
- break;
1060
- case GI_TYPE_TAG_UTF8:
1061
- g_base_info_unref(element_type_info);
1062
- rb_argument = CSTRGSLIST2RVAL(argument->v_pointer);
1063
- break;
1064
- case GI_TYPE_TAG_FILENAME:
1065
- g_base_info_unref(element_type_info);
1066
- rb_argument = FILENAMEGSLIST2RVAL(argument->v_pointer);
1067
- break;
1068
- case GI_TYPE_TAG_ARRAY:
1069
- g_base_info_unref(element_type_info);
1070
- rb_raise(rb_eNotImpError,
1071
- "TODO: GIArgument(GSList)[%s] -> Ruby",
1072
- g_type_tag_to_string(element_type_tag));
1073
- break;
1074
- case GI_TYPE_TAG_INTERFACE:
1075
- rb_argument = rb_gi_argument_to_ruby_gslist_interface(argument,
1076
- type_info,
1077
- element_type_info);
1078
- break;
1079
- case GI_TYPE_TAG_GLIST:
1080
- case GI_TYPE_TAG_GSLIST:
1081
- case GI_TYPE_TAG_GHASH:
1082
- case GI_TYPE_TAG_ERROR:
1083
- case GI_TYPE_TAG_UNICHAR:
1084
- g_base_info_unref(element_type_info);
1085
- rb_raise(rb_eNotImpError,
1086
- "TODO: GIArgument(GSList)[%s] -> Ruby",
1087
- g_type_tag_to_string(element_type_tag));
1088
- break;
1089
- default:
1090
- g_base_info_unref(element_type_info);
1091
- g_assert_not_reached();
1092
- break;
1093
- }
1094
-
1095
- return rb_argument;
1096
- }
1097
-
1098
- typedef struct {
1099
- GIArgument *argument;
1100
- VALUE rb_table;
1101
- GITypeInfo *key_type_info;
1102
- GITypeTag key_type_tag;
1103
- GITypeInfo *value_type_info;
1104
- GITypeTag value_type_tag;
1105
- } GHashToRubyData;
1106
-
1107
- static void
1108
- rb_gi_argument_to_ruby_ghash_foreach_body(gpointer key,
1109
- gpointer value,
1110
- gpointer user_data)
1111
- {
1112
- GHashToRubyData *data = user_data;
1113
- VALUE rb_key;
1114
- VALUE rb_value;
1115
-
1116
- switch (data->key_type_tag) {
1117
- case GI_TYPE_TAG_VOID:
1118
- case GI_TYPE_TAG_BOOLEAN:
1119
- case GI_TYPE_TAG_INT8:
1120
- case GI_TYPE_TAG_UINT8:
1121
- case GI_TYPE_TAG_INT16:
1122
- case GI_TYPE_TAG_UINT16:
1123
- case GI_TYPE_TAG_INT32:
1124
- case GI_TYPE_TAG_UINT32:
1125
- case GI_TYPE_TAG_INT64:
1126
- case GI_TYPE_TAG_UINT64:
1127
- case GI_TYPE_TAG_FLOAT:
1128
- case GI_TYPE_TAG_DOUBLE:
1129
- case GI_TYPE_TAG_GTYPE:
1130
- rb_raise(rb_eNotImpError,
1131
- "TODO: GIArgument(GHash)[%s][%s] -> Ruby",
1132
- g_type_tag_to_string(data->key_type_tag),
1133
- g_type_tag_to_string(data->value_type_tag));
1134
- break;
1135
- case GI_TYPE_TAG_UTF8:
1136
- rb_key = CSTR2RVAL(key);
1137
- break;
1138
- case GI_TYPE_TAG_FILENAME:
1139
- case GI_TYPE_TAG_ARRAY:
1140
- rb_raise(rb_eNotImpError,
1141
- "TODO: GIArgument(GHash)[%s][%s] -> Ruby",
1142
- g_type_tag_to_string(data->key_type_tag),
1143
- g_type_tag_to_string(data->value_type_tag));
1144
- break;
1145
- case GI_TYPE_TAG_INTERFACE:
1146
- {
1147
- GIArgument key_argument;
1148
- key_argument.v_pointer = key;
1149
- rb_key = rb_gi_argument_to_ruby_interface(&key_argument,
1150
- FALSE,
1151
- data->key_type_info);
1152
- }
1153
- break;
1154
- case GI_TYPE_TAG_GLIST:
1155
- case GI_TYPE_TAG_GSLIST:
1156
- case GI_TYPE_TAG_GHASH:
1157
- case GI_TYPE_TAG_ERROR:
1158
- case GI_TYPE_TAG_UNICHAR:
1159
- rb_raise(rb_eNotImpError,
1160
- "TODO: GIArgument(GHash)[%s][%s] -> Ruby",
1161
- g_type_tag_to_string(data->key_type_tag),
1162
- g_type_tag_to_string(data->value_type_tag));
1163
- break;
1164
- default:
1165
- g_assert_not_reached();
1166
- break;
1167
- }
1168
-
1169
- switch (data->value_type_tag) {
1170
- case GI_TYPE_TAG_VOID:
1171
- case GI_TYPE_TAG_BOOLEAN:
1172
- case GI_TYPE_TAG_INT8:
1173
- case GI_TYPE_TAG_UINT8:
1174
- case GI_TYPE_TAG_INT16:
1175
- case GI_TYPE_TAG_UINT16:
1176
- case GI_TYPE_TAG_INT32:
1177
- case GI_TYPE_TAG_UINT32:
1178
- case GI_TYPE_TAG_INT64:
1179
- case GI_TYPE_TAG_UINT64:
1180
- case GI_TYPE_TAG_FLOAT:
1181
- case GI_TYPE_TAG_DOUBLE:
1182
- case GI_TYPE_TAG_GTYPE:
1183
- rb_raise(rb_eNotImpError,
1184
- "TODO: GIArgument(GHash)[%s][%s] -> Ruby",
1185
- g_type_tag_to_string(data->key_type_tag),
1186
- g_type_tag_to_string(data->value_type_tag));
1187
- break;
1188
- case GI_TYPE_TAG_UTF8:
1189
- rb_value = CSTR2RVAL(value);
1190
- break;
1191
- case GI_TYPE_TAG_FILENAME:
1192
- case GI_TYPE_TAG_ARRAY:
1193
- rb_raise(rb_eNotImpError,
1194
- "TODO: GIArgument(GHash)[%s][%s] -> Ruby",
1195
- g_type_tag_to_string(data->key_type_tag),
1196
- g_type_tag_to_string(data->value_type_tag));
1197
- break;
1198
- case GI_TYPE_TAG_INTERFACE:
1199
- {
1200
- GIArgument value_argument;
1201
- value_argument.v_pointer = value;
1202
- rb_value = rb_gi_argument_to_ruby_interface(&value_argument,
1203
- FALSE,
1204
- data->value_type_info);
1205
- }
1206
- break;
1207
- case GI_TYPE_TAG_GLIST:
1208
- case GI_TYPE_TAG_GSLIST:
1209
- case GI_TYPE_TAG_GHASH:
1210
- case GI_TYPE_TAG_ERROR:
1211
- case GI_TYPE_TAG_UNICHAR:
1212
- rb_raise(rb_eNotImpError,
1213
- "TODO: GIArgument(GHash)[%s][%s] -> Ruby",
1214
- g_type_tag_to_string(data->key_type_tag),
1215
- g_type_tag_to_string(data->value_type_tag));
1216
- break;
1217
- default:
1218
- g_assert_not_reached();
1219
- break;
1220
- }
1221
-
1222
- rb_hash_aset(data->rb_table, rb_key, rb_value);
1223
- }
1224
-
1225
- static VALUE
1226
- rb_gi_argument_to_ruby_ghash_body(VALUE user_data)
1227
- {
1228
- GHashToRubyData *data = (GHashToRubyData *)user_data;
1229
-
1230
- g_hash_table_foreach(data->argument->v_pointer,
1231
- rb_gi_argument_to_ruby_ghash_foreach_body,
1232
- data);
1233
-
1234
- return data->rb_table;
1235
- }
1236
-
1237
- static VALUE
1238
- rb_gi_argument_to_ruby_ghash_ensure(VALUE user_data)
1239
- {
1240
- GHashToRubyData *data = (GHashToRubyData *)user_data;
1241
-
1242
- g_base_info_unref(data->key_type_info);
1243
- g_base_info_unref(data->value_type_info);
1244
-
1245
- return Qnil;
1246
- }
1247
-
1248
- static VALUE
1249
- rb_gi_argument_to_ruby_ghash(GIArgument *argument, GITypeInfo *type_info)
1250
- {
1251
- GHashToRubyData data;
1252
-
1253
- data.argument = argument;
1254
- data.rb_table = rb_hash_new();
1255
-
1256
- data.key_type_info = g_type_info_get_param_type(type_info, 0);
1257
- data.key_type_tag = g_type_info_get_tag(data.key_type_info);
1258
-
1259
- data.value_type_info = g_type_info_get_param_type(type_info, 1);
1260
- data.value_type_tag = g_type_info_get_tag(data.value_type_info);
1261
-
1262
- return rb_ensure(rb_gi_argument_to_ruby_ghash_body, (VALUE)&data,
1263
- rb_gi_argument_to_ruby_ghash_ensure, (VALUE)&data);
1264
- }
1265
-
1266
- static VALUE
1267
- rb_gi_argument_to_ruby_unichar(GIArgument *argument)
1268
- {
1269
- VALUE rb_argument;
1270
- gunichar ucs4_character;
1271
- gchar *utf8_string;
1272
- GError *error = NULL;
1273
-
1274
- ucs4_character = argument->v_uint32;
1275
- utf8_string = g_ucs4_to_utf8(&ucs4_character, 1, NULL, NULL, &error);
1276
- if (error) {
1277
- RG_RAISE_ERROR(error);
1278
- }
1279
- rb_argument = CSTR2RVAL_FREE(utf8_string);
1280
-
1281
- return rb_argument;
1282
- }
1283
-
1284
- VALUE
1285
- rb_gi_argument_to_ruby(GIArgument *argument,
1286
- gboolean duplicate,
1287
- GITypeInfo *type_info,
1288
- GArray *in_args,
1289
- GArray *out_args,
1290
- GPtrArray *args_metadata)
1291
- {
1292
- VALUE rb_argument = Qnil;
1293
- GITypeTag type_tag;
1294
-
1295
- type_tag = g_type_info_get_tag(type_info);
1296
- switch (type_tag) {
1297
- case GI_TYPE_TAG_VOID:
1298
- if (g_type_info_is_pointer(type_info)) {
1299
- rb_argument = ULONG2NUM(GPOINTER_TO_UINT(argument->v_pointer));
1300
- } else {
1301
- rb_argument = Qnil;
1302
- }
1303
- break;
1304
- case GI_TYPE_TAG_BOOLEAN:
1305
- rb_argument = CBOOL2RVAL(argument->v_boolean);
1306
- break;
1307
- case GI_TYPE_TAG_INT8:
1308
- rb_argument = INT2NUM(argument->v_int8);
1309
- break;
1310
- case GI_TYPE_TAG_UINT8:
1311
- rb_argument = UINT2NUM(argument->v_uint8);
1312
- break;
1313
- case GI_TYPE_TAG_INT16:
1314
- rb_argument = INT2NUM(argument->v_int16);
1315
- break;
1316
- case GI_TYPE_TAG_UINT16:
1317
- rb_argument = UINT2NUM(argument->v_uint16);
1318
- break;
1319
- case GI_TYPE_TAG_INT32:
1320
- rb_argument = INT2NUM(argument->v_int32);
1321
- break;
1322
- case GI_TYPE_TAG_UINT32:
1323
- rb_argument = UINT2NUM(argument->v_uint32);
1324
- break;
1325
- case GI_TYPE_TAG_INT64:
1326
- rb_argument = LL2NUM(argument->v_int64);
1327
- break;
1328
- case GI_TYPE_TAG_UINT64:
1329
- rb_argument = ULL2NUM(argument->v_uint64);
1330
- break;
1331
- case GI_TYPE_TAG_FLOAT:
1332
- rb_argument = DBL2NUM(argument->v_float);
1333
- break;
1334
- case GI_TYPE_TAG_DOUBLE:
1335
- rb_argument = DBL2NUM(argument->v_double);
1336
- break;
1337
- case GI_TYPE_TAG_GTYPE:
1338
- if (argument->v_size == G_TYPE_INVALID) {
1339
- rb_argument = Qnil;
1340
- } else {
1341
- rb_argument = rbgobj_gtype_new(argument->v_size);
1342
- }
1343
- break;
1344
- case GI_TYPE_TAG_UTF8:
1345
- rb_argument = CSTR2RVAL(argument->v_string);
1346
- break;
1347
- case GI_TYPE_TAG_FILENAME:
1348
- /* TODO: set encoding */
1349
- rb_argument = CSTR2RVAL(argument->v_string);
1350
- break;
1351
- case GI_TYPE_TAG_ARRAY:
1352
- rb_argument = rb_gi_argument_to_ruby_array(argument,
1353
- type_info,
1354
- in_args,
1355
- out_args,
1356
- args_metadata);
1357
- break;
1358
- case GI_TYPE_TAG_INTERFACE:
1359
- rb_argument = rb_gi_argument_to_ruby_interface(argument,
1360
- duplicate,
1361
- type_info);
1362
- break;
1363
- case GI_TYPE_TAG_GLIST:
1364
- rb_argument = rb_gi_argument_to_ruby_glist(argument, type_info);
1365
- break;
1366
- case GI_TYPE_TAG_GSLIST:
1367
- rb_argument = rb_gi_argument_to_ruby_gslist(argument, type_info);
1368
- break;
1369
- case GI_TYPE_TAG_GHASH:
1370
- rb_argument = rb_gi_argument_to_ruby_ghash(argument, type_info);
1371
- break;
1372
- case GI_TYPE_TAG_ERROR:
1373
- rb_argument = GERROR2RVAL(argument->v_pointer);
1374
- break;
1375
- case GI_TYPE_TAG_UNICHAR:
1376
- rb_argument = rb_gi_argument_to_ruby_unichar(argument);
1377
- break;
1378
- default:
1379
- g_assert_not_reached();
1380
- break;
1381
- }
1382
-
1383
- return rb_argument;
1384
- }
1385
-
1386
- static void
1387
- rb_gi_return_argument_free_container(GIArgument *argument,
1388
- GITypeInfo *type_info)
1389
- {
1390
- GITypeTag type_tag;
1391
-
1392
- type_tag = g_type_info_get_tag(type_info);
1393
-
1394
- switch (type_tag) {
1395
- case GI_TYPE_TAG_VOID:
1396
- case GI_TYPE_TAG_BOOLEAN:
1397
- case GI_TYPE_TAG_INT8:
1398
- case GI_TYPE_TAG_UINT8:
1399
- case GI_TYPE_TAG_INT16:
1400
- case GI_TYPE_TAG_UINT16:
1401
- case GI_TYPE_TAG_INT32:
1402
- case GI_TYPE_TAG_UINT32:
1403
- case GI_TYPE_TAG_INT64:
1404
- case GI_TYPE_TAG_UINT64:
1405
- case GI_TYPE_TAG_FLOAT:
1406
- case GI_TYPE_TAG_DOUBLE:
1407
- case GI_TYPE_TAG_GTYPE:
1408
- case GI_TYPE_TAG_UTF8:
1409
- case GI_TYPE_TAG_FILENAME:
1410
- rb_raise(rb_eNotImpError,
1411
- "TODO: free GIArgument(%s) as container",
1412
- g_type_tag_to_string(type_tag));
1413
- break;
1414
- case GI_TYPE_TAG_ARRAY:
1415
- g_free(argument->v_pointer);
1416
- break;
1417
- case GI_TYPE_TAG_INTERFACE:
1418
- rb_raise(rb_eNotImpError,
1419
- "TODO: free GIArgument(%s) as container",
1420
- g_type_tag_to_string(type_tag));
1421
- break;
1422
- case GI_TYPE_TAG_GLIST:
1423
- g_list_free(argument->v_pointer);
1424
- break;
1425
- case GI_TYPE_TAG_GSLIST:
1426
- g_slist_free(argument->v_pointer);
1427
- break;
1428
- case GI_TYPE_TAG_GHASH:
1429
- g_hash_table_unref(argument->v_pointer);
1430
- break;
1431
- case GI_TYPE_TAG_ERROR:
1432
- case GI_TYPE_TAG_UNICHAR:
1433
- rb_raise(rb_eNotImpError,
1434
- "TODO: free GIArgument(%s) as container",
1435
- g_type_tag_to_string(type_tag));
1436
- break;
1437
- default:
1438
- g_assert_not_reached();
1439
- break;
1440
- }
1441
- }
1442
-
1443
- static void
1444
- rb_gi_return_argument_free_everything_array_c(GIArgument *argument,
1445
- GITypeInfo *type_info)
1446
- {
1447
- GITypeInfo *element_type_info;
1448
- GITypeTag element_type_tag;
1449
-
1450
- element_type_info = g_type_info_get_param_type(type_info, 0);
1451
- element_type_tag = g_type_info_get_tag(element_type_info);
1452
- g_base_info_unref(element_type_info);
1453
-
1454
- switch (element_type_tag) {
1455
- case GI_TYPE_TAG_VOID:
1456
- rb_raise(rb_eNotImpError,
1457
- "TODO: free GIArgument(array)[c][%s] everything",
1458
- g_type_tag_to_string(element_type_tag));
1459
- break;
1460
- case GI_TYPE_TAG_BOOLEAN:
1461
- case GI_TYPE_TAG_INT8:
1462
- case GI_TYPE_TAG_UINT8:
1463
- case GI_TYPE_TAG_INT16:
1464
- case GI_TYPE_TAG_UINT16:
1465
- case GI_TYPE_TAG_INT32:
1466
- case GI_TYPE_TAG_UINT32:
1467
- case GI_TYPE_TAG_INT64:
1468
- case GI_TYPE_TAG_UINT64:
1469
- case GI_TYPE_TAG_FLOAT:
1470
- case GI_TYPE_TAG_DOUBLE:
1471
- g_free(argument->v_pointer);
1472
- break;
1473
- case GI_TYPE_TAG_GTYPE:
1474
- rb_raise(rb_eNotImpError,
1475
- "TODO: free GIArgument(array)[c][%s] everything",
1476
- g_type_tag_to_string(element_type_tag));
1477
- break;
1478
- case GI_TYPE_TAG_UTF8:
1479
- g_strfreev(argument->v_pointer);
1480
- break;
1481
- case GI_TYPE_TAG_FILENAME:
1482
- g_strfreev(argument->v_pointer);
1483
- break;
1484
- case GI_TYPE_TAG_ARRAY:
1485
- case GI_TYPE_TAG_INTERFACE:
1486
- case GI_TYPE_TAG_GLIST:
1487
- case GI_TYPE_TAG_GSLIST:
1488
- case GI_TYPE_TAG_GHASH:
1489
- case GI_TYPE_TAG_ERROR:
1490
- case GI_TYPE_TAG_UNICHAR:
1491
- rb_raise(rb_eNotImpError,
1492
- "TODO: free GIArgument(array)[c][%s] everything",
1493
- g_type_tag_to_string(element_type_tag));
1494
- break;
1495
- default:
1496
- g_assert_not_reached();
1497
- break;
1498
- }
1499
- }
1500
-
1501
- static void
1502
- rb_gi_return_argument_free_everything_array(GIArgument *argument,
1503
- GITypeInfo *type_info)
1504
- {
1505
- switch (g_type_info_get_array_type(type_info)) {
1506
- case GI_ARRAY_TYPE_C:
1507
- rb_gi_return_argument_free_everything_array_c(argument, type_info);
1508
- break;
1509
- case GI_ARRAY_TYPE_ARRAY:
1510
- g_array_free(argument->v_pointer, TRUE);
1511
- break;
1512
- case GI_ARRAY_TYPE_PTR_ARRAY:
1513
- g_ptr_array_free(argument->v_pointer, TRUE);
1514
- break;
1515
- case GI_ARRAY_TYPE_BYTE_ARRAY:
1516
- g_ptr_array_free(argument->v_pointer, TRUE);
1517
- break;
1518
- default:
1519
- g_assert_not_reached();
1520
- break;
1521
- }
1522
- }
1523
-
1524
- static void
1525
- rb_gi_return_argument_free_everything_interface_struct(GIArgument *argument,
1526
- GType gtype)
1527
- {
1528
- if (!argument->v_pointer) {
1529
- return;
1530
- }
1531
-
1532
- if (!gtype) {
1533
- xfree(argument->v_pointer);
1534
- }
1535
-
1536
- if (G_TYPE_IS_BOXED(gtype)) {
1537
- g_boxed_free(gtype, argument->v_pointer);
1538
- } else {
1539
- rbgobj_instance_unref(argument->v_pointer);
1540
- }
1541
- }
1542
-
1543
- static void
1544
- rb_gi_return_argument_free_everything_interface(GIArgument *argument,
1545
- GITypeInfo *type_info)
1546
- {
1547
- GIBaseInfo *interface_info;
1548
- GIInfoType interface_type;
1549
- GType gtype;
1550
-
1551
- interface_info = g_type_info_get_interface(type_info);
1552
- interface_type = g_base_info_get_type(interface_info);
1553
- gtype = g_registered_type_info_get_g_type(interface_info);
1554
- g_base_info_unref(interface_info);
1555
-
1556
- switch (interface_type) {
1557
- case GI_INFO_TYPE_INVALID:
1558
- rb_raise(rb_eNotImpError,
1559
- "TODO: free GIArgument(interface)[invalid] everything");
1560
- break;
1561
- case GI_INFO_TYPE_FUNCTION:
1562
- rb_raise(rb_eNotImpError,
1563
- "TODO: free GIArgument(interface)[function] everything");
1564
- break;
1565
- case GI_INFO_TYPE_CALLBACK:
1566
- rb_raise(rb_eNotImpError,
1567
- "TODO: free GIArgument(interface)[callback] everything");
1568
- break;
1569
- case GI_INFO_TYPE_STRUCT:
1570
- rb_gi_return_argument_free_everything_interface_struct(argument, gtype);
1571
- break;
1572
- case GI_INFO_TYPE_BOXED:
1573
- rb_raise(rb_eNotImpError,
1574
- "TODO: free GIArgument(interface)[boxed] everything");
1575
- break;
1576
- case GI_INFO_TYPE_ENUM:
1577
- rb_raise(rb_eNotImpError,
1578
- "TODO: free GIArgument(interface)[enum] everything");
1579
- break;
1580
- case GI_INFO_TYPE_FLAGS:
1581
- rb_raise(rb_eNotImpError,
1582
- "TODO: free GIArgument(interface)[flags] everything");
1583
- break;
1584
- case GI_INFO_TYPE_OBJECT:
1585
- if (argument->v_pointer) {
1586
- GObject *object = argument->v_pointer;
1587
- if (g_object_is_floating(object)) {
1588
- g_object_ref_sink(object);
1589
- }
1590
- g_object_unref(object);
1591
- }
1592
- break;
1593
- case GI_INFO_TYPE_INTERFACE:
1594
- if (argument->v_pointer) {
1595
- g_object_unref(argument->v_pointer);
1596
- }
1597
- break;
1598
- case GI_INFO_TYPE_CONSTANT:
1599
- rb_raise(rb_eNotImpError,
1600
- "TODO: free GIArgument(interface)[constant] everything");
1601
- break;
1602
- case GI_INFO_TYPE_INVALID_0:
1603
- g_assert_not_reached();
1604
- break;
1605
- case GI_INFO_TYPE_UNION:
1606
- if (gtype == G_TYPE_NONE) {
1607
- rb_raise(rb_eNotImpError,
1608
- "TODO: free GIArgument(interface)[union] everything");
1609
- } else {
1610
- g_boxed_free(gtype, argument->v_pointer);
1611
- }
1612
- break;
1613
- case GI_INFO_TYPE_VALUE:
1614
- rb_raise(rb_eNotImpError,
1615
- "TODO: free GIArgument(interface)[value] everything");
1616
- break;
1617
- case GI_INFO_TYPE_SIGNAL:
1618
- rb_raise(rb_eNotImpError,
1619
- "TODO: free GIArgument(interface)[signal] everything");
1620
- break;
1621
- case GI_INFO_TYPE_VFUNC:
1622
- rb_raise(rb_eNotImpError,
1623
- "TODO: free GIArgument(interface)[vfunc] everything");
1624
- break;
1625
- case GI_INFO_TYPE_PROPERTY:
1626
- rb_raise(rb_eNotImpError,
1627
- "TODO: free GIArgument(interface)[property] everything");
1628
- break;
1629
- case GI_INFO_TYPE_FIELD:
1630
- rb_raise(rb_eNotImpError,
1631
- "TODO: free GIArgument(interface)[field] everything");
1632
- break;
1633
- case GI_INFO_TYPE_ARG:
1634
- rb_raise(rb_eNotImpError,
1635
- "TODO: free GIArgument(interface)[arg] everything");
1636
- break;
1637
- case GI_INFO_TYPE_TYPE:
1638
- rb_raise(rb_eNotImpError,
1639
- "TODO: free GIArgument(interface)[type] everything");
1640
- break;
1641
- case GI_INFO_TYPE_UNRESOLVED:
1642
- rb_raise(rb_eNotImpError,
1643
- "TODO: free GIArgument(interface)[unresolved] everything");
1644
- break;
1645
- default:
1646
- g_assert_not_reached();
1647
- break;
1648
- }
1649
- }
1650
-
1651
- static void
1652
- rb_gi_boxed_free_callback(gpointer boxed, gpointer user_data)
1653
- {
1654
- GType *gtype = user_data;
1655
-
1656
- g_boxed_free(*gtype, boxed);
1657
- }
1658
-
1659
-
1660
- static void
1661
- rb_gi_return_argument_free_everything_glist_interface(GIArgument *argument,
1662
- G_GNUC_UNUSED GITypeInfo *type_info,
1663
- GITypeInfo *element_type_info)
1664
- {
1665
- GIBaseInfo *interface_info;
1666
- GIInfoType interface_type;
1667
- const gchar *interface_name;
1668
- GType gtype;
1669
-
1670
- interface_info = g_type_info_get_interface(element_type_info);
1671
- interface_type = g_base_info_get_type(interface_info);
1672
- interface_name = g_info_type_to_string(interface_type);
1673
- gtype = g_registered_type_info_get_g_type(interface_info);
1674
- g_base_info_unref(interface_info);
1675
- g_base_info_unref(element_type_info);
1676
-
1677
- switch (interface_type) {
1678
- case GI_INFO_TYPE_INVALID:
1679
- case GI_INFO_TYPE_FUNCTION:
1680
- case GI_INFO_TYPE_CALLBACK:
1681
- rb_raise(rb_eNotImpError,
1682
- "TODO: free GIArgument(GList)[interface(%s)](%s) everything",
1683
- interface_name,
1684
- g_type_name(gtype));
1685
- break;
1686
- case GI_INFO_TYPE_STRUCT:
1687
- if (gtype == G_TYPE_NONE) {
1688
- rb_raise(rb_eNotImpError,
1689
- "TODO: free GIArgument(GList)[interface(%s)](%s) everything",
1690
- interface_name,
1691
- g_type_name(gtype));
1692
- } else {
1693
- g_list_foreach(argument->v_pointer,
1694
- rb_gi_boxed_free_callback,
1695
- &gtype);
1696
- g_list_free(argument->v_pointer);
1697
- }
1698
- break;
1699
- case GI_INFO_TYPE_BOXED:
1700
- g_list_foreach(argument->v_pointer, rb_gi_boxed_free_callback, &gtype);
1701
- g_list_free(argument->v_pointer);
1702
- break;
1703
- case GI_INFO_TYPE_ENUM:
1704
- case GI_INFO_TYPE_FLAGS:
1705
- rb_raise(rb_eNotImpError,
1706
- "TODO: free GIArgument(GList)[interface(%s)](%s) everything",
1707
- interface_name,
1708
- g_type_name(gtype));
1709
- break;
1710
- case GI_INFO_TYPE_OBJECT:
1711
- case GI_INFO_TYPE_INTERFACE:
1712
- g_list_foreach(argument->v_pointer, (GFunc)g_object_unref, NULL);
1713
- g_list_free(argument->v_pointer);
1714
- break;
1715
- case GI_INFO_TYPE_CONSTANT:
1716
- case GI_INFO_TYPE_INVALID_0:
1717
- case GI_INFO_TYPE_UNION:
1718
- case GI_INFO_TYPE_VALUE:
1719
- case GI_INFO_TYPE_SIGNAL:
1720
- case GI_INFO_TYPE_VFUNC:
1721
- case GI_INFO_TYPE_PROPERTY:
1722
- case GI_INFO_TYPE_FIELD:
1723
- case GI_INFO_TYPE_ARG:
1724
- case GI_INFO_TYPE_TYPE:
1725
- case GI_INFO_TYPE_UNRESOLVED:
1726
- rb_raise(rb_eNotImpError,
1727
- "TODO: free GIArgument(GList)[interface(%s)](%s) everything",
1728
- interface_name,
1729
- g_type_name(gtype));
1730
- break;
1731
- default:
1732
- g_assert_not_reached();
1733
- break;
1734
- }
1735
- }
1736
-
1737
- static void
1738
- rb_gi_return_argument_free_everything_glist(GIArgument *argument,
1739
- GITypeInfo *type_info)
1740
- {
1741
- GITypeInfo *element_type_info;
1742
- GITypeTag element_type_tag;
1743
-
1744
- element_type_info = g_type_info_get_param_type(type_info, 0);
1745
- element_type_tag = g_type_info_get_tag(element_type_info);
1746
-
1747
- switch (element_type_tag) {
1748
- case GI_TYPE_TAG_VOID:
1749
- case GI_TYPE_TAG_BOOLEAN:
1750
- case GI_TYPE_TAG_INT8:
1751
- case GI_TYPE_TAG_UINT8:
1752
- case GI_TYPE_TAG_INT16:
1753
- case GI_TYPE_TAG_UINT16:
1754
- case GI_TYPE_TAG_INT32:
1755
- case GI_TYPE_TAG_UINT32:
1756
- case GI_TYPE_TAG_INT64:
1757
- case GI_TYPE_TAG_UINT64:
1758
- case GI_TYPE_TAG_FLOAT:
1759
- case GI_TYPE_TAG_DOUBLE:
1760
- case GI_TYPE_TAG_GTYPE:
1761
- g_base_info_unref(element_type_info);
1762
- rb_raise(rb_eNotImpError,
1763
- "TODO: free GIArgument(GList)[%s] everything",
1764
- g_type_tag_to_string(element_type_tag));
1765
- break;
1766
- case GI_TYPE_TAG_UTF8:
1767
- g_base_info_unref(element_type_info);
1768
- g_list_foreach(argument->v_pointer, (GFunc)g_free, NULL);
1769
- g_list_free(argument->v_pointer);
1770
- break;
1771
- case GI_TYPE_TAG_FILENAME:
1772
- case GI_TYPE_TAG_ARRAY:
1773
- g_base_info_unref(element_type_info);
1774
- rb_raise(rb_eNotImpError,
1775
- "TODO: free GIArgument(GList)[%s] everything",
1776
- g_type_tag_to_string(element_type_tag));
1777
- break;
1778
- case GI_TYPE_TAG_INTERFACE:
1779
- rb_gi_return_argument_free_everything_glist_interface(argument,
1780
- type_info,
1781
- element_type_info);
1782
- break;
1783
- case GI_TYPE_TAG_GLIST:
1784
- case GI_TYPE_TAG_GSLIST:
1785
- case GI_TYPE_TAG_GHASH:
1786
- case GI_TYPE_TAG_ERROR:
1787
- case GI_TYPE_TAG_UNICHAR:
1788
- g_base_info_unref(element_type_info);
1789
- rb_raise(rb_eNotImpError,
1790
- "TODO: free GIArgument(GList)[%s] everything",
1791
- g_type_tag_to_string(element_type_tag));
1792
- break;
1793
- default:
1794
- g_base_info_unref(element_type_info);
1795
- g_assert_not_reached();
1796
- break;
1797
- }
1798
- }
1799
-
1800
- static void
1801
- rb_gi_return_argument_free_everything_gslist_interface(GIArgument *argument,
1802
- G_GNUC_UNUSED GITypeInfo *type_info,
1803
- GITypeInfo *element_type_info)
1804
- {
1805
- GIBaseInfo *interface_info;
1806
- GIInfoType interface_type;
1807
- const gchar *interface_name;
1808
- GType gtype;
1809
-
1810
- interface_info = g_type_info_get_interface(element_type_info);
1811
- interface_type = g_base_info_get_type(interface_info);
1812
- interface_name = g_info_type_to_string(interface_type);
1813
- gtype = g_registered_type_info_get_g_type(interface_info);
1814
- g_base_info_unref(interface_info);
1815
- g_base_info_unref(element_type_info);
1816
-
1817
- switch (interface_type) {
1818
- case GI_INFO_TYPE_INVALID:
1819
- case GI_INFO_TYPE_FUNCTION:
1820
- case GI_INFO_TYPE_CALLBACK:
1821
- rb_raise(rb_eNotImpError,
1822
- "TODO: free GIArgument(GSList)[interface(%s)](%s) everything",
1823
- interface_name,
1824
- g_type_name(gtype));
1825
- break;
1826
- case GI_INFO_TYPE_STRUCT:
1827
- if (gtype == G_TYPE_NONE) {
1828
- rb_raise(rb_eNotImpError,
1829
- "TODO: free GIArgument(GSList)[interface(%s)](%s) everything",
1830
- interface_name,
1831
- g_type_name(gtype));
1832
- } else {
1833
- g_slist_foreach(argument->v_pointer,
1834
- rb_gi_boxed_free_callback,
1835
- &gtype);
1836
- g_slist_free(argument->v_pointer);
1837
- }
1838
- break;
1839
- case GI_INFO_TYPE_BOXED:
1840
- g_slist_foreach(argument->v_pointer, rb_gi_boxed_free_callback, &gtype);
1841
- g_slist_free(argument->v_pointer);
1842
- break;
1843
- case GI_INFO_TYPE_ENUM:
1844
- case GI_INFO_TYPE_FLAGS:
1845
- rb_raise(rb_eNotImpError,
1846
- "TODO: free GIArgument(GSList)[interface(%s)](%s) everything",
1847
- interface_name,
1848
- g_type_name(gtype));
1849
- break;
1850
- case GI_INFO_TYPE_OBJECT:
1851
- case GI_INFO_TYPE_INTERFACE:
1852
- g_slist_foreach(argument->v_pointer, (GFunc)g_object_unref, NULL);
1853
- g_slist_free(argument->v_pointer);
1854
- break;
1855
- case GI_INFO_TYPE_CONSTANT:
1856
- case GI_INFO_TYPE_INVALID_0:
1857
- case GI_INFO_TYPE_UNION:
1858
- case GI_INFO_TYPE_VALUE:
1859
- case GI_INFO_TYPE_SIGNAL:
1860
- case GI_INFO_TYPE_VFUNC:
1861
- case GI_INFO_TYPE_PROPERTY:
1862
- case GI_INFO_TYPE_FIELD:
1863
- case GI_INFO_TYPE_ARG:
1864
- case GI_INFO_TYPE_TYPE:
1865
- case GI_INFO_TYPE_UNRESOLVED:
1866
- rb_raise(rb_eNotImpError,
1867
- "TODO: free GIArgument(GSList)[interface(%s)](%s) everything",
1868
- interface_name,
1869
- g_type_name(gtype));
1870
- break;
1871
- default:
1872
- g_assert_not_reached();
1873
- break;
1874
- }
1875
- }
1876
-
1877
- static void
1878
- rb_gi_return_argument_free_everything_gslist(GIArgument *argument,
1879
- GITypeInfo *type_info)
1880
- {
1881
- GITypeInfo *element_type_info;
1882
- GITypeTag element_type_tag;
1883
-
1884
- if (!argument->v_pointer)
1885
- return;
1886
-
1887
- element_type_info = g_type_info_get_param_type(type_info, 0);
1888
- element_type_tag = g_type_info_get_tag(element_type_info);
1889
-
1890
- switch (element_type_tag) {
1891
- case GI_TYPE_TAG_VOID:
1892
- case GI_TYPE_TAG_BOOLEAN:
1893
- case GI_TYPE_TAG_INT8:
1894
- case GI_TYPE_TAG_UINT8:
1895
- case GI_TYPE_TAG_INT16:
1896
- case GI_TYPE_TAG_UINT16:
1897
- case GI_TYPE_TAG_INT32:
1898
- case GI_TYPE_TAG_UINT32:
1899
- case GI_TYPE_TAG_INT64:
1900
- case GI_TYPE_TAG_UINT64:
1901
- case GI_TYPE_TAG_FLOAT:
1902
- case GI_TYPE_TAG_DOUBLE:
1903
- case GI_TYPE_TAG_GTYPE:
1904
- g_base_info_unref(element_type_info);
1905
- rb_raise(rb_eNotImpError,
1906
- "TODO: free GIArgument(GSList)[%s] everything",
1907
- g_type_tag_to_string(element_type_tag));
1908
- break;
1909
- case GI_TYPE_TAG_UTF8:
1910
- case GI_TYPE_TAG_FILENAME:
1911
- g_base_info_unref(element_type_info);
1912
- g_slist_foreach(argument->v_pointer, (GFunc)g_free, NULL);
1913
- g_slist_free(argument->v_pointer);
1914
- break;
1915
- case GI_TYPE_TAG_ARRAY:
1916
- g_base_info_unref(element_type_info);
1917
- rb_raise(rb_eNotImpError,
1918
- "TODO: free GIArgument(GSList)[%s] everything",
1919
- g_type_tag_to_string(element_type_tag));
1920
- break;
1921
- case GI_TYPE_TAG_INTERFACE:
1922
- rb_gi_return_argument_free_everything_gslist_interface(argument,
1923
- type_info,
1924
- element_type_info);
1925
- break;
1926
- case GI_TYPE_TAG_GLIST:
1927
- case GI_TYPE_TAG_GSLIST:
1928
- case GI_TYPE_TAG_GHASH:
1929
- case GI_TYPE_TAG_ERROR:
1930
- case GI_TYPE_TAG_UNICHAR:
1931
- g_base_info_unref(element_type_info);
1932
- rb_raise(rb_eNotImpError,
1933
- "TODO: free GIArgument(GSList)[%s] everything",
1934
- g_type_tag_to_string(element_type_tag));
1935
- break;
1936
- default:
1937
- g_base_info_unref(element_type_info);
1938
- g_assert_not_reached();
1939
- break;
1940
- }
1941
- }
1942
-
1943
- static void
1944
- rb_gi_return_argument_free_everything(GIArgument *argument,
1945
- GITypeInfo *type_info)
1946
- {
1947
- GITypeTag type_tag;
1948
-
1949
- type_tag = g_type_info_get_tag(type_info);
1950
- switch (type_tag) {
1951
- case GI_TYPE_TAG_VOID:
1952
- break;
1953
- case GI_TYPE_TAG_BOOLEAN:
1954
- case GI_TYPE_TAG_INT8:
1955
- case GI_TYPE_TAG_UINT8:
1956
- case GI_TYPE_TAG_INT16:
1957
- case GI_TYPE_TAG_UINT16:
1958
- case GI_TYPE_TAG_INT32:
1959
- case GI_TYPE_TAG_UINT32:
1960
- case GI_TYPE_TAG_INT64:
1961
- case GI_TYPE_TAG_UINT64:
1962
- case GI_TYPE_TAG_FLOAT:
1963
- case GI_TYPE_TAG_DOUBLE:
1964
- case GI_TYPE_TAG_GTYPE:
1965
- rb_raise(rb_eNotImpError,
1966
- "TODO: free GIArgument(%s) everything",
1967
- g_type_tag_to_string(type_tag));
1968
- break;
1969
- case GI_TYPE_TAG_UTF8:
1970
- g_free(argument->v_string);
1971
- break;
1972
- case GI_TYPE_TAG_FILENAME:
1973
- g_free(argument->v_string);
1974
- break;
1975
- case GI_TYPE_TAG_ARRAY:
1976
- rb_gi_return_argument_free_everything_array(argument, type_info);
1977
- break;
1978
- case GI_TYPE_TAG_INTERFACE:
1979
- rb_gi_return_argument_free_everything_interface(argument, type_info);
1980
- break;
1981
- case GI_TYPE_TAG_GLIST:
1982
- rb_gi_return_argument_free_everything_glist(argument, type_info);
1983
- break;
1984
- case GI_TYPE_TAG_GSLIST:
1985
- rb_gi_return_argument_free_everything_gslist(argument, type_info);
1986
- break;
1987
- case GI_TYPE_TAG_GHASH:
1988
- g_hash_table_unref(argument->v_pointer);
1989
- break;
1990
- case GI_TYPE_TAG_ERROR:
1991
- case GI_TYPE_TAG_UNICHAR:
1992
- rb_raise(rb_eNotImpError,
1993
- "TODO: free GIArgument(%s) everything",
1994
- g_type_tag_to_string(type_tag));
1995
- break;
1996
- default:
1997
- g_assert_not_reached();
1998
- break;
1999
- }
2000
- }
2001
-
2002
- VALUE
2003
- rb_gi_return_argument_to_ruby(GICallableInfo *callable_info,
2004
- GIArgument *argument,
2005
- GArray *in_args,
2006
- GArray *out_args,
2007
- GPtrArray *args_metadata)
2008
- {
2009
- VALUE rb_argument;
2010
- gboolean may_return_null;
2011
- GITypeInfo return_value_info;
2012
-
2013
- may_return_null = g_callable_info_may_return_null(callable_info);
2014
- g_callable_info_load_return_type(callable_info, &return_value_info);
2015
- if (may_return_null && !argument->v_pointer) {
2016
- GITypeTag return_value_tag = g_type_info_get_tag(&return_value_info);
2017
- switch (return_value_tag) {
2018
- case GI_TYPE_TAG_GLIST:
2019
- case GI_TYPE_TAG_GSLIST:
2020
- return rb_ary_new();
2021
- default:
2022
- return Qnil;
2023
- }
2024
- }
2025
-
2026
- rb_argument = rb_gi_argument_to_ruby(argument, FALSE, &return_value_info,
2027
- in_args, out_args, args_metadata);
2028
- switch (g_callable_info_get_caller_owns(callable_info)) {
2029
- case GI_TRANSFER_NOTHING:
2030
- break;
2031
- case GI_TRANSFER_CONTAINER:
2032
- rb_gi_return_argument_free_container(argument, &return_value_info);
2033
- break;
2034
- case GI_TRANSFER_EVERYTHING:
2035
- rb_gi_return_argument_free_everything(argument, &return_value_info);
2036
- break;
2037
- default:
2038
- g_assert_not_reached();
2039
- break;
2040
- }
2041
- return rb_argument;
2042
- }
2043
-
2044
- void
2045
- rb_gi_argument_init(void)
2046
- {
2047
- rb_cGLibBoxed = rb_const_get(mGLib, rb_intern("Boxed"));
2048
- rb_cGLibBytes = rb_const_get(mGLib, rb_intern("Bytes"));
2049
- rb_cGLibObject = rb_const_get(mGLib, rb_intern("Object"));
2050
- rb_cGLibValue = rb_const_get(mGLib, rb_intern("Value"));
2051
- }