gobject-introspection 3.3.8 → 3.3.9

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
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-in.c ADDED
@@ -0,0 +1,2229 @@
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_callback_data_destroy_notify(gpointer data)
25
+ {
26
+ RBGICallbackData *callback_data = data;
27
+ rb_gi_callback_data_free(callback_data);
28
+ }
29
+
30
+ typedef struct {
31
+ RBGIArguments *args;
32
+ RBGICallback *callback;
33
+ RBGICallbackData *callback_data;
34
+ } RBGICallbackInvokeData;
35
+
36
+ static VALUE
37
+ rb_gi_arguments_in_to_ruby(RBGIArguments *args)
38
+ {
39
+ VALUE rb_in_args;
40
+ guint i;
41
+
42
+ rb_in_args = rb_ary_new_capa(args->metadata->len);
43
+ for (i = 0; i < args->metadata->len; i++) {
44
+ RBGIArgMetadata *metadata;
45
+ GITypeInfo *type_info;
46
+ VALUE rb_arg;
47
+
48
+ metadata = g_ptr_array_index(args->metadata, i);
49
+
50
+ if (metadata->direction == GI_DIRECTION_OUT) {
51
+ continue;
52
+ }
53
+ if (metadata->closure_p) {
54
+ continue;
55
+ }
56
+
57
+ type_info = g_arg_info_get_type(&(metadata->arg_info));
58
+ /* TODO */
59
+ rb_arg = GI_ARGUMENT2RVAL(metadata->in_arg,
60
+ FALSE,
61
+ type_info,
62
+ args->in_args,
63
+ args->out_args,
64
+ args->metadata);
65
+ rb_ary_push(rb_in_args, rb_arg);
66
+ }
67
+
68
+ return rb_in_args;
69
+ }
70
+
71
+ static VALUE
72
+ rb_gi_callback_invoke(VALUE user_data)
73
+ {
74
+ RBGICallbackInvokeData *data = (RBGICallbackInvokeData *)user_data;
75
+ ID id_call;
76
+ VALUE rb_callback = rb_gi_callback_data_get_rb_callback(data->callback_data);
77
+ VALUE rb_args = rb_gi_arguments_in_to_ruby(data->args);
78
+
79
+ CONST_ID(id_call, "call");
80
+ return rb_funcallv(rb_callback,
81
+ id_call,
82
+ RARRAY_LENINT(rb_args),
83
+ RARRAY_CONST_PTR(rb_args));
84
+ }
85
+
86
+ static void
87
+ rb_gi_ffi_closure_callback(G_GNUC_UNUSED ffi_cif *cif,
88
+ void *return_value,
89
+ void **raw_args,
90
+ void *data)
91
+ {
92
+ RBGICallback *callback = data;
93
+ RBGICallbackData *callback_data = NULL;
94
+ RBGIArguments args;
95
+ VALUE rb_results;
96
+
97
+ rb_gi_arguments_init(&args,
98
+ callback->callback_info,
99
+ Qnil,
100
+ Qnil,
101
+ raw_args);
102
+ {
103
+ guint i;
104
+
105
+ for (i = 0; i < args.metadata->len; i++) {
106
+ RBGIArgMetadata *metadata;
107
+
108
+ metadata = g_ptr_array_index(args.metadata, i);
109
+ if (!metadata->closure_p) {
110
+ continue;
111
+ }
112
+
113
+ callback_data = *((RBGICallbackData **)(raw_args[i]));
114
+ break;
115
+ }
116
+
117
+ if (!callback_data && args.metadata->len > 0) {
118
+ RBGIArgMetadata *metadata;
119
+
120
+ i = args.metadata->len - 1;
121
+ metadata = g_ptr_array_index(args.metadata, i);
122
+ if (metadata->type.tag == GI_TYPE_TAG_VOID &&
123
+ metadata->pointer_p &&
124
+ strcmp(metadata->name, "data") == 0) {
125
+ callback_data = *((RBGICallbackData **)(raw_args[i]));
126
+ }
127
+ }
128
+ }
129
+
130
+ {
131
+ RBGICallbackInvokeData data;
132
+ data.args = &args;
133
+ data.callback = callback;
134
+ data.callback_data = callback_data;
135
+ rb_results = rbgutil_invoke_callback(rb_gi_callback_invoke,
136
+ (VALUE)&data);
137
+ }
138
+ rb_gi_arguments_fill_raw_results(&args, rb_results, return_value);
139
+ rb_gi_arguments_clear(&args);
140
+
141
+ {
142
+ RBGIArgMetadata *callback_metadata =
143
+ rb_gi_callback_data_get_metadata(callback_data);
144
+ if (callback_metadata->scope_type == GI_SCOPE_TYPE_ASYNC) {
145
+ rb_gi_callback_data_free(callback_data);
146
+ }
147
+ }
148
+ }
149
+
150
+ static void
151
+ rb_gi_arguments_in_init_arg_ruby_callback(RBGIArguments *args,
152
+ RBGIArgMetadata *metadata)
153
+ {
154
+ gpointer callback_function;
155
+ GIArgInfo *arg_info;
156
+ GIArgument *callback_argument;
157
+ GIArgument *closure_argument = NULL;
158
+ GIArgument *destroy_argument = NULL;
159
+ RBGICallback *callback = NULL;
160
+
161
+ /* TODO: metadata->free_func = ...; */
162
+ arg_info = &(metadata->arg_info);
163
+ callback_argument = metadata->in_arg;
164
+ if (metadata->closure_in_arg_index != -1) {
165
+ closure_argument = &(g_array_index(args->in_args,
166
+ GIArgument,
167
+ metadata->closure_in_arg_index));
168
+ }
169
+ if (metadata->destroy_in_arg_index != -1) {
170
+ destroy_argument = &(g_array_index(args->in_args,
171
+ GIArgument,
172
+ metadata->destroy_in_arg_index));
173
+ }
174
+
175
+ if (!rb_block_given_p() && g_arg_info_may_be_null(arg_info)) {
176
+ callback_argument->v_pointer = NULL;
177
+ if (closure_argument) {
178
+ closure_argument->v_pointer = NULL;
179
+ }
180
+ if (destroy_argument) {
181
+ destroy_argument->v_pointer = NULL;
182
+ }
183
+ return;
184
+ }
185
+
186
+ callback_function = rb_gi_callback_find(arg_info);
187
+ if (callback_function) {
188
+ callback_argument->v_pointer = callback_function;
189
+ } else {
190
+ callback = RB_ZALLOC(RBGICallback);
191
+ callback->type_info = g_arg_info_get_type(arg_info);
192
+ callback->callback_info = g_type_info_get_interface(callback->type_info);
193
+ callback->closure =
194
+ g_callable_info_prepare_closure(callback->callback_info,
195
+ &(callback->cif),
196
+ rb_gi_ffi_closure_callback,
197
+ callback);
198
+ callback_argument->v_pointer = callback->closure;
199
+ }
200
+
201
+ if (closure_argument) {
202
+ closure_argument->v_pointer = rb_gi_callback_data_new(args,
203
+ callback,
204
+ metadata);
205
+ }
206
+
207
+ if (destroy_argument) {
208
+ destroy_argument->v_pointer = rb_gi_callback_data_destroy_notify;
209
+ }
210
+ }
211
+
212
+ static void
213
+ rb_gi_arguments_in_init_arg_ruby_void(RBGIArguments *args,
214
+ RBGIArgMetadata *metadata)
215
+ {
216
+ gpointer *target;
217
+ if (metadata->direction == GI_DIRECTION_INOUT) {
218
+ target = ALLOC(gpointer);
219
+ metadata->in_arg->v_pointer = target;
220
+ } else {
221
+ target = &(metadata->in_arg->v_pointer);
222
+ }
223
+
224
+ if (!g_type_info_is_pointer(metadata->type.info)) {
225
+ *target = NULL;
226
+ return;
227
+ }
228
+
229
+ if (RB_TYPE_P(metadata->rb_arg, RUBY_T_STRING)) {
230
+ *target = RSTRING_PTR(metadata->rb_arg);
231
+ } else if (rbg_is_object(metadata->rb_arg)) {
232
+ *target = RVAL2GOBJ(metadata->rb_arg);
233
+ } else {
234
+ *target = GUINT_TO_POINTER(NUM2ULONG(metadata->rb_arg));
235
+ }
236
+ }
237
+
238
+ static void
239
+ rb_gi_arguments_in_free_array_c_value(RBGIArguments *args,
240
+ RBGIArgMetadata *metadata,
241
+ gpointer user_data)
242
+ {
243
+ gpointer target;
244
+ if (metadata->direction == GI_DIRECTION_INOUT) {
245
+ target = *((gpointer *)(metadata->in_arg->v_pointer));
246
+ xfree(metadata->in_arg->v_pointer);
247
+ } else {
248
+ target = metadata->in_arg->v_pointer;
249
+ }
250
+
251
+ switch (metadata->transfer) {
252
+ case GI_TRANSFER_NOTHING:
253
+ xfree(target);
254
+ break;
255
+ case GI_TRANSFER_CONTAINER:
256
+ case GI_TRANSFER_EVERYTHING:
257
+ break;
258
+ }
259
+ }
260
+
261
+ static void
262
+ rb_gi_arguments_in_free_array_c_string(RBGIArguments *args,
263
+ RBGIArgMetadata *metadata,
264
+ gpointer user_data)
265
+ {
266
+ if (metadata->direction == GI_DIRECTION_INOUT) {
267
+ xfree(metadata->in_arg->v_pointer);
268
+ }
269
+ }
270
+
271
+ static void
272
+ rb_gi_arguments_in_free_array_c_strv(RBGIArguments *args,
273
+ RBGIArgMetadata *metadata,
274
+ gpointer user_data)
275
+ {
276
+ gpointer target;
277
+ if (metadata->direction == GI_DIRECTION_INOUT) {
278
+ target = *((gpointer *)(metadata->in_arg->v_pointer));
279
+ xfree(metadata->in_arg->v_pointer);
280
+ } else {
281
+ target = metadata->in_arg->v_pointer;
282
+ }
283
+
284
+ switch (metadata->transfer) {
285
+ case GI_TRANSFER_NOTHING:
286
+ g_free(target);
287
+ break;
288
+ case GI_TRANSFER_CONTAINER:
289
+ case GI_TRANSFER_EVERYTHING:
290
+ break;
291
+ }
292
+ }
293
+
294
+ static void
295
+ rb_gi_arguments_in_free_array_c_filename(RBGIArguments *args,
296
+ RBGIArgMetadata *metadata,
297
+ gpointer user_data)
298
+ {
299
+ gchar **target;
300
+ if (metadata->direction == GI_DIRECTION_INOUT) {
301
+ target = *((gchar ***)(metadata->in_arg->v_pointer));
302
+ xfree(metadata->in_arg->v_pointer);
303
+ } else {
304
+ target = metadata->in_arg->v_pointer;
305
+ }
306
+
307
+ switch (metadata->transfer) {
308
+ case GI_TRANSFER_NOTHING:
309
+ g_strfreev(target);
310
+ break;
311
+ case GI_TRANSFER_CONTAINER:
312
+ {
313
+ gsize i;
314
+ for (i = 0; target[i]; i++) {
315
+ g_free(target[i]);
316
+ }
317
+ }
318
+ break;
319
+ case GI_TRANSFER_EVERYTHING:
320
+ break;
321
+ }
322
+ }
323
+
324
+ static void
325
+ rb_gi_arguments_in_init_arg_ruby_array_set_length(RBGIArguments *args,
326
+ RBGIArgMetadata *metadata,
327
+ gint64 length)
328
+ {
329
+ GIArgument *length_argument = metadata->array_length_arg;
330
+ if (!length_argument) {
331
+ return;
332
+ }
333
+
334
+ RBGIArgMetadata *length_metadata = metadata->array_length_metadata;
335
+ switch (length_metadata->type.tag) {
336
+ case GI_TYPE_TAG_VOID:
337
+ case GI_TYPE_TAG_BOOLEAN:
338
+ rb_raise(rb_eNotImpError,
339
+ "TODO: invalid argument?: length[%s]",
340
+ g_type_tag_to_string(length_metadata->type.tag));
341
+ break;
342
+ case GI_TYPE_TAG_INT8:
343
+ if (metadata->direction == GI_DIRECTION_INOUT) {
344
+ length_argument->v_pointer = ALLOC(gint8);
345
+ *((gint8 *)length_argument->v_pointer) = length;
346
+ } else {
347
+ length_argument->v_int8 = length;
348
+ }
349
+ break;
350
+ case GI_TYPE_TAG_UINT8:
351
+ if (metadata->direction == GI_DIRECTION_INOUT) {
352
+ length_argument->v_pointer = ALLOC(guint8);
353
+ *((guint8 *)length_argument->v_pointer) = length;
354
+ } else {
355
+ length_argument->v_uint8 = length;
356
+ }
357
+ break;
358
+ case GI_TYPE_TAG_INT16:
359
+ if (metadata->direction == GI_DIRECTION_INOUT) {
360
+ length_argument->v_pointer = ALLOC(gint16);
361
+ *((gint16 *)length_argument->v_pointer) = length;
362
+ } else {
363
+ length_argument->v_int16 = length;
364
+ }
365
+ break;
366
+ case GI_TYPE_TAG_UINT16:
367
+ if (metadata->direction == GI_DIRECTION_INOUT) {
368
+ length_argument->v_pointer = ALLOC(guint16);
369
+ *((guint16 *)length_argument->v_pointer) = length;
370
+ } else {
371
+ length_argument->v_uint16 = length;
372
+ }
373
+ break;
374
+ case GI_TYPE_TAG_INT32:
375
+ if (metadata->direction == GI_DIRECTION_INOUT) {
376
+ length_argument->v_pointer = ALLOC(gint32);
377
+ *((gint32 *)length_argument->v_pointer) = (gint32)length;
378
+ } else {
379
+ length_argument->v_int32 = (gint32)length;
380
+ }
381
+ break;
382
+ case GI_TYPE_TAG_UINT32:
383
+ if (metadata->direction == GI_DIRECTION_INOUT) {
384
+ length_argument->v_pointer = ALLOC(guint32);
385
+ *((guint32 *)length_argument->v_pointer) = (guint32)length;
386
+ } else {
387
+ length_argument->v_uint32 = (guint32)length;
388
+ }
389
+ break;
390
+ case GI_TYPE_TAG_INT64:
391
+ if (metadata->direction == GI_DIRECTION_INOUT) {
392
+ length_argument->v_pointer = ALLOC(gint64);
393
+ *((gint64 *)length_argument->v_pointer) = length;
394
+ } else {
395
+ length_argument->v_int64 = length;
396
+ }
397
+ break;
398
+ case GI_TYPE_TAG_UINT64:
399
+ if (metadata->direction == GI_DIRECTION_INOUT) {
400
+ length_argument->v_pointer = ALLOC(guint64);
401
+ *((guint64 *)length_argument->v_pointer) = length;
402
+ } else {
403
+ length_argument->v_uint64 = length;
404
+ }
405
+ break;
406
+ case GI_TYPE_TAG_FLOAT:
407
+ case GI_TYPE_TAG_DOUBLE:
408
+ case GI_TYPE_TAG_GTYPE:
409
+ case GI_TYPE_TAG_UTF8:
410
+ case GI_TYPE_TAG_FILENAME:
411
+ case GI_TYPE_TAG_ARRAY:
412
+ case GI_TYPE_TAG_INTERFACE:
413
+ case GI_TYPE_TAG_GLIST:
414
+ case GI_TYPE_TAG_GSLIST:
415
+ case GI_TYPE_TAG_GHASH:
416
+ case GI_TYPE_TAG_ERROR:
417
+ case GI_TYPE_TAG_UNICHAR:
418
+ rb_raise(rb_eNotImpError,
419
+ "TODO: invalid argument?: length[%s]",
420
+ g_type_tag_to_string(length_metadata->type.tag));
421
+ break;
422
+ default:
423
+ g_assert_not_reached();
424
+ break;
425
+ }
426
+ }
427
+
428
+ static void
429
+ rb_gi_arguments_in_init_arg_ruby_array_c_generic(RBGIArguments *args,
430
+ RBGIArgMetadata *metadata,
431
+ VALUE rb_array,
432
+ gpointer raw_array)
433
+ {
434
+ GIArgument *array_argument;
435
+ long n_elements;
436
+
437
+ array_argument = &(g_array_index(args->in_args,
438
+ GIArgument,
439
+ metadata->in_arg_index));
440
+ if (metadata->direction == GI_DIRECTION_INOUT) {
441
+ array_argument->v_pointer = ALLOC(gpointer);
442
+ *((gpointer *)(array_argument->v_pointer)) = raw_array;
443
+ } else {
444
+ array_argument->v_pointer = raw_array;
445
+ }
446
+
447
+ n_elements = RARRAY_LEN(rb_array);
448
+ rb_gi_arguments_in_init_arg_ruby_array_set_length(args,
449
+ metadata,
450
+ n_elements);
451
+ }
452
+
453
+ static void
454
+ rb_gi_arguments_in_init_arg_ruby_array_c_boolean(RBGIArguments *args,
455
+ RBGIArgMetadata *metadata,
456
+ VALUE rb_array)
457
+ {
458
+ gboolean *raw_array;
459
+ long i, n_elements;
460
+
461
+ n_elements = RARRAY_LEN(rb_array);
462
+ raw_array = ALLOC_N(gboolean, n_elements);
463
+ for (i = 0; i < n_elements; i++) {
464
+ raw_array[i] = RVAL2CBOOL(RARRAY_AREF(rb_array, i));
465
+ }
466
+
467
+ rb_gi_arguments_in_init_arg_ruby_array_c_generic(args,
468
+ metadata,
469
+ rb_array,
470
+ raw_array);
471
+ }
472
+
473
+ static void
474
+ rb_gi_arguments_in_init_arg_ruby_array_c_int8(RBGIArguments *args,
475
+ RBGIArgMetadata *metadata,
476
+ VALUE rb_array)
477
+ {
478
+ gint8 *raw_array;
479
+ long i, n_elements;
480
+
481
+ n_elements = RARRAY_LEN(rb_array);
482
+ raw_array = ALLOC_N(gint8, n_elements);
483
+ for (i = 0; i < n_elements; i++) {
484
+ raw_array[i] = NUM2CHR(RARRAY_AREF(rb_array, i));
485
+ }
486
+
487
+ rb_gi_arguments_in_init_arg_ruby_array_c_generic(args,
488
+ metadata,
489
+ rb_array,
490
+ raw_array);
491
+ }
492
+
493
+ static void
494
+ rb_gi_arguments_in_init_arg_ruby_array_c_uint8(RBGIArguments *args,
495
+ RBGIArgMetadata *metadata,
496
+ VALUE rb_array)
497
+ {
498
+ guint8 *raw_array;
499
+ long i, n_elements;
500
+
501
+ n_elements = RARRAY_LEN(rb_array);
502
+ raw_array = ALLOC_N(guint8, n_elements);
503
+ for (i = 0; i < n_elements; i++) {
504
+ raw_array[i] = (guint8)NUM2CHR(RARRAY_AREF(rb_array, i));
505
+ }
506
+
507
+ rb_gi_arguments_in_init_arg_ruby_array_c_generic(args,
508
+ metadata,
509
+ rb_array,
510
+ raw_array);
511
+ }
512
+
513
+ static void
514
+ rb_gi_arguments_in_init_arg_ruby_array_c_int16(RBGIArguments *args,
515
+ RBGIArgMetadata *metadata,
516
+ VALUE rb_array)
517
+ {
518
+ gint16 *raw_array;
519
+ long i, n_elements;
520
+
521
+ n_elements = RARRAY_LEN(rb_array);
522
+ raw_array = ALLOC_N(gint16, n_elements);
523
+ for (i = 0; i < n_elements; i++) {
524
+ raw_array[i] = NUM2SHORT(RARRAY_AREF(rb_array, i));
525
+ }
526
+
527
+ rb_gi_arguments_in_init_arg_ruby_array_c_generic(args,
528
+ metadata,
529
+ rb_array,
530
+ raw_array);
531
+ }
532
+
533
+ static void
534
+ rb_gi_arguments_in_init_arg_ruby_array_c_uint16(RBGIArguments *args,
535
+ RBGIArgMetadata *metadata,
536
+ VALUE rb_array)
537
+ {
538
+ guint16 *raw_array;
539
+ long i, n_elements;
540
+
541
+ n_elements = RARRAY_LEN(rb_array);
542
+ raw_array = ALLOC_N(guint16, n_elements);
543
+ for (i = 0; i < n_elements; i++) {
544
+ raw_array[i] = NUM2USHORT(RARRAY_AREF(rb_array, i));
545
+ }
546
+
547
+ rb_gi_arguments_in_init_arg_ruby_array_c_generic(args,
548
+ metadata,
549
+ rb_array,
550
+ raw_array);
551
+ }
552
+
553
+ static void
554
+ rb_gi_arguments_in_init_arg_ruby_array_c_int32(RBGIArguments *args,
555
+ RBGIArgMetadata *metadata,
556
+ VALUE rb_array)
557
+ {
558
+ gint32 *raw_array;
559
+ long i, n_elements;
560
+
561
+ n_elements = RARRAY_LEN(rb_array);
562
+ raw_array = ALLOC_N(gint32, n_elements);
563
+ for (i = 0; i < n_elements; i++) {
564
+ raw_array[i] = NUM2INT(RARRAY_AREF(rb_array, i));
565
+ }
566
+
567
+ rb_gi_arguments_in_init_arg_ruby_array_c_generic(args,
568
+ metadata,
569
+ rb_array,
570
+ raw_array);
571
+ }
572
+
573
+ static void
574
+ rb_gi_arguments_in_init_arg_ruby_array_c_uint32(RBGIArguments *args,
575
+ RBGIArgMetadata *metadata,
576
+ VALUE rb_array)
577
+ {
578
+ guint32 *raw_array;
579
+ long i, n_elements;
580
+
581
+ n_elements = RARRAY_LEN(rb_array);
582
+ raw_array = ALLOC_N(guint32, n_elements);
583
+ for (i = 0; i < n_elements; i++) {
584
+ raw_array[i] = NUM2UINT(RARRAY_AREF(rb_array, i));
585
+ }
586
+
587
+ rb_gi_arguments_in_init_arg_ruby_array_c_generic(args,
588
+ metadata,
589
+ rb_array,
590
+ raw_array);
591
+ }
592
+
593
+ static void
594
+ rb_gi_arguments_in_init_arg_ruby_array_c_int64(RBGIArguments *args,
595
+ RBGIArgMetadata *metadata,
596
+ VALUE rb_array)
597
+ {
598
+ gint64 *raw_array;
599
+ long i, n_elements;
600
+
601
+ n_elements = RARRAY_LEN(rb_array);
602
+ raw_array = ALLOC_N(gint64, n_elements);
603
+ for (i = 0; i < n_elements; i++) {
604
+ raw_array[i] = NUM2LL(RARRAY_AREF(rb_array, i));
605
+ }
606
+
607
+ rb_gi_arguments_in_init_arg_ruby_array_c_generic(args,
608
+ metadata,
609
+ rb_array,
610
+ raw_array);
611
+ }
612
+
613
+ static void
614
+ rb_gi_arguments_in_init_arg_ruby_array_c_uint64(RBGIArguments *args,
615
+ RBGIArgMetadata *metadata,
616
+ VALUE rb_array)
617
+ {
618
+ guint64 *raw_array;
619
+ long i, n_elements;
620
+
621
+ n_elements = RARRAY_LEN(rb_array);
622
+ raw_array = ALLOC_N(guint64, n_elements);
623
+ for (i = 0; i < n_elements; i++) {
624
+ raw_array[i] = NUM2ULL(RARRAY_AREF(rb_array, i));
625
+ }
626
+
627
+ rb_gi_arguments_in_init_arg_ruby_array_c_generic(args,
628
+ metadata,
629
+ rb_array,
630
+ raw_array);
631
+ }
632
+
633
+ static void
634
+ rb_gi_arguments_in_init_arg_ruby_array_c_float(RBGIArguments *args,
635
+ RBGIArgMetadata *metadata,
636
+ VALUE rb_array)
637
+ {
638
+ gfloat *raw_array;
639
+ long i, n_elements;
640
+
641
+ n_elements = RARRAY_LEN(rb_array);
642
+ raw_array = ALLOC_N(gfloat, n_elements);
643
+ for (i = 0; i < n_elements; i++) {
644
+ raw_array[i] = NUM2DBL(RARRAY_AREF(rb_array, i));
645
+ }
646
+
647
+ rb_gi_arguments_in_init_arg_ruby_array_c_generic(args,
648
+ metadata,
649
+ rb_array,
650
+ raw_array);
651
+ }
652
+
653
+ static void
654
+ rb_gi_arguments_in_init_arg_ruby_array_c_double(RBGIArguments *args,
655
+ RBGIArgMetadata *metadata,
656
+ VALUE rb_array)
657
+ {
658
+ gdouble *raw_array;
659
+ long i, n_elements;
660
+
661
+ n_elements = RARRAY_LEN(rb_array);
662
+ raw_array = ALLOC_N(gdouble, n_elements);
663
+ for (i = 0; i < n_elements; i++) {
664
+ raw_array[i] = NUM2DBL(RARRAY_AREF(rb_array, i));
665
+ }
666
+
667
+ rb_gi_arguments_in_init_arg_ruby_array_c_generic(args,
668
+ metadata,
669
+ rb_array,
670
+ raw_array);
671
+ }
672
+
673
+ static void
674
+ rb_gi_arguments_in_init_arg_ruby_array_c_gtype(RBGIArguments *args,
675
+ RBGIArgMetadata *metadata,
676
+ VALUE rb_array)
677
+ {
678
+ GType *raw_array;
679
+ long i, n_elements;
680
+
681
+ n_elements = RARRAY_LEN(rb_array);
682
+ raw_array = ALLOC_N(GType, n_elements);
683
+ for (i = 0; i < n_elements; i++) {
684
+ VALUE rb_type = RARRAY_AREF(rb_array, i);
685
+ raw_array[i] = rbgobj_gtype_get(rb_type);
686
+ }
687
+
688
+ rb_gi_arguments_in_init_arg_ruby_array_c_generic(args,
689
+ metadata,
690
+ rb_array,
691
+ raw_array);
692
+ }
693
+
694
+ static void
695
+ rb_gi_arguments_in_free_array_c_interface_struct(RBGIArguments *args,
696
+ RBGIArgMetadata *metadata,
697
+ gpointer user_data)
698
+ {
699
+ gpointer target;
700
+ if (metadata->direction == GI_DIRECTION_INOUT) {
701
+ target = *((gpointer *)(metadata->in_arg->v_pointer));
702
+ xfree(metadata->in_arg->v_pointer);
703
+ } else {
704
+ target = metadata->in_arg->v_pointer;
705
+ }
706
+
707
+ switch (metadata->transfer) {
708
+ case GI_TRANSFER_NOTHING:
709
+ xfree(target);
710
+ break;
711
+ case GI_TRANSFER_CONTAINER:
712
+ case GI_TRANSFER_EVERYTHING:
713
+ break;
714
+ }
715
+ }
716
+
717
+ static void
718
+ rb_gi_arguments_in_init_arg_ruby_array_c_interface_struct(RBGIArguments *args,
719
+ RBGIArgMetadata *metadata,
720
+ VALUE rb_array)
721
+ {
722
+ GIStructInfo *struct_info =
723
+ (GIStructInfo *)(metadata->element_type.interface_info);
724
+ guint8 *raw_array;
725
+ gsize struct_size;
726
+ long i, n_elements;
727
+
728
+ n_elements = RARRAY_LEN(rb_array);
729
+ struct_size = g_struct_info_get_size(struct_info);
730
+ raw_array = ALLOC_N(guint8, struct_size * n_elements);
731
+ for (i = 0; i < n_elements; i++) {
732
+ VALUE rb_element = RARRAY_AREF(rb_array, i);
733
+ gpointer element;
734
+ element = rb_gi_struct_info_from_ruby(struct_info, rb_element);
735
+ memcpy(raw_array + (struct_size * i),
736
+ element,
737
+ struct_size);
738
+ }
739
+
740
+ rb_gi_arguments_in_init_arg_ruby_array_c_generic(args,
741
+ metadata,
742
+ rb_array,
743
+ raw_array);
744
+ metadata->free_func = rb_gi_arguments_in_free_array_c_interface_struct;
745
+ }
746
+
747
+ static void
748
+ rb_gi_arguments_in_free_array_c_interface_object(RBGIArguments *args,
749
+ RBGIArgMetadata *metadata,
750
+ gpointer user_data)
751
+ {
752
+ gpointer target;
753
+ if (metadata->direction == GI_DIRECTION_INOUT) {
754
+ target = *((gpointer *)(metadata->in_arg->v_pointer));
755
+ xfree(metadata->in_arg->v_pointer);
756
+ } else {
757
+ target = metadata->in_arg->v_pointer;
758
+ }
759
+
760
+ switch (metadata->transfer) {
761
+ case GI_TRANSFER_NOTHING:
762
+ xfree(target);
763
+ break;
764
+ case GI_TRANSFER_CONTAINER:
765
+ /* raw_array.each(&:unref)? */
766
+ rb_raise(rb_eNotImpError,
767
+ "TODO: %s Ruby -> GIArgument(array/%s)[interface(%s)](%s)",
768
+ rb_gi_direction_to_string(metadata->direction),
769
+ rb_gi_array_type_to_string(metadata->array_type),
770
+ g_info_type_to_string(metadata->element_type.interface_type),
771
+ g_type_name(metadata->element_type.interface_gtype));
772
+ break;
773
+ case GI_TRANSFER_EVERYTHING:
774
+ break;
775
+ }
776
+ }
777
+
778
+ static void
779
+ rb_gi_arguments_in_init_arg_ruby_array_c_interface_object(RBGIArguments *args,
780
+ RBGIArgMetadata *metadata,
781
+ VALUE rb_array)
782
+ {
783
+ gpointer *raw_array;
784
+ long i, n_elements, size;
785
+
786
+ n_elements = RARRAY_LEN(rb_array);
787
+ size = n_elements;
788
+ if (metadata->zero_terminated_p) {
789
+ size++;
790
+ }
791
+ raw_array = ALLOC_N(gpointer, size);
792
+ for (i = 0; i < n_elements; i++) {
793
+ VALUE rb_element = RARRAY_AREF(rb_array, i);
794
+ raw_array[i] = RVAL2GOBJ(rb_element);
795
+ }
796
+ if (metadata->zero_terminated_p) {
797
+ raw_array[i] = NULL;
798
+ }
799
+
800
+ rb_gi_arguments_in_init_arg_ruby_array_c_generic(args,
801
+ metadata,
802
+ rb_array,
803
+ raw_array);
804
+ metadata->free_func = rb_gi_arguments_in_free_array_c_interface_object;
805
+ }
806
+
807
+ static void
808
+ rb_gi_arguments_in_init_arg_ruby_array_c_interface(RBGIArguments *args,
809
+ RBGIArgMetadata *metadata,
810
+ VALUE rb_array)
811
+ {
812
+ switch (metadata->element_type.interface_type) {
813
+ case GI_INFO_TYPE_INVALID:
814
+ case GI_INFO_TYPE_FUNCTION:
815
+ case GI_INFO_TYPE_CALLBACK:
816
+ rb_raise(rb_eNotImpError,
817
+ "TODO: %s Ruby -> GIArgument(array/%s)[interface(%s)](%s)",
818
+ rb_gi_direction_to_string(metadata->direction),
819
+ rb_gi_array_type_to_string(metadata->array_type),
820
+ g_info_type_to_string(metadata->element_type.interface_type),
821
+ g_type_name(metadata->element_type.interface_gtype));
822
+ break;
823
+ case GI_INFO_TYPE_STRUCT:
824
+ rb_gi_arguments_in_init_arg_ruby_array_c_interface_struct(args,
825
+ metadata,
826
+ rb_array);
827
+ break;
828
+ case GI_INFO_TYPE_BOXED:
829
+ case GI_INFO_TYPE_ENUM:
830
+ case GI_INFO_TYPE_FLAGS:
831
+ rb_raise(rb_eNotImpError,
832
+ "TODO: %s Ruby -> GIArgument(array/%s)[interface(%s)](%s)",
833
+ rb_gi_direction_to_string(metadata->direction),
834
+ rb_gi_array_type_to_string(metadata->array_type),
835
+ g_info_type_to_string(metadata->element_type.interface_type),
836
+ g_type_name(metadata->element_type.interface_gtype));
837
+ break;
838
+ case GI_INFO_TYPE_OBJECT:
839
+ rb_gi_arguments_in_init_arg_ruby_array_c_interface_object(args,
840
+ metadata,
841
+ rb_array);
842
+ break;
843
+ case GI_INFO_TYPE_INTERFACE:
844
+ case GI_INFO_TYPE_CONSTANT:
845
+ case GI_INFO_TYPE_INVALID_0:
846
+ case GI_INFO_TYPE_UNION:
847
+ case GI_INFO_TYPE_VALUE:
848
+ case GI_INFO_TYPE_SIGNAL:
849
+ case GI_INFO_TYPE_VFUNC:
850
+ case GI_INFO_TYPE_PROPERTY:
851
+ case GI_INFO_TYPE_FIELD:
852
+ case GI_INFO_TYPE_ARG:
853
+ case GI_INFO_TYPE_TYPE:
854
+ case GI_INFO_TYPE_UNRESOLVED:
855
+ rb_raise(rb_eNotImpError,
856
+ "TODO: %s Ruby -> GIArgument(array/%s)[interface(%s)](%s)",
857
+ rb_gi_direction_to_string(metadata->direction),
858
+ rb_gi_array_type_to_string(metadata->array_type),
859
+ g_info_type_to_string(metadata->element_type.interface_type),
860
+ g_type_name(metadata->element_type.interface_gtype));
861
+ break;
862
+ default:
863
+ g_assert_not_reached();
864
+ break;
865
+ }
866
+ }
867
+
868
+ static void
869
+ rb_gi_arguments_in_init_arg_ruby_array_c(RBGIArguments *args,
870
+ RBGIArgMetadata *metadata)
871
+ {
872
+ VALUE rb_arg = metadata->rb_arg;
873
+
874
+ metadata->free_func = rb_gi_arguments_in_free_array_c_value;
875
+ switch (metadata->element_type.tag) {
876
+ case GI_TYPE_TAG_VOID:
877
+ rb_raise(rb_eNotImpError,
878
+ "TODO: [%s] %s Ruby -> GIArgument(array/%s)[%s][%s]",
879
+ metadata->name,
880
+ rb_gi_direction_to_string(metadata->direction),
881
+ rb_gi_array_type_to_string(metadata->array_type),
882
+ g_type_tag_to_string(metadata->element_type.tag),
883
+ rb_gi_transfer_to_string(metadata->transfer));
884
+ break;
885
+ case GI_TYPE_TAG_BOOLEAN:
886
+ rb_arg = rbg_to_array(rb_arg);
887
+ rb_gi_arguments_in_init_arg_ruby_array_c_boolean(args,
888
+ metadata,
889
+ rb_arg);
890
+ break;
891
+ case GI_TYPE_TAG_INT8:
892
+ case GI_TYPE_TAG_UINT8:
893
+ if (RB_TYPE_P(rb_arg, RUBY_T_STRING)) {
894
+ gchar *raw_array = RSTRING_PTR(rb_arg);
895
+ gsize length = RSTRING_LEN(rb_arg);
896
+ if (metadata->transfer != GI_TRANSFER_NOTHING) {
897
+ rb_raise(rb_eNotImpError,
898
+ "TODO: [%s] %s Ruby -> GIArgument(array/%s)[%s][%s]",
899
+ metadata->name,
900
+ rb_gi_direction_to_string(metadata->direction),
901
+ rb_gi_array_type_to_string(metadata->array_type),
902
+ g_type_tag_to_string(metadata->element_type.tag),
903
+ rb_gi_transfer_to_string(metadata->transfer));
904
+ }
905
+ if (metadata->direction == GI_DIRECTION_INOUT) {
906
+ metadata->in_arg->v_pointer = ALLOC(gpointer);
907
+ *((gpointer *)(metadata->in_arg->v_pointer)) = raw_array;
908
+ } else {
909
+ metadata->in_arg->v_pointer = raw_array;
910
+ }
911
+ rb_gi_arguments_in_init_arg_ruby_array_set_length(args,
912
+ metadata,
913
+ length);
914
+ metadata->free_func = rb_gi_arguments_in_free_array_c_string;
915
+ } else {
916
+ rb_arg = rbg_to_array(rb_arg);
917
+ if (metadata->element_type.tag == GI_TYPE_TAG_INT8) {
918
+ rb_gi_arguments_in_init_arg_ruby_array_c_int8(args,
919
+ metadata,
920
+ rb_arg);
921
+ } else {
922
+ rb_gi_arguments_in_init_arg_ruby_array_c_uint8(args,
923
+ metadata,
924
+ rb_arg);
925
+ }
926
+ }
927
+ break;
928
+ case GI_TYPE_TAG_INT16:
929
+ rb_arg = rbg_to_array(rb_arg);
930
+ rb_gi_arguments_in_init_arg_ruby_array_c_int16(args,
931
+ metadata,
932
+ rb_arg);
933
+ break;
934
+ case GI_TYPE_TAG_UINT16:
935
+ rb_arg = rbg_to_array(rb_arg);
936
+ rb_gi_arguments_in_init_arg_ruby_array_c_uint16(args,
937
+ metadata,
938
+ rb_arg);
939
+ break;
940
+ case GI_TYPE_TAG_INT32:
941
+ rb_arg = rbg_to_array(rb_arg);
942
+ rb_gi_arguments_in_init_arg_ruby_array_c_int32(args,
943
+ metadata,
944
+ rb_arg);
945
+ break;
946
+ case GI_TYPE_TAG_UINT32:
947
+ rb_arg = rbg_to_array(rb_arg);
948
+ rb_gi_arguments_in_init_arg_ruby_array_c_uint32(args,
949
+ metadata,
950
+ rb_arg);
951
+ break;
952
+ case GI_TYPE_TAG_INT64:
953
+ rb_arg = rbg_to_array(rb_arg);
954
+ rb_gi_arguments_in_init_arg_ruby_array_c_int64(args,
955
+ metadata,
956
+ rb_arg);
957
+ break;
958
+ case GI_TYPE_TAG_UINT64:
959
+ rb_arg = rbg_to_array(rb_arg);
960
+ rb_gi_arguments_in_init_arg_ruby_array_c_uint64(args,
961
+ metadata,
962
+ rb_arg);
963
+ break;
964
+ case GI_TYPE_TAG_FLOAT:
965
+ rb_arg = rbg_to_array(rb_arg);
966
+ rb_gi_arguments_in_init_arg_ruby_array_c_float(args,
967
+ metadata,
968
+ rb_arg);
969
+ break;
970
+ case GI_TYPE_TAG_DOUBLE:
971
+ rb_arg = rbg_to_array(rb_arg);
972
+ rb_gi_arguments_in_init_arg_ruby_array_c_double(args,
973
+ metadata,
974
+ rb_arg);
975
+ break;
976
+ case GI_TYPE_TAG_GTYPE:
977
+ rb_arg = rbg_to_array(rb_arg);
978
+ rb_gi_arguments_in_init_arg_ruby_array_c_gtype(args,
979
+ metadata,
980
+ rb_arg);
981
+ break;
982
+ case GI_TYPE_TAG_UTF8:
983
+ {
984
+ GIArgument *array_argument = metadata->in_arg;
985
+ gchar **raw_array;
986
+ long length;
987
+ rb_arg = rbg_to_array(rb_arg);
988
+ if (metadata->transfer == GI_TRANSFER_EVERYTHING) {
989
+ raw_array = rbg_rval2strv_dup(&rb_arg, &length);
990
+ } else {
991
+ raw_array = rbg_rval2strv(&rb_arg, &length);
992
+ }
993
+ if (metadata->direction == GI_DIRECTION_INOUT) {
994
+ array_argument->v_pointer = ALLOC(gpointer);
995
+ *((gpointer *)(array_argument->v_pointer)) = raw_array;
996
+ } else {
997
+ array_argument->v_pointer = raw_array;
998
+ }
999
+ rb_gi_arguments_in_init_arg_ruby_array_set_length(args,
1000
+ metadata,
1001
+ length);
1002
+ metadata->free_func = rb_gi_arguments_in_free_array_c_strv;
1003
+ }
1004
+ break;
1005
+ case GI_TYPE_TAG_FILENAME:
1006
+ {
1007
+ GIArgument *array_argument = metadata->in_arg;
1008
+ gchar **raw_array;
1009
+ long length;
1010
+ rb_arg = rbg_to_array(rb_arg);
1011
+ raw_array = rbg_rval2filenamev(&rb_arg, &length);
1012
+ if (metadata->direction == GI_DIRECTION_INOUT) {
1013
+ array_argument->v_pointer = ALLOC(gpointer);
1014
+ *((gpointer *)(array_argument->v_pointer)) = raw_array;
1015
+ } else {
1016
+ array_argument->v_pointer = raw_array;
1017
+ }
1018
+ rb_gi_arguments_in_init_arg_ruby_array_set_length(args,
1019
+ metadata,
1020
+ length);
1021
+ metadata->free_func = rb_gi_arguments_in_free_array_c_filename;
1022
+ }
1023
+ break;
1024
+ case GI_TYPE_TAG_ARRAY:
1025
+ rb_raise(rb_eNotImpError,
1026
+ "TODO: [%s::%s](%s) %s Ruby -> GIArgument(array/%s)[%s]",
1027
+ args->namespace,
1028
+ args->name,
1029
+ metadata->name,
1030
+ rb_gi_direction_to_string(metadata->direction),
1031
+ rb_gi_array_type_to_string(metadata->array_type),
1032
+ g_type_tag_to_string(metadata->element_type.tag));
1033
+ break;
1034
+ case GI_TYPE_TAG_INTERFACE:
1035
+ rb_arg = rbg_to_array(rb_arg);
1036
+ rb_gi_arguments_in_init_arg_ruby_array_c_interface(args,
1037
+ metadata,
1038
+ rb_arg);
1039
+ break;
1040
+ case GI_TYPE_TAG_GLIST:
1041
+ case GI_TYPE_TAG_GSLIST:
1042
+ case GI_TYPE_TAG_GHASH:
1043
+ case GI_TYPE_TAG_ERROR:
1044
+ case GI_TYPE_TAG_UNICHAR:
1045
+ rb_raise(rb_eNotImpError,
1046
+ "TODO: %s Ruby -> GIArgument(array/%s)[%s][%s]",
1047
+ rb_gi_direction_to_string(metadata->direction),
1048
+ rb_gi_array_type_to_string(metadata->array_type),
1049
+ g_type_tag_to_string(metadata->element_type.tag),
1050
+ rb_gi_transfer_to_string(metadata->transfer));
1051
+ break;
1052
+ default:
1053
+ g_assert_not_reached();
1054
+ break;
1055
+ }
1056
+ }
1057
+
1058
+ static void
1059
+ rb_gi_arguments_in_init_arg_ruby_array(RBGIArguments *args,
1060
+ RBGIArgMetadata *metadata)
1061
+ {
1062
+ if (NIL_P(metadata->rb_arg) && metadata->may_be_null_p) {
1063
+ memset(metadata->in_arg, 0, sizeof(GIArgument));
1064
+ if (metadata->array_length_arg) {
1065
+ memset(metadata->array_length_arg, 0, sizeof(GIArgument));
1066
+ }
1067
+ return;
1068
+ }
1069
+
1070
+ switch (metadata->array_type) {
1071
+ case GI_ARRAY_TYPE_C:
1072
+ rb_gi_arguments_in_init_arg_ruby_array_c(args, metadata);
1073
+ break;
1074
+ case GI_ARRAY_TYPE_ARRAY:
1075
+ case GI_ARRAY_TYPE_PTR_ARRAY:
1076
+ case GI_ARRAY_TYPE_BYTE_ARRAY:
1077
+ rb_raise(rb_eNotImpError,
1078
+ "TODO: %s Ruby -> GIArgument(array/%s)[%s][%s]",
1079
+ rb_gi_direction_to_string(metadata->direction),
1080
+ rb_gi_array_type_to_string(metadata->array_type),
1081
+ g_type_tag_to_string(metadata->element_type.tag),
1082
+ rb_gi_transfer_to_string(metadata->transfer));
1083
+ break;
1084
+ default:
1085
+ g_assert_not_reached();
1086
+ break;
1087
+ }
1088
+ }
1089
+
1090
+ static void
1091
+ rb_gi_arguments_in_free_default(RBGIArguments *args,
1092
+ RBGIArgMetadata *metadata,
1093
+ gpointer user_data)
1094
+ {
1095
+ if (metadata->direction == GI_DIRECTION_INOUT) {
1096
+ xfree(metadata->in_arg->v_pointer);
1097
+ }
1098
+ }
1099
+
1100
+ static void
1101
+ rb_gi_arguments_in_free_filename(RBGIArguments *args,
1102
+ RBGIArgMetadata *metadata,
1103
+ gpointer user_data)
1104
+ {
1105
+ gchar *target;
1106
+ if (metadata->direction == GI_DIRECTION_INOUT) {
1107
+ target = *((gchar **)(metadata->in_arg->v_pointer));
1108
+ xfree(metadata->in_arg->v_pointer);
1109
+ } else {
1110
+ target = metadata->in_arg->v_string;
1111
+ }
1112
+
1113
+ switch (metadata->transfer) {
1114
+ case GI_TRANSFER_NOTHING:
1115
+ g_free(target);
1116
+ break;
1117
+ case GI_TRANSFER_CONTAINER:
1118
+ case GI_TRANSFER_EVERYTHING:
1119
+ break;
1120
+ }
1121
+ }
1122
+
1123
+ static void
1124
+ rb_gi_arguments_in_free_interface_struct(RBGIArguments *args,
1125
+ RBGIArgMetadata *metadata,
1126
+ gpointer user_data)
1127
+ {
1128
+ if (metadata->direction == GI_DIRECTION_INOUT) {
1129
+ xfree(metadata->in_arg->v_pointer);
1130
+ }
1131
+
1132
+ switch (metadata->transfer) {
1133
+ case GI_TRANSFER_NOTHING:
1134
+ break;
1135
+ case GI_TRANSFER_CONTAINER:
1136
+ case GI_TRANSFER_EVERYTHING:
1137
+ if (metadata->type.interface_gtype == G_TYPE_NONE) {
1138
+ rb_raise(rb_eNotImpError,
1139
+ "TODO: [%s] free %s "
1140
+ "Ruby -> GIArgument(interface)[%s][%s][%s]",
1141
+ metadata->name,
1142
+ rb_gi_direction_to_string(metadata->direction),
1143
+ g_info_type_to_string(metadata->type.interface_type),
1144
+ g_type_name(metadata->type.interface_gtype),
1145
+ rb_gi_transfer_to_string(metadata->transfer));
1146
+ }
1147
+ rbgobj_boxed_unown(metadata->rb_arg);
1148
+ break;
1149
+ }
1150
+ }
1151
+
1152
+ static void
1153
+ rb_gi_arguments_in_free_interface_struct_gvalue(RBGIArguments *args,
1154
+ RBGIArgMetadata *metadata,
1155
+ gpointer user_data)
1156
+ {
1157
+ GValue *target;
1158
+ if (metadata->direction == GI_DIRECTION_INOUT) {
1159
+ target = *((GValue **)(metadata->in_arg->v_pointer));
1160
+ xfree(metadata->in_arg->v_pointer);
1161
+ } else {
1162
+ target = metadata->in_arg->v_pointer;
1163
+ }
1164
+
1165
+ switch (metadata->transfer) {
1166
+ case GI_TRANSFER_NOTHING:
1167
+ g_value_unset(target);
1168
+ xfree(target);
1169
+ break;
1170
+ case GI_TRANSFER_CONTAINER:
1171
+ case GI_TRANSFER_EVERYTHING:
1172
+ break;
1173
+ }
1174
+ }
1175
+
1176
+ static void
1177
+ rb_gi_arguments_in_free_interface_struct_gbytes(RBGIArguments *args,
1178
+ RBGIArgMetadata *metadata,
1179
+ gpointer user_data)
1180
+ {
1181
+ GBytes *target;
1182
+ if (metadata->direction == GI_DIRECTION_INOUT) {
1183
+ target = *((GBytes **)(metadata->in_arg->v_pointer));
1184
+ xfree(metadata->in_arg->v_pointer);
1185
+ } else {
1186
+ target = metadata->in_arg->v_pointer;
1187
+ }
1188
+
1189
+ switch (metadata->transfer) {
1190
+ case GI_TRANSFER_NOTHING:
1191
+ g_bytes_unref(target);
1192
+ break;
1193
+ case GI_TRANSFER_CONTAINER:
1194
+ case GI_TRANSFER_EVERYTHING:
1195
+ break;
1196
+ }
1197
+ }
1198
+
1199
+ static void
1200
+ rb_gi_arguments_in_free_interface_object(RBGIArguments *args,
1201
+ RBGIArgMetadata *metadata,
1202
+ gpointer user_data)
1203
+ {
1204
+ if (metadata->direction == GI_DIRECTION_INOUT) {
1205
+ xfree(metadata->in_arg->v_pointer);
1206
+ }
1207
+
1208
+ switch (metadata->transfer) {
1209
+ case GI_TRANSFER_NOTHING:
1210
+ break;
1211
+ case GI_TRANSFER_CONTAINER:
1212
+ case GI_TRANSFER_EVERYTHING:
1213
+ break;
1214
+ }
1215
+ }
1216
+
1217
+ static void
1218
+ rb_gi_arguments_in_init_arg_ruby_interface(RBGIArguments *args,
1219
+ RBGIArgMetadata *metadata)
1220
+ {
1221
+ switch (metadata->type.interface_type) {
1222
+ case GI_INFO_TYPE_INVALID:
1223
+ case GI_INFO_TYPE_FUNCTION:
1224
+ case GI_INFO_TYPE_CALLBACK:
1225
+ rb_raise(rb_eNotImpError,
1226
+ "TODO: [%s] %s Ruby -> GIArgument(interface)[%s][%s]",
1227
+ metadata->name,
1228
+ rb_gi_direction_to_string(metadata->direction),
1229
+ g_info_type_to_string(metadata->type.interface_type),
1230
+ rb_gi_transfer_to_string(metadata->transfer));
1231
+ break;
1232
+ case GI_INFO_TYPE_STRUCT:
1233
+ if (metadata->transfer != GI_TRANSFER_NOTHING) {
1234
+ rb_raise(rb_eNotImpError,
1235
+ "TODO: [%s] %s Ruby -> GIArgument(interface)[%s][%s][%s]",
1236
+ metadata->name,
1237
+ rb_gi_direction_to_string(metadata->direction),
1238
+ g_info_type_to_string(metadata->type.interface_type),
1239
+ g_type_name(metadata->type.interface_gtype),
1240
+ rb_gi_transfer_to_string(metadata->transfer));
1241
+ }
1242
+ metadata->free_func = rb_gi_arguments_in_free_interface_struct;
1243
+ if (metadata->type.interface_gtype == G_TYPE_VALUE) {
1244
+ GValue *gvalue;
1245
+ if (rbg_is_value(metadata->rb_arg)) {
1246
+ gvalue = RVAL2BOXED(metadata->rb_arg, G_TYPE_VALUE);
1247
+ } else {
1248
+ gvalue = ALLOC(GValue);
1249
+ memset(gvalue, 0, sizeof(GValue));
1250
+ rbgobj_initialize_gvalue(gvalue, metadata->rb_arg);
1251
+ metadata->free_func =
1252
+ rb_gi_arguments_in_free_interface_struct_gvalue;
1253
+ }
1254
+ metadata->in_arg->v_pointer = gvalue;
1255
+ } else if (metadata->type.interface_gtype == G_TYPE_BYTES) {
1256
+ if (rbg_is_bytes(metadata->rb_arg)) {
1257
+ metadata->in_arg->v_pointer =
1258
+ RVAL2BOXED(metadata->rb_arg, G_TYPE_BYTES);
1259
+ } else {
1260
+ VALUE rb_string;
1261
+ GBytes *gbytes;
1262
+
1263
+ rb_string = StringValue(metadata->rb_arg);
1264
+ gbytes = g_bytes_new(RSTRING_PTR(rb_string),
1265
+ RSTRING_LEN(rb_string));
1266
+ metadata->in_arg->v_pointer = gbytes;
1267
+ metadata->free_func =
1268
+ rb_gi_arguments_in_free_interface_struct_gbytes;
1269
+ }
1270
+ } else if (metadata->type.interface_gtype == G_TYPE_CLOSURE) {
1271
+ GClosure *rclosure = NULL;
1272
+
1273
+ rclosure = g_rclosure_new(metadata->rb_arg, Qnil, NULL);
1274
+ g_rclosure_attach(rclosure, args->rb_receiver);
1275
+ metadata->in_arg->v_pointer = rclosure;
1276
+ } else {
1277
+ metadata->in_arg->v_pointer =
1278
+ rb_gi_struct_get_raw(metadata->rb_arg,
1279
+ metadata->type.interface_gtype);
1280
+ }
1281
+ break;
1282
+ case GI_INFO_TYPE_BOXED:
1283
+ rb_raise(rb_eNotImpError,
1284
+ "TODO: [%s] %s Ruby -> GIArgument(interface)[%s][%s][%s]",
1285
+ metadata->name,
1286
+ rb_gi_direction_to_string(metadata->direction),
1287
+ g_info_type_to_string(metadata->type.interface_type),
1288
+ g_type_name(metadata->type.interface_gtype),
1289
+ rb_gi_transfer_to_string(metadata->transfer));
1290
+ break;
1291
+ case GI_INFO_TYPE_ENUM:
1292
+ if (metadata->type.interface_gtype == G_TYPE_NONE) {
1293
+ metadata->in_arg->v_int32 = NUM2INT(metadata->rb_arg);
1294
+ } else {
1295
+ metadata->in_arg->v_int32 =
1296
+ RVAL2GENUM(metadata->rb_arg, metadata->type.interface_gtype);
1297
+ }
1298
+ break;
1299
+ case GI_INFO_TYPE_FLAGS:
1300
+ if (metadata->type.interface_gtype == G_TYPE_NONE) {
1301
+ metadata->in_arg->v_int32 = NUM2INT(metadata->rb_arg);
1302
+ } else {
1303
+ metadata->in_arg->v_int32 =
1304
+ RVAL2GFLAGS(metadata->rb_arg, metadata->type.interface_gtype);
1305
+ }
1306
+ break;
1307
+ case GI_INFO_TYPE_OBJECT:
1308
+ case GI_INFO_TYPE_INTERFACE:
1309
+ metadata->in_arg->v_pointer = RVAL2GOBJ(metadata->rb_arg);
1310
+ if (metadata->in_arg->v_pointer &&
1311
+ metadata->type.interface_gtype != G_TYPE_NONE &&
1312
+ !G_TYPE_CHECK_INSTANCE_TYPE(metadata->in_arg->v_pointer,
1313
+ metadata->type.interface_gtype)) {
1314
+ rb_raise(rb_eArgError,
1315
+ "must be <%s> object: <%" PRIsVALUE ">",
1316
+ g_type_name(metadata->type.interface_gtype),
1317
+ metadata->rb_arg);
1318
+ }
1319
+ if (metadata->in_arg->v_pointer &&
1320
+ metadata->transfer != GI_TRANSFER_NOTHING) {
1321
+ g_object_ref(metadata->in_arg->v_pointer);
1322
+ }
1323
+ metadata->free_func = rb_gi_arguments_in_free_interface_object;
1324
+ break;
1325
+ case GI_INFO_TYPE_CONSTANT:
1326
+ rb_raise(rb_eNotImpError,
1327
+ "TODO: [%s][%s](%s) %s "
1328
+ "Ruby -> GIArgument(interface)[%s][%s][%s]",
1329
+ args->namespace,
1330
+ args->name,
1331
+ metadata->name,
1332
+ rb_gi_direction_to_string(metadata->direction),
1333
+ g_info_type_to_string(metadata->type.interface_type),
1334
+ g_type_name(metadata->type.interface_gtype),
1335
+ rb_gi_transfer_to_string(metadata->transfer));
1336
+ break;
1337
+ case GI_INFO_TYPE_INVALID_0:
1338
+ g_assert_not_reached();
1339
+ break;
1340
+ case GI_INFO_TYPE_UNION:
1341
+ if (metadata->transfer != GI_TRANSFER_NOTHING) {
1342
+ rb_raise(rb_eNotImpError,
1343
+ "TODO: [%s] %s Ruby -> GIArgument(interface)[%s][%s][%s]",
1344
+ metadata->name,
1345
+ rb_gi_direction_to_string(metadata->direction),
1346
+ g_info_type_to_string(metadata->type.interface_type),
1347
+ g_type_name(metadata->type.interface_gtype),
1348
+ rb_gi_transfer_to_string(metadata->transfer));
1349
+ }
1350
+ if (metadata->type.interface_gtype == G_TYPE_NONE) {
1351
+ rb_raise(rb_eNotImpError,
1352
+ "TODO: [%s] %s Ruby -> GIArgument(interface)[%s][%s][%s]",
1353
+ metadata->name,
1354
+ rb_gi_direction_to_string(metadata->direction),
1355
+ g_info_type_to_string(metadata->type.interface_type),
1356
+ g_type_name(metadata->type.interface_gtype),
1357
+ rb_gi_transfer_to_string(metadata->transfer));
1358
+ } else {
1359
+ metadata->in_arg->v_pointer =
1360
+ RVAL2BOXED(metadata->rb_arg, metadata->type.interface_gtype);
1361
+ }
1362
+ break;
1363
+ case GI_INFO_TYPE_VALUE:
1364
+ case GI_INFO_TYPE_SIGNAL:
1365
+ case GI_INFO_TYPE_VFUNC:
1366
+ case GI_INFO_TYPE_PROPERTY:
1367
+ case GI_INFO_TYPE_FIELD:
1368
+ case GI_INFO_TYPE_ARG:
1369
+ case GI_INFO_TYPE_TYPE:
1370
+ case GI_INFO_TYPE_UNRESOLVED:
1371
+ default:
1372
+ rb_raise(rb_eNotImpError,
1373
+ "TODO: [%s] %s Ruby -> GIArgument(interface)[%s][%s]",
1374
+ metadata->name,
1375
+ rb_gi_direction_to_string(metadata->direction),
1376
+ g_info_type_to_string(metadata->type.interface_type),
1377
+ rb_gi_transfer_to_string(metadata->transfer));
1378
+ break;
1379
+ }
1380
+
1381
+ if (metadata->direction == GI_DIRECTION_INOUT) {
1382
+ gpointer target = metadata->in_arg->v_pointer;
1383
+ metadata->in_arg->v_pointer = ALLOC(gpointer);
1384
+ *((gpointer *)(metadata->in_arg->v_pointer)) = target;
1385
+ }
1386
+ }
1387
+
1388
+ static void
1389
+ rb_gi_arguments_in_free_list(RBGIArguments *args,
1390
+ RBGIArgMetadata *metadata,
1391
+ gpointer user_data)
1392
+ {
1393
+ gpointer target;
1394
+ if (metadata->direction == GI_DIRECTION_INOUT) {
1395
+ target = *((gpointer *)(metadata->in_arg->v_pointer));
1396
+ xfree(metadata->in_arg->v_pointer);
1397
+ } else {
1398
+ target = metadata->in_arg->v_pointer;
1399
+ }
1400
+
1401
+ switch (metadata->transfer) {
1402
+ case GI_TRANSFER_NOTHING:
1403
+ if (metadata->type.tag == GI_TYPE_TAG_GLIST) {
1404
+ g_list_free(target);
1405
+ } else {
1406
+ g_slist_free(target);
1407
+ }
1408
+ break;
1409
+ case GI_TRANSFER_CONTAINER:
1410
+ break;
1411
+ default:
1412
+ rb_raise(rb_eNotImpError,
1413
+ "TODO: [%s] free %s "
1414
+ "Ruby -> GIArgument(%s)[%s][%s]",
1415
+ metadata->name,
1416
+ rb_gi_direction_to_string(metadata->direction),
1417
+ g_type_tag_to_string(metadata->type.tag),
1418
+ g_type_tag_to_string(metadata->element_type.tag),
1419
+ rb_gi_transfer_to_string(metadata->transfer));
1420
+ break;
1421
+ }
1422
+ }
1423
+
1424
+ static void
1425
+ rb_gi_arguments_in_init_arg_ruby_list(RBGIArguments *args,
1426
+ RBGIArgMetadata *metadata)
1427
+ {
1428
+ GType gtype = metadata->element_type.interface_gtype;
1429
+
1430
+ metadata->free_func = rb_gi_arguments_in_free_list;
1431
+ switch (metadata->element_type.tag) {
1432
+ case GI_TYPE_TAG_VOID:
1433
+ case GI_TYPE_TAG_BOOLEAN:
1434
+ case GI_TYPE_TAG_INT8:
1435
+ case GI_TYPE_TAG_UINT8:
1436
+ case GI_TYPE_TAG_INT16:
1437
+ case GI_TYPE_TAG_UINT16:
1438
+ case GI_TYPE_TAG_INT32:
1439
+ case GI_TYPE_TAG_UINT32:
1440
+ case GI_TYPE_TAG_INT64:
1441
+ case GI_TYPE_TAG_UINT64:
1442
+ case GI_TYPE_TAG_FLOAT:
1443
+ case GI_TYPE_TAG_DOUBLE:
1444
+ case GI_TYPE_TAG_GTYPE:
1445
+ case GI_TYPE_TAG_UTF8:
1446
+ case GI_TYPE_TAG_FILENAME:
1447
+ case GI_TYPE_TAG_ARRAY:
1448
+ rb_raise(rb_eNotImpError,
1449
+ "TODO: [%s] %s Ruby -> GIArgument(%s)[%s][%s]",
1450
+ metadata->name,
1451
+ rb_gi_direction_to_string(metadata->direction),
1452
+ g_type_tag_to_string(metadata->type.tag),
1453
+ g_type_tag_to_string(metadata->element_type.tag),
1454
+ rb_gi_transfer_to_string(metadata->transfer));
1455
+ break;
1456
+ case GI_TYPE_TAG_INTERFACE:
1457
+ if (metadata->type.tag == GI_TYPE_TAG_GLIST) {
1458
+ metadata->in_arg->v_pointer = RVAL2GOBJGLIST(metadata->rb_arg);
1459
+ } else {
1460
+ metadata->in_arg->v_pointer = RVAL2GOBJGSLIST(metadata->rb_arg);
1461
+ }
1462
+ if (gtype != G_TYPE_NONE) {
1463
+ if (metadata->type.tag == GI_TYPE_TAG_GLIST) {
1464
+ GList *node;
1465
+ for (node = metadata->in_arg->v_pointer;
1466
+ node;
1467
+ node = g_list_next(node)) {
1468
+ GObject *object = node->data;
1469
+ if (!G_TYPE_CHECK_INSTANCE_TYPE(object, gtype)) {
1470
+ g_list_free(metadata->in_arg->v_pointer);
1471
+ rb_raise(rb_eArgError,
1472
+ "must be <%s> objects: <%" PRIsVALUE ">",
1473
+ g_type_name(gtype),
1474
+ metadata->rb_arg);
1475
+ }
1476
+ }
1477
+ } else {
1478
+ GSList *node;
1479
+ for (node = metadata->in_arg->v_pointer;
1480
+ node;
1481
+ node = g_slist_next(node)) {
1482
+ GObject *object = node->data;
1483
+ if (!G_TYPE_CHECK_INSTANCE_TYPE(object, gtype)) {
1484
+ g_slist_free(metadata->in_arg->v_pointer);
1485
+ rb_raise(rb_eArgError,
1486
+ "must be <%s> objects: <%" PRIsVALUE ">",
1487
+ g_type_name(gtype),
1488
+ metadata->rb_arg);
1489
+ }
1490
+ }
1491
+ }
1492
+ }
1493
+ break;
1494
+ case GI_TYPE_TAG_GLIST:
1495
+ case GI_TYPE_TAG_GSLIST:
1496
+ case GI_TYPE_TAG_GHASH:
1497
+ case GI_TYPE_TAG_ERROR:
1498
+ case GI_TYPE_TAG_UNICHAR:
1499
+ rb_raise(rb_eNotImpError,
1500
+ "TODO: [%s] %s Ruby -> GIArgument(%s)[%s][%s]",
1501
+ metadata->name,
1502
+ rb_gi_direction_to_string(metadata->direction),
1503
+ g_type_tag_to_string(metadata->type.tag),
1504
+ g_type_tag_to_string(metadata->element_type.tag),
1505
+ rb_gi_transfer_to_string(metadata->transfer));
1506
+ break;
1507
+ default:
1508
+ g_assert_not_reached();
1509
+ break;
1510
+ }
1511
+
1512
+ if (metadata->direction == GI_DIRECTION_INOUT) {
1513
+ gpointer target = metadata->in_arg->v_pointer;
1514
+ metadata->in_arg->v_pointer = ALLOC(gpointer);
1515
+ *((gpointer *)(metadata->in_arg->v_pointer)) = target;
1516
+ }
1517
+ }
1518
+
1519
+ typedef struct {
1520
+ VALUE rb_value;
1521
+ RBGIArgMetadataType *type;
1522
+ const gchar *context;
1523
+ } RubyToCData;
1524
+
1525
+ typedef gpointer (*RubyToCFunc)(RubyToCData *data);
1526
+
1527
+ static gpointer
1528
+ ruby_to_c_utf8(RubyToCData *data)
1529
+ {
1530
+ return g_strdup(RVAL2CSTR(data->rb_value));
1531
+ }
1532
+
1533
+ static gpointer
1534
+ ruby_to_c_interface_enum(RubyToCData *data)
1535
+ {
1536
+ gint32 value;
1537
+ if (data->type->interface_gtype == G_TYPE_NONE) {
1538
+ value = NUM2INT(data->rb_value);
1539
+ } else {
1540
+ value = RVAL2GENUM(data->rb_value, data->type->interface_gtype);
1541
+ }
1542
+ return GINT_TO_POINTER(value);
1543
+ }
1544
+
1545
+ typedef struct {
1546
+ GIArgument *argument;
1547
+ GITypeInfo *type_info;
1548
+ VALUE rb_argument;
1549
+ VALUE self;
1550
+ } ArgumentFromRubyData;
1551
+
1552
+ typedef struct {
1553
+ GHashTable *hash_table;
1554
+ RubyToCFunc key_ruby_to_c_func;
1555
+ RubyToCData *key_ruby_to_c_data;
1556
+ RubyToCFunc value_ruby_to_c_func;
1557
+ RubyToCData *value_ruby_to_c_data;
1558
+ } ArgumentFromRubyGHashData;
1559
+
1560
+ static int
1561
+ rb_gi_arguments_in_init_arg_ruby_ghash_convert(VALUE rb_key,
1562
+ VALUE rb_value,
1563
+ VALUE user_data)
1564
+ {
1565
+ ArgumentFromRubyGHashData *data = (ArgumentFromRubyGHashData *)user_data;
1566
+ gpointer key;
1567
+ gpointer value;
1568
+ data->key_ruby_to_c_data->rb_value = rb_key;
1569
+ key = data->key_ruby_to_c_func(data->key_ruby_to_c_data);
1570
+ data->value_ruby_to_c_data->rb_value = rb_value;
1571
+ value = data->key_ruby_to_c_func(data->value_ruby_to_c_data);
1572
+ g_hash_table_insert(data->hash_table, key, value);
1573
+ return ST_CONTINUE;
1574
+ }
1575
+
1576
+ static VALUE
1577
+ rb_gi_arguments_in_init_arg_ruby_ghash_body(VALUE value_data)
1578
+ {
1579
+ RBGIArgMetadata *metadata = (RBGIArgMetadata *)value_data;
1580
+ GHashFunc hash_func = NULL;
1581
+ GEqualFunc equal_func = NULL;
1582
+ GDestroyNotify key_destroy_func = NULL;
1583
+ GDestroyNotify value_destroy_func = NULL;
1584
+ RubyToCFunc key_ruby_to_c_func = NULL;
1585
+ RubyToCData key_ruby_to_c_data;
1586
+ RubyToCFunc value_ruby_to_c_func = NULL;
1587
+ RubyToCData value_ruby_to_c_data;
1588
+ ArgumentFromRubyGHashData convert_data;
1589
+
1590
+ key_ruby_to_c_data.type = &(metadata->key_type);
1591
+ switch (metadata->key_type.tag) {
1592
+ case GI_TYPE_TAG_VOID:
1593
+ case GI_TYPE_TAG_BOOLEAN:
1594
+ case GI_TYPE_TAG_INT8:
1595
+ case GI_TYPE_TAG_UINT8:
1596
+ case GI_TYPE_TAG_INT16:
1597
+ case GI_TYPE_TAG_UINT16:
1598
+ case GI_TYPE_TAG_INT32:
1599
+ case GI_TYPE_TAG_UINT32:
1600
+ case GI_TYPE_TAG_INT64:
1601
+ case GI_TYPE_TAG_UINT64:
1602
+ case GI_TYPE_TAG_FLOAT:
1603
+ case GI_TYPE_TAG_DOUBLE:
1604
+ case GI_TYPE_TAG_GTYPE:
1605
+ rb_raise(rb_eNotImpError,
1606
+ "TODO: Ruby -> GIArgument(GHash)[key][%s]",
1607
+ g_type_tag_to_string(metadata->key_type.tag));
1608
+ break;
1609
+ case GI_TYPE_TAG_UTF8:
1610
+ hash_func = g_str_hash;
1611
+ equal_func = g_str_equal;
1612
+ key_destroy_func = g_free;
1613
+ key_ruby_to_c_func = ruby_to_c_utf8;
1614
+ key_ruby_to_c_data.context = "Ruby -> GIArgument(GHash)[key][utf8]";
1615
+ break;
1616
+ case GI_TYPE_TAG_FILENAME:
1617
+ case GI_TYPE_TAG_ARRAY:
1618
+ case GI_TYPE_TAG_INTERFACE:
1619
+ case GI_TYPE_TAG_GLIST:
1620
+ case GI_TYPE_TAG_GSLIST:
1621
+ case GI_TYPE_TAG_GHASH:
1622
+ case GI_TYPE_TAG_ERROR:
1623
+ case GI_TYPE_TAG_UNICHAR:
1624
+ rb_raise(rb_eNotImpError,
1625
+ "TODO: Ruby -> GIArgument(GHash)[key][%s]",
1626
+ g_type_tag_to_string(metadata->key_type.tag));
1627
+ break;
1628
+ default:
1629
+ g_assert_not_reached();
1630
+ break;
1631
+ }
1632
+
1633
+ value_ruby_to_c_data.type = &(metadata->value_type);
1634
+ switch (metadata->value_type.tag) {
1635
+ case GI_TYPE_TAG_VOID:
1636
+ case GI_TYPE_TAG_BOOLEAN:
1637
+ case GI_TYPE_TAG_INT8:
1638
+ case GI_TYPE_TAG_UINT8:
1639
+ case GI_TYPE_TAG_INT16:
1640
+ case GI_TYPE_TAG_UINT16:
1641
+ case GI_TYPE_TAG_INT32:
1642
+ case GI_TYPE_TAG_UINT32:
1643
+ case GI_TYPE_TAG_INT64:
1644
+ case GI_TYPE_TAG_UINT64:
1645
+ case GI_TYPE_TAG_FLOAT:
1646
+ case GI_TYPE_TAG_DOUBLE:
1647
+ case GI_TYPE_TAG_GTYPE:
1648
+ case GI_TYPE_TAG_UTF8:
1649
+ case GI_TYPE_TAG_FILENAME:
1650
+ case GI_TYPE_TAG_ARRAY:
1651
+ rb_raise(rb_eNotImpError,
1652
+ "TODO: Ruby -> GIArgument(GHash)[value][%s]",
1653
+ g_type_tag_to_string(metadata->value_type.tag));
1654
+ break;
1655
+ case GI_TYPE_TAG_INTERFACE:
1656
+ switch (metadata->value_type.interface_type) {
1657
+ case GI_INFO_TYPE_INVALID:
1658
+ case GI_INFO_TYPE_FUNCTION:
1659
+ case GI_INFO_TYPE_CALLBACK:
1660
+ case GI_INFO_TYPE_STRUCT:
1661
+ case GI_INFO_TYPE_BOXED:
1662
+ rb_raise(rb_eNotImpError,
1663
+ "TODO: Ruby -> GIArgument(GHash)[value][%s][%s]",
1664
+ g_type_tag_to_string(metadata->value_type.tag),
1665
+ g_info_type_to_string(metadata->value_type.interface_type));
1666
+ break;
1667
+ case GI_INFO_TYPE_ENUM:
1668
+ value_destroy_func = NULL;
1669
+ value_ruby_to_c_func = ruby_to_c_interface_enum;
1670
+ value_ruby_to_c_data.context =
1671
+ "Ruby -> GIArgument(GHash)[value][interface]";
1672
+ break;
1673
+ case GI_INFO_TYPE_FLAGS:
1674
+ case GI_INFO_TYPE_OBJECT:
1675
+ case GI_INFO_TYPE_INTERFACE:
1676
+ case GI_INFO_TYPE_CONSTANT:
1677
+ case GI_INFO_TYPE_INVALID_0:
1678
+ case GI_INFO_TYPE_UNION:
1679
+ case GI_INFO_TYPE_VALUE:
1680
+ case GI_INFO_TYPE_SIGNAL:
1681
+ case GI_INFO_TYPE_VFUNC:
1682
+ case GI_INFO_TYPE_PROPERTY:
1683
+ case GI_INFO_TYPE_FIELD:
1684
+ case GI_INFO_TYPE_ARG:
1685
+ case GI_INFO_TYPE_TYPE:
1686
+ case GI_INFO_TYPE_UNRESOLVED:
1687
+ rb_raise(rb_eNotImpError,
1688
+ "TODO: Ruby -> GIArgument(GHash)[value][%s][%s]",
1689
+ g_type_tag_to_string(metadata->value_type.tag),
1690
+ g_info_type_to_string(metadata->value_type.interface_type));
1691
+ break;
1692
+ default:
1693
+ g_assert_not_reached();
1694
+ break;
1695
+ }
1696
+ break;
1697
+ case GI_TYPE_TAG_GLIST:
1698
+ case GI_TYPE_TAG_GSLIST:
1699
+ case GI_TYPE_TAG_GHASH:
1700
+ case GI_TYPE_TAG_ERROR:
1701
+ case GI_TYPE_TAG_UNICHAR:
1702
+ rb_raise(rb_eNotImpError,
1703
+ "TODO: Ruby -> GIArgument(GHash)[value][%s]",
1704
+ g_type_tag_to_string(metadata->value_type.tag));
1705
+ break;
1706
+ default:
1707
+ g_assert_not_reached();
1708
+ break;
1709
+ }
1710
+
1711
+ metadata->in_arg->v_pointer = g_hash_table_new_full(hash_func,
1712
+ equal_func,
1713
+ key_destroy_func,
1714
+ value_destroy_func);
1715
+ convert_data.hash_table = metadata->in_arg->v_pointer;
1716
+ convert_data.key_ruby_to_c_func = key_ruby_to_c_func;
1717
+ convert_data.key_ruby_to_c_data = &key_ruby_to_c_data;
1718
+ convert_data.value_ruby_to_c_func = value_ruby_to_c_func;
1719
+ convert_data.value_ruby_to_c_data = &value_ruby_to_c_data;
1720
+ rb_hash_foreach(metadata->rb_arg,
1721
+ rb_gi_arguments_in_init_arg_ruby_ghash_convert,
1722
+ (VALUE)&convert_data);
1723
+
1724
+ return Qnil;
1725
+ }
1726
+
1727
+ static VALUE
1728
+ rb_gi_arguments_in_init_arg_ruby_ghash_rescue(VALUE value_data,
1729
+ VALUE exception)
1730
+ {
1731
+ RBGIArgMetadata *metadata = (RBGIArgMetadata *)value_data;
1732
+
1733
+ if (metadata->in_arg->v_pointer) {
1734
+ g_hash_table_unref(metadata->in_arg->v_pointer);
1735
+ metadata->in_arg->v_pointer = NULL;
1736
+ }
1737
+
1738
+ rb_exc_raise(exception);
1739
+
1740
+ return Qnil;
1741
+ }
1742
+
1743
+ static void
1744
+ rb_gi_arguments_in_free_ghash(RBGIArguments *args,
1745
+ RBGIArgMetadata *metadata,
1746
+ gpointer user_data)
1747
+ {
1748
+ GHashTable *target;
1749
+ if (metadata->direction == GI_DIRECTION_INOUT) {
1750
+ target = *((GHashTable **)(metadata->in_arg->v_pointer));
1751
+ xfree(metadata->in_arg->v_pointer);
1752
+ } else {
1753
+ target = metadata->in_arg->v_pointer;
1754
+ }
1755
+ g_hash_table_unref(target);
1756
+ }
1757
+
1758
+ static void
1759
+ rb_gi_arguments_in_init_arg_ruby_ghash(RBGIArguments *args,
1760
+ RBGIArgMetadata *metadata)
1761
+ {
1762
+ if (metadata->transfer != GI_TRANSFER_NOTHING) {
1763
+ rb_raise(rb_eNotImpError,
1764
+ "TODO: [%s] free %s "
1765
+ "Ruby -> GIArgument(%s){%s,%s}[%s]",
1766
+ metadata->name,
1767
+ rb_gi_direction_to_string(metadata->direction),
1768
+ g_type_tag_to_string(metadata->type.tag),
1769
+ g_type_tag_to_string(metadata->key_type.tag),
1770
+ g_type_tag_to_string(metadata->value_type.tag),
1771
+ rb_gi_transfer_to_string(metadata->transfer));
1772
+ }
1773
+ metadata->in_arg->v_pointer = NULL;
1774
+ rb_rescue(rb_gi_arguments_in_init_arg_ruby_ghash_body, (VALUE)metadata,
1775
+ rb_gi_arguments_in_init_arg_ruby_ghash_rescue, (VALUE)metadata);
1776
+ if (metadata->direction == GI_DIRECTION_INOUT) {
1777
+ GHashTable *target = metadata->in_arg->v_pointer;
1778
+ metadata->in_arg->v_pointer = ALLOC(GHashTable *);
1779
+ *((GHashTable **)(metadata->in_arg->v_pointer)) = target;
1780
+ }
1781
+ metadata->free_func = rb_gi_arguments_in_free_ghash;
1782
+ }
1783
+
1784
+ static void
1785
+ rb_gi_arguments_in_init_arg_ruby(RBGIArguments *args,
1786
+ RBGIArgMetadata *metadata)
1787
+ {
1788
+ if (metadata->callback_p && !metadata->destroy_p) {
1789
+ rb_gi_arguments_in_init_arg_ruby_callback(args, metadata);
1790
+ return;
1791
+ }
1792
+
1793
+ if (metadata->rb_arg_index == -1) {
1794
+ return;
1795
+ }
1796
+
1797
+ if (metadata->array_p) {
1798
+ rb_gi_arguments_in_init_arg_ruby_array(args, metadata);
1799
+ return;
1800
+ }
1801
+
1802
+ if (NIL_P(metadata->rb_arg)) {
1803
+ GIBaseInfo *klass;
1804
+ const char *suffix;
1805
+
1806
+ if (metadata->may_be_null_p) {
1807
+ memset(metadata->in_arg, 0, sizeof(GIArgument));
1808
+ return;
1809
+ }
1810
+
1811
+ klass = g_base_info_get_container(args->info);
1812
+ if (metadata->rb_arg_index == 1) {
1813
+ suffix = "st";
1814
+ } else if (metadata->rb_arg_index == 2) {
1815
+ suffix = "nd";
1816
+ } else if (metadata->rb_arg_index == 3) {
1817
+ suffix = "rd";
1818
+ } else {
1819
+ suffix = "th";
1820
+ }
1821
+ rb_raise(rb_eArgError,
1822
+ "<%s%s%s%s%s>: the %u%s argument must not nil: <%s>",
1823
+ g_base_info_get_namespace(args->info),
1824
+ klass ? "::" : "",
1825
+ klass ? g_base_info_get_name(klass) : "",
1826
+ klass ? "#" : ".",
1827
+ g_base_info_get_name(args->info),
1828
+ metadata->rb_arg_index,
1829
+ suffix,
1830
+ metadata->name);
1831
+ }
1832
+
1833
+ metadata->free_func = rb_gi_arguments_in_free_default;
1834
+ switch (metadata->type.tag) {
1835
+ case GI_TYPE_TAG_VOID:
1836
+ rb_gi_arguments_in_init_arg_ruby_void(args, metadata);
1837
+ break;
1838
+ case GI_TYPE_TAG_BOOLEAN:
1839
+ {
1840
+ gboolean *target;
1841
+ if (metadata->direction == GI_DIRECTION_INOUT) {
1842
+ target = ALLOC(gboolean);
1843
+ metadata->in_arg->v_pointer = target;
1844
+ } else {
1845
+ target = &(metadata->in_arg->v_boolean);
1846
+ }
1847
+ *target = RVAL2CBOOL(metadata->rb_arg);
1848
+ }
1849
+ break;
1850
+ case GI_TYPE_TAG_INT8:
1851
+ {
1852
+ gint8 *target;
1853
+ if (metadata->direction == GI_DIRECTION_INOUT) {
1854
+ target = ALLOC(gint8);
1855
+ metadata->in_arg->v_pointer = target;
1856
+ } else {
1857
+ target = &(metadata->in_arg->v_int8);
1858
+ }
1859
+ *target = NUM2CHR(metadata->rb_arg);
1860
+ }
1861
+ break;
1862
+ case GI_TYPE_TAG_UINT8:
1863
+ {
1864
+ guint8 *target;
1865
+ if (metadata->direction == GI_DIRECTION_INOUT) {
1866
+ target = ALLOC(guint8);
1867
+ metadata->in_arg->v_pointer = target;
1868
+ } else {
1869
+ target = &(metadata->in_arg->v_uint8);
1870
+ }
1871
+ *target = (guint8)NUM2CHR(metadata->rb_arg);
1872
+ }
1873
+ break;
1874
+ case GI_TYPE_TAG_INT16:
1875
+ {
1876
+ gint16 *target;
1877
+ if (metadata->direction == GI_DIRECTION_INOUT) {
1878
+ target = ALLOC(gint16);
1879
+ metadata->in_arg->v_pointer = target;
1880
+ } else {
1881
+ target = &(metadata->in_arg->v_int16);
1882
+ }
1883
+ *target = NUM2SHORT(metadata->rb_arg);
1884
+ }
1885
+ break;
1886
+ case GI_TYPE_TAG_UINT16:
1887
+ {
1888
+ guint16 *target;
1889
+ if (metadata->direction == GI_DIRECTION_INOUT) {
1890
+ target = ALLOC(guint16);
1891
+ metadata->in_arg->v_pointer = target;
1892
+ } else {
1893
+ target = &(metadata->in_arg->v_uint16);
1894
+ }
1895
+ *target = NUM2USHORT(metadata->rb_arg);
1896
+ }
1897
+ break;
1898
+ case GI_TYPE_TAG_INT32:
1899
+ {
1900
+ gint32 *target;
1901
+ if (metadata->direction == GI_DIRECTION_INOUT) {
1902
+ target = ALLOC(gint32);
1903
+ metadata->in_arg->v_pointer = target;
1904
+ } else {
1905
+ target = &(metadata->in_arg->v_int32);
1906
+ }
1907
+ *target = NUM2INT(metadata->rb_arg);
1908
+ }
1909
+ break;
1910
+ case GI_TYPE_TAG_UINT32:
1911
+ {
1912
+ guint32 *target;
1913
+ if (metadata->direction == GI_DIRECTION_INOUT) {
1914
+ target = ALLOC(guint32);
1915
+ metadata->in_arg->v_pointer = target;
1916
+ } else {
1917
+ target = &(metadata->in_arg->v_uint32);
1918
+ }
1919
+ *target = NUM2UINT(metadata->rb_arg);
1920
+ }
1921
+ break;
1922
+ case GI_TYPE_TAG_INT64:
1923
+ {
1924
+ gint64 *target;
1925
+ if (metadata->direction == GI_DIRECTION_INOUT) {
1926
+ target = ALLOC(gint64);
1927
+ metadata->in_arg->v_pointer = target;
1928
+ } else {
1929
+ target = &(metadata->in_arg->v_int64);
1930
+ }
1931
+ *target = NUM2LL(metadata->rb_arg);
1932
+ }
1933
+ break;
1934
+ case GI_TYPE_TAG_UINT64:
1935
+ {
1936
+ guint64 *target;
1937
+ if (metadata->direction == GI_DIRECTION_INOUT) {
1938
+ target = ALLOC(guint64);
1939
+ metadata->in_arg->v_pointer = target;
1940
+ } else {
1941
+ target = &(metadata->in_arg->v_uint64);
1942
+ }
1943
+ *target = NUM2ULL(metadata->rb_arg);
1944
+ }
1945
+ break;
1946
+ case GI_TYPE_TAG_FLOAT:
1947
+ {
1948
+ gfloat *target;
1949
+ if (metadata->direction == GI_DIRECTION_INOUT) {
1950
+ target = ALLOC(gfloat);
1951
+ metadata->in_arg->v_pointer = target;
1952
+ } else {
1953
+ target = &(metadata->in_arg->v_float);
1954
+ }
1955
+ *target = NUM2DBL(metadata->rb_arg);
1956
+ }
1957
+ break;
1958
+ case GI_TYPE_TAG_DOUBLE:
1959
+ {
1960
+ gdouble *target;
1961
+ if (metadata->direction == GI_DIRECTION_INOUT) {
1962
+ target = ALLOC(gdouble);
1963
+ metadata->in_arg->v_pointer = target;
1964
+ } else {
1965
+ target = &(metadata->in_arg->v_double);
1966
+ }
1967
+ *target = NUM2DBL(metadata->rb_arg);
1968
+ }
1969
+ break;
1970
+ case GI_TYPE_TAG_GTYPE:
1971
+ {
1972
+ GType *target;
1973
+ if (metadata->direction == GI_DIRECTION_INOUT) {
1974
+ target = ALLOC(GType);
1975
+ metadata->in_arg->v_pointer = target;
1976
+ } else {
1977
+ target = &(metadata->in_arg->v_size);
1978
+ }
1979
+ *target = rbgobj_gtype_from_ruby(metadata->rb_arg);
1980
+ }
1981
+ break;
1982
+ case GI_TYPE_TAG_UTF8:
1983
+ {
1984
+ gchar **target;
1985
+ if (metadata->direction == GI_DIRECTION_INOUT) {
1986
+ target = ALLOC(gchar *);
1987
+ metadata->in_arg->v_pointer = target;
1988
+ } else {
1989
+ target = &(metadata->in_arg->v_string);
1990
+ }
1991
+ *target = (gchar *)RVAL2CSTR_ACCEPT_SYMBOL(metadata->rb_arg);
1992
+ }
1993
+ break;
1994
+ case GI_TYPE_TAG_FILENAME:
1995
+ {
1996
+ gchar **target;
1997
+ if (metadata->direction == GI_DIRECTION_INOUT) {
1998
+ target = ALLOC(gchar *);
1999
+ metadata->in_arg->v_pointer = target;
2000
+ } else {
2001
+ target = &(metadata->in_arg->v_string);
2002
+ }
2003
+ *target = rbg_filename_from_ruby(metadata->rb_arg);
2004
+ metadata->free_func = rb_gi_arguments_in_free_filename;
2005
+ }
2006
+ break;
2007
+ case GI_TYPE_TAG_ARRAY:
2008
+ rb_raise(rb_eNotImpError,
2009
+ "should not be reached: Ruby -> GIArgument(%s)",
2010
+ g_type_tag_to_string(metadata->type.tag));
2011
+ break;
2012
+ case GI_TYPE_TAG_INTERFACE:
2013
+ rb_gi_arguments_in_init_arg_ruby_interface(args, metadata);
2014
+ break;
2015
+ case GI_TYPE_TAG_GLIST:
2016
+ case GI_TYPE_TAG_GSLIST:
2017
+ rb_gi_arguments_in_init_arg_ruby_list(args, metadata);
2018
+ break;
2019
+ case GI_TYPE_TAG_GHASH:
2020
+ rb_gi_arguments_in_init_arg_ruby_ghash(args, metadata);
2021
+ break;
2022
+ case GI_TYPE_TAG_ERROR:
2023
+ rb_raise(rb_eNotImpError,
2024
+ "TODO: [%s] %s Ruby -> GIArgument(%s)",
2025
+ metadata->name,
2026
+ rb_gi_direction_to_string(metadata->direction),
2027
+ g_type_tag_to_string(metadata->type.tag));
2028
+ break;
2029
+ case GI_TYPE_TAG_UNICHAR:
2030
+ {
2031
+ gunichar *target;
2032
+ if (metadata->direction == GI_DIRECTION_INOUT) {
2033
+ target = ALLOC(gunichar);
2034
+ metadata->in_arg->v_pointer = target;
2035
+ } else {
2036
+ target = &(metadata->in_arg->v_uint32);
2037
+ }
2038
+ *target = NUM2UINT(metadata->rb_arg);
2039
+ }
2040
+ break;
2041
+ default:
2042
+ g_assert_not_reached();
2043
+ break;
2044
+ }
2045
+ }
2046
+
2047
+ static void
2048
+ rb_gi_arguments_in_init_arg_raw_interface(RBGIArguments *args,
2049
+ RBGIArgMetadata *metadata)
2050
+ {
2051
+ switch (metadata->type.interface_type) {
2052
+ case GI_INFO_TYPE_INVALID:
2053
+ case GI_INFO_TYPE_FUNCTION:
2054
+ case GI_INFO_TYPE_CALLBACK:
2055
+ rb_raise(rb_eNotImpError,
2056
+ "TODO: %s::%s: raw argument -> GIArgument(interface)[%s]: <%s>",
2057
+ g_base_info_get_namespace(args->info),
2058
+ g_base_info_get_name(args->info),
2059
+ g_info_type_to_string(metadata->type.interface_type),
2060
+ g_base_info_get_name(metadata->type.interface_info));
2061
+ break;
2062
+ case GI_INFO_TYPE_STRUCT:
2063
+ metadata->in_arg->v_pointer = *((gpointer *)(args->raw_args[metadata->index]));
2064
+ break;
2065
+ case GI_INFO_TYPE_BOXED:
2066
+ case GI_INFO_TYPE_ENUM:
2067
+ rb_raise(rb_eNotImpError,
2068
+ "TODO: %s::%s: raw argument -> GIArgument(interface)[%s]: <%s>",
2069
+ g_base_info_get_namespace(args->info),
2070
+ g_base_info_get_name(args->info),
2071
+ g_info_type_to_string(metadata->type.interface_type),
2072
+ g_base_info_get_name(metadata->type.interface_info));
2073
+ break;
2074
+ case GI_INFO_TYPE_FLAGS:
2075
+ metadata->in_arg->v_int32= *((gint32 *)(args->raw_args[metadata->index]));
2076
+ break;
2077
+ case GI_INFO_TYPE_OBJECT:
2078
+ case GI_INFO_TYPE_INTERFACE:
2079
+ metadata->in_arg->v_pointer = *((gpointer *)(args->raw_args[metadata->index]));
2080
+ break;
2081
+ case GI_INFO_TYPE_CONSTANT:
2082
+ rb_raise(rb_eNotImpError,
2083
+ "TODO: %s::%s: raw argument -> GIArgument(interface)[%s]: <%s>",
2084
+ g_base_info_get_namespace(args->info),
2085
+ g_base_info_get_name(args->info),
2086
+ g_info_type_to_string(metadata->type.interface_type),
2087
+ g_base_info_get_name(metadata->type.interface_info));
2088
+ break;
2089
+ case GI_INFO_TYPE_INVALID_0:
2090
+ g_assert_not_reached();
2091
+ break;
2092
+ case GI_INFO_TYPE_UNION:
2093
+ case GI_INFO_TYPE_VALUE:
2094
+ case GI_INFO_TYPE_SIGNAL:
2095
+ case GI_INFO_TYPE_VFUNC:
2096
+ case GI_INFO_TYPE_PROPERTY:
2097
+ case GI_INFO_TYPE_FIELD:
2098
+ case GI_INFO_TYPE_ARG:
2099
+ case GI_INFO_TYPE_TYPE:
2100
+ case GI_INFO_TYPE_UNRESOLVED:
2101
+ default:
2102
+ rb_raise(rb_eNotImpError,
2103
+ "TODO: %s::%s: raw argument -> GIArgument(interface)[%s]: <%s>",
2104
+ g_base_info_get_namespace(args->info),
2105
+ g_base_info_get_name(args->info),
2106
+ g_info_type_to_string(metadata->type.interface_type),
2107
+ g_base_info_get_name(metadata->type.interface_info));
2108
+ break;
2109
+ }
2110
+ }
2111
+
2112
+ static void
2113
+ rb_gi_arguments_in_init_arg_raw(RBGIArguments *args,
2114
+ RBGIArgMetadata *metadata)
2115
+ {
2116
+ switch (metadata->type.tag) {
2117
+ case GI_TYPE_TAG_VOID:
2118
+ metadata->in_arg->v_pointer = *((gpointer *)(args->raw_args[metadata->index]));
2119
+ break;
2120
+ case GI_TYPE_TAG_BOOLEAN:
2121
+ metadata->in_arg->v_boolean = *((gboolean *)(args->raw_args[metadata->index]));
2122
+ break;
2123
+ case GI_TYPE_TAG_INT8:
2124
+ metadata->in_arg->v_int8 = *((gint8 *)(args->raw_args[metadata->index]));
2125
+ break;
2126
+ case GI_TYPE_TAG_UINT8:
2127
+ metadata->in_arg->v_uint8 = *((guint8 *)(args->raw_args[metadata->index]));
2128
+ break;
2129
+ case GI_TYPE_TAG_INT16:
2130
+ metadata->in_arg->v_int16 = *((gint16 *)(args->raw_args[metadata->index]));
2131
+ break;
2132
+ case GI_TYPE_TAG_UINT16:
2133
+ metadata->in_arg->v_uint16 = *((guint16 *)(args->raw_args[metadata->index]));
2134
+ break;
2135
+ case GI_TYPE_TAG_INT32:
2136
+ metadata->in_arg->v_int32 = *((gint32 *)(args->raw_args[metadata->index]));
2137
+ break;
2138
+ case GI_TYPE_TAG_UINT32:
2139
+ metadata->in_arg->v_uint32 = *((guint32 *)(args->raw_args[metadata->index]));
2140
+ break;
2141
+ case GI_TYPE_TAG_INT64:
2142
+ metadata->in_arg->v_int64 = *((gint64 *)(args->raw_args[metadata->index]));
2143
+ break;
2144
+ case GI_TYPE_TAG_UINT64:
2145
+ metadata->in_arg->v_uint64 = *((guint64 *)(args->raw_args[metadata->index]));
2146
+ break;
2147
+ case GI_TYPE_TAG_FLOAT:
2148
+ metadata->in_arg->v_float = *((gfloat *)(args->raw_args[metadata->index]));
2149
+ break;
2150
+ case GI_TYPE_TAG_DOUBLE:
2151
+ metadata->in_arg->v_double = *((gdouble *)(args->raw_args[metadata->index]));
2152
+ break;
2153
+ case GI_TYPE_TAG_GTYPE:
2154
+ metadata->in_arg->v_size = *((gsize *)(args->raw_args[metadata->index]));
2155
+ break;
2156
+ case GI_TYPE_TAG_UTF8:
2157
+ case GI_TYPE_TAG_FILENAME:
2158
+ metadata->in_arg->v_string = *((gchar **)(args->raw_args[metadata->index]));
2159
+ break;
2160
+ case GI_TYPE_TAG_ARRAY:
2161
+ metadata->in_arg->v_pointer = *((gpointer *)(args->raw_args[metadata->index]));
2162
+ break;
2163
+ case GI_TYPE_TAG_INTERFACE:
2164
+ rb_gi_arguments_in_init_arg_raw_interface(args, metadata);
2165
+ break;
2166
+ case GI_TYPE_TAG_GLIST:
2167
+ case GI_TYPE_TAG_GSLIST:
2168
+ case GI_TYPE_TAG_GHASH:
2169
+ metadata->in_arg->v_pointer = *((gpointer *)(args->raw_args[metadata->index]));
2170
+ break;
2171
+ case GI_TYPE_TAG_ERROR:
2172
+ metadata->in_arg->v_pointer = *((GError **)(args->raw_args[metadata->index]));
2173
+ break;
2174
+ case GI_TYPE_TAG_UNICHAR:
2175
+ metadata->in_arg->v_uint32 = *((gunichar *)(args->raw_args[metadata->index]));
2176
+ break;
2177
+ default:
2178
+ g_assert_not_reached();
2179
+ break;
2180
+ }
2181
+ }
2182
+
2183
+ void
2184
+ rb_gi_arguments_in_init(RBGIArguments *args)
2185
+ {
2186
+ guint i;
2187
+
2188
+ for (i = 0; i < args->metadata->len; i++) {
2189
+ RBGIArgMetadata *metadata;
2190
+
2191
+ metadata = g_ptr_array_index(args->metadata, i);
2192
+ if (metadata->direction == GI_DIRECTION_OUT) {
2193
+ continue;
2194
+ }
2195
+
2196
+ if (args->rb_mode_p) {
2197
+ rb_gi_arguments_in_init_arg_ruby(args, metadata);
2198
+ } else {
2199
+ rb_gi_arguments_in_init_arg_raw(args, metadata);
2200
+ }
2201
+ }
2202
+ }
2203
+
2204
+ void
2205
+ rb_gi_arguments_in_clear(RBGIArguments *args)
2206
+ {
2207
+ guint i;
2208
+
2209
+ if (!args->rb_mode_p) {
2210
+ return;
2211
+ }
2212
+
2213
+ for (i = 0; i < args->metadata->len; i++) {
2214
+ RBGIArgMetadata *metadata;
2215
+
2216
+ metadata = g_ptr_array_index(args->metadata, i);
2217
+ if (metadata->direction == GI_DIRECTION_OUT) {
2218
+ continue;
2219
+ }
2220
+
2221
+ if (metadata->in_arg_index == -1) {
2222
+ continue;
2223
+ }
2224
+
2225
+ if (metadata->free_func) {
2226
+ metadata->free_func(args, metadata, metadata->free_func_data);
2227
+ }
2228
+ }
2229
+ }