No issues found
| Tool | Failure ID | Location | Function | Message | Data |
|---|---|---|---|---|---|
| clang-analyzer | no-output-found | rb-marshal.c | Message(text='Unable to locate XML output from invoke-clang-analyzer') | None | |
| clang-analyzer | no-output-found | rb-marshal.c | Message(text='Unable to locate XML output from invoke-clang-analyzer') | None |
1 #ifndef __rb_marshal_MARSHAL_H__
2 #define __rb_marshal_MARSHAL_H__
3
4 #include <glib-object.h>
5
6 G_BEGIN_DECLS
7
8 #ifdef G_ENABLE_DEBUG
9 #define g_marshal_value_peek_boolean(v) g_value_get_boolean (v)
10 #define g_marshal_value_peek_char(v) g_value_get_schar (v)
11 #define g_marshal_value_peek_uchar(v) g_value_get_uchar (v)
12 #define g_marshal_value_peek_int(v) g_value_get_int (v)
13 #define g_marshal_value_peek_uint(v) g_value_get_uint (v)
14 #define g_marshal_value_peek_long(v) g_value_get_long (v)
15 #define g_marshal_value_peek_ulong(v) g_value_get_ulong (v)
16 #define g_marshal_value_peek_int64(v) g_value_get_int64 (v)
17 #define g_marshal_value_peek_uint64(v) g_value_get_uint64 (v)
18 #define g_marshal_value_peek_enum(v) g_value_get_enum (v)
19 #define g_marshal_value_peek_flags(v) g_value_get_flags (v)
20 #define g_marshal_value_peek_float(v) g_value_get_float (v)
21 #define g_marshal_value_peek_double(v) g_value_get_double (v)
22 #define g_marshal_value_peek_string(v) (char*) g_value_get_string (v)
23 #define g_marshal_value_peek_param(v) g_value_get_param (v)
24 #define g_marshal_value_peek_boxed(v) g_value_get_boxed (v)
25 #define g_marshal_value_peek_pointer(v) g_value_get_pointer (v)
26 #define g_marshal_value_peek_object(v) g_value_get_object (v)
27 #define g_marshal_value_peek_variant(v) g_value_get_variant (v)
28 #else /* !G_ENABLE_DEBUG */
29 /* WARNING: This code accesses GValues directly, which is UNSUPPORTED API.
30 * Do not access GValues directly in your code. Instead, use the
31 * g_value_get_*() functions
32 */
33 #define g_marshal_value_peek_boolean(v) (v)->data[0].v_int
34 #define g_marshal_value_peek_char(v) (v)->data[0].v_int
35 #define g_marshal_value_peek_uchar(v) (v)->data[0].v_uint
36 #define g_marshal_value_peek_int(v) (v)->data[0].v_int
37 #define g_marshal_value_peek_uint(v) (v)->data[0].v_uint
38 #define g_marshal_value_peek_long(v) (v)->data[0].v_long
39 #define g_marshal_value_peek_ulong(v) (v)->data[0].v_ulong
40 #define g_marshal_value_peek_int64(v) (v)->data[0].v_int64
41 #define g_marshal_value_peek_uint64(v) (v)->data[0].v_uint64
42 #define g_marshal_value_peek_enum(v) (v)->data[0].v_long
43 #define g_marshal_value_peek_flags(v) (v)->data[0].v_ulong
44 #define g_marshal_value_peek_float(v) (v)->data[0].v_float
45 #define g_marshal_value_peek_double(v) (v)->data[0].v_double
46 #define g_marshal_value_peek_string(v) (v)->data[0].v_pointer
47 #define g_marshal_value_peek_param(v) (v)->data[0].v_pointer
48 #define g_marshal_value_peek_boxed(v) (v)->data[0].v_pointer
49 #define g_marshal_value_peek_pointer(v) (v)->data[0].v_pointer
50 #define g_marshal_value_peek_object(v) (v)->data[0].v_pointer
51 #define g_marshal_value_peek_variant(v) (v)->data[0].v_pointer
52 #endif /* !G_ENABLE_DEBUG */
53
54
55 /* BOOLEAN:BOOLEAN,BOOLEAN (./rb-marshal.list:1) */
56 extern void rb_marshal_BOOLEAN__BOOLEAN_BOOLEAN (GClosure *closure,
57 GValue *return_value,
58 guint n_param_values,
59 const GValue *param_values,
60 gpointer invocation_hint,
61 gpointer marshal_data);
62 void
63 rb_marshal_BOOLEAN__BOOLEAN_BOOLEAN (GClosure *closure,
64 GValue *return_value G_GNUC_UNUSED,
65 guint n_param_values,
66 const GValue *param_values,
67 gpointer invocation_hint G_GNUC_UNUSED,
68 gpointer marshal_data)
69 {
70 typedef gboolean (*GMarshalFunc_BOOLEAN__BOOLEAN_BOOLEAN) (gpointer data1,
71 gboolean arg_1,
72 gboolean arg_2,
73 gpointer data2);
74 register GMarshalFunc_BOOLEAN__BOOLEAN_BOOLEAN callback;
75 register GCClosure *cc = (GCClosure*) closure;
76 register gpointer data1, data2;
77 gboolean v_return;
78
79 g_return_if_fail (return_value != NULL);
80 g_return_if_fail (n_param_values == 3);
81
82 if (G_CCLOSURE_SWAP_DATA (closure))
83 {
84 data1 = closure->data;
85 data2 = g_value_peek_pointer (param_values + 0);
86 }
87 else
88 {
89 data1 = g_value_peek_pointer (param_values + 0);
90 data2 = closure->data;
91 }
92 callback = (GMarshalFunc_BOOLEAN__BOOLEAN_BOOLEAN) (marshal_data ? marshal_data : cc->callback);
93
94 v_return = callback (data1,
95 g_marshal_value_peek_boolean (param_values + 1),
96 g_marshal_value_peek_boolean (param_values + 2),
97 data2);
98
99 g_value_set_boolean (return_value, v_return);
100 }
101
102 /* BOOLEAN:BOOLEAN,BOOLEAN,BOOLEAN (./rb-marshal.list:2) */
103 extern void rb_marshal_BOOLEAN__BOOLEAN_BOOLEAN_BOOLEAN (GClosure *closure,
104 GValue *return_value,
105 guint n_param_values,
106 const GValue *param_values,
107 gpointer invocation_hint,
108 gpointer marshal_data);
109 void
110 rb_marshal_BOOLEAN__BOOLEAN_BOOLEAN_BOOLEAN (GClosure *closure,
111 GValue *return_value G_GNUC_UNUSED,
112 guint n_param_values,
113 const GValue *param_values,
114 gpointer invocation_hint G_GNUC_UNUSED,
115 gpointer marshal_data)
116 {
117 typedef gboolean (*GMarshalFunc_BOOLEAN__BOOLEAN_BOOLEAN_BOOLEAN) (gpointer data1,
118 gboolean arg_1,
119 gboolean arg_2,
120 gboolean arg_3,
121 gpointer data2);
122 register GMarshalFunc_BOOLEAN__BOOLEAN_BOOLEAN_BOOLEAN callback;
123 register GCClosure *cc = (GCClosure*) closure;
124 register gpointer data1, data2;
125 gboolean v_return;
126
127 g_return_if_fail (return_value != NULL);
128 g_return_if_fail (n_param_values == 4);
129
130 if (G_CCLOSURE_SWAP_DATA (closure))
131 {
132 data1 = closure->data;
133 data2 = g_value_peek_pointer (param_values + 0);
134 }
135 else
136 {
137 data1 = g_value_peek_pointer (param_values + 0);
138 data2 = closure->data;
139 }
140 callback = (GMarshalFunc_BOOLEAN__BOOLEAN_BOOLEAN_BOOLEAN) (marshal_data ? marshal_data : cc->callback);
141
142 v_return = callback (data1,
143 g_marshal_value_peek_boolean (param_values + 1),
144 g_marshal_value_peek_boolean (param_values + 2),
145 g_marshal_value_peek_boolean (param_values + 3),
146 data2);
147
148 g_value_set_boolean (return_value, v_return);
149 }
150
151 /* BOOLEAN:BOXED (./rb-marshal.list:3) */
152 extern void rb_marshal_BOOLEAN__BOXED (GClosure *closure,
153 GValue *return_value,
154 guint n_param_values,
155 const GValue *param_values,
156 gpointer invocation_hint,
157 gpointer marshal_data);
158 void
159 rb_marshal_BOOLEAN__BOXED (GClosure *closure,
160 GValue *return_value G_GNUC_UNUSED,
161 guint n_param_values,
162 const GValue *param_values,
163 gpointer invocation_hint G_GNUC_UNUSED,
164 gpointer marshal_data)
165 {
166 typedef gboolean (*GMarshalFunc_BOOLEAN__BOXED) (gpointer data1,
167 gpointer arg_1,
168 gpointer data2);
169 register GMarshalFunc_BOOLEAN__BOXED callback;
170 register GCClosure *cc = (GCClosure*) closure;
171 register gpointer data1, data2;
172 gboolean v_return;
173
174 g_return_if_fail (return_value != NULL);
175 g_return_if_fail (n_param_values == 2);
176
177 if (G_CCLOSURE_SWAP_DATA (closure))
178 {
179 data1 = closure->data;
180 data2 = g_value_peek_pointer (param_values + 0);
181 }
182 else
183 {
184 data1 = g_value_peek_pointer (param_values + 0);
185 data2 = closure->data;
186 }
187 callback = (GMarshalFunc_BOOLEAN__BOXED) (marshal_data ? marshal_data : cc->callback);
188
189 v_return = callback (data1,
190 g_marshal_value_peek_boxed (param_values + 1),
191 data2);
192
193 g_value_set_boolean (return_value, v_return);
194 }
195
196 /* BOOLEAN:OBJECT (./rb-marshal.list:4) */
197 extern void rb_marshal_BOOLEAN__OBJECT (GClosure *closure,
198 GValue *return_value,
199 guint n_param_values,
200 const GValue *param_values,
201 gpointer invocation_hint,
202 gpointer marshal_data);
203 void
204 rb_marshal_BOOLEAN__OBJECT (GClosure *closure,
205 GValue *return_value G_GNUC_UNUSED,
206 guint n_param_values,
207 const GValue *param_values,
208 gpointer invocation_hint G_GNUC_UNUSED,
209 gpointer marshal_data)
210 {
211 typedef gboolean (*GMarshalFunc_BOOLEAN__OBJECT) (gpointer data1,
212 gpointer arg_1,
213 gpointer data2);
214 register GMarshalFunc_BOOLEAN__OBJECT callback;
215 register GCClosure *cc = (GCClosure*) closure;
216 register gpointer data1, data2;
217 gboolean v_return;
218
219 g_return_if_fail (return_value != NULL);
220 g_return_if_fail (n_param_values == 2);
221
222 if (G_CCLOSURE_SWAP_DATA (closure))
223 {
224 data1 = closure->data;
225 data2 = g_value_peek_pointer (param_values + 0);
226 }
227 else
228 {
229 data1 = g_value_peek_pointer (param_values + 0);
230 data2 = closure->data;
231 }
232 callback = (GMarshalFunc_BOOLEAN__OBJECT) (marshal_data ? marshal_data : cc->callback);
233
234 v_return = callback (data1,
235 g_marshal_value_peek_object (param_values + 1),
236 data2);
237
238 g_value_set_boolean (return_value, v_return);
239 }
240
241 /* BOOLEAN:POINTER (./rb-marshal.list:5) */
242 extern void rb_marshal_BOOLEAN__POINTER (GClosure *closure,
243 GValue *return_value,
244 guint n_param_values,
245 const GValue *param_values,
246 gpointer invocation_hint,
247 gpointer marshal_data);
248 void
249 rb_marshal_BOOLEAN__POINTER (GClosure *closure,
250 GValue *return_value G_GNUC_UNUSED,
251 guint n_param_values,
252 const GValue *param_values,
253 gpointer invocation_hint G_GNUC_UNUSED,
254 gpointer marshal_data)
255 {
256 typedef gboolean (*GMarshalFunc_BOOLEAN__POINTER) (gpointer data1,
257 gpointer arg_1,
258 gpointer data2);
259 register GMarshalFunc_BOOLEAN__POINTER callback;
260 register GCClosure *cc = (GCClosure*) closure;
261 register gpointer data1, data2;
262 gboolean v_return;
263
264 g_return_if_fail (return_value != NULL);
265 g_return_if_fail (n_param_values == 2);
266
267 if (G_CCLOSURE_SWAP_DATA (closure))
268 {
269 data1 = closure->data;
270 data2 = g_value_peek_pointer (param_values + 0);
271 }
272 else
273 {
274 data1 = g_value_peek_pointer (param_values + 0);
275 data2 = closure->data;
276 }
277 callback = (GMarshalFunc_BOOLEAN__POINTER) (marshal_data ? marshal_data : cc->callback);
278
279 v_return = callback (data1,
280 g_marshal_value_peek_pointer (param_values + 1),
281 data2);
282
283 g_value_set_boolean (return_value, v_return);
284 }
285
286 /* BOOLEAN:POINTER,POINTER (./rb-marshal.list:6) */
287 extern void rb_marshal_BOOLEAN__POINTER_POINTER (GClosure *closure,
288 GValue *return_value,
289 guint n_param_values,
290 const GValue *param_values,
291 gpointer invocation_hint,
292 gpointer marshal_data);
293 void
294 rb_marshal_BOOLEAN__POINTER_POINTER (GClosure *closure,
295 GValue *return_value G_GNUC_UNUSED,
296 guint n_param_values,
297 const GValue *param_values,
298 gpointer invocation_hint G_GNUC_UNUSED,
299 gpointer marshal_data)
300 {
301 typedef gboolean (*GMarshalFunc_BOOLEAN__POINTER_POINTER) (gpointer data1,
302 gpointer arg_1,
303 gpointer arg_2,
304 gpointer data2);
305 register GMarshalFunc_BOOLEAN__POINTER_POINTER callback;
306 register GCClosure *cc = (GCClosure*) closure;
307 register gpointer data1, data2;
308 gboolean v_return;
309
310 g_return_if_fail (return_value != NULL);
311 g_return_if_fail (n_param_values == 3);
312
313 if (G_CCLOSURE_SWAP_DATA (closure))
314 {
315 data1 = closure->data;
316 data2 = g_value_peek_pointer (param_values + 0);
317 }
318 else
319 {
320 data1 = g_value_peek_pointer (param_values + 0);
321 data2 = closure->data;
322 }
323 callback = (GMarshalFunc_BOOLEAN__POINTER_POINTER) (marshal_data ? marshal_data : cc->callback);
324
325 v_return = callback (data1,
326 g_marshal_value_peek_pointer (param_values + 1),
327 g_marshal_value_peek_pointer (param_values + 2),
328 data2);
329
330 g_value_set_boolean (return_value, v_return);
331 }
332
333 /* BOOLEAN:POINTER,POINTER,POINTER (./rb-marshal.list:7) */
334 extern void rb_marshal_BOOLEAN__POINTER_POINTER_POINTER (GClosure *closure,
335 GValue *return_value,
336 guint n_param_values,
337 const GValue *param_values,
338 gpointer invocation_hint,
339 gpointer marshal_data);
340 void
341 rb_marshal_BOOLEAN__POINTER_POINTER_POINTER (GClosure *closure,
342 GValue *return_value G_GNUC_UNUSED,
343 guint n_param_values,
344 const GValue *param_values,
345 gpointer invocation_hint G_GNUC_UNUSED,
346 gpointer marshal_data)
347 {
348 typedef gboolean (*GMarshalFunc_BOOLEAN__POINTER_POINTER_POINTER) (gpointer data1,
349 gpointer arg_1,
350 gpointer arg_2,
351 gpointer arg_3,
352 gpointer data2);
353 register GMarshalFunc_BOOLEAN__POINTER_POINTER_POINTER callback;
354 register GCClosure *cc = (GCClosure*) closure;
355 register gpointer data1, data2;
356 gboolean v_return;
357
358 g_return_if_fail (return_value != NULL);
359 g_return_if_fail (n_param_values == 4);
360
361 if (G_CCLOSURE_SWAP_DATA (closure))
362 {
363 data1 = closure->data;
364 data2 = g_value_peek_pointer (param_values + 0);
365 }
366 else
367 {
368 data1 = g_value_peek_pointer (param_values + 0);
369 data2 = closure->data;
370 }
371 callback = (GMarshalFunc_BOOLEAN__POINTER_POINTER_POINTER) (marshal_data ? marshal_data : cc->callback);
372
373 v_return = callback (data1,
374 g_marshal_value_peek_pointer (param_values + 1),
375 g_marshal_value_peek_pointer (param_values + 2),
376 g_marshal_value_peek_pointer (param_values + 3),
377 data2);
378
379 g_value_set_boolean (return_value, v_return);
380 }
381
382 /* BOOLEAN:STRING,BOOLEAN (./rb-marshal.list:8) */
383 extern void rb_marshal_BOOLEAN__STRING_BOOLEAN (GClosure *closure,
384 GValue *return_value,
385 guint n_param_values,
386 const GValue *param_values,
387 gpointer invocation_hint,
388 gpointer marshal_data);
389 void
390 rb_marshal_BOOLEAN__STRING_BOOLEAN (GClosure *closure,
391 GValue *return_value G_GNUC_UNUSED,
392 guint n_param_values,
393 const GValue *param_values,
394 gpointer invocation_hint G_GNUC_UNUSED,
395 gpointer marshal_data)
396 {
397 typedef gboolean (*GMarshalFunc_BOOLEAN__STRING_BOOLEAN) (gpointer data1,
398 gpointer arg_1,
399 gboolean arg_2,
400 gpointer data2);
401 register GMarshalFunc_BOOLEAN__STRING_BOOLEAN callback;
402 register GCClosure *cc = (GCClosure*) closure;
403 register gpointer data1, data2;
404 gboolean v_return;
405
406 g_return_if_fail (return_value != NULL);
407 g_return_if_fail (n_param_values == 3);
408
409 if (G_CCLOSURE_SWAP_DATA (closure))
410 {
411 data1 = closure->data;
412 data2 = g_value_peek_pointer (param_values + 0);
413 }
414 else
415 {
416 data1 = g_value_peek_pointer (param_values + 0);
417 data2 = closure->data;
418 }
419 callback = (GMarshalFunc_BOOLEAN__STRING_BOOLEAN) (marshal_data ? marshal_data : cc->callback);
420
421 v_return = callback (data1,
422 g_marshal_value_peek_string (param_values + 1),
423 g_marshal_value_peek_boolean (param_values + 2),
424 data2);
425
426 g_value_set_boolean (return_value, v_return);
427 }
428
429 /* BOOLEAN:STRING,STRING,OBJECT (./rb-marshal.list:9) */
430 extern void rb_marshal_BOOLEAN__STRING_STRING_OBJECT (GClosure *closure,
431 GValue *return_value,
432 guint n_param_values,
433 const GValue *param_values,
434 gpointer invocation_hint,
435 gpointer marshal_data);
436 void
437 rb_marshal_BOOLEAN__STRING_STRING_OBJECT (GClosure *closure,
438 GValue *return_value G_GNUC_UNUSED,
439 guint n_param_values,
440 const GValue *param_values,
441 gpointer invocation_hint G_GNUC_UNUSED,
442 gpointer marshal_data)
443 {
444 typedef gboolean (*GMarshalFunc_BOOLEAN__STRING_STRING_OBJECT) (gpointer data1,
445 gpointer arg_1,
446 gpointer arg_2,
447 gpointer arg_3,
448 gpointer data2);
449 register GMarshalFunc_BOOLEAN__STRING_STRING_OBJECT callback;
450 register GCClosure *cc = (GCClosure*) closure;
451 register gpointer data1, data2;
452 gboolean v_return;
453
454 g_return_if_fail (return_value != NULL);
455 g_return_if_fail (n_param_values == 4);
456
457 if (G_CCLOSURE_SWAP_DATA (closure))
458 {
459 data1 = closure->data;
460 data2 = g_value_peek_pointer (param_values + 0);
461 }
462 else
463 {
464 data1 = g_value_peek_pointer (param_values + 0);
465 data2 = closure->data;
466 }
467 callback = (GMarshalFunc_BOOLEAN__STRING_STRING_OBJECT) (marshal_data ? marshal_data : cc->callback);
468
469 v_return = callback (data1,
470 g_marshal_value_peek_string (param_values + 1),
471 g_marshal_value_peek_string (param_values + 2),
472 g_marshal_value_peek_object (param_values + 3),
473 data2);
474
475 g_value_set_boolean (return_value, v_return);
476 }
477
478 /* INT:VOID (./rb-marshal.list:10) */
479 extern void rb_marshal_INT__VOID (GClosure *closure,
480 GValue *return_value,
481 guint n_param_values,
482 const GValue *param_values,
483 gpointer invocation_hint,
484 gpointer marshal_data);
485 void
486 rb_marshal_INT__VOID (GClosure *closure,
487 GValue *return_value G_GNUC_UNUSED,
488 guint n_param_values,
489 const GValue *param_values,
490 gpointer invocation_hint G_GNUC_UNUSED,
491 gpointer marshal_data)
492 {
493 typedef gint (*GMarshalFunc_INT__VOID) (gpointer data1,
494 gpointer data2);
495 register GMarshalFunc_INT__VOID callback;
496 register GCClosure *cc = (GCClosure*) closure;
497 register gpointer data1, data2;
498 gint v_return;
499
500 g_return_if_fail (return_value != NULL);
501 g_return_if_fail (n_param_values == 1);
502
503 if (G_CCLOSURE_SWAP_DATA (closure))
504 {
505 data1 = closure->data;
506 data2 = g_value_peek_pointer (param_values + 0);
507 }
508 else
509 {
510 data1 = g_value_peek_pointer (param_values + 0);
511 data2 = closure->data;
512 }
513 callback = (GMarshalFunc_INT__VOID) (marshal_data ? marshal_data : cc->callback);
514
515 v_return = callback (data1,
516 data2);
517
518 g_value_set_int (return_value, v_return);
519 }
520
521 /* OBJECT:OBJECT (./rb-marshal.list:11) */
522 extern void rb_marshal_OBJECT__OBJECT (GClosure *closure,
523 GValue *return_value,
524 guint n_param_values,
525 const GValue *param_values,
526 gpointer invocation_hint,
527 gpointer marshal_data);
528 void
529 rb_marshal_OBJECT__OBJECT (GClosure *closure,
530 GValue *return_value G_GNUC_UNUSED,
531 guint n_param_values,
532 const GValue *param_values,
533 gpointer invocation_hint G_GNUC_UNUSED,
534 gpointer marshal_data)
535 {
536 typedef GObject* (*GMarshalFunc_OBJECT__OBJECT) (gpointer data1,
537 gpointer arg_1,
538 gpointer data2);
539 register GMarshalFunc_OBJECT__OBJECT callback;
540 register GCClosure *cc = (GCClosure*) closure;
541 register gpointer data1, data2;
542 GObject* v_return;
543
544 g_return_if_fail (return_value != NULL);
545 g_return_if_fail (n_param_values == 2);
546
547 if (G_CCLOSURE_SWAP_DATA (closure))
548 {
549 data1 = closure->data;
550 data2 = g_value_peek_pointer (param_values + 0);
551 }
552 else
553 {
554 data1 = g_value_peek_pointer (param_values + 0);
555 data2 = closure->data;
556 }
557 callback = (GMarshalFunc_OBJECT__OBJECT) (marshal_data ? marshal_data : cc->callback);
558
559 v_return = callback (data1,
560 g_marshal_value_peek_object (param_values + 1),
561 data2);
562
563 g_value_take_object (return_value, v_return);
564 }
565
566 /* OBJECT:OBJECT,OBJECT (./rb-marshal.list:12) */
567 extern void rb_marshal_OBJECT__OBJECT_OBJECT (GClosure *closure,
568 GValue *return_value,
569 guint n_param_values,
570 const GValue *param_values,
571 gpointer invocation_hint,
572 gpointer marshal_data);
573 void
574 rb_marshal_OBJECT__OBJECT_OBJECT (GClosure *closure,
575 GValue *return_value G_GNUC_UNUSED,
576 guint n_param_values,
577 const GValue *param_values,
578 gpointer invocation_hint G_GNUC_UNUSED,
579 gpointer marshal_data)
580 {
581 typedef GObject* (*GMarshalFunc_OBJECT__OBJECT_OBJECT) (gpointer data1,
582 gpointer arg_1,
583 gpointer arg_2,
584 gpointer data2);
585 register GMarshalFunc_OBJECT__OBJECT_OBJECT callback;
586 register GCClosure *cc = (GCClosure*) closure;
587 register gpointer data1, data2;
588 GObject* v_return;
589
590 g_return_if_fail (return_value != NULL);
591 g_return_if_fail (n_param_values == 3);
592
593 if (G_CCLOSURE_SWAP_DATA (closure))
594 {
595 data1 = closure->data;
596 data2 = g_value_peek_pointer (param_values + 0);
597 }
598 else
599 {
600 data1 = g_value_peek_pointer (param_values + 0);
601 data2 = closure->data;
602 }
603 callback = (GMarshalFunc_OBJECT__OBJECT_OBJECT) (marshal_data ? marshal_data : cc->callback);
604
605 v_return = callback (data1,
606 g_marshal_value_peek_object (param_values + 1),
607 g_marshal_value_peek_object (param_values + 2),
608 data2);
609
610 g_value_take_object (return_value, v_return);
611 }
612
613 /* OBJECT:VOID (./rb-marshal.list:13) */
614 extern void rb_marshal_OBJECT__VOID (GClosure *closure,
615 GValue *return_value,
616 guint n_param_values,
617 const GValue *param_values,
618 gpointer invocation_hint,
619 gpointer marshal_data);
620 void
621 rb_marshal_OBJECT__VOID (GClosure *closure,
622 GValue *return_value G_GNUC_UNUSED,
623 guint n_param_values,
624 const GValue *param_values,
625 gpointer invocation_hint G_GNUC_UNUSED,
626 gpointer marshal_data)
627 {
628 typedef GObject* (*GMarshalFunc_OBJECT__VOID) (gpointer data1,
629 gpointer data2);
630 register GMarshalFunc_OBJECT__VOID callback;
631 register GCClosure *cc = (GCClosure*) closure;
632 register gpointer data1, data2;
633 GObject* v_return;
634
635 g_return_if_fail (return_value != NULL);
636 g_return_if_fail (n_param_values == 1);
637
638 if (G_CCLOSURE_SWAP_DATA (closure))
639 {
640 data1 = closure->data;
641 data2 = g_value_peek_pointer (param_values + 0);
642 }
643 else
644 {
645 data1 = g_value_peek_pointer (param_values + 0);
646 data2 = closure->data;
647 }
648 callback = (GMarshalFunc_OBJECT__VOID) (marshal_data ? marshal_data : cc->callback);
649
650 v_return = callback (data1,
651 data2);
652
653 g_value_take_object (return_value, v_return);
654 }
655
656 /* STRING:STRING (./rb-marshal.list:14) */
657 extern void rb_marshal_STRING__STRING (GClosure *closure,
658 GValue *return_value,
659 guint n_param_values,
660 const GValue *param_values,
661 gpointer invocation_hint,
662 gpointer marshal_data);
663 void
664 rb_marshal_STRING__STRING (GClosure *closure,
665 GValue *return_value G_GNUC_UNUSED,
666 guint n_param_values,
667 const GValue *param_values,
668 gpointer invocation_hint G_GNUC_UNUSED,
669 gpointer marshal_data)
670 {
671 typedef gchar* (*GMarshalFunc_STRING__STRING) (gpointer data1,
672 gpointer arg_1,
673 gpointer data2);
674 register GMarshalFunc_STRING__STRING callback;
675 register GCClosure *cc = (GCClosure*) closure;
676 register gpointer data1, data2;
677 gchar* v_return;
678
679 g_return_if_fail (return_value != NULL);
680 g_return_if_fail (n_param_values == 2);
681
682 if (G_CCLOSURE_SWAP_DATA (closure))
683 {
684 data1 = closure->data;
685 data2 = g_value_peek_pointer (param_values + 0);
686 }
687 else
688 {
689 data1 = g_value_peek_pointer (param_values + 0);
690 data2 = closure->data;
691 }
692 callback = (GMarshalFunc_STRING__STRING) (marshal_data ? marshal_data : cc->callback);
693
694 v_return = callback (data1,
695 g_marshal_value_peek_string (param_values + 1),
696 data2);
697
698 g_value_take_string (return_value, v_return);
699 }
700
701 /* STRING:BOXED,STRING,STRING (./rb-marshal.list:15) */
702 extern void rb_marshal_STRING__BOXED_STRING_STRING (GClosure *closure,
703 GValue *return_value,
704 guint n_param_values,
705 const GValue *param_values,
706 gpointer invocation_hint,
707 gpointer marshal_data);
708 void
709 rb_marshal_STRING__BOXED_STRING_STRING (GClosure *closure,
710 GValue *return_value G_GNUC_UNUSED,
711 guint n_param_values,
712 const GValue *param_values,
713 gpointer invocation_hint G_GNUC_UNUSED,
714 gpointer marshal_data)
715 {
716 typedef gchar* (*GMarshalFunc_STRING__BOXED_STRING_STRING) (gpointer data1,
717 gpointer arg_1,
718 gpointer arg_2,
719 gpointer arg_3,
720 gpointer data2);
721 register GMarshalFunc_STRING__BOXED_STRING_STRING callback;
722 register GCClosure *cc = (GCClosure*) closure;
723 register gpointer data1, data2;
724 gchar* v_return;
725
726 g_return_if_fail (return_value != NULL);
727 g_return_if_fail (n_param_values == 4);
728
729 if (G_CCLOSURE_SWAP_DATA (closure))
730 {
731 data1 = closure->data;
732 data2 = g_value_peek_pointer (param_values + 0);
733 }
734 else
735 {
736 data1 = g_value_peek_pointer (param_values + 0);
737 data2 = closure->data;
738 }
739 callback = (GMarshalFunc_STRING__BOXED_STRING_STRING) (marshal_data ? marshal_data : cc->callback);
740
741 v_return = callback (data1,
742 g_marshal_value_peek_boxed (param_values + 1),
743 g_marshal_value_peek_string (param_values + 2),
744 g_marshal_value_peek_string (param_values + 3),
745 data2);
746
747 g_value_take_string (return_value, v_return);
748 }
749
750 /* VOID:BOOLEAN,BOOLEAN (./rb-marshal.list:16) */
751 extern void rb_marshal_VOID__BOOLEAN_BOOLEAN (GClosure *closure,
752 GValue *return_value,
753 guint n_param_values,
754 const GValue *param_values,
755 gpointer invocation_hint,
756 gpointer marshal_data);
757 void
758 rb_marshal_VOID__BOOLEAN_BOOLEAN (GClosure *closure,
759 GValue *return_value G_GNUC_UNUSED,
760 guint n_param_values,
761 const GValue *param_values,
762 gpointer invocation_hint G_GNUC_UNUSED,
763 gpointer marshal_data)
764 {
765 typedef void (*GMarshalFunc_VOID__BOOLEAN_BOOLEAN) (gpointer data1,
766 gboolean arg_1,
767 gboolean arg_2,
768 gpointer data2);
769 register GMarshalFunc_VOID__BOOLEAN_BOOLEAN callback;
770 register GCClosure *cc = (GCClosure*) closure;
771 register gpointer data1, data2;
772
773 g_return_if_fail (n_param_values == 3);
774
775 if (G_CCLOSURE_SWAP_DATA (closure))
776 {
777 data1 = closure->data;
778 data2 = g_value_peek_pointer (param_values + 0);
779 }
780 else
781 {
782 data1 = g_value_peek_pointer (param_values + 0);
783 data2 = closure->data;
784 }
785 callback = (GMarshalFunc_VOID__BOOLEAN_BOOLEAN) (marshal_data ? marshal_data : cc->callback);
786
787 callback (data1,
788 g_marshal_value_peek_boolean (param_values + 1),
789 g_marshal_value_peek_boolean (param_values + 2),
790 data2);
791 }
792
793 /* BOXED:BOXED (./rb-marshal.list:17) */
794 extern void rb_marshal_BOXED__BOXED (GClosure *closure,
795 GValue *return_value,
796 guint n_param_values,
797 const GValue *param_values,
798 gpointer invocation_hint,
799 gpointer marshal_data);
800 void
801 rb_marshal_BOXED__BOXED (GClosure *closure,
802 GValue *return_value G_GNUC_UNUSED,
803 guint n_param_values,
804 const GValue *param_values,
805 gpointer invocation_hint G_GNUC_UNUSED,
806 gpointer marshal_data)
807 {
808 typedef gpointer (*GMarshalFunc_BOXED__BOXED) (gpointer data1,
809 gpointer arg_1,
810 gpointer data2);
811 register GMarshalFunc_BOXED__BOXED callback;
812 register GCClosure *cc = (GCClosure*) closure;
813 register gpointer data1, data2;
814 gpointer v_return;
815
816 g_return_if_fail (return_value != NULL);
817 g_return_if_fail (n_param_values == 2);
818
819 if (G_CCLOSURE_SWAP_DATA (closure))
820 {
821 data1 = closure->data;
822 data2 = g_value_peek_pointer (param_values + 0);
823 }
824 else
825 {
826 data1 = g_value_peek_pointer (param_values + 0);
827 data2 = closure->data;
828 }
829 callback = (GMarshalFunc_BOXED__BOXED) (marshal_data ? marshal_data : cc->callback);
830
831 v_return = callback (data1,
832 g_marshal_value_peek_boxed (param_values + 1),
833 data2);
834
835 g_value_take_boxed (return_value, v_return);
836 }
837
838 /* BOXED:OBJECT (./rb-marshal.list:18) */
839 extern void rb_marshal_BOXED__OBJECT (GClosure *closure,
840 GValue *return_value,
841 guint n_param_values,
842 const GValue *param_values,
843 gpointer invocation_hint,
844 gpointer marshal_data);
845 void
846 rb_marshal_BOXED__OBJECT (GClosure *closure,
847 GValue *return_value G_GNUC_UNUSED,
848 guint n_param_values,
849 const GValue *param_values,
850 gpointer invocation_hint G_GNUC_UNUSED,
851 gpointer marshal_data)
852 {
853 typedef gpointer (*GMarshalFunc_BOXED__OBJECT) (gpointer data1,
854 gpointer arg_1,
855 gpointer data2);
856 register GMarshalFunc_BOXED__OBJECT callback;
857 register GCClosure *cc = (GCClosure*) closure;
858 register gpointer data1, data2;
859 gpointer v_return;
860
861 g_return_if_fail (return_value != NULL);
862 g_return_if_fail (n_param_values == 2);
863
864 if (G_CCLOSURE_SWAP_DATA (closure))
865 {
866 data1 = closure->data;
867 data2 = g_value_peek_pointer (param_values + 0);
868 }
869 else
870 {
871 data1 = g_value_peek_pointer (param_values + 0);
872 data2 = closure->data;
873 }
874 callback = (GMarshalFunc_BOXED__OBJECT) (marshal_data ? marshal_data : cc->callback);
875
876 v_return = callback (data1,
877 g_marshal_value_peek_object (param_values + 1),
878 data2);
879
880 g_value_take_boxed (return_value, v_return);
881 }
882
883 /* BOXED:STRING (./rb-marshal.list:19) */
884 extern void rb_marshal_BOXED__STRING (GClosure *closure,
885 GValue *return_value,
886 guint n_param_values,
887 const GValue *param_values,
888 gpointer invocation_hint,
889 gpointer marshal_data);
890 void
891 rb_marshal_BOXED__STRING (GClosure *closure,
892 GValue *return_value G_GNUC_UNUSED,
893 guint n_param_values,
894 const GValue *param_values,
895 gpointer invocation_hint G_GNUC_UNUSED,
896 gpointer marshal_data)
897 {
898 typedef gpointer (*GMarshalFunc_BOXED__STRING) (gpointer data1,
899 gpointer arg_1,
900 gpointer data2);
901 register GMarshalFunc_BOXED__STRING callback;
902 register GCClosure *cc = (GCClosure*) closure;
903 register gpointer data1, data2;
904 gpointer v_return;
905
906 g_return_if_fail (return_value != NULL);
907 g_return_if_fail (n_param_values == 2);
908
909 if (G_CCLOSURE_SWAP_DATA (closure))
910 {
911 data1 = closure->data;
912 data2 = g_value_peek_pointer (param_values + 0);
913 }
914 else
915 {
916 data1 = g_value_peek_pointer (param_values + 0);
917 data2 = closure->data;
918 }
919 callback = (GMarshalFunc_BOXED__STRING) (marshal_data ? marshal_data : cc->callback);
920
921 v_return = callback (data1,
922 g_marshal_value_peek_string (param_values + 1),
923 data2);
924
925 g_value_take_boxed (return_value, v_return);
926 }
927
928 /* POINTER:BOXED (./rb-marshal.list:20) */
929 extern void rb_marshal_POINTER__BOXED (GClosure *closure,
930 GValue *return_value,
931 guint n_param_values,
932 const GValue *param_values,
933 gpointer invocation_hint,
934 gpointer marshal_data);
935 void
936 rb_marshal_POINTER__BOXED (GClosure *closure,
937 GValue *return_value G_GNUC_UNUSED,
938 guint n_param_values,
939 const GValue *param_values,
940 gpointer invocation_hint G_GNUC_UNUSED,
941 gpointer marshal_data)
942 {
943 typedef gpointer (*GMarshalFunc_POINTER__BOXED) (gpointer data1,
944 gpointer arg_1,
945 gpointer data2);
946 register GMarshalFunc_POINTER__BOXED callback;
947 register GCClosure *cc = (GCClosure*) closure;
948 register gpointer data1, data2;
949 gpointer v_return;
950
951 g_return_if_fail (return_value != NULL);
952 g_return_if_fail (n_param_values == 2);
953
954 if (G_CCLOSURE_SWAP_DATA (closure))
955 {
956 data1 = closure->data;
957 data2 = g_value_peek_pointer (param_values + 0);
958 }
959 else
960 {
961 data1 = g_value_peek_pointer (param_values + 0);
962 data2 = closure->data;
963 }
964 callback = (GMarshalFunc_POINTER__BOXED) (marshal_data ? marshal_data : cc->callback);
965
966 v_return = callback (data1,
967 g_marshal_value_peek_boxed (param_values + 1),
968 data2);
969
970 g_value_set_pointer (return_value, v_return);
971 }
972
973 /* VOID:BOXED,BOXED (./rb-marshal.list:21) */
974 extern void rb_marshal_VOID__BOXED_BOXED (GClosure *closure,
975 GValue *return_value,
976 guint n_param_values,
977 const GValue *param_values,
978 gpointer invocation_hint,
979 gpointer marshal_data);
980 void
981 rb_marshal_VOID__BOXED_BOXED (GClosure *closure,
982 GValue *return_value G_GNUC_UNUSED,
983 guint n_param_values,
984 const GValue *param_values,
985 gpointer invocation_hint G_GNUC_UNUSED,
986 gpointer marshal_data)
987 {
988 typedef void (*GMarshalFunc_VOID__BOXED_BOXED) (gpointer data1,
989 gpointer arg_1,
990 gpointer arg_2,
991 gpointer data2);
992 register GMarshalFunc_VOID__BOXED_BOXED callback;
993 register GCClosure *cc = (GCClosure*) closure;
994 register gpointer data1, data2;
995
996 g_return_if_fail (n_param_values == 3);
997
998 if (G_CCLOSURE_SWAP_DATA (closure))
999 {
1000 data1 = closure->data;
1001 data2 = g_value_peek_pointer (param_values + 0);
1002 }
1003 else
1004 {
1005 data1 = g_value_peek_pointer (param_values + 0);
1006 data2 = closure->data;
1007 }
1008 callback = (GMarshalFunc_VOID__BOXED_BOXED) (marshal_data ? marshal_data : cc->callback);
1009
1010 callback (data1,
1011 g_marshal_value_peek_boxed (param_values + 1),
1012 g_marshal_value_peek_boxed (param_values + 2),
1013 data2);
1014 }
1015
1016 /* VOID:BOXED,INT,POINTER,POINTER (./rb-marshal.list:22) */
1017 extern void rb_marshal_VOID__BOXED_INT_POINTER_POINTER (GClosure *closure,
1018 GValue *return_value,
1019 guint n_param_values,
1020 const GValue *param_values,
1021 gpointer invocation_hint,
1022 gpointer marshal_data);
1023 void
1024 rb_marshal_VOID__BOXED_INT_POINTER_POINTER (GClosure *closure,
1025 GValue *return_value G_GNUC_UNUSED,
1026 guint n_param_values,
1027 const GValue *param_values,
1028 gpointer invocation_hint G_GNUC_UNUSED,
1029 gpointer marshal_data)
1030 {
1031 typedef void (*GMarshalFunc_VOID__BOXED_INT_POINTER_POINTER) (gpointer data1,
1032 gpointer arg_1,
1033 gint arg_2,
1034 gpointer arg_3,
1035 gpointer arg_4,
1036 gpointer data2);
1037 register GMarshalFunc_VOID__BOXED_INT_POINTER_POINTER callback;
1038 register GCClosure *cc = (GCClosure*) closure;
1039 register gpointer data1, data2;
1040
1041 g_return_if_fail (n_param_values == 5);
1042
1043 if (G_CCLOSURE_SWAP_DATA (closure))
1044 {
1045 data1 = closure->data;
1046 data2 = g_value_peek_pointer (param_values + 0);
1047 }
1048 else
1049 {
1050 data1 = g_value_peek_pointer (param_values + 0);
1051 data2 = closure->data;
1052 }
1053 callback = (GMarshalFunc_VOID__BOXED_INT_POINTER_POINTER) (marshal_data ? marshal_data : cc->callback);
1054
1055 callback (data1,
1056 g_marshal_value_peek_boxed (param_values + 1),
1057 g_marshal_value_peek_int (param_values + 2),
1058 g_marshal_value_peek_pointer (param_values + 3),
1059 g_marshal_value_peek_pointer (param_values + 4),
1060 data2);
1061 }
1062
1063 /* VOID:BOXED,OBJECT (./rb-marshal.list:23) */
1064 extern void rb_marshal_VOID__BOXED_OBJECT (GClosure *closure,
1065 GValue *return_value,
1066 guint n_param_values,
1067 const GValue *param_values,
1068 gpointer invocation_hint,
1069 gpointer marshal_data);
1070 void
1071 rb_marshal_VOID__BOXED_OBJECT (GClosure *closure,
1072 GValue *return_value G_GNUC_UNUSED,
1073 guint n_param_values,
1074 const GValue *param_values,
1075 gpointer invocation_hint G_GNUC_UNUSED,
1076 gpointer marshal_data)
1077 {
1078 typedef void (*GMarshalFunc_VOID__BOXED_OBJECT) (gpointer data1,
1079 gpointer arg_1,
1080 gpointer arg_2,
1081 gpointer data2);
1082 register GMarshalFunc_VOID__BOXED_OBJECT callback;
1083 register GCClosure *cc = (GCClosure*) closure;
1084 register gpointer data1, data2;
1085
1086 g_return_if_fail (n_param_values == 3);
1087
1088 if (G_CCLOSURE_SWAP_DATA (closure))
1089 {
1090 data1 = closure->data;
1091 data2 = g_value_peek_pointer (param_values + 0);
1092 }
1093 else
1094 {
1095 data1 = g_value_peek_pointer (param_values + 0);
1096 data2 = closure->data;
1097 }
1098 callback = (GMarshalFunc_VOID__BOXED_OBJECT) (marshal_data ? marshal_data : cc->callback);
1099
1100 callback (data1,
1101 g_marshal_value_peek_boxed (param_values + 1),
1102 g_marshal_value_peek_object (param_values + 2),
1103 data2);
1104 }
1105
1106 /* VOID:BOXED,POINTER (./rb-marshal.list:24) */
1107 extern void rb_marshal_VOID__BOXED_POINTER (GClosure *closure,
1108 GValue *return_value,
1109 guint n_param_values,
1110 const GValue *param_values,
1111 gpointer invocation_hint,
1112 gpointer marshal_data);
1113 void
1114 rb_marshal_VOID__BOXED_POINTER (GClosure *closure,
1115 GValue *return_value G_GNUC_UNUSED,
1116 guint n_param_values,
1117 const GValue *param_values,
1118 gpointer invocation_hint G_GNUC_UNUSED,
1119 gpointer marshal_data)
1120 {
1121 typedef void (*GMarshalFunc_VOID__BOXED_POINTER) (gpointer data1,
1122 gpointer arg_1,
1123 gpointer arg_2,
1124 gpointer data2);
1125 register GMarshalFunc_VOID__BOXED_POINTER callback;
1126 register GCClosure *cc = (GCClosure*) closure;
1127 register gpointer data1, data2;
1128
1129 g_return_if_fail (n_param_values == 3);
1130
1131 if (G_CCLOSURE_SWAP_DATA (closure))
1132 {
1133 data1 = closure->data;
1134 data2 = g_value_peek_pointer (param_values + 0);
1135 }
1136 else
1137 {
1138 data1 = g_value_peek_pointer (param_values + 0);
1139 data2 = closure->data;
1140 }
1141 callback = (GMarshalFunc_VOID__BOXED_POINTER) (marshal_data ? marshal_data : cc->callback);
1142
1143 callback (data1,
1144 g_marshal_value_peek_boxed (param_values + 1),
1145 g_marshal_value_peek_pointer (param_values + 2),
1146 data2);
1147 }
1148
1149 /* VOID:BOXED,STRING (./rb-marshal.list:25) */
1150 extern void rb_marshal_VOID__BOXED_STRING (GClosure *closure,
1151 GValue *return_value,
1152 guint n_param_values,
1153 const GValue *param_values,
1154 gpointer invocation_hint,
1155 gpointer marshal_data);
1156 void
1157 rb_marshal_VOID__BOXED_STRING (GClosure *closure,
1158 GValue *return_value G_GNUC_UNUSED,
1159 guint n_param_values,
1160 const GValue *param_values,
1161 gpointer invocation_hint G_GNUC_UNUSED,
1162 gpointer marshal_data)
1163 {
1164 typedef void (*GMarshalFunc_VOID__BOXED_STRING) (gpointer data1,
1165 gpointer arg_1,
1166 gpointer arg_2,
1167 gpointer data2);
1168 register GMarshalFunc_VOID__BOXED_STRING callback;
1169 register GCClosure *cc = (GCClosure*) closure;
1170 register gpointer data1, data2;
1171
1172 g_return_if_fail (n_param_values == 3);
1173
1174 if (G_CCLOSURE_SWAP_DATA (closure))
1175 {
1176 data1 = closure->data;
1177 data2 = g_value_peek_pointer (param_values + 0);
1178 }
1179 else
1180 {
1181 data1 = g_value_peek_pointer (param_values + 0);
1182 data2 = closure->data;
1183 }
1184 callback = (GMarshalFunc_VOID__BOXED_STRING) (marshal_data ? marshal_data : cc->callback);
1185
1186 callback (data1,
1187 g_marshal_value_peek_boxed (param_values + 1),
1188 g_marshal_value_peek_string (param_values + 2),
1189 data2);
1190 }
1191
1192 /* VOID:BOXED,STRING,BOXED (./rb-marshal.list:26) */
1193 extern void rb_marshal_VOID__BOXED_STRING_BOXED (GClosure *closure,
1194 GValue *return_value,
1195 guint n_param_values,
1196 const GValue *param_values,
1197 gpointer invocation_hint,
1198 gpointer marshal_data);
1199 void
1200 rb_marshal_VOID__BOXED_STRING_BOXED (GClosure *closure,
1201 GValue *return_value G_GNUC_UNUSED,
1202 guint n_param_values,
1203 const GValue *param_values,
1204 gpointer invocation_hint G_GNUC_UNUSED,
1205 gpointer marshal_data)
1206 {
1207 typedef void (*GMarshalFunc_VOID__BOXED_STRING_BOXED) (gpointer data1,
1208 gpointer arg_1,
1209 gpointer arg_2,
1210 gpointer arg_3,
1211 gpointer data2);
1212 register GMarshalFunc_VOID__BOXED_STRING_BOXED callback;
1213 register GCClosure *cc = (GCClosure*) closure;
1214 register gpointer data1, data2;
1215
1216 g_return_if_fail (n_param_values == 4);
1217
1218 if (G_CCLOSURE_SWAP_DATA (closure))
1219 {
1220 data1 = closure->data;
1221 data2 = g_value_peek_pointer (param_values + 0);
1222 }
1223 else
1224 {
1225 data1 = g_value_peek_pointer (param_values + 0);
1226 data2 = closure->data;
1227 }
1228 callback = (GMarshalFunc_VOID__BOXED_STRING_BOXED) (marshal_data ? marshal_data : cc->callback);
1229
1230 callback (data1,
1231 g_marshal_value_peek_boxed (param_values + 1),
1232 g_marshal_value_peek_string (param_values + 2),
1233 g_marshal_value_peek_boxed (param_values + 3),
1234 data2);
1235 }
1236
1237 /* VOID:BOXED,STRING,INT,INT,DOUBLE (./rb-marshal.list:27) */
1238 extern void rb_marshal_VOID__BOXED_STRING_INT_INT_DOUBLE (GClosure *closure,
1239 GValue *return_value,
1240 guint n_param_values,
1241 const GValue *param_values,
1242 gpointer invocation_hint,
1243 gpointer marshal_data);
1244 void
1245 rb_marshal_VOID__BOXED_STRING_INT_INT_DOUBLE (GClosure *closure,
1246 GValue *return_value G_GNUC_UNUSED,
1247 guint n_param_values,
1248 const GValue *param_values,
1249 gpointer invocation_hint G_GNUC_UNUSED,
1250 gpointer marshal_data)
1251 {
1252 typedef void (*GMarshalFunc_VOID__BOXED_STRING_INT_INT_DOUBLE) (gpointer data1,
1253 gpointer arg_1,
1254 gpointer arg_2,
1255 gint arg_3,
1256 gint arg_4,
1257 gdouble arg_5,
1258 gpointer data2);
1259 register GMarshalFunc_VOID__BOXED_STRING_INT_INT_DOUBLE callback;
1260 register GCClosure *cc = (GCClosure*) closure;
1261 register gpointer data1, data2;
1262
1263 g_return_if_fail (n_param_values == 6);
1264
1265 if (G_CCLOSURE_SWAP_DATA (closure))
1266 {
1267 data1 = closure->data;
1268 data2 = g_value_peek_pointer (param_values + 0);
1269 }
1270 else
1271 {
1272 data1 = g_value_peek_pointer (param_values + 0);
1273 data2 = closure->data;
1274 }
1275 callback = (GMarshalFunc_VOID__BOXED_STRING_INT_INT_DOUBLE) (marshal_data ? marshal_data : cc->callback);
1276
1277 callback (data1,
1278 g_marshal_value_peek_boxed (param_values + 1),
1279 g_marshal_value_peek_string (param_values + 2),
1280 g_marshal_value_peek_int (param_values + 3),
1281 g_marshal_value_peek_int (param_values + 4),
1282 g_marshal_value_peek_double (param_values + 5),
1283 data2);
1284 }
1285
1286 /* VOID:BOXED,STRING,UINT64,STRING,POINTER (./rb-marshal.list:28) */
1287 extern void rb_marshal_VOID__BOXED_STRING_UINT64_STRING_POINTER (GClosure *closure,
1288 GValue *return_value,
1289 guint n_param_values,
1290 const GValue *param_values,
1291 gpointer invocation_hint,
1292 gpointer marshal_data);
1293 void
1294 rb_marshal_VOID__BOXED_STRING_UINT64_STRING_POINTER (GClosure *closure,
1295 GValue *return_value G_GNUC_UNUSED,
1296 guint n_param_values,
1297 const GValue *param_values,
1298 gpointer invocation_hint G_GNUC_UNUSED,
1299 gpointer marshal_data)
1300 {
1301 typedef void (*GMarshalFunc_VOID__BOXED_STRING_UINT64_STRING_POINTER) (gpointer data1,
1302 gpointer arg_1,
1303 gpointer arg_2,
1304 guint64 arg_3,
1305 gpointer arg_4,
1306 gpointer arg_5,
1307 gpointer data2);
1308 register GMarshalFunc_VOID__BOXED_STRING_UINT64_STRING_POINTER callback;
1309 register GCClosure *cc = (GCClosure*) closure;
1310 register gpointer data1, data2;
1311
1312 g_return_if_fail (n_param_values == 6);
1313
1314 if (G_CCLOSURE_SWAP_DATA (closure))
1315 {
1316 data1 = closure->data;
1317 data2 = g_value_peek_pointer (param_values + 0);
1318 }
1319 else
1320 {
1321 data1 = g_value_peek_pointer (param_values + 0);
1322 data2 = closure->data;
1323 }
1324 callback = (GMarshalFunc_VOID__BOXED_STRING_UINT64_STRING_POINTER) (marshal_data ? marshal_data : cc->callback);
1325
1326 callback (data1,
1327 g_marshal_value_peek_boxed (param_values + 1),
1328 g_marshal_value_peek_string (param_values + 2),
1329 g_marshal_value_peek_uint64 (param_values + 3),
1330 g_marshal_value_peek_string (param_values + 4),
1331 g_marshal_value_peek_pointer (param_values + 5),
1332 data2);
1333 }
1334
1335 /* VOID:BOXED,ULONG (./rb-marshal.list:29) */
1336 extern void rb_marshal_VOID__BOXED_ULONG (GClosure *closure,
1337 GValue *return_value,
1338 guint n_param_values,
1339 const GValue *param_values,
1340 gpointer invocation_hint,
1341 gpointer marshal_data);
1342 void
1343 rb_marshal_VOID__BOXED_ULONG (GClosure *closure,
1344 GValue *return_value G_GNUC_UNUSED,
1345 guint n_param_values,
1346 const GValue *param_values,
1347 gpointer invocation_hint G_GNUC_UNUSED,
1348 gpointer marshal_data)
1349 {
1350 typedef void (*GMarshalFunc_VOID__BOXED_ULONG) (gpointer data1,
1351 gpointer arg_1,
1352 gulong arg_2,
1353 gpointer data2);
1354 register GMarshalFunc_VOID__BOXED_ULONG callback;
1355 register GCClosure *cc = (GCClosure*) closure;
1356 register gpointer data1, data2;
1357
1358 g_return_if_fail (n_param_values == 3);
1359
1360 if (G_CCLOSURE_SWAP_DATA (closure))
1361 {
1362 data1 = closure->data;
1363 data2 = g_value_peek_pointer (param_values + 0);
1364 }
1365 else
1366 {
1367 data1 = g_value_peek_pointer (param_values + 0);
1368 data2 = closure->data;
1369 }
1370 callback = (GMarshalFunc_VOID__BOXED_ULONG) (marshal_data ? marshal_data : cc->callback);
1371
1372 callback (data1,
1373 g_marshal_value_peek_boxed (param_values + 1),
1374 g_marshal_value_peek_ulong (param_values + 2),
1375 data2);
1376 }
1377
1378 /* VOID:DOUBLE,LONG (./rb-marshal.list:30) */
1379 extern void rb_marshal_VOID__DOUBLE_LONG (GClosure *closure,
1380 GValue *return_value,
1381 guint n_param_values,
1382 const GValue *param_values,
1383 gpointer invocation_hint,
1384 gpointer marshal_data);
1385 void
1386 rb_marshal_VOID__DOUBLE_LONG (GClosure *closure,
1387 GValue *return_value G_GNUC_UNUSED,
1388 guint n_param_values,
1389 const GValue *param_values,
1390 gpointer invocation_hint G_GNUC_UNUSED,
1391 gpointer marshal_data)
1392 {
1393 typedef void (*GMarshalFunc_VOID__DOUBLE_LONG) (gpointer data1,
1394 gdouble arg_1,
1395 glong arg_2,
1396 gpointer data2);
1397 register GMarshalFunc_VOID__DOUBLE_LONG callback;
1398 register GCClosure *cc = (GCClosure*) closure;
1399 register gpointer data1, data2;
1400
1401 g_return_if_fail (n_param_values == 3);
1402
1403 if (G_CCLOSURE_SWAP_DATA (closure))
1404 {
1405 data1 = closure->data;
1406 data2 = g_value_peek_pointer (param_values + 0);
1407 }
1408 else
1409 {
1410 data1 = g_value_peek_pointer (param_values + 0);
1411 data2 = closure->data;
1412 }
1413 callback = (GMarshalFunc_VOID__DOUBLE_LONG) (marshal_data ? marshal_data : cc->callback);
1414
1415 callback (data1,
1416 g_marshal_value_peek_double (param_values + 1),
1417 g_marshal_value_peek_long (param_values + 2),
1418 data2);
1419 }
1420
1421 /* VOID:INT,INT (./rb-marshal.list:31) */
1422 extern void rb_marshal_VOID__INT_INT (GClosure *closure,
1423 GValue *return_value,
1424 guint n_param_values,
1425 const GValue *param_values,
1426 gpointer invocation_hint,
1427 gpointer marshal_data);
1428 void
1429 rb_marshal_VOID__INT_INT (GClosure *closure,
1430 GValue *return_value G_GNUC_UNUSED,
1431 guint n_param_values,
1432 const GValue *param_values,
1433 gpointer invocation_hint G_GNUC_UNUSED,
1434 gpointer marshal_data)
1435 {
1436 typedef void (*GMarshalFunc_VOID__INT_INT) (gpointer data1,
1437 gint arg_1,
1438 gint arg_2,
1439 gpointer data2);
1440 register GMarshalFunc_VOID__INT_INT callback;
1441 register GCClosure *cc = (GCClosure*) closure;
1442 register gpointer data1, data2;
1443
1444 g_return_if_fail (n_param_values == 3);
1445
1446 if (G_CCLOSURE_SWAP_DATA (closure))
1447 {
1448 data1 = closure->data;
1449 data2 = g_value_peek_pointer (param_values + 0);
1450 }
1451 else
1452 {
1453 data1 = g_value_peek_pointer (param_values + 0);
1454 data2 = closure->data;
1455 }
1456 callback = (GMarshalFunc_VOID__INT_INT) (marshal_data ? marshal_data : cc->callback);
1457
1458 callback (data1,
1459 g_marshal_value_peek_int (param_values + 1),
1460 g_marshal_value_peek_int (param_values + 2),
1461 data2);
1462 }
1463
1464 /* VOID:INT,INT,DOUBLE,INT (./rb-marshal.list:32) */
1465 extern void rb_marshal_VOID__INT_INT_DOUBLE_INT (GClosure *closure,
1466 GValue *return_value,
1467 guint n_param_values,
1468 const GValue *param_values,
1469 gpointer invocation_hint,
1470 gpointer marshal_data);
1471 void
1472 rb_marshal_VOID__INT_INT_DOUBLE_INT (GClosure *closure,
1473 GValue *return_value G_GNUC_UNUSED,
1474 guint n_param_values,
1475 const GValue *param_values,
1476 gpointer invocation_hint G_GNUC_UNUSED,
1477 gpointer marshal_data)
1478 {
1479 typedef void (*GMarshalFunc_VOID__INT_INT_DOUBLE_INT) (gpointer data1,
1480 gint arg_1,
1481 gint arg_2,
1482 gdouble arg_3,
1483 gint arg_4,
1484 gpointer data2);
1485 register GMarshalFunc_VOID__INT_INT_DOUBLE_INT callback;
1486 register GCClosure *cc = (GCClosure*) closure;
1487 register gpointer data1, data2;
1488
1489 g_return_if_fail (n_param_values == 5);
1490
1491 if (G_CCLOSURE_SWAP_DATA (closure))
1492 {
1493 data1 = closure->data;
1494 data2 = g_value_peek_pointer (param_values + 0);
1495 }
1496 else
1497 {
1498 data1 = g_value_peek_pointer (param_values + 0);
1499 data2 = closure->data;
1500 }
1501 callback = (GMarshalFunc_VOID__INT_INT_DOUBLE_INT) (marshal_data ? marshal_data : cc->callback);
1502
1503 callback (data1,
1504 g_marshal_value_peek_int (param_values + 1),
1505 g_marshal_value_peek_int (param_values + 2),
1506 g_marshal_value_peek_double (param_values + 3),
1507 g_marshal_value_peek_int (param_values + 4),
1508 data2);
1509 }
1510
1511 /* VOID:INT64 (./rb-marshal.list:33) */
1512 extern void rb_marshal_VOID__INT64 (GClosure *closure,
1513 GValue *return_value,
1514 guint n_param_values,
1515 const GValue *param_values,
1516 gpointer invocation_hint,
1517 gpointer marshal_data);
1518 void
1519 rb_marshal_VOID__INT64 (GClosure *closure,
1520 GValue *return_value G_GNUC_UNUSED,
1521 guint n_param_values,
1522 const GValue *param_values,
1523 gpointer invocation_hint G_GNUC_UNUSED,
1524 gpointer marshal_data)
1525 {
1526 typedef void (*GMarshalFunc_VOID__INT64) (gpointer data1,
1527 gint64 arg_1,
1528 gpointer data2);
1529 register GMarshalFunc_VOID__INT64 callback;
1530 register GCClosure *cc = (GCClosure*) closure;
1531 register gpointer data1, data2;
1532
1533 g_return_if_fail (n_param_values == 2);
1534
1535 if (G_CCLOSURE_SWAP_DATA (closure))
1536 {
1537 data1 = closure->data;
1538 data2 = g_value_peek_pointer (param_values + 0);
1539 }
1540 else
1541 {
1542 data1 = g_value_peek_pointer (param_values + 0);
1543 data2 = closure->data;
1544 }
1545 callback = (GMarshalFunc_VOID__INT64) (marshal_data ? marshal_data : cc->callback);
1546
1547 callback (data1,
1548 g_marshal_value_peek_int64 (param_values + 1),
1549 data2);
1550 }
1551
1552 /* VOID:OBJECT,INT,INT (./rb-marshal.list:34) */
1553 extern void rb_marshal_VOID__OBJECT_INT_INT (GClosure *closure,
1554 GValue *return_value,
1555 guint n_param_values,
1556 const GValue *param_values,
1557 gpointer invocation_hint,
1558 gpointer marshal_data);
1559 void
1560 rb_marshal_VOID__OBJECT_INT_INT (GClosure *closure,
1561 GValue *return_value G_GNUC_UNUSED,
1562 guint n_param_values,
1563 const GValue *param_values,
1564 gpointer invocation_hint G_GNUC_UNUSED,
1565 gpointer marshal_data)
1566 {
1567 typedef void (*GMarshalFunc_VOID__OBJECT_INT_INT) (gpointer data1,
1568 gpointer arg_1,
1569 gint arg_2,
1570 gint arg_3,
1571 gpointer data2);
1572 register GMarshalFunc_VOID__OBJECT_INT_INT callback;
1573 register GCClosure *cc = (GCClosure*) closure;
1574 register gpointer data1, data2;
1575
1576 g_return_if_fail (n_param_values == 4);
1577
1578 if (G_CCLOSURE_SWAP_DATA (closure))
1579 {
1580 data1 = closure->data;
1581 data2 = g_value_peek_pointer (param_values + 0);
1582 }
1583 else
1584 {
1585 data1 = g_value_peek_pointer (param_values + 0);
1586 data2 = closure->data;
1587 }
1588 callback = (GMarshalFunc_VOID__OBJECT_INT_INT) (marshal_data ? marshal_data : cc->callback);
1589
1590 callback (data1,
1591 g_marshal_value_peek_object (param_values + 1),
1592 g_marshal_value_peek_int (param_values + 2),
1593 g_marshal_value_peek_int (param_values + 3),
1594 data2);
1595 }
1596
1597 /* VOID:OBJECT,INT,INT,BOXED,UINT,UINT (./rb-marshal.list:35) */
1598 extern void rb_marshal_VOID__OBJECT_INT_INT_BOXED_UINT_UINT (GClosure *closure,
1599 GValue *return_value,
1600 guint n_param_values,
1601 const GValue *param_values,
1602 gpointer invocation_hint,
1603 gpointer marshal_data);
1604 void
1605 rb_marshal_VOID__OBJECT_INT_INT_BOXED_UINT_UINT (GClosure *closure,
1606 GValue *return_value G_GNUC_UNUSED,
1607 guint n_param_values,
1608 const GValue *param_values,
1609 gpointer invocation_hint G_GNUC_UNUSED,
1610 gpointer marshal_data)
1611 {
1612 typedef void (*GMarshalFunc_VOID__OBJECT_INT_INT_BOXED_UINT_UINT) (gpointer data1,
1613 gpointer arg_1,
1614 gint arg_2,
1615 gint arg_3,
1616 gpointer arg_4,
1617 guint arg_5,
1618 guint arg_6,
1619 gpointer data2);
1620 register GMarshalFunc_VOID__OBJECT_INT_INT_BOXED_UINT_UINT callback;
1621 register GCClosure *cc = (GCClosure*) closure;
1622 register gpointer data1, data2;
1623
1624 g_return_if_fail (n_param_values == 7);
1625
1626 if (G_CCLOSURE_SWAP_DATA (closure))
1627 {
1628 data1 = closure->data;
1629 data2 = g_value_peek_pointer (param_values + 0);
1630 }
1631 else
1632 {
1633 data1 = g_value_peek_pointer (param_values + 0);
1634 data2 = closure->data;
1635 }
1636 callback = (GMarshalFunc_VOID__OBJECT_INT_INT_BOXED_UINT_UINT) (marshal_data ? marshal_data : cc->callback);
1637
1638 callback (data1,
1639 g_marshal_value_peek_object (param_values + 1),
1640 g_marshal_value_peek_int (param_values + 2),
1641 g_marshal_value_peek_int (param_values + 3),
1642 g_marshal_value_peek_boxed (param_values + 4),
1643 g_marshal_value_peek_uint (param_values + 5),
1644 g_marshal_value_peek_uint (param_values + 6),
1645 data2);
1646 }
1647
1648 /* VOID:OBJECT,INT,POINTER (./rb-marshal.list:36) */
1649 extern void rb_marshal_VOID__OBJECT_INT_POINTER (GClosure *closure,
1650 GValue *return_value,
1651 guint n_param_values,
1652 const GValue *param_values,
1653 gpointer invocation_hint,
1654 gpointer marshal_data);
1655 void
1656 rb_marshal_VOID__OBJECT_INT_POINTER (GClosure *closure,
1657 GValue *return_value G_GNUC_UNUSED,
1658 guint n_param_values,
1659 const GValue *param_values,
1660 gpointer invocation_hint G_GNUC_UNUSED,
1661 gpointer marshal_data)
1662 {
1663 typedef void (*GMarshalFunc_VOID__OBJECT_INT_POINTER) (gpointer data1,
1664 gpointer arg_1,
1665 gint arg_2,
1666 gpointer arg_3,
1667 gpointer data2);
1668 register GMarshalFunc_VOID__OBJECT_INT_POINTER callback;
1669 register GCClosure *cc = (GCClosure*) closure;
1670 register gpointer data1, data2;
1671
1672 g_return_if_fail (n_param_values == 4);
1673
1674 if (G_CCLOSURE_SWAP_DATA (closure))
1675 {
1676 data1 = closure->data;
1677 data2 = g_value_peek_pointer (param_values + 0);
1678 }
1679 else
1680 {
1681 data1 = g_value_peek_pointer (param_values + 0);
1682 data2 = closure->data;
1683 }
1684 callback = (GMarshalFunc_VOID__OBJECT_INT_POINTER) (marshal_data ? marshal_data : cc->callback);
1685
1686 callback (data1,
1687 g_marshal_value_peek_object (param_values + 1),
1688 g_marshal_value_peek_int (param_values + 2),
1689 g_marshal_value_peek_pointer (param_values + 3),
1690 data2);
1691 }
1692
1693 /* VOID:POINTER,BOOLEAN (./rb-marshal.list:37) */
1694 extern void rb_marshal_VOID__POINTER_BOOLEAN (GClosure *closure,
1695 GValue *return_value,
1696 guint n_param_values,
1697 const GValue *param_values,
1698 gpointer invocation_hint,
1699 gpointer marshal_data);
1700 void
1701 rb_marshal_VOID__POINTER_BOOLEAN (GClosure *closure,
1702 GValue *return_value G_GNUC_UNUSED,
1703 guint n_param_values,
1704 const GValue *param_values,
1705 gpointer invocation_hint G_GNUC_UNUSED,
1706 gpointer marshal_data)
1707 {
1708 typedef void (*GMarshalFunc_VOID__POINTER_BOOLEAN) (gpointer data1,
1709 gpointer arg_1,
1710 gboolean arg_2,
1711 gpointer data2);
1712 register GMarshalFunc_VOID__POINTER_BOOLEAN callback;
1713 register GCClosure *cc = (GCClosure*) closure;
1714 register gpointer data1, data2;
1715
1716 g_return_if_fail (n_param_values == 3);
1717
1718 if (G_CCLOSURE_SWAP_DATA (closure))
1719 {
1720 data1 = closure->data;
1721 data2 = g_value_peek_pointer (param_values + 0);
1722 }
1723 else
1724 {
1725 data1 = g_value_peek_pointer (param_values + 0);
1726 data2 = closure->data;
1727 }
1728 callback = (GMarshalFunc_VOID__POINTER_BOOLEAN) (marshal_data ? marshal_data : cc->callback);
1729
1730 callback (data1,
1731 g_marshal_value_peek_pointer (param_values + 1),
1732 g_marshal_value_peek_boolean (param_values + 2),
1733 data2);
1734 }
1735
1736 /* VOID:POINTER,INT (./rb-marshal.list:38) */
1737 extern void rb_marshal_VOID__POINTER_INT (GClosure *closure,
1738 GValue *return_value,
1739 guint n_param_values,
1740 const GValue *param_values,
1741 gpointer invocation_hint,
1742 gpointer marshal_data);
1743 void
1744 rb_marshal_VOID__POINTER_INT (GClosure *closure,
1745 GValue *return_value G_GNUC_UNUSED,
1746 guint n_param_values,
1747 const GValue *param_values,
1748 gpointer invocation_hint G_GNUC_UNUSED,
1749 gpointer marshal_data)
1750 {
1751 typedef void (*GMarshalFunc_VOID__POINTER_INT) (gpointer data1,
1752 gpointer arg_1,
1753 gint arg_2,
1754 gpointer data2);
1755 register GMarshalFunc_VOID__POINTER_INT callback;
1756 register GCClosure *cc = (GCClosure*) closure;
1757 register gpointer data1, data2;
1758
1759 g_return_if_fail (n_param_values == 3);
1760
1761 if (G_CCLOSURE_SWAP_DATA (closure))
1762 {
1763 data1 = closure->data;
1764 data2 = g_value_peek_pointer (param_values + 0);
1765 }
1766 else
1767 {
1768 data1 = g_value_peek_pointer (param_values + 0);
1769 data2 = closure->data;
1770 }
1771 callback = (GMarshalFunc_VOID__POINTER_INT) (marshal_data ? marshal_data : cc->callback);
1772
1773 callback (data1,
1774 g_marshal_value_peek_pointer (param_values + 1),
1775 g_marshal_value_peek_int (param_values + 2),
1776 data2);
1777 }
1778
1779 /* VOID:POINTER,INT64,INT64 (./rb-marshal.list:39) */
1780 extern void rb_marshal_VOID__POINTER_INT64_INT64 (GClosure *closure,
1781 GValue *return_value,
1782 guint n_param_values,
1783 const GValue *param_values,
1784 gpointer invocation_hint,
1785 gpointer marshal_data);
1786 void
1787 rb_marshal_VOID__POINTER_INT64_INT64 (GClosure *closure,
1788 GValue *return_value G_GNUC_UNUSED,
1789 guint n_param_values,
1790 const GValue *param_values,
1791 gpointer invocation_hint G_GNUC_UNUSED,
1792 gpointer marshal_data)
1793 {
1794 typedef void (*GMarshalFunc_VOID__POINTER_INT64_INT64) (gpointer data1,
1795 gpointer arg_1,
1796 gint64 arg_2,
1797 gint64 arg_3,
1798 gpointer data2);
1799 register GMarshalFunc_VOID__POINTER_INT64_INT64 callback;
1800 register GCClosure *cc = (GCClosure*) closure;
1801 register gpointer data1, data2;
1802
1803 g_return_if_fail (n_param_values == 4);
1804
1805 if (G_CCLOSURE_SWAP_DATA (closure))
1806 {
1807 data1 = closure->data;
1808 data2 = g_value_peek_pointer (param_values + 0);
1809 }
1810 else
1811 {
1812 data1 = g_value_peek_pointer (param_values + 0);
1813 data2 = closure->data;
1814 }
1815 callback = (GMarshalFunc_VOID__POINTER_INT64_INT64) (marshal_data ? marshal_data : cc->callback);
1816
1817 callback (data1,
1818 g_marshal_value_peek_pointer (param_values + 1),
1819 g_marshal_value_peek_int64 (param_values + 2),
1820 g_marshal_value_peek_int64 (param_values + 3),
1821 data2);
1822 }
1823
1824 /* VOID:POINTER,INT,POINTER (./rb-marshal.list:40) */
1825 extern void rb_marshal_VOID__POINTER_INT_POINTER (GClosure *closure,
1826 GValue *return_value,
1827 guint n_param_values,
1828 const GValue *param_values,
1829 gpointer invocation_hint,
1830 gpointer marshal_data);
1831 void
1832 rb_marshal_VOID__POINTER_INT_POINTER (GClosure *closure,
1833 GValue *return_value G_GNUC_UNUSED,
1834 guint n_param_values,
1835 const GValue *param_values,
1836 gpointer invocation_hint G_GNUC_UNUSED,
1837 gpointer marshal_data)
1838 {
1839 typedef void (*GMarshalFunc_VOID__POINTER_INT_POINTER) (gpointer data1,
1840 gpointer arg_1,
1841 gint arg_2,
1842 gpointer arg_3,
1843 gpointer data2);
1844 register GMarshalFunc_VOID__POINTER_INT_POINTER callback;
1845 register GCClosure *cc = (GCClosure*) closure;
1846 register gpointer data1, data2;
1847
1848 g_return_if_fail (n_param_values == 4);
1849
1850 if (G_CCLOSURE_SWAP_DATA (closure))
1851 {
1852 data1 = closure->data;
1853 data2 = g_value_peek_pointer (param_values + 0);
1854 }
1855 else
1856 {
1857 data1 = g_value_peek_pointer (param_values + 0);
1858 data2 = closure->data;
1859 }
1860 callback = (GMarshalFunc_VOID__POINTER_INT_POINTER) (marshal_data ? marshal_data : cc->callback);
1861
1862 callback (data1,
1863 g_marshal_value_peek_pointer (param_values + 1),
1864 g_marshal_value_peek_int (param_values + 2),
1865 g_marshal_value_peek_pointer (param_values + 3),
1866 data2);
1867 }
1868
1869 /* VOID:POINTER,LONG,LONG (./rb-marshal.list:41) */
1870 extern void rb_marshal_VOID__POINTER_LONG_LONG (GClosure *closure,
1871 GValue *return_value,
1872 guint n_param_values,
1873 const GValue *param_values,
1874 gpointer invocation_hint,
1875 gpointer marshal_data);
1876 void
1877 rb_marshal_VOID__POINTER_LONG_LONG (GClosure *closure,
1878 GValue *return_value G_GNUC_UNUSED,
1879 guint n_param_values,
1880 const GValue *param_values,
1881 gpointer invocation_hint G_GNUC_UNUSED,
1882 gpointer marshal_data)
1883 {
1884 typedef void (*GMarshalFunc_VOID__POINTER_LONG_LONG) (gpointer data1,
1885 gpointer arg_1,
1886 glong arg_2,
1887 glong arg_3,
1888 gpointer data2);
1889 register GMarshalFunc_VOID__POINTER_LONG_LONG callback;
1890 register GCClosure *cc = (GCClosure*) closure;
1891 register gpointer data1, data2;
1892
1893 g_return_if_fail (n_param_values == 4);
1894
1895 if (G_CCLOSURE_SWAP_DATA (closure))
1896 {
1897 data1 = closure->data;
1898 data2 = g_value_peek_pointer (param_values + 0);
1899 }
1900 else
1901 {
1902 data1 = g_value_peek_pointer (param_values + 0);
1903 data2 = closure->data;
1904 }
1905 callback = (GMarshalFunc_VOID__POINTER_LONG_LONG) (marshal_data ? marshal_data : cc->callback);
1906
1907 callback (data1,
1908 g_marshal_value_peek_pointer (param_values + 1),
1909 g_marshal_value_peek_long (param_values + 2),
1910 g_marshal_value_peek_long (param_values + 3),
1911 data2);
1912 }
1913
1914 /* VOID:POINTER,OBJECT (./rb-marshal.list:42) */
1915 extern void rb_marshal_VOID__POINTER_OBJECT (GClosure *closure,
1916 GValue *return_value,
1917 guint n_param_values,
1918 const GValue *param_values,
1919 gpointer invocation_hint,
1920 gpointer marshal_data);
1921 void
1922 rb_marshal_VOID__POINTER_OBJECT (GClosure *closure,
1923 GValue *return_value G_GNUC_UNUSED,
1924 guint n_param_values,
1925 const GValue *param_values,
1926 gpointer invocation_hint G_GNUC_UNUSED,
1927 gpointer marshal_data)
1928 {
1929 typedef void (*GMarshalFunc_VOID__POINTER_OBJECT) (gpointer data1,
1930 gpointer arg_1,
1931 gpointer arg_2,
1932 gpointer data2);
1933 register GMarshalFunc_VOID__POINTER_OBJECT callback;
1934 register GCClosure *cc = (GCClosure*) closure;
1935 register gpointer data1, data2;
1936
1937 g_return_if_fail (n_param_values == 3);
1938
1939 if (G_CCLOSURE_SWAP_DATA (closure))
1940 {
1941 data1 = closure->data;
1942 data2 = g_value_peek_pointer (param_values + 0);
1943 }
1944 else
1945 {
1946 data1 = g_value_peek_pointer (param_values + 0);
1947 data2 = closure->data;
1948 }
1949 callback = (GMarshalFunc_VOID__POINTER_OBJECT) (marshal_data ? marshal_data : cc->callback);
1950
1951 callback (data1,
1952 g_marshal_value_peek_pointer (param_values + 1),
1953 g_marshal_value_peek_object (param_values + 2),
1954 data2);
1955 }
1956
1957 /* VOID:POINTER,POINTER (./rb-marshal.list:43) */
1958 extern void rb_marshal_VOID__POINTER_POINTER (GClosure *closure,
1959 GValue *return_value,
1960 guint n_param_values,
1961 const GValue *param_values,
1962 gpointer invocation_hint,
1963 gpointer marshal_data);
1964 void
1965 rb_marshal_VOID__POINTER_POINTER (GClosure *closure,
1966 GValue *return_value G_GNUC_UNUSED,
1967 guint n_param_values,
1968 const GValue *param_values,
1969 gpointer invocation_hint G_GNUC_UNUSED,
1970 gpointer marshal_data)
1971 {
1972 typedef void (*GMarshalFunc_VOID__POINTER_POINTER) (gpointer data1,
1973 gpointer arg_1,
1974 gpointer arg_2,
1975 gpointer data2);
1976 register GMarshalFunc_VOID__POINTER_POINTER callback;
1977 register GCClosure *cc = (GCClosure*) closure;
1978 register gpointer data1, data2;
1979
1980 g_return_if_fail (n_param_values == 3);
1981
1982 if (G_CCLOSURE_SWAP_DATA (closure))
1983 {
1984 data1 = closure->data;
1985 data2 = g_value_peek_pointer (param_values + 0);
1986 }
1987 else
1988 {
1989 data1 = g_value_peek_pointer (param_values + 0);
1990 data2 = closure->data;
1991 }
1992 callback = (GMarshalFunc_VOID__POINTER_POINTER) (marshal_data ? marshal_data : cc->callback);
1993
1994 callback (data1,
1995 g_marshal_value_peek_pointer (param_values + 1),
1996 g_marshal_value_peek_pointer (param_values + 2),
1997 data2);
1998 }
1999
2000 /* VOID:POINTER,POINTER,POINTER (./rb-marshal.list:44) */
2001 extern void rb_marshal_VOID__POINTER_POINTER_POINTER (GClosure *closure,
2002 GValue *return_value,
2003 guint n_param_values,
2004 const GValue *param_values,
2005 gpointer invocation_hint,
2006 gpointer marshal_data);
2007 void
2008 rb_marshal_VOID__POINTER_POINTER_POINTER (GClosure *closure,
2009 GValue *return_value G_GNUC_UNUSED,
2010 guint n_param_values,
2011 const GValue *param_values,
2012 gpointer invocation_hint G_GNUC_UNUSED,
2013 gpointer marshal_data)
2014 {
2015 typedef void (*GMarshalFunc_VOID__POINTER_POINTER_POINTER) (gpointer data1,
2016 gpointer arg_1,
2017 gpointer arg_2,
2018 gpointer arg_3,
2019 gpointer data2);
2020 register GMarshalFunc_VOID__POINTER_POINTER_POINTER callback;
2021 register GCClosure *cc = (GCClosure*) closure;
2022 register gpointer data1, data2;
2023
2024 g_return_if_fail (n_param_values == 4);
2025
2026 if (G_CCLOSURE_SWAP_DATA (closure))
2027 {
2028 data1 = closure->data;
2029 data2 = g_value_peek_pointer (param_values + 0);
2030 }
2031 else
2032 {
2033 data1 = g_value_peek_pointer (param_values + 0);
2034 data2 = closure->data;
2035 }
2036 callback = (GMarshalFunc_VOID__POINTER_POINTER_POINTER) (marshal_data ? marshal_data : cc->callback);
2037
2038 callback (data1,
2039 g_marshal_value_peek_pointer (param_values + 1),
2040 g_marshal_value_peek_pointer (param_values + 2),
2041 g_marshal_value_peek_pointer (param_values + 3),
2042 data2);
2043 }
2044
2045 /* VOID:POINTER,STRING (./rb-marshal.list:45) */
2046 extern void rb_marshal_VOID__POINTER_STRING (GClosure *closure,
2047 GValue *return_value,
2048 guint n_param_values,
2049 const GValue *param_values,
2050 gpointer invocation_hint,
2051 gpointer marshal_data);
2052 void
2053 rb_marshal_VOID__POINTER_STRING (GClosure *closure,
2054 GValue *return_value G_GNUC_UNUSED,
2055 guint n_param_values,
2056 const GValue *param_values,
2057 gpointer invocation_hint G_GNUC_UNUSED,
2058 gpointer marshal_data)
2059 {
2060 typedef void (*GMarshalFunc_VOID__POINTER_STRING) (gpointer data1,
2061 gpointer arg_1,
2062 gpointer arg_2,
2063 gpointer data2);
2064 register GMarshalFunc_VOID__POINTER_STRING callback;
2065 register GCClosure *cc = (GCClosure*) closure;
2066 register gpointer data1, data2;
2067
2068 g_return_if_fail (n_param_values == 3);
2069
2070 if (G_CCLOSURE_SWAP_DATA (closure))
2071 {
2072 data1 = closure->data;
2073 data2 = g_value_peek_pointer (param_values + 0);
2074 }
2075 else
2076 {
2077 data1 = g_value_peek_pointer (param_values + 0);
2078 data2 = closure->data;
2079 }
2080 callback = (GMarshalFunc_VOID__POINTER_STRING) (marshal_data ? marshal_data : cc->callback);
2081
2082 callback (data1,
2083 g_marshal_value_peek_pointer (param_values + 1),
2084 g_marshal_value_peek_string (param_values + 2),
2085 data2);
2086 }
2087
2088 /* VOID:POINTER,UINT (./rb-marshal.list:46) */
2089 extern void rb_marshal_VOID__POINTER_UINT (GClosure *closure,
2090 GValue *return_value,
2091 guint n_param_values,
2092 const GValue *param_values,
2093 gpointer invocation_hint,
2094 gpointer marshal_data);
2095 void
2096 rb_marshal_VOID__POINTER_UINT (GClosure *closure,
2097 GValue *return_value G_GNUC_UNUSED,
2098 guint n_param_values,
2099 const GValue *param_values,
2100 gpointer invocation_hint G_GNUC_UNUSED,
2101 gpointer marshal_data)
2102 {
2103 typedef void (*GMarshalFunc_VOID__POINTER_UINT) (gpointer data1,
2104 gpointer arg_1,
2105 guint arg_2,
2106 gpointer data2);
2107 register GMarshalFunc_VOID__POINTER_UINT callback;
2108 register GCClosure *cc = (GCClosure*) closure;
2109 register gpointer data1, data2;
2110
2111 g_return_if_fail (n_param_values == 3);
2112
2113 if (G_CCLOSURE_SWAP_DATA (closure))
2114 {
2115 data1 = closure->data;
2116 data2 = g_value_peek_pointer (param_values + 0);
2117 }
2118 else
2119 {
2120 data1 = g_value_peek_pointer (param_values + 0);
2121 data2 = closure->data;
2122 }
2123 callback = (GMarshalFunc_VOID__POINTER_UINT) (marshal_data ? marshal_data : cc->callback);
2124
2125 callback (data1,
2126 g_marshal_value_peek_pointer (param_values + 1),
2127 g_marshal_value_peek_uint (param_values + 2),
2128 data2);
2129 }
2130
2131 /* VOID:POINTER,ULONG (./rb-marshal.list:47) */
2132 extern void rb_marshal_VOID__POINTER_ULONG (GClosure *closure,
2133 GValue *return_value,
2134 guint n_param_values,
2135 const GValue *param_values,
2136 gpointer invocation_hint,
2137 gpointer marshal_data);
2138 void
2139 rb_marshal_VOID__POINTER_ULONG (GClosure *closure,
2140 GValue *return_value G_GNUC_UNUSED,
2141 guint n_param_values,
2142 const GValue *param_values,
2143 gpointer invocation_hint G_GNUC_UNUSED,
2144 gpointer marshal_data)
2145 {
2146 typedef void (*GMarshalFunc_VOID__POINTER_ULONG) (gpointer data1,
2147 gpointer arg_1,
2148 gulong arg_2,
2149 gpointer data2);
2150 register GMarshalFunc_VOID__POINTER_ULONG callback;
2151 register GCClosure *cc = (GCClosure*) closure;
2152 register gpointer data1, data2;
2153
2154 g_return_if_fail (n_param_values == 3);
2155
2156 if (G_CCLOSURE_SWAP_DATA (closure))
2157 {
2158 data1 = closure->data;
2159 data2 = g_value_peek_pointer (param_values + 0);
2160 }
2161 else
2162 {
2163 data1 = g_value_peek_pointer (param_values + 0);
2164 data2 = closure->data;
2165 }
2166 callback = (GMarshalFunc_VOID__POINTER_ULONG) (marshal_data ? marshal_data : cc->callback);
2167
2168 callback (data1,
2169 g_marshal_value_peek_pointer (param_values + 1),
2170 g_marshal_value_peek_ulong (param_values + 2),
2171 data2);
2172 }
2173
2174 /* VOID:STRING,DOUBLE (./rb-marshal.list:48) */
2175 extern void rb_marshal_VOID__STRING_DOUBLE (GClosure *closure,
2176 GValue *return_value,
2177 guint n_param_values,
2178 const GValue *param_values,
2179 gpointer invocation_hint,
2180 gpointer marshal_data);
2181 void
2182 rb_marshal_VOID__STRING_DOUBLE (GClosure *closure,
2183 GValue *return_value G_GNUC_UNUSED,
2184 guint n_param_values,
2185 const GValue *param_values,
2186 gpointer invocation_hint G_GNUC_UNUSED,
2187 gpointer marshal_data)
2188 {
2189 typedef void (*GMarshalFunc_VOID__STRING_DOUBLE) (gpointer data1,
2190 gpointer arg_1,
2191 gdouble arg_2,
2192 gpointer data2);
2193 register GMarshalFunc_VOID__STRING_DOUBLE callback;
2194 register GCClosure *cc = (GCClosure*) closure;
2195 register gpointer data1, data2;
2196
2197 g_return_if_fail (n_param_values == 3);
2198
2199 if (G_CCLOSURE_SWAP_DATA (closure))
2200 {
2201 data1 = closure->data;
2202 data2 = g_value_peek_pointer (param_values + 0);
2203 }
2204 else
2205 {
2206 data1 = g_value_peek_pointer (param_values + 0);
2207 data2 = closure->data;
2208 }
2209 callback = (GMarshalFunc_VOID__STRING_DOUBLE) (marshal_data ? marshal_data : cc->callback);
2210
2211 callback (data1,
2212 g_marshal_value_peek_string (param_values + 1),
2213 g_marshal_value_peek_double (param_values + 2),
2214 data2);
2215 }
2216
2217 /* VOID:STRING,INT (./rb-marshal.list:49) */
2218 extern void rb_marshal_VOID__STRING_INT (GClosure *closure,
2219 GValue *return_value,
2220 guint n_param_values,
2221 const GValue *param_values,
2222 gpointer invocation_hint,
2223 gpointer marshal_data);
2224 void
2225 rb_marshal_VOID__STRING_INT (GClosure *closure,
2226 GValue *return_value G_GNUC_UNUSED,
2227 guint n_param_values,
2228 const GValue *param_values,
2229 gpointer invocation_hint G_GNUC_UNUSED,
2230 gpointer marshal_data)
2231 {
2232 typedef void (*GMarshalFunc_VOID__STRING_INT) (gpointer data1,
2233 gpointer arg_1,
2234 gint arg_2,
2235 gpointer data2);
2236 register GMarshalFunc_VOID__STRING_INT callback;
2237 register GCClosure *cc = (GCClosure*) closure;
2238 register gpointer data1, data2;
2239
2240 g_return_if_fail (n_param_values == 3);
2241
2242 if (G_CCLOSURE_SWAP_DATA (closure))
2243 {
2244 data1 = closure->data;
2245 data2 = g_value_peek_pointer (param_values + 0);
2246 }
2247 else
2248 {
2249 data1 = g_value_peek_pointer (param_values + 0);
2250 data2 = closure->data;
2251 }
2252 callback = (GMarshalFunc_VOID__STRING_INT) (marshal_data ? marshal_data : cc->callback);
2253
2254 callback (data1,
2255 g_marshal_value_peek_string (param_values + 1),
2256 g_marshal_value_peek_int (param_values + 2),
2257 data2);
2258 }
2259
2260 /* VOID:STRING,OBJECT (./rb-marshal.list:50) */
2261 extern void rb_marshal_VOID__STRING_OBJECT (GClosure *closure,
2262 GValue *return_value,
2263 guint n_param_values,
2264 const GValue *param_values,
2265 gpointer invocation_hint,
2266 gpointer marshal_data);
2267 void
2268 rb_marshal_VOID__STRING_OBJECT (GClosure *closure,
2269 GValue *return_value G_GNUC_UNUSED,
2270 guint n_param_values,
2271 const GValue *param_values,
2272 gpointer invocation_hint G_GNUC_UNUSED,
2273 gpointer marshal_data)
2274 {
2275 typedef void (*GMarshalFunc_VOID__STRING_OBJECT) (gpointer data1,
2276 gpointer arg_1,
2277 gpointer arg_2,
2278 gpointer data2);
2279 register GMarshalFunc_VOID__STRING_OBJECT callback;
2280 register GCClosure *cc = (GCClosure*) closure;
2281 register gpointer data1, data2;
2282
2283 g_return_if_fail (n_param_values == 3);
2284
2285 if (G_CCLOSURE_SWAP_DATA (closure))
2286 {
2287 data1 = closure->data;
2288 data2 = g_value_peek_pointer (param_values + 0);
2289 }
2290 else
2291 {
2292 data1 = g_value_peek_pointer (param_values + 0);
2293 data2 = closure->data;
2294 }
2295 callback = (GMarshalFunc_VOID__STRING_OBJECT) (marshal_data ? marshal_data : cc->callback);
2296
2297 callback (data1,
2298 g_marshal_value_peek_string (param_values + 1),
2299 g_marshal_value_peek_object (param_values + 2),
2300 data2);
2301 }
2302
2303 /* VOID:STRING,POINTER (./rb-marshal.list:51) */
2304 extern void rb_marshal_VOID__STRING_POINTER (GClosure *closure,
2305 GValue *return_value,
2306 guint n_param_values,
2307 const GValue *param_values,
2308 gpointer invocation_hint,
2309 gpointer marshal_data);
2310 void
2311 rb_marshal_VOID__STRING_POINTER (GClosure *closure,
2312 GValue *return_value G_GNUC_UNUSED,
2313 guint n_param_values,
2314 const GValue *param_values,
2315 gpointer invocation_hint G_GNUC_UNUSED,
2316 gpointer marshal_data)
2317 {
2318 typedef void (*GMarshalFunc_VOID__STRING_POINTER) (gpointer data1,
2319 gpointer arg_1,
2320 gpointer arg_2,
2321 gpointer data2);
2322 register GMarshalFunc_VOID__STRING_POINTER callback;
2323 register GCClosure *cc = (GCClosure*) closure;
2324 register gpointer data1, data2;
2325
2326 g_return_if_fail (n_param_values == 3);
2327
2328 if (G_CCLOSURE_SWAP_DATA (closure))
2329 {
2330 data1 = closure->data;
2331 data2 = g_value_peek_pointer (param_values + 0);
2332 }
2333 else
2334 {
2335 data1 = g_value_peek_pointer (param_values + 0);
2336 data2 = closure->data;
2337 }
2338 callback = (GMarshalFunc_VOID__STRING_POINTER) (marshal_data ? marshal_data : cc->callback);
2339
2340 callback (data1,
2341 g_marshal_value_peek_string (param_values + 1),
2342 g_marshal_value_peek_pointer (param_values + 2),
2343 data2);
2344 }
2345
2346 /* VOID:STRING,STRING (./rb-marshal.list:52) */
2347 extern void rb_marshal_VOID__STRING_STRING (GClosure *closure,
2348 GValue *return_value,
2349 guint n_param_values,
2350 const GValue *param_values,
2351 gpointer invocation_hint,
2352 gpointer marshal_data);
2353 void
2354 rb_marshal_VOID__STRING_STRING (GClosure *closure,
2355 GValue *return_value G_GNUC_UNUSED,
2356 guint n_param_values,
2357 const GValue *param_values,
2358 gpointer invocation_hint G_GNUC_UNUSED,
2359 gpointer marshal_data)
2360 {
2361 typedef void (*GMarshalFunc_VOID__STRING_STRING) (gpointer data1,
2362 gpointer arg_1,
2363 gpointer arg_2,
2364 gpointer data2);
2365 register GMarshalFunc_VOID__STRING_STRING callback;
2366 register GCClosure *cc = (GCClosure*) closure;
2367 register gpointer data1, data2;
2368
2369 g_return_if_fail (n_param_values == 3);
2370
2371 if (G_CCLOSURE_SWAP_DATA (closure))
2372 {
2373 data1 = closure->data;
2374 data2 = g_value_peek_pointer (param_values + 0);
2375 }
2376 else
2377 {
2378 data1 = g_value_peek_pointer (param_values + 0);
2379 data2 = closure->data;
2380 }
2381 callback = (GMarshalFunc_VOID__STRING_STRING) (marshal_data ? marshal_data : cc->callback);
2382
2383 callback (data1,
2384 g_marshal_value_peek_string (param_values + 1),
2385 g_marshal_value_peek_string (param_values + 2),
2386 data2);
2387 }
2388
2389 /* VOID:STRING,STRING,OBJECT (./rb-marshal.list:53) */
2390 extern void rb_marshal_VOID__STRING_STRING_OBJECT (GClosure *closure,
2391 GValue *return_value,
2392 guint n_param_values,
2393 const GValue *param_values,
2394 gpointer invocation_hint,
2395 gpointer marshal_data);
2396 void
2397 rb_marshal_VOID__STRING_STRING_OBJECT (GClosure *closure,
2398 GValue *return_value G_GNUC_UNUSED,
2399 guint n_param_values,
2400 const GValue *param_values,
2401 gpointer invocation_hint G_GNUC_UNUSED,
2402 gpointer marshal_data)
2403 {
2404 typedef void (*GMarshalFunc_VOID__STRING_STRING_OBJECT) (gpointer data1,
2405 gpointer arg_1,
2406 gpointer arg_2,
2407 gpointer arg_3,
2408 gpointer data2);
2409 register GMarshalFunc_VOID__STRING_STRING_OBJECT callback;
2410 register GCClosure *cc = (GCClosure*) closure;
2411 register gpointer data1, data2;
2412
2413 g_return_if_fail (n_param_values == 4);
2414
2415 if (G_CCLOSURE_SWAP_DATA (closure))
2416 {
2417 data1 = closure->data;
2418 data2 = g_value_peek_pointer (param_values + 0);
2419 }
2420 else
2421 {
2422 data1 = g_value_peek_pointer (param_values + 0);
2423 data2 = closure->data;
2424 }
2425 callback = (GMarshalFunc_VOID__STRING_STRING_OBJECT) (marshal_data ? marshal_data : cc->callback);
2426
2427 callback (data1,
2428 g_marshal_value_peek_string (param_values + 1),
2429 g_marshal_value_peek_string (param_values + 2),
2430 g_marshal_value_peek_object (param_values + 3),
2431 data2);
2432 }
2433
2434 /* VOID:STRING,STRING,STRING (./rb-marshal.list:54) */
2435 extern void rb_marshal_VOID__STRING_STRING_STRING (GClosure *closure,
2436 GValue *return_value,
2437 guint n_param_values,
2438 const GValue *param_values,
2439 gpointer invocation_hint,
2440 gpointer marshal_data);
2441 void
2442 rb_marshal_VOID__STRING_STRING_STRING (GClosure *closure,
2443 GValue *return_value G_GNUC_UNUSED,
2444 guint n_param_values,
2445 const GValue *param_values,
2446 gpointer invocation_hint G_GNUC_UNUSED,
2447 gpointer marshal_data)
2448 {
2449 typedef void (*GMarshalFunc_VOID__STRING_STRING_STRING) (gpointer data1,
2450 gpointer arg_1,
2451 gpointer arg_2,
2452 gpointer arg_3,
2453 gpointer data2);
2454 register GMarshalFunc_VOID__STRING_STRING_STRING callback;
2455 register GCClosure *cc = (GCClosure*) closure;
2456 register gpointer data1, data2;
2457
2458 g_return_if_fail (n_param_values == 4);
2459
2460 if (G_CCLOSURE_SWAP_DATA (closure))
2461 {
2462 data1 = closure->data;
2463 data2 = g_value_peek_pointer (param_values + 0);
2464 }
2465 else
2466 {
2467 data1 = g_value_peek_pointer (param_values + 0);
2468 data2 = closure->data;
2469 }
2470 callback = (GMarshalFunc_VOID__STRING_STRING_STRING) (marshal_data ? marshal_data : cc->callback);
2471
2472 callback (data1,
2473 g_marshal_value_peek_string (param_values + 1),
2474 g_marshal_value_peek_string (param_values + 2),
2475 g_marshal_value_peek_string (param_values + 3),
2476 data2);
2477 }
2478
2479 /* VOID:STRING,STRING,STRING,UINT,BOOLEAN (./rb-marshal.list:55) */
2480 extern void rb_marshal_VOID__STRING_STRING_STRING_UINT_BOOLEAN (GClosure *closure,
2481 GValue *return_value,
2482 guint n_param_values,
2483 const GValue *param_values,
2484 gpointer invocation_hint,
2485 gpointer marshal_data);
2486 void
2487 rb_marshal_VOID__STRING_STRING_STRING_UINT_BOOLEAN (GClosure *closure,
2488 GValue *return_value G_GNUC_UNUSED,
2489 guint n_param_values,
2490 const GValue *param_values,
2491 gpointer invocation_hint G_GNUC_UNUSED,
2492 gpointer marshal_data)
2493 {
2494 typedef void (*GMarshalFunc_VOID__STRING_STRING_STRING_UINT_BOOLEAN) (gpointer data1,
2495 gpointer arg_1,
2496 gpointer arg_2,
2497 gpointer arg_3,
2498 guint arg_4,
2499 gboolean arg_5,
2500 gpointer data2);
2501 register GMarshalFunc_VOID__STRING_STRING_STRING_UINT_BOOLEAN callback;
2502 register GCClosure *cc = (GCClosure*) closure;
2503 register gpointer data1, data2;
2504
2505 g_return_if_fail (n_param_values == 6);
2506
2507 if (G_CCLOSURE_SWAP_DATA (closure))
2508 {
2509 data1 = closure->data;
2510 data2 = g_value_peek_pointer (param_values + 0);
2511 }
2512 else
2513 {
2514 data1 = g_value_peek_pointer (param_values + 0);
2515 data2 = closure->data;
2516 }
2517 callback = (GMarshalFunc_VOID__STRING_STRING_STRING_UINT_BOOLEAN) (marshal_data ? marshal_data : cc->callback);
2518
2519 callback (data1,
2520 g_marshal_value_peek_string (param_values + 1),
2521 g_marshal_value_peek_string (param_values + 2),
2522 g_marshal_value_peek_string (param_values + 3),
2523 g_marshal_value_peek_uint (param_values + 4),
2524 g_marshal_value_peek_boolean (param_values + 5),
2525 data2);
2526 }
2527
2528 /* VOID:UINT,STRING,STRING,STRING,BOOLEAN (./rb-marshal.list:56) */
2529 extern void rb_marshal_VOID__UINT_STRING_STRING_STRING_BOOLEAN (GClosure *closure,
2530 GValue *return_value,
2531 guint n_param_values,
2532 const GValue *param_values,
2533 gpointer invocation_hint,
2534 gpointer marshal_data);
2535 void
2536 rb_marshal_VOID__UINT_STRING_STRING_STRING_BOOLEAN (GClosure *closure,
2537 GValue *return_value G_GNUC_UNUSED,
2538 guint n_param_values,
2539 const GValue *param_values,
2540 gpointer invocation_hint G_GNUC_UNUSED,
2541 gpointer marshal_data)
2542 {
2543 typedef void (*GMarshalFunc_VOID__UINT_STRING_STRING_STRING_BOOLEAN) (gpointer data1,
2544 guint arg_1,
2545 gpointer arg_2,
2546 gpointer arg_3,
2547 gpointer arg_4,
2548 gboolean arg_5,
2549 gpointer data2);
2550 register GMarshalFunc_VOID__UINT_STRING_STRING_STRING_BOOLEAN callback;
2551 register GCClosure *cc = (GCClosure*) closure;
2552 register gpointer data1, data2;
2553
2554 g_return_if_fail (n_param_values == 6);
2555
2556 if (G_CCLOSURE_SWAP_DATA (closure))
2557 {
2558 data1 = closure->data;
2559 data2 = g_value_peek_pointer (param_values + 0);
2560 }
2561 else
2562 {
2563 data1 = g_value_peek_pointer (param_values + 0);
2564 data2 = closure->data;
2565 }
2566 callback = (GMarshalFunc_VOID__UINT_STRING_STRING_STRING_BOOLEAN) (marshal_data ? marshal_data : cc->callback);
2567
2568 callback (data1,
2569 g_marshal_value_peek_uint (param_values + 1),
2570 g_marshal_value_peek_string (param_values + 2),
2571 g_marshal_value_peek_string (param_values + 3),
2572 g_marshal_value_peek_string (param_values + 4),
2573 g_marshal_value_peek_boolean (param_values + 5),
2574 data2);
2575 }
2576
2577 /* VOID:UINT64 (./rb-marshal.list:57) */
2578 extern void rb_marshal_VOID__UINT64 (GClosure *closure,
2579 GValue *return_value,
2580 guint n_param_values,
2581 const GValue *param_values,
2582 gpointer invocation_hint,
2583 gpointer marshal_data);
2584 void
2585 rb_marshal_VOID__UINT64 (GClosure *closure,
2586 GValue *return_value G_GNUC_UNUSED,
2587 guint n_param_values,
2588 const GValue *param_values,
2589 gpointer invocation_hint G_GNUC_UNUSED,
2590 gpointer marshal_data)
2591 {
2592 typedef void (*GMarshalFunc_VOID__UINT64) (gpointer data1,
2593 guint64 arg_1,
2594 gpointer data2);
2595 register GMarshalFunc_VOID__UINT64 callback;
2596 register GCClosure *cc = (GCClosure*) closure;
2597 register gpointer data1, data2;
2598
2599 g_return_if_fail (n_param_values == 2);
2600
2601 if (G_CCLOSURE_SWAP_DATA (closure))
2602 {
2603 data1 = closure->data;
2604 data2 = g_value_peek_pointer (param_values + 0);
2605 }
2606 else
2607 {
2608 data1 = g_value_peek_pointer (param_values + 0);
2609 data2 = closure->data;
2610 }
2611 callback = (GMarshalFunc_VOID__UINT64) (marshal_data ? marshal_data : cc->callback);
2612
2613 callback (data1,
2614 g_marshal_value_peek_uint64 (param_values + 1),
2615 data2);
2616 }
2617
2618 /* VOID:UINT64,STRING,POINTER (./rb-marshal.list:58) */
2619 extern void rb_marshal_VOID__UINT64_STRING_POINTER (GClosure *closure,
2620 GValue *return_value,
2621 guint n_param_values,
2622 const GValue *param_values,
2623 gpointer invocation_hint,
2624 gpointer marshal_data);
2625 void
2626 rb_marshal_VOID__UINT64_STRING_POINTER (GClosure *closure,
2627 GValue *return_value G_GNUC_UNUSED,
2628 guint n_param_values,
2629 const GValue *param_values,
2630 gpointer invocation_hint G_GNUC_UNUSED,
2631 gpointer marshal_data)
2632 {
2633 typedef void (*GMarshalFunc_VOID__UINT64_STRING_POINTER) (gpointer data1,
2634 guint64 arg_1,
2635 gpointer arg_2,
2636 gpointer arg_3,
2637 gpointer data2);
2638 register GMarshalFunc_VOID__UINT64_STRING_POINTER callback;
2639 register GCClosure *cc = (GCClosure*) closure;
2640 register gpointer data1, data2;
2641
2642 g_return_if_fail (n_param_values == 4);
2643
2644 if (G_CCLOSURE_SWAP_DATA (closure))
2645 {
2646 data1 = closure->data;
2647 data2 = g_value_peek_pointer (param_values + 0);
2648 }
2649 else
2650 {
2651 data1 = g_value_peek_pointer (param_values + 0);
2652 data2 = closure->data;
2653 }
2654 callback = (GMarshalFunc_VOID__UINT64_STRING_POINTER) (marshal_data ? marshal_data : cc->callback);
2655
2656 callback (data1,
2657 g_marshal_value_peek_uint64 (param_values + 1),
2658 g_marshal_value_peek_string (param_values + 2),
2659 g_marshal_value_peek_pointer (param_values + 3),
2660 data2);
2661 }
2662
2663 /* VOID:ULONG,FLOAT (./rb-marshal.list:59) */
2664 extern void rb_marshal_VOID__ULONG_FLOAT (GClosure *closure,
2665 GValue *return_value,
2666 guint n_param_values,
2667 const GValue *param_values,
2668 gpointer invocation_hint,
2669 gpointer marshal_data);
2670 void
2671 rb_marshal_VOID__ULONG_FLOAT (GClosure *closure,
2672 GValue *return_value G_GNUC_UNUSED,
2673 guint n_param_values,
2674 const GValue *param_values,
2675 gpointer invocation_hint G_GNUC_UNUSED,
2676 gpointer marshal_data)
2677 {
2678 typedef void (*GMarshalFunc_VOID__ULONG_FLOAT) (gpointer data1,
2679 gulong arg_1,
2680 gfloat arg_2,
2681 gpointer data2);
2682 register GMarshalFunc_VOID__ULONG_FLOAT callback;
2683 register GCClosure *cc = (GCClosure*) closure;
2684 register gpointer data1, data2;
2685
2686 g_return_if_fail (n_param_values == 3);
2687
2688 if (G_CCLOSURE_SWAP_DATA (closure))
2689 {
2690 data1 = closure->data;
2691 data2 = g_value_peek_pointer (param_values + 0);
2692 }
2693 else
2694 {
2695 data1 = g_value_peek_pointer (param_values + 0);
2696 data2 = closure->data;
2697 }
2698 callback = (GMarshalFunc_VOID__ULONG_FLOAT) (marshal_data ? marshal_data : cc->callback);
2699
2700 callback (data1,
2701 g_marshal_value_peek_ulong (param_values + 1),
2702 g_marshal_value_peek_float (param_values + 2),
2703 data2);
2704 }
2705
2706 /* VOID:OBJECT,BOOLEAN (./rb-marshal.list:60) */
2707 extern void rb_marshal_VOID__OBJECT_BOOLEAN (GClosure *closure,
2708 GValue *return_value,
2709 guint n_param_values,
2710 const GValue *param_values,
2711 gpointer invocation_hint,
2712 gpointer marshal_data);
2713 void
2714 rb_marshal_VOID__OBJECT_BOOLEAN (GClosure *closure,
2715 GValue *return_value G_GNUC_UNUSED,
2716 guint n_param_values,
2717 const GValue *param_values,
2718 gpointer invocation_hint G_GNUC_UNUSED,
2719 gpointer marshal_data)
2720 {
2721 typedef void (*GMarshalFunc_VOID__OBJECT_BOOLEAN) (gpointer data1,
2722 gpointer arg_1,
2723 gboolean arg_2,
2724 gpointer data2);
2725 register GMarshalFunc_VOID__OBJECT_BOOLEAN callback;
2726 register GCClosure *cc = (GCClosure*) closure;
2727 register gpointer data1, data2;
2728
2729 g_return_if_fail (n_param_values == 3);
2730
2731 if (G_CCLOSURE_SWAP_DATA (closure))
2732 {
2733 data1 = closure->data;
2734 data2 = g_value_peek_pointer (param_values + 0);
2735 }
2736 else
2737 {
2738 data1 = g_value_peek_pointer (param_values + 0);
2739 data2 = closure->data;
2740 }
2741 callback = (GMarshalFunc_VOID__OBJECT_BOOLEAN) (marshal_data ? marshal_data : cc->callback);
2742
2743 callback (data1,
2744 g_marshal_value_peek_object (param_values + 1),
2745 g_marshal_value_peek_boolean (param_values + 2),
2746 data2);
2747 }
2748
2749 /* VOID:STRING,STRING,POINTER,POINTER (./rb-marshal.list:61) */
2750 extern void rb_marshal_VOID__STRING_STRING_POINTER_POINTER (GClosure *closure,
2751 GValue *return_value,
2752 guint n_param_values,
2753 const GValue *param_values,
2754 gpointer invocation_hint,
2755 gpointer marshal_data);
2756 void
2757 rb_marshal_VOID__STRING_STRING_POINTER_POINTER (GClosure *closure,
2758 GValue *return_value G_GNUC_UNUSED,
2759 guint n_param_values,
2760 const GValue *param_values,
2761 gpointer invocation_hint G_GNUC_UNUSED,
2762 gpointer marshal_data)
2763 {
2764 typedef void (*GMarshalFunc_VOID__STRING_STRING_POINTER_POINTER) (gpointer data1,
2765 gpointer arg_1,
2766 gpointer arg_2,
2767 gpointer arg_3,
2768 gpointer arg_4,
2769 gpointer data2);
2770 register GMarshalFunc_VOID__STRING_STRING_POINTER_POINTER callback;
2771 register GCClosure *cc = (GCClosure*) closure;
2772 register gpointer data1, data2;
2773
2774 g_return_if_fail (n_param_values == 5);
2775
2776 if (G_CCLOSURE_SWAP_DATA (closure))
2777 {
2778 data1 = closure->data;
2779 data2 = g_value_peek_pointer (param_values + 0);
2780 }
2781 else
2782 {
2783 data1 = g_value_peek_pointer (param_values + 0);
2784 data2 = closure->data;
2785 }
2786 callback = (GMarshalFunc_VOID__STRING_STRING_POINTER_POINTER) (marshal_data ? marshal_data : cc->callback);
2787
2788 callback (data1,
2789 g_marshal_value_peek_string (param_values + 1),
2790 g_marshal_value_peek_string (param_values + 2),
2791 g_marshal_value_peek_pointer (param_values + 3),
2792 g_marshal_value_peek_pointer (param_values + 4),
2793 data2);
2794 }
2795
2796 /* VOID:STRING,UINT,UINT,STRING (./rb-marshal.list:62) */
2797 extern void rb_marshal_VOID__STRING_UINT_UINT_STRING (GClosure *closure,
2798 GValue *return_value,
2799 guint n_param_values,
2800 const GValue *param_values,
2801 gpointer invocation_hint,
2802 gpointer marshal_data);
2803 void
2804 rb_marshal_VOID__STRING_UINT_UINT_STRING (GClosure *closure,
2805 GValue *return_value G_GNUC_UNUSED,
2806 guint n_param_values,
2807 const GValue *param_values,
2808 gpointer invocation_hint G_GNUC_UNUSED,
2809 gpointer marshal_data)
2810 {
2811 typedef void (*GMarshalFunc_VOID__STRING_UINT_UINT_STRING) (gpointer data1,
2812 gpointer arg_1,
2813 guint arg_2,
2814 guint arg_3,
2815 gpointer arg_4,
2816 gpointer data2);
2817 register GMarshalFunc_VOID__STRING_UINT_UINT_STRING callback;
2818 register GCClosure *cc = (GCClosure*) closure;
2819 register gpointer data1, data2;
2820
2821 g_return_if_fail (n_param_values == 5);
2822
2823 if (G_CCLOSURE_SWAP_DATA (closure))
2824 {
2825 data1 = closure->data;
2826 data2 = g_value_peek_pointer (param_values + 0);
2827 }
2828 else
2829 {
2830 data1 = g_value_peek_pointer (param_values + 0);
2831 data2 = closure->data;
2832 }
2833 callback = (GMarshalFunc_VOID__STRING_UINT_UINT_STRING) (marshal_data ? marshal_data : cc->callback);
2834
2835 callback (data1,
2836 g_marshal_value_peek_string (param_values + 1),
2837 g_marshal_value_peek_uint (param_values + 2),
2838 g_marshal_value_peek_uint (param_values + 3),
2839 g_marshal_value_peek_string (param_values + 4),
2840 data2);
2841 }
2842
2843 G_END_DECLS
2844
2845 #endif /* __rb_marshal_MARSHAL_H__ */