← Back to branch summary

~ubuntu-branches/ubuntu/utopic/glib2.0/utopic

« back to all changes in this revision

Viewing changes to gobject/gmarshal.c

Tags: upstream-2.12.12
Import upstream version 2.12.12

Show diffs side-by-side

added added

removed removed

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