No issues found
| Tool | Failure ID | Location | Function | Message | Data |
|---|---|---|---|---|---|
| clang-analyzer | no-output-found | ../../src/libtracker-miner/tracker-marshal.c | Message(text='Unable to locate XML output from invoke-clang-analyzer') | None | |
| clang-analyzer | no-output-found | ../../src/libtracker-miner/tracker-marshal.c | Message(text='Unable to locate XML output from invoke-clang-analyzer') | None |
1 #include "tracker-marshal.h"
2
3 #include <glib-object.h>
4
5
6 #ifdef G_ENABLE_DEBUG
7 #define g_marshal_value_peek_boolean(v) g_value_get_boolean (v)
8 #define g_marshal_value_peek_char(v) g_value_get_schar (v)
9 #define g_marshal_value_peek_uchar(v) g_value_get_uchar (v)
10 #define g_marshal_value_peek_int(v) g_value_get_int (v)
11 #define g_marshal_value_peek_uint(v) g_value_get_uint (v)
12 #define g_marshal_value_peek_long(v) g_value_get_long (v)
13 #define g_marshal_value_peek_ulong(v) g_value_get_ulong (v)
14 #define g_marshal_value_peek_int64(v) g_value_get_int64 (v)
15 #define g_marshal_value_peek_uint64(v) g_value_get_uint64 (v)
16 #define g_marshal_value_peek_enum(v) g_value_get_enum (v)
17 #define g_marshal_value_peek_flags(v) g_value_get_flags (v)
18 #define g_marshal_value_peek_float(v) g_value_get_float (v)
19 #define g_marshal_value_peek_double(v) g_value_get_double (v)
20 #define g_marshal_value_peek_string(v) (char*) g_value_get_string (v)
21 #define g_marshal_value_peek_param(v) g_value_get_param (v)
22 #define g_marshal_value_peek_boxed(v) g_value_get_boxed (v)
23 #define g_marshal_value_peek_pointer(v) g_value_get_pointer (v)
24 #define g_marshal_value_peek_object(v) g_value_get_object (v)
25 #define g_marshal_value_peek_variant(v) g_value_get_variant (v)
26 #else /* !G_ENABLE_DEBUG */
27 /* WARNING: This code accesses GValues directly, which is UNSUPPORTED API.
28 * Do not access GValues directly in your code. Instead, use the
29 * g_value_get_*() functions
30 */
31 #define g_marshal_value_peek_boolean(v) (v)->data[0].v_int
32 #define g_marshal_value_peek_char(v) (v)->data[0].v_int
33 #define g_marshal_value_peek_uchar(v) (v)->data[0].v_uint
34 #define g_marshal_value_peek_int(v) (v)->data[0].v_int
35 #define g_marshal_value_peek_uint(v) (v)->data[0].v_uint
36 #define g_marshal_value_peek_long(v) (v)->data[0].v_long
37 #define g_marshal_value_peek_ulong(v) (v)->data[0].v_ulong
38 #define g_marshal_value_peek_int64(v) (v)->data[0].v_int64
39 #define g_marshal_value_peek_uint64(v) (v)->data[0].v_uint64
40 #define g_marshal_value_peek_enum(v) (v)->data[0].v_long
41 #define g_marshal_value_peek_flags(v) (v)->data[0].v_ulong
42 #define g_marshal_value_peek_float(v) (v)->data[0].v_float
43 #define g_marshal_value_peek_double(v) (v)->data[0].v_double
44 #define g_marshal_value_peek_string(v) (v)->data[0].v_pointer
45 #define g_marshal_value_peek_param(v) (v)->data[0].v_pointer
46 #define g_marshal_value_peek_boxed(v) (v)->data[0].v_pointer
47 #define g_marshal_value_peek_pointer(v) (v)->data[0].v_pointer
48 #define g_marshal_value_peek_object(v) (v)->data[0].v_pointer
49 #define g_marshal_value_peek_variant(v) (v)->data[0].v_pointer
50 #endif /* !G_ENABLE_DEBUG */
51
52
53 /* VOID:OBJECT,BOOLEAN (tracker-marshal.list:1) */
54 void
55 tracker_marshal_VOID__OBJECT_BOOLEAN (GClosure *closure,
56 GValue *return_value G_GNUC_UNUSED,
57 guint n_param_values,
58 const GValue *param_values,
59 gpointer invocation_hint G_GNUC_UNUSED,
60 gpointer marshal_data)
61 {
62 typedef void (*GMarshalFunc_VOID__OBJECT_BOOLEAN) (gpointer data1,
63 gpointer arg_1,
64 gboolean arg_2,
65 gpointer data2);
66 register GMarshalFunc_VOID__OBJECT_BOOLEAN callback;
67 register GCClosure *cc = (GCClosure*) closure;
68 register gpointer data1, data2;
69
70 g_return_if_fail (n_param_values == 3);
71
72 if (G_CCLOSURE_SWAP_DATA (closure))
73 {
74 data1 = closure->data;
75 data2 = g_value_peek_pointer (param_values + 0);
76 }
77 else
78 {
79 data1 = g_value_peek_pointer (param_values + 0);
80 data2 = closure->data;
81 }
82 callback = (GMarshalFunc_VOID__OBJECT_BOOLEAN) (marshal_data ? marshal_data : cc->callback);
83
84 callback (data1,
85 g_marshal_value_peek_object (param_values + 1),
86 g_marshal_value_peek_boolean (param_values + 2),
87 data2);
88 }
89
90 /* VOID:OBJECT,OBJECT (tracker-marshal.list:2) */
91 void
92 tracker_marshal_VOID__OBJECT_OBJECT (GClosure *closure,
93 GValue *return_value G_GNUC_UNUSED,
94 guint n_param_values,
95 const GValue *param_values,
96 gpointer invocation_hint G_GNUC_UNUSED,
97 gpointer marshal_data)
98 {
99 typedef void (*GMarshalFunc_VOID__OBJECT_OBJECT) (gpointer data1,
100 gpointer arg_1,
101 gpointer arg_2,
102 gpointer data2);
103 register GMarshalFunc_VOID__OBJECT_OBJECT callback;
104 register GCClosure *cc = (GCClosure*) closure;
105 register gpointer data1, data2;
106
107 g_return_if_fail (n_param_values == 3);
108
109 if (G_CCLOSURE_SWAP_DATA (closure))
110 {
111 data1 = closure->data;
112 data2 = g_value_peek_pointer (param_values + 0);
113 }
114 else
115 {
116 data1 = g_value_peek_pointer (param_values + 0);
117 data2 = closure->data;
118 }
119 callback = (GMarshalFunc_VOID__OBJECT_OBJECT) (marshal_data ? marshal_data : cc->callback);
120
121 callback (data1,
122 g_marshal_value_peek_object (param_values + 1),
123 g_marshal_value_peek_object (param_values + 2),
124 data2);
125 }
126
127 /* VOID:OBJECT,OBJECT,BOOLEAN,BOOLEAN (tracker-marshal.list:3) */
128 void
129 tracker_marshal_VOID__OBJECT_OBJECT_BOOLEAN_BOOLEAN (GClosure *closure,
130 GValue *return_value G_GNUC_UNUSED,
131 guint n_param_values,
132 const GValue *param_values,
133 gpointer invocation_hint G_GNUC_UNUSED,
134 gpointer marshal_data)
135 {
136 typedef void (*GMarshalFunc_VOID__OBJECT_OBJECT_BOOLEAN_BOOLEAN) (gpointer data1,
137 gpointer arg_1,
138 gpointer arg_2,
139 gboolean arg_3,
140 gboolean arg_4,
141 gpointer data2);
142 register GMarshalFunc_VOID__OBJECT_OBJECT_BOOLEAN_BOOLEAN callback;
143 register GCClosure *cc = (GCClosure*) closure;
144 register gpointer data1, data2;
145
146 g_return_if_fail (n_param_values == 5);
147
148 if (G_CCLOSURE_SWAP_DATA (closure))
149 {
150 data1 = closure->data;
151 data2 = g_value_peek_pointer (param_values + 0);
152 }
153 else
154 {
155 data1 = g_value_peek_pointer (param_values + 0);
156 data2 = closure->data;
157 }
158 callback = (GMarshalFunc_VOID__OBJECT_OBJECT_BOOLEAN_BOOLEAN) (marshal_data ? marshal_data : cc->callback);
159
160 callback (data1,
161 g_marshal_value_peek_object (param_values + 1),
162 g_marshal_value_peek_object (param_values + 2),
163 g_marshal_value_peek_boolean (param_values + 3),
164 g_marshal_value_peek_boolean (param_values + 4),
165 data2);
166 }
167
168 /* VOID:OBJECT,POINTER,UINT,UINT,UINT,UINT (tracker-marshal.list:4) */
169 void
170 tracker_marshal_VOID__OBJECT_POINTER_UINT_UINT_UINT_UINT (GClosure *closure,
171 GValue *return_value G_GNUC_UNUSED,
172 guint n_param_values,
173 const GValue *param_values,
174 gpointer invocation_hint G_GNUC_UNUSED,
175 gpointer marshal_data)
176 {
177 typedef void (*GMarshalFunc_VOID__OBJECT_POINTER_UINT_UINT_UINT_UINT) (gpointer data1,
178 gpointer arg_1,
179 gpointer arg_2,
180 guint arg_3,
181 guint arg_4,
182 guint arg_5,
183 guint arg_6,
184 gpointer data2);
185 register GMarshalFunc_VOID__OBJECT_POINTER_UINT_UINT_UINT_UINT callback;
186 register GCClosure *cc = (GCClosure*) closure;
187 register gpointer data1, data2;
188
189 g_return_if_fail (n_param_values == 7);
190
191 if (G_CCLOSURE_SWAP_DATA (closure))
192 {
193 data1 = closure->data;
194 data2 = g_value_peek_pointer (param_values + 0);
195 }
196 else
197 {
198 data1 = g_value_peek_pointer (param_values + 0);
199 data2 = closure->data;
200 }
201 callback = (GMarshalFunc_VOID__OBJECT_POINTER_UINT_UINT_UINT_UINT) (marshal_data ? marshal_data : cc->callback);
202
203 callback (data1,
204 g_marshal_value_peek_object (param_values + 1),
205 g_marshal_value_peek_pointer (param_values + 2),
206 g_marshal_value_peek_uint (param_values + 3),
207 g_marshal_value_peek_uint (param_values + 4),
208 g_marshal_value_peek_uint (param_values + 5),
209 g_marshal_value_peek_uint (param_values + 6),
210 data2);
211 }
212
213 /* VOID:OBJECT,UINT,UINT,UINT,UINT (tracker-marshal.list:5) */
214 void
215 tracker_marshal_VOID__OBJECT_UINT_UINT_UINT_UINT (GClosure *closure,
216 GValue *return_value G_GNUC_UNUSED,
217 guint n_param_values,
218 const GValue *param_values,
219 gpointer invocation_hint G_GNUC_UNUSED,
220 gpointer marshal_data)
221 {
222 typedef void (*GMarshalFunc_VOID__OBJECT_UINT_UINT_UINT_UINT) (gpointer data1,
223 gpointer arg_1,
224 guint arg_2,
225 guint arg_3,
226 guint arg_4,
227 guint arg_5,
228 gpointer data2);
229 register GMarshalFunc_VOID__OBJECT_UINT_UINT_UINT_UINT callback;
230 register GCClosure *cc = (GCClosure*) closure;
231 register gpointer data1, data2;
232
233 g_return_if_fail (n_param_values == 6);
234
235 if (G_CCLOSURE_SWAP_DATA (closure))
236 {
237 data1 = closure->data;
238 data2 = g_value_peek_pointer (param_values + 0);
239 }
240 else
241 {
242 data1 = g_value_peek_pointer (param_values + 0);
243 data2 = closure->data;
244 }
245 callback = (GMarshalFunc_VOID__OBJECT_UINT_UINT_UINT_UINT) (marshal_data ? marshal_data : cc->callback);
246
247 callback (data1,
248 g_marshal_value_peek_object (param_values + 1),
249 g_marshal_value_peek_uint (param_values + 2),
250 g_marshal_value_peek_uint (param_values + 3),
251 g_marshal_value_peek_uint (param_values + 4),
252 g_marshal_value_peek_uint (param_values + 5),
253 data2);
254 }
255
256 /* VOID:DOUBLE,UINT,UINT,UINT,UINT (tracker-marshal.list:6) */
257 void
258 tracker_marshal_VOID__DOUBLE_UINT_UINT_UINT_UINT (GClosure *closure,
259 GValue *return_value G_GNUC_UNUSED,
260 guint n_param_values,
261 const GValue *param_values,
262 gpointer invocation_hint G_GNUC_UNUSED,
263 gpointer marshal_data)
264 {
265 typedef void (*GMarshalFunc_VOID__DOUBLE_UINT_UINT_UINT_UINT) (gpointer data1,
266 gdouble arg_1,
267 guint arg_2,
268 guint arg_3,
269 guint arg_4,
270 guint arg_5,
271 gpointer data2);
272 register GMarshalFunc_VOID__DOUBLE_UINT_UINT_UINT_UINT callback;
273 register GCClosure *cc = (GCClosure*) closure;
274 register gpointer data1, data2;
275
276 g_return_if_fail (n_param_values == 6);
277
278 if (G_CCLOSURE_SWAP_DATA (closure))
279 {
280 data1 = closure->data;
281 data2 = g_value_peek_pointer (param_values + 0);
282 }
283 else
284 {
285 data1 = g_value_peek_pointer (param_values + 0);
286 data2 = closure->data;
287 }
288 callback = (GMarshalFunc_VOID__DOUBLE_UINT_UINT_UINT_UINT) (marshal_data ? marshal_data : cc->callback);
289
290 callback (data1,
291 g_marshal_value_peek_double (param_values + 1),
292 g_marshal_value_peek_uint (param_values + 2),
293 g_marshal_value_peek_uint (param_values + 3),
294 g_marshal_value_peek_uint (param_values + 4),
295 g_marshal_value_peek_uint (param_values + 5),
296 data2);
297 }
298
299 /* VOID:STRING,DOUBLE,INT (tracker-marshal.list:7) */
300 void
301 tracker_marshal_VOID__STRING_DOUBLE_INT (GClosure *closure,
302 GValue *return_value G_GNUC_UNUSED,
303 guint n_param_values,
304 const GValue *param_values,
305 gpointer invocation_hint G_GNUC_UNUSED,
306 gpointer marshal_data)
307 {
308 typedef void (*GMarshalFunc_VOID__STRING_DOUBLE_INT) (gpointer data1,
309 gpointer arg_1,
310 gdouble arg_2,
311 gint arg_3,
312 gpointer data2);
313 register GMarshalFunc_VOID__STRING_DOUBLE_INT callback;
314 register GCClosure *cc = (GCClosure*) closure;
315 register gpointer data1, data2;
316
317 g_return_if_fail (n_param_values == 4);
318
319 if (G_CCLOSURE_SWAP_DATA (closure))
320 {
321 data1 = closure->data;
322 data2 = g_value_peek_pointer (param_values + 0);
323 }
324 else
325 {
326 data1 = g_value_peek_pointer (param_values + 0);
327 data2 = closure->data;
328 }
329 callback = (GMarshalFunc_VOID__STRING_DOUBLE_INT) (marshal_data ? marshal_data : cc->callback);
330
331 callback (data1,
332 g_marshal_value_peek_string (param_values + 1),
333 g_marshal_value_peek_double (param_values + 2),
334 g_marshal_value_peek_int (param_values + 3),
335 data2);
336 }
337
338 /* VOID:STRING,STRING (tracker-marshal.list:8) */
339 void
340 tracker_marshal_VOID__STRING_STRING (GClosure *closure,
341 GValue *return_value G_GNUC_UNUSED,
342 guint n_param_values,
343 const GValue *param_values,
344 gpointer invocation_hint G_GNUC_UNUSED,
345 gpointer marshal_data)
346 {
347 typedef void (*GMarshalFunc_VOID__STRING_STRING) (gpointer data1,
348 gpointer arg_1,
349 gpointer arg_2,
350 gpointer data2);
351 register GMarshalFunc_VOID__STRING_STRING callback;
352 register GCClosure *cc = (GCClosure*) closure;
353 register gpointer data1, data2;
354
355 g_return_if_fail (n_param_values == 3);
356
357 if (G_CCLOSURE_SWAP_DATA (closure))
358 {
359 data1 = closure->data;
360 data2 = g_value_peek_pointer (param_values + 0);
361 }
362 else
363 {
364 data1 = g_value_peek_pointer (param_values + 0);
365 data2 = closure->data;
366 }
367 callback = (GMarshalFunc_VOID__STRING_STRING) (marshal_data ? marshal_data : cc->callback);
368
369 callback (data1,
370 g_marshal_value_peek_string (param_values + 1),
371 g_marshal_value_peek_string (param_values + 2),
372 data2);
373 }
374
375 /* VOID:STRING,STRING,DOUBLE,INT (tracker-marshal.list:9) */
376 void
377 tracker_marshal_VOID__STRING_STRING_DOUBLE_INT (GClosure *closure,
378 GValue *return_value G_GNUC_UNUSED,
379 guint n_param_values,
380 const GValue *param_values,
381 gpointer invocation_hint G_GNUC_UNUSED,
382 gpointer marshal_data)
383 {
384 typedef void (*GMarshalFunc_VOID__STRING_STRING_DOUBLE_INT) (gpointer data1,
385 gpointer arg_1,
386 gpointer arg_2,
387 gdouble arg_3,
388 gint arg_4,
389 gpointer data2);
390 register GMarshalFunc_VOID__STRING_STRING_DOUBLE_INT callback;
391 register GCClosure *cc = (GCClosure*) closure;
392 register gpointer data1, data2;
393
394 g_return_if_fail (n_param_values == 5);
395
396 if (G_CCLOSURE_SWAP_DATA (closure))
397 {
398 data1 = closure->data;
399 data2 = g_value_peek_pointer (param_values + 0);
400 }
401 else
402 {
403 data1 = g_value_peek_pointer (param_values + 0);
404 data2 = closure->data;
405 }
406 callback = (GMarshalFunc_VOID__STRING_STRING_DOUBLE_INT) (marshal_data ? marshal_data : cc->callback);
407
408 callback (data1,
409 g_marshal_value_peek_string (param_values + 1),
410 g_marshal_value_peek_string (param_values + 2),
411 g_marshal_value_peek_double (param_values + 3),
412 g_marshal_value_peek_int (param_values + 4),
413 data2);
414 }
415
416 /* VOID:STRING,STRING,BOOLEAN,BOOLEAN (tracker-marshal.list:10) */
417 void
418 tracker_marshal_VOID__STRING_STRING_BOOLEAN_BOOLEAN (GClosure *closure,
419 GValue *return_value G_GNUC_UNUSED,
420 guint n_param_values,
421 const GValue *param_values,
422 gpointer invocation_hint G_GNUC_UNUSED,
423 gpointer marshal_data)
424 {
425 typedef void (*GMarshalFunc_VOID__STRING_STRING_BOOLEAN_BOOLEAN) (gpointer data1,
426 gpointer arg_1,
427 gpointer arg_2,
428 gboolean arg_3,
429 gboolean arg_4,
430 gpointer data2);
431 register GMarshalFunc_VOID__STRING_STRING_BOOLEAN_BOOLEAN callback;
432 register GCClosure *cc = (GCClosure*) closure;
433 register gpointer data1, data2;
434
435 g_return_if_fail (n_param_values == 5);
436
437 if (G_CCLOSURE_SWAP_DATA (closure))
438 {
439 data1 = closure->data;
440 data2 = g_value_peek_pointer (param_values + 0);
441 }
442 else
443 {
444 data1 = g_value_peek_pointer (param_values + 0);
445 data2 = closure->data;
446 }
447 callback = (GMarshalFunc_VOID__STRING_STRING_BOOLEAN_BOOLEAN) (marshal_data ? marshal_data : cc->callback);
448
449 callback (data1,
450 g_marshal_value_peek_string (param_values + 1),
451 g_marshal_value_peek_string (param_values + 2),
452 g_marshal_value_peek_boolean (param_values + 3),
453 g_marshal_value_peek_boolean (param_values + 4),
454 data2);
455 }
456
457 /* VOID:STRING,STRING,STRING,BOOLEAN,BOOLEAN (tracker-marshal.list:11) */
458 void
459 tracker_marshal_VOID__STRING_STRING_STRING_BOOLEAN_BOOLEAN (GClosure *closure,
460 GValue *return_value G_GNUC_UNUSED,
461 guint n_param_values,
462 const GValue *param_values,
463 gpointer invocation_hint G_GNUC_UNUSED,
464 gpointer marshal_data)
465 {
466 typedef void (*GMarshalFunc_VOID__STRING_STRING_STRING_BOOLEAN_BOOLEAN) (gpointer data1,
467 gpointer arg_1,
468 gpointer arg_2,
469 gpointer arg_3,
470 gboolean arg_4,
471 gboolean arg_5,
472 gpointer data2);
473 register GMarshalFunc_VOID__STRING_STRING_STRING_BOOLEAN_BOOLEAN callback;
474 register GCClosure *cc = (GCClosure*) closure;
475 register gpointer data1, data2;
476
477 g_return_if_fail (n_param_values == 6);
478
479 if (G_CCLOSURE_SWAP_DATA (closure))
480 {
481 data1 = closure->data;
482 data2 = g_value_peek_pointer (param_values + 0);
483 }
484 else
485 {
486 data1 = g_value_peek_pointer (param_values + 0);
487 data2 = closure->data;
488 }
489 callback = (GMarshalFunc_VOID__STRING_STRING_STRING_BOOLEAN_BOOLEAN) (marshal_data ? marshal_data : cc->callback);
490
491 callback (data1,
492 g_marshal_value_peek_string (param_values + 1),
493 g_marshal_value_peek_string (param_values + 2),
494 g_marshal_value_peek_string (param_values + 3),
495 g_marshal_value_peek_boolean (param_values + 4),
496 g_marshal_value_peek_boolean (param_values + 5),
497 data2);
498 }
499
500 /* BOOL:OBJECT,OBJECT,OBJECT (tracker-marshal.list:12) */
501 void
502 tracker_marshal_BOOLEAN__OBJECT_OBJECT_OBJECT (GClosure *closure,
503 GValue *return_value G_GNUC_UNUSED,
504 guint n_param_values,
505 const GValue *param_values,
506 gpointer invocation_hint G_GNUC_UNUSED,
507 gpointer marshal_data)
508 {
509 typedef gboolean (*GMarshalFunc_BOOLEAN__OBJECT_OBJECT_OBJECT) (gpointer data1,
510 gpointer arg_1,
511 gpointer arg_2,
512 gpointer arg_3,
513 gpointer data2);
514 register GMarshalFunc_BOOLEAN__OBJECT_OBJECT_OBJECT callback;
515 register GCClosure *cc = (GCClosure*) closure;
516 register gpointer data1, data2;
517 gboolean v_return;
518
519 g_return_if_fail (return_value != NULL);
520 g_return_if_fail (n_param_values == 4);
521
522 if (G_CCLOSURE_SWAP_DATA (closure))
523 {
524 data1 = closure->data;
525 data2 = g_value_peek_pointer (param_values + 0);
526 }
527 else
528 {
529 data1 = g_value_peek_pointer (param_values + 0);
530 data2 = closure->data;
531 }
532 callback = (GMarshalFunc_BOOLEAN__OBJECT_OBJECT_OBJECT) (marshal_data ? marshal_data : cc->callback);
533
534 v_return = callback (data1,
535 g_marshal_value_peek_object (param_values + 1),
536 g_marshal_value_peek_object (param_values + 2),
537 g_marshal_value_peek_object (param_values + 3),
538 data2);
539
540 g_value_set_boolean (return_value, v_return);
541 }
542
543 /* BOOL:OBJECT,OBJECT (tracker-marshal.list:13) */
544 void
545 tracker_marshal_BOOLEAN__OBJECT_OBJECT (GClosure *closure,
546 GValue *return_value G_GNUC_UNUSED,
547 guint n_param_values,
548 const GValue *param_values,
549 gpointer invocation_hint G_GNUC_UNUSED,
550 gpointer marshal_data)
551 {
552 typedef gboolean (*GMarshalFunc_BOOLEAN__OBJECT_OBJECT) (gpointer data1,
553 gpointer arg_1,
554 gpointer arg_2,
555 gpointer data2);
556 register GMarshalFunc_BOOLEAN__OBJECT_OBJECT callback;
557 register GCClosure *cc = (GCClosure*) closure;
558 register gpointer data1, data2;
559 gboolean v_return;
560
561 g_return_if_fail (return_value != NULL);
562 g_return_if_fail (n_param_values == 3);
563
564 if (G_CCLOSURE_SWAP_DATA (closure))
565 {
566 data1 = closure->data;
567 data2 = g_value_peek_pointer (param_values + 0);
568 }
569 else
570 {
571 data1 = g_value_peek_pointer (param_values + 0);
572 data2 = closure->data;
573 }
574 callback = (GMarshalFunc_BOOLEAN__OBJECT_OBJECT) (marshal_data ? marshal_data : cc->callback);
575
576 v_return = callback (data1,
577 g_marshal_value_peek_object (param_values + 1),
578 g_marshal_value_peek_object (param_values + 2),
579 data2);
580
581 g_value_set_boolean (return_value, v_return);
582 }
583
584 /* BOOL:OBJECT,POINTER (tracker-marshal.list:14) */
585 void
586 tracker_marshal_BOOLEAN__OBJECT_POINTER (GClosure *closure,
587 GValue *return_value G_GNUC_UNUSED,
588 guint n_param_values,
589 const GValue *param_values,
590 gpointer invocation_hint G_GNUC_UNUSED,
591 gpointer marshal_data)
592 {
593 typedef gboolean (*GMarshalFunc_BOOLEAN__OBJECT_POINTER) (gpointer data1,
594 gpointer arg_1,
595 gpointer arg_2,
596 gpointer data2);
597 register GMarshalFunc_BOOLEAN__OBJECT_POINTER callback;
598 register GCClosure *cc = (GCClosure*) closure;
599 register gpointer data1, data2;
600 gboolean v_return;
601
602 g_return_if_fail (return_value != NULL);
603 g_return_if_fail (n_param_values == 3);
604
605 if (G_CCLOSURE_SWAP_DATA (closure))
606 {
607 data1 = closure->data;
608 data2 = g_value_peek_pointer (param_values + 0);
609 }
610 else
611 {
612 data1 = g_value_peek_pointer (param_values + 0);
613 data2 = closure->data;
614 }
615 callback = (GMarshalFunc_BOOLEAN__OBJECT_POINTER) (marshal_data ? marshal_data : cc->callback);
616
617 v_return = callback (data1,
618 g_marshal_value_peek_object (param_values + 1),
619 g_marshal_value_peek_pointer (param_values + 2),
620 data2);
621
622 g_value_set_boolean (return_value, v_return);
623 }
624
625 /* BOOL:OBJECT (tracker-marshal.list:15) */
626 void
627 tracker_marshal_BOOLEAN__OBJECT (GClosure *closure,
628 GValue *return_value G_GNUC_UNUSED,
629 guint n_param_values,
630 const GValue *param_values,
631 gpointer invocation_hint G_GNUC_UNUSED,
632 gpointer marshal_data)
633 {
634 typedef gboolean (*GMarshalFunc_BOOLEAN__OBJECT) (gpointer data1,
635 gpointer arg_1,
636 gpointer data2);
637 register GMarshalFunc_BOOLEAN__OBJECT callback;
638 register GCClosure *cc = (GCClosure*) closure;
639 register gpointer data1, data2;
640 gboolean v_return;
641
642 g_return_if_fail (return_value != NULL);
643 g_return_if_fail (n_param_values == 2);
644
645 if (G_CCLOSURE_SWAP_DATA (closure))
646 {
647 data1 = closure->data;
648 data2 = g_value_peek_pointer (param_values + 0);
649 }
650 else
651 {
652 data1 = g_value_peek_pointer (param_values + 0);
653 data2 = closure->data;
654 }
655 callback = (GMarshalFunc_BOOLEAN__OBJECT) (marshal_data ? marshal_data : cc->callback);
656
657 v_return = callback (data1,
658 g_marshal_value_peek_object (param_values + 1),
659 data2);
660
661 g_value_set_boolean (return_value, v_return);
662 }
663
664 /* BOOL:OBJECT,BOXED,BOXED,OBJECT (tracker-marshal.list:16) */
665 void
666 tracker_marshal_BOOLEAN__OBJECT_BOXED_BOXED_OBJECT (GClosure *closure,
667 GValue *return_value G_GNUC_UNUSED,
668 guint n_param_values,
669 const GValue *param_values,
670 gpointer invocation_hint G_GNUC_UNUSED,
671 gpointer marshal_data)
672 {
673 typedef gboolean (*GMarshalFunc_BOOLEAN__OBJECT_BOXED_BOXED_OBJECT) (gpointer data1,
674 gpointer arg_1,
675 gpointer arg_2,
676 gpointer arg_3,
677 gpointer arg_4,
678 gpointer data2);
679 register GMarshalFunc_BOOLEAN__OBJECT_BOXED_BOXED_OBJECT callback;
680 register GCClosure *cc = (GCClosure*) closure;
681 register gpointer data1, data2;
682 gboolean v_return;
683
684 g_return_if_fail (return_value != NULL);
685 g_return_if_fail (n_param_values == 5);
686
687 if (G_CCLOSURE_SWAP_DATA (closure))
688 {
689 data1 = closure->data;
690 data2 = g_value_peek_pointer (param_values + 0);
691 }
692 else
693 {
694 data1 = g_value_peek_pointer (param_values + 0);
695 data2 = closure->data;
696 }
697 callback = (GMarshalFunc_BOOLEAN__OBJECT_BOXED_BOXED_OBJECT) (marshal_data ? marshal_data : cc->callback);
698
699 v_return = callback (data1,
700 g_marshal_value_peek_object (param_values + 1),
701 g_marshal_value_peek_boxed (param_values + 2),
702 g_marshal_value_peek_boxed (param_values + 3),
703 g_marshal_value_peek_object (param_values + 4),
704 data2);
705
706 g_value_set_boolean (return_value, v_return);
707 }