← Back to branch summary

~ubuntu-branches/ubuntu/oneiric/rhythmbox/oneiric

« back to all changes in this revision

Viewing changes to lib/rb-marshal.c

  • Committer: Bazaar Package Importer
  • Author(s): Sebastien Bacher
  • Date: 2006-06-26 19:06:10 UTC
  • mto: (2.1.1 lenny) (1.1.37 upstream)
  • mto: This revision was merged to the branch mainline in revision 18.
  • Revision ID: james.westby@ubuntu.com-20060626190610-08x8lgvvfs0gr619
Tags: upstream-0.9.5
Import upstream version 0.9.5

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/rb-marshal.c
51
51
#endif /* !G_ENABLE_DEBUG */
52
52
 
53
53
 
54
 
/* VOID:OBJECT,INT,INT,BOXED,UINT,UINT (./rb-marshal.list:1) */
 
54
/* BOOLEAN:BOOLEAN,BOOLEAN,BOOLEAN (./rb-marshal.list:1) */
 
55
extern void rb_marshal_BOOLEAN__BOOLEAN_BOOLEAN_BOOLEAN (GClosure     *closure,
 
56
                                                         GValue       *return_value,
 
57
                                                         guint         n_param_values,
 
58
                                                         const GValue *param_values,
 
59
                                                         gpointer      invocation_hint,
 
60
                                                         gpointer      marshal_data);
 
61
void
 
62
rb_marshal_BOOLEAN__BOOLEAN_BOOLEAN_BOOLEAN (GClosure     *closure,
 
63
                                             GValue       *return_value,
 
64
                                             guint         n_param_values,
 
65
                                             const GValue *param_values,
 
66
                                             gpointer      invocation_hint,
 
67
                                             gpointer      marshal_data)
 
68
{
 
69
  typedef gboolean (*GMarshalFunc_BOOLEAN__BOOLEAN_BOOLEAN_BOOLEAN) (gpointer     data1,
 
70
                                                                     gboolean     arg_1,
 
71
                                                                     gboolean     arg_2,
 
72
                                                                     gboolean     arg_3,
 
73
                                                                     gpointer     data2);
 
74
  register GMarshalFunc_BOOLEAN__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 == 4);
 
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_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
                       g_marshal_value_peek_boolean (param_values + 3),
 
98
                       data2);
 
99
 
 
100
  g_value_set_boolean (return_value, v_return);
 
101
}
 
102
 
 
103
/* BOOLEAN:POINTER (./rb-marshal.list:2) */
 
104
extern void rb_marshal_BOOLEAN__POINTER (GClosure     *closure,
 
105
                                         GValue       *return_value,
 
106
                                         guint         n_param_values,
 
107
                                         const GValue *param_values,
 
108
                                         gpointer      invocation_hint,
 
109
                                         gpointer      marshal_data);
 
110
void
 
111
rb_marshal_BOOLEAN__POINTER (GClosure     *closure,
 
112
                             GValue       *return_value,
 
113
                             guint         n_param_values,
 
114
                             const GValue *param_values,
 
115
                             gpointer      invocation_hint,
 
116
                             gpointer      marshal_data)
 
117
{
 
118
  typedef gboolean (*GMarshalFunc_BOOLEAN__POINTER) (gpointer     data1,
 
119
                                                     gpointer     arg_1,
 
120
                                                     gpointer     data2);
 
121
  register GMarshalFunc_BOOLEAN__POINTER callback;
 
122
  register GCClosure *cc = (GCClosure*) closure;
 
123
  register gpointer data1, data2;
 
124
  gboolean v_return;
 
125
 
 
126
  g_return_if_fail (return_value != NULL);
 
127
  g_return_if_fail (n_param_values == 2);
 
128
 
 
129
  if (G_CCLOSURE_SWAP_DATA (closure))
 
130
    {
 
131
      data1 = closure->data;
 
132
      data2 = g_value_peek_pointer (param_values + 0);
 
133
    }
 
134
  else
 
135
    {
 
136
      data1 = g_value_peek_pointer (param_values + 0);
 
137
      data2 = closure->data;
 
138
    }
 
139
  callback = (GMarshalFunc_BOOLEAN__POINTER) (marshal_data ? marshal_data : cc->callback);
 
140
 
 
141
  v_return = callback (data1,
 
142
                       g_marshal_value_peek_pointer (param_values + 1),
 
143
                       data2);
 
144
 
 
145
  g_value_set_boolean (return_value, v_return);
 
146
}
 
147
 
 
148
/* INT:VOID (./rb-marshal.list:3) */
 
149
extern void rb_marshal_INT__VOID (GClosure     *closure,
 
150
                                  GValue       *return_value,
 
151
                                  guint         n_param_values,
 
152
                                  const GValue *param_values,
 
153
                                  gpointer      invocation_hint,
 
154
                                  gpointer      marshal_data);
 
155
void
 
156
rb_marshal_INT__VOID (GClosure     *closure,
 
157
                      GValue       *return_value,
 
158
                      guint         n_param_values,
 
159
                      const GValue *param_values,
 
160
                      gpointer      invocation_hint,
 
161
                      gpointer      marshal_data)
 
162
{
 
163
  typedef gint (*GMarshalFunc_INT__VOID) (gpointer     data1,
 
164
                                          gpointer     data2);
 
165
  register GMarshalFunc_INT__VOID callback;
 
166
  register GCClosure *cc = (GCClosure*) closure;
 
167
  register gpointer data1, data2;
 
168
  gint v_return;
 
169
 
 
170
  g_return_if_fail (return_value != NULL);
 
171
  g_return_if_fail (n_param_values == 1);
 
172
 
 
173
  if (G_CCLOSURE_SWAP_DATA (closure))
 
174
    {
 
175
      data1 = closure->data;
 
176
      data2 = g_value_peek_pointer (param_values + 0);
 
177
    }
 
178
  else
 
179
    {
 
180
      data1 = g_value_peek_pointer (param_values + 0);
 
181
      data2 = closure->data;
 
182
    }
 
183
  callback = (GMarshalFunc_INT__VOID) (marshal_data ? marshal_data : cc->callback);
 
184
 
 
185
  v_return = callback (data1,
 
186
                       data2);
 
187
 
 
188
  g_value_set_int (return_value, v_return);
 
189
}
 
190
 
 
191
/* OBJECT:OBJECT (./rb-marshal.list:4) */
 
192
extern void rb_marshal_OBJECT__OBJECT (GClosure     *closure,
 
193
                                       GValue       *return_value,
 
194
                                       guint         n_param_values,
 
195
                                       const GValue *param_values,
 
196
                                       gpointer      invocation_hint,
 
197
                                       gpointer      marshal_data);
 
198
void
 
199
rb_marshal_OBJECT__OBJECT (GClosure     *closure,
 
200
                           GValue       *return_value,
 
201
                           guint         n_param_values,
 
202
                           const GValue *param_values,
 
203
                           gpointer      invocation_hint,
 
204
                           gpointer      marshal_data)
 
205
{
 
206
  typedef GObject* (*GMarshalFunc_OBJECT__OBJECT) (gpointer     data1,
 
207
                                                   gpointer     arg_1,
 
208
                                                   gpointer     data2);
 
209
  register GMarshalFunc_OBJECT__OBJECT callback;
 
210
  register GCClosure *cc = (GCClosure*) closure;
 
211
  register gpointer data1, data2;
 
212
  GObject* v_return;
 
213
 
 
214
  g_return_if_fail (return_value != NULL);
 
215
  g_return_if_fail (n_param_values == 2);
 
216
 
 
217
  if (G_CCLOSURE_SWAP_DATA (closure))
 
218
    {
 
219
      data1 = closure->data;
 
220
      data2 = g_value_peek_pointer (param_values + 0);
 
221
    }
 
222
  else
 
223
    {
 
224
      data1 = g_value_peek_pointer (param_values + 0);
 
225
      data2 = closure->data;
 
226
    }
 
227
  callback = (GMarshalFunc_OBJECT__OBJECT) (marshal_data ? marshal_data : cc->callback);
 
228
 
 
229
  v_return = callback (data1,
 
230
                       g_marshal_value_peek_object (param_values + 1),
 
231
                       data2);
 
232
 
 
233
  g_value_take_object (return_value, v_return);
 
234
}
 
235
 
 
236
/* STRING:STRING (./rb-marshal.list:5) */
 
237
extern void rb_marshal_STRING__STRING (GClosure     *closure,
 
238
                                       GValue       *return_value,
 
239
                                       guint         n_param_values,
 
240
                                       const GValue *param_values,
 
241
                                       gpointer      invocation_hint,
 
242
                                       gpointer      marshal_data);
 
243
void
 
244
rb_marshal_STRING__STRING (GClosure     *closure,
 
245
                           GValue       *return_value,
 
246
                           guint         n_param_values,
 
247
                           const GValue *param_values,
 
248
                           gpointer      invocation_hint,
 
249
                           gpointer      marshal_data)
 
250
{
 
251
  typedef gchar* (*GMarshalFunc_STRING__STRING) (gpointer     data1,
 
252
                                                 gpointer     arg_1,
 
253
                                                 gpointer     data2);
 
254
  register GMarshalFunc_STRING__STRING callback;
 
255
  register GCClosure *cc = (GCClosure*) closure;
 
256
  register gpointer data1, data2;
 
257
  gchar* v_return;
 
258
 
 
259
  g_return_if_fail (return_value != NULL);
 
260
  g_return_if_fail (n_param_values == 2);
 
261
 
 
262
  if (G_CCLOSURE_SWAP_DATA (closure))
 
263
    {
 
264
      data1 = closure->data;
 
265
      data2 = g_value_peek_pointer (param_values + 0);
 
266
    }
 
267
  else
 
268
    {
 
269
      data1 = g_value_peek_pointer (param_values + 0);
 
270
      data2 = closure->data;
 
271
    }
 
272
  callback = (GMarshalFunc_STRING__STRING) (marshal_data ? marshal_data : cc->callback);
 
273
 
 
274
  v_return = callback (data1,
 
275
                       g_marshal_value_peek_string (param_values + 1),
 
276
                       data2);
 
277
 
 
278
  g_value_take_string (return_value, v_return);
 
279
}
 
280
 
 
281
/* VOID:BOOLEAN,BOOLEAN (./rb-marshal.list:6) */
 
282
extern void rb_marshal_VOID__BOOLEAN_BOOLEAN (GClosure     *closure,
 
283
                                              GValue       *return_value,
 
284
                                              guint         n_param_values,
 
285
                                              const GValue *param_values,
 
286
                                              gpointer      invocation_hint,
 
287
                                              gpointer      marshal_data);
 
288
void
 
289
rb_marshal_VOID__BOOLEAN_BOOLEAN (GClosure     *closure,
 
290
                                  GValue       *return_value,
 
291
                                  guint         n_param_values,
 
292
                                  const GValue *param_values,
 
293
                                  gpointer      invocation_hint,
 
294
                                  gpointer      marshal_data)
 
295
{
 
296
  typedef void (*GMarshalFunc_VOID__BOOLEAN_BOOLEAN) (gpointer     data1,
 
297
                                                      gboolean     arg_1,
 
298
                                                      gboolean     arg_2,
 
299
                                                      gpointer     data2);
 
300
  register GMarshalFunc_VOID__BOOLEAN_BOOLEAN callback;
 
301
  register GCClosure *cc = (GCClosure*) closure;
 
302
  register gpointer data1, data2;
 
303
 
 
304
  g_return_if_fail (n_param_values == 3);
 
305
 
 
306
  if (G_CCLOSURE_SWAP_DATA (closure))
 
307
    {
 
308
      data1 = closure->data;
 
309
      data2 = g_value_peek_pointer (param_values + 0);
 
310
    }
 
311
  else
 
312
    {
 
313
      data1 = g_value_peek_pointer (param_values + 0);
 
314
      data2 = closure->data;
 
315
    }
 
316
  callback = (GMarshalFunc_VOID__BOOLEAN_BOOLEAN) (marshal_data ? marshal_data : cc->callback);
 
317
 
 
318
  callback (data1,
 
319
            g_marshal_value_peek_boolean (param_values + 1),
 
320
            g_marshal_value_peek_boolean (param_values + 2),
 
321
            data2);
 
322
}
 
323
 
 
324
/* VOID:DOUBLE,LONG (./rb-marshal.list:7) */
 
325
extern void rb_marshal_VOID__DOUBLE_LONG (GClosure     *closure,
 
326
                                          GValue       *return_value,
 
327
                                          guint         n_param_values,
 
328
                                          const GValue *param_values,
 
329
                                          gpointer      invocation_hint,
 
330
                                          gpointer      marshal_data);
 
331
void
 
332
rb_marshal_VOID__DOUBLE_LONG (GClosure     *closure,
 
333
                              GValue       *return_value,
 
334
                              guint         n_param_values,
 
335
                              const GValue *param_values,
 
336
                              gpointer      invocation_hint,
 
337
                              gpointer      marshal_data)
 
338
{
 
339
  typedef void (*GMarshalFunc_VOID__DOUBLE_LONG) (gpointer     data1,
 
340
                                                  gdouble      arg_1,
 
341
                                                  glong        arg_2,
 
342
                                                  gpointer     data2);
 
343
  register GMarshalFunc_VOID__DOUBLE_LONG callback;
 
344
  register GCClosure *cc = (GCClosure*) closure;
 
345
  register gpointer data1, data2;
 
346
 
 
347
  g_return_if_fail (n_param_values == 3);
 
348
 
 
349
  if (G_CCLOSURE_SWAP_DATA (closure))
 
350
    {
 
351
      data1 = closure->data;
 
352
      data2 = g_value_peek_pointer (param_values + 0);
 
353
    }
 
354
  else
 
355
    {
 
356
      data1 = g_value_peek_pointer (param_values + 0);
 
357
      data2 = closure->data;
 
358
    }
 
359
  callback = (GMarshalFunc_VOID__DOUBLE_LONG) (marshal_data ? marshal_data : cc->callback);
 
360
 
 
361
  callback (data1,
 
362
            g_marshal_value_peek_double (param_values + 1),
 
363
            g_marshal_value_peek_long (param_values + 2),
 
364
            data2);
 
365
}
 
366
 
 
367
/* VOID:INT,INT,DOUBLE (./rb-marshal.list:8) */
 
368
extern void rb_marshal_VOID__INT_INT_DOUBLE (GClosure     *closure,
 
369
                                             GValue       *return_value,
 
370
                                             guint         n_param_values,
 
371
                                             const GValue *param_values,
 
372
                                             gpointer      invocation_hint,
 
373
                                             gpointer      marshal_data);
 
374
void
 
375
rb_marshal_VOID__INT_INT_DOUBLE (GClosure     *closure,
 
376
                                 GValue       *return_value,
 
377
                                 guint         n_param_values,
 
378
                                 const GValue *param_values,
 
379
                                 gpointer      invocation_hint,
 
380
                                 gpointer      marshal_data)
 
381
{
 
382
  typedef void (*GMarshalFunc_VOID__INT_INT_DOUBLE) (gpointer     data1,
 
383
                                                     gint         arg_1,
 
384
                                                     gint         arg_2,
 
385
                                                     gdouble      arg_3,
 
386
                                                     gpointer     data2);
 
387
  register GMarshalFunc_VOID__INT_INT_DOUBLE callback;
 
388
  register GCClosure *cc = (GCClosure*) closure;
 
389
  register gpointer data1, data2;
 
390
 
 
391
  g_return_if_fail (n_param_values == 4);
 
392
 
 
393
  if (G_CCLOSURE_SWAP_DATA (closure))
 
394
    {
 
395
      data1 = closure->data;
 
396
      data2 = g_value_peek_pointer (param_values + 0);
 
397
    }
 
398
  else
 
399
    {
 
400
      data1 = g_value_peek_pointer (param_values + 0);
 
401
      data2 = closure->data;
 
402
    }
 
403
  callback = (GMarshalFunc_VOID__INT_INT_DOUBLE) (marshal_data ? marshal_data : cc->callback);
 
404
 
 
405
  callback (data1,
 
406
            g_marshal_value_peek_int (param_values + 1),
 
407
            g_marshal_value_peek_int (param_values + 2),
 
408
            g_marshal_value_peek_double (param_values + 3),
 
409
            data2);
 
410
}
 
411
 
 
412
/* VOID:INT,POINTER (./rb-marshal.list:9) */
 
413
extern void rb_marshal_VOID__INT_POINTER (GClosure     *closure,
 
414
                                          GValue       *return_value,
 
415
                                          guint         n_param_values,
 
416
                                          const GValue *param_values,
 
417
                                          gpointer      invocation_hint,
 
418
                                          gpointer      marshal_data);
 
419
void
 
420
rb_marshal_VOID__INT_POINTER (GClosure     *closure,
 
421
                              GValue       *return_value,
 
422
                              guint         n_param_values,
 
423
                              const GValue *param_values,
 
424
                              gpointer      invocation_hint,
 
425
                              gpointer      marshal_data)
 
426
{
 
427
  typedef void (*GMarshalFunc_VOID__INT_POINTER) (gpointer     data1,
 
428
                                                  gint         arg_1,
 
429
                                                  gpointer     arg_2,
 
430
                                                  gpointer     data2);
 
431
  register GMarshalFunc_VOID__INT_POINTER callback;
 
432
  register GCClosure *cc = (GCClosure*) closure;
 
433
  register gpointer data1, data2;
 
434
 
 
435
  g_return_if_fail (n_param_values == 3);
 
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__INT_POINTER) (marshal_data ? marshal_data : cc->callback);
 
448
 
 
449
  callback (data1,
 
450
            g_marshal_value_peek_int (param_values + 1),
 
451
            g_marshal_value_peek_pointer (param_values + 2),
 
452
            data2);
 
453
}
 
454
 
 
455
/* VOID:OBJECT,INT,INT (./rb-marshal.list:10) */
 
456
extern void rb_marshal_VOID__OBJECT_INT_INT (GClosure     *closure,
 
457
                                             GValue       *return_value,
 
458
                                             guint         n_param_values,
 
459
                                             const GValue *param_values,
 
460
                                             gpointer      invocation_hint,
 
461
                                             gpointer      marshal_data);
 
462
void
 
463
rb_marshal_VOID__OBJECT_INT_INT (GClosure     *closure,
 
464
                                 GValue       *return_value,
 
465
                                 guint         n_param_values,
 
466
                                 const GValue *param_values,
 
467
                                 gpointer      invocation_hint,
 
468
                                 gpointer      marshal_data)
 
469
{
 
470
  typedef void (*GMarshalFunc_VOID__OBJECT_INT_INT) (gpointer     data1,
 
471
                                                     gpointer     arg_1,
 
472
                                                     gint         arg_2,
 
473
                                                     gint         arg_3,
 
474
                                                     gpointer     data2);
 
475
  register GMarshalFunc_VOID__OBJECT_INT_INT callback;
 
476
  register GCClosure *cc = (GCClosure*) closure;
 
477
  register gpointer data1, data2;
 
478
 
 
479
  g_return_if_fail (n_param_values == 4);
 
480
 
 
481
  if (G_CCLOSURE_SWAP_DATA (closure))
 
482
    {
 
483
      data1 = closure->data;
 
484
      data2 = g_value_peek_pointer (param_values + 0);
 
485
    }
 
486
  else
 
487
    {
 
488
      data1 = g_value_peek_pointer (param_values + 0);
 
489
      data2 = closure->data;
 
490
    }
 
491
  callback = (GMarshalFunc_VOID__OBJECT_INT_INT) (marshal_data ? marshal_data : cc->callback);
 
492
 
 
493
  callback (data1,
 
494
            g_marshal_value_peek_object (param_values + 1),
 
495
            g_marshal_value_peek_int (param_values + 2),
 
496
            g_marshal_value_peek_int (param_values + 3),
 
497
            data2);
 
498
}
 
499
 
 
500
/* VOID:OBJECT,INT,INT,BOXED,UINT,UINT (./rb-marshal.list:11) */
55
501
extern void rb_marshal_VOID__OBJECT_INT_INT_BOXED_UINT_UINT (GClosure     *closure,
56
502
                                                             GValue       *return_value,
57
503
                                                             guint         n_param_values,
102
548
            data2);
103
549
}
104
550
 
105
 
/* VOID:OBJECT,INT,INT (./rb-marshal.list:2) */
106
 
extern void rb_marshal_VOID__OBJECT_INT_INT (GClosure     *closure,
107
 
                                             GValue       *return_value,
108
 
                                             guint         n_param_values,
109
 
                                             const GValue *param_values,
110
 
                                             gpointer      invocation_hint,
111
 
                                             gpointer      marshal_data);
112
 
void
113
 
rb_marshal_VOID__OBJECT_INT_INT (GClosure     *closure,
114
 
                                 GValue       *return_value,
115
 
                                 guint         n_param_values,
116
 
                                 const GValue *param_values,
117
 
                                 gpointer      invocation_hint,
118
 
                                 gpointer      marshal_data)
119
 
{
120
 
  typedef void (*GMarshalFunc_VOID__OBJECT_INT_INT) (gpointer     data1,
121
 
                                                     gpointer     arg_1,
122
 
                                                     gint         arg_2,
123
 
                                                     gint         arg_3,
124
 
                                                     gpointer     data2);
125
 
  register GMarshalFunc_VOID__OBJECT_INT_INT callback;
126
 
  register GCClosure *cc = (GCClosure*) closure;
127
 
  register gpointer data1, data2;
128
 
 
129
 
  g_return_if_fail (n_param_values == 4);
130
 
 
131
 
  if (G_CCLOSURE_SWAP_DATA (closure))
132
 
    {
133
 
      data1 = closure->data;
134
 
      data2 = g_value_peek_pointer (param_values + 0);
135
 
    }
136
 
  else
137
 
    {
138
 
      data1 = g_value_peek_pointer (param_values + 0);
139
 
      data2 = closure->data;
140
 
    }
141
 
  callback = (GMarshalFunc_VOID__OBJECT_INT_INT) (marshal_data ? marshal_data : cc->callback);
142
 
 
143
 
  callback (data1,
144
 
            g_marshal_value_peek_object (param_values + 1),
145
 
            g_marshal_value_peek_int (param_values + 2),
146
 
            g_marshal_value_peek_int (param_values + 3),
147
 
            data2);
148
 
}
149
 
 
150
 
/* VOID:STRING,DOUBLE (./rb-marshal.list:3) */
151
 
extern void rb_marshal_VOID__STRING_DOUBLE (GClosure     *closure,
152
 
                                            GValue       *return_value,
153
 
                                            guint         n_param_values,
154
 
                                            const GValue *param_values,
155
 
                                            gpointer      invocation_hint,
156
 
                                            gpointer      marshal_data);
157
 
void
158
 
rb_marshal_VOID__STRING_DOUBLE (GClosure     *closure,
159
 
                                GValue       *return_value,
160
 
                                guint         n_param_values,
161
 
                                const GValue *param_values,
162
 
                                gpointer      invocation_hint,
163
 
                                gpointer      marshal_data)
164
 
{
165
 
  typedef void (*GMarshalFunc_VOID__STRING_DOUBLE) (gpointer     data1,
166
 
                                                    gpointer     arg_1,
167
 
                                                    gdouble      arg_2,
168
 
                                                    gpointer     data2);
169
 
  register GMarshalFunc_VOID__STRING_DOUBLE callback;
170
 
  register GCClosure *cc = (GCClosure*) closure;
171
 
  register gpointer data1, data2;
172
 
 
173
 
  g_return_if_fail (n_param_values == 3);
174
 
 
175
 
  if (G_CCLOSURE_SWAP_DATA (closure))
176
 
    {
177
 
      data1 = closure->data;
178
 
      data2 = g_value_peek_pointer (param_values + 0);
179
 
    }
180
 
  else
181
 
    {
182
 
      data1 = g_value_peek_pointer (param_values + 0);
183
 
      data2 = closure->data;
184
 
    }
185
 
  callback = (GMarshalFunc_VOID__STRING_DOUBLE) (marshal_data ? marshal_data : cc->callback);
186
 
 
187
 
  callback (data1,
188
 
            g_marshal_value_peek_string (param_values + 1),
189
 
            g_marshal_value_peek_double (param_values + 2),
190
 
            data2);
191
 
}
192
 
 
193
 
/* VOID:STRING,INT (./rb-marshal.list:4) */
194
 
extern void rb_marshal_VOID__STRING_INT (GClosure     *closure,
195
 
                                         GValue       *return_value,
196
 
                                         guint         n_param_values,
197
 
                                         const GValue *param_values,
198
 
                                         gpointer      invocation_hint,
199
 
                                         gpointer      marshal_data);
200
 
void
201
 
rb_marshal_VOID__STRING_INT (GClosure     *closure,
202
 
                             GValue       *return_value,
203
 
                             guint         n_param_values,
204
 
                             const GValue *param_values,
205
 
                             gpointer      invocation_hint,
206
 
                             gpointer      marshal_data)
207
 
{
208
 
  typedef void (*GMarshalFunc_VOID__STRING_INT) (gpointer     data1,
209
 
                                                 gpointer     arg_1,
210
 
                                                 gint         arg_2,
211
 
                                                 gpointer     data2);
212
 
  register GMarshalFunc_VOID__STRING_INT callback;
213
 
  register GCClosure *cc = (GCClosure*) closure;
214
 
  register gpointer data1, data2;
215
 
 
216
 
  g_return_if_fail (n_param_values == 3);
217
 
 
218
 
  if (G_CCLOSURE_SWAP_DATA (closure))
219
 
    {
220
 
      data1 = closure->data;
221
 
      data2 = g_value_peek_pointer (param_values + 0);
222
 
    }
223
 
  else
224
 
    {
225
 
      data1 = g_value_peek_pointer (param_values + 0);
226
 
      data2 = closure->data;
227
 
    }
228
 
  callback = (GMarshalFunc_VOID__STRING_INT) (marshal_data ? marshal_data : cc->callback);
229
 
 
230
 
  callback (data1,
231
 
            g_marshal_value_peek_string (param_values + 1),
232
 
            g_marshal_value_peek_int (param_values + 2),
233
 
            data2);
234
 
}
235
 
 
236
 
/* VOID:STRING,STRING (./rb-marshal.list:5) */
237
 
extern void rb_marshal_VOID__STRING_STRING (GClosure     *closure,
238
 
                                            GValue       *return_value,
239
 
                                            guint         n_param_values,
240
 
                                            const GValue *param_values,
241
 
                                            gpointer      invocation_hint,
242
 
                                            gpointer      marshal_data);
243
 
void
244
 
rb_marshal_VOID__STRING_STRING (GClosure     *closure,
245
 
                                GValue       *return_value,
246
 
                                guint         n_param_values,
247
 
                                const GValue *param_values,
248
 
                                gpointer      invocation_hint,
249
 
                                gpointer      marshal_data)
250
 
{
251
 
  typedef void (*GMarshalFunc_VOID__STRING_STRING) (gpointer     data1,
252
 
                                                    gpointer     arg_1,
253
 
                                                    gpointer     arg_2,
254
 
                                                    gpointer     data2);
255
 
  register GMarshalFunc_VOID__STRING_STRING callback;
256
 
  register GCClosure *cc = (GCClosure*) closure;
257
 
  register gpointer data1, data2;
258
 
 
259
 
  g_return_if_fail (n_param_values == 3);
260
 
 
261
 
  if (G_CCLOSURE_SWAP_DATA (closure))
262
 
    {
263
 
      data1 = closure->data;
264
 
      data2 = g_value_peek_pointer (param_values + 0);
265
 
    }
266
 
  else
267
 
    {
268
 
      data1 = g_value_peek_pointer (param_values + 0);
269
 
      data2 = closure->data;
270
 
    }
271
 
  callback = (GMarshalFunc_VOID__STRING_STRING) (marshal_data ? marshal_data : cc->callback);
272
 
 
273
 
  callback (data1,
274
 
            g_marshal_value_peek_string (param_values + 1),
275
 
            g_marshal_value_peek_string (param_values + 2),
276
 
            data2);
277
 
}
278
 
 
279
 
/* VOID:STRING,STRING,STRING (./rb-marshal.list:6) */
280
 
extern void rb_marshal_VOID__STRING_STRING_STRING (GClosure     *closure,
281
 
                                                   GValue       *return_value,
282
 
                                                   guint         n_param_values,
283
 
                                                   const GValue *param_values,
284
 
                                                   gpointer      invocation_hint,
285
 
                                                   gpointer      marshal_data);
286
 
void
287
 
rb_marshal_VOID__STRING_STRING_STRING (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
 
{
294
 
  typedef void (*GMarshalFunc_VOID__STRING_STRING_STRING) (gpointer     data1,
295
 
                                                           gpointer     arg_1,
296
 
                                                           gpointer     arg_2,
297
 
                                                           gpointer     arg_3,
298
 
                                                           gpointer     data2);
299
 
  register GMarshalFunc_VOID__STRING_STRING_STRING callback;
300
 
  register GCClosure *cc = (GCClosure*) closure;
301
 
  register gpointer data1, data2;
302
 
 
303
 
  g_return_if_fail (n_param_values == 4);
304
 
 
305
 
  if (G_CCLOSURE_SWAP_DATA (closure))
306
 
    {
307
 
      data1 = closure->data;
308
 
      data2 = g_value_peek_pointer (param_values + 0);
309
 
    }
310
 
  else
311
 
    {
312
 
      data1 = g_value_peek_pointer (param_values + 0);
313
 
      data2 = closure->data;
314
 
    }
315
 
  callback = (GMarshalFunc_VOID__STRING_STRING_STRING) (marshal_data ? marshal_data : cc->callback);
316
 
 
317
 
  callback (data1,
318
 
            g_marshal_value_peek_string (param_values + 1),
319
 
            g_marshal_value_peek_string (param_values + 2),
320
 
            g_marshal_value_peek_string (param_values + 3),
321
 
            data2);
322
 
}
323
 
 
324
 
/* BOOLEAN:POINTER (./rb-marshal.list:7) */
325
 
extern void rb_marshal_BOOLEAN__POINTER (GClosure     *closure,
326
 
                                         GValue       *return_value,
327
 
                                         guint         n_param_values,
328
 
                                         const GValue *param_values,
329
 
                                         gpointer      invocation_hint,
330
 
                                         gpointer      marshal_data);
331
 
void
332
 
rb_marshal_BOOLEAN__POINTER (GClosure     *closure,
333
 
                             GValue       *return_value,
334
 
                             guint         n_param_values,
335
 
                             const GValue *param_values,
336
 
                             gpointer      invocation_hint,
337
 
                             gpointer      marshal_data)
338
 
{
339
 
  typedef gboolean (*GMarshalFunc_BOOLEAN__POINTER) (gpointer     data1,
340
 
                                                     gpointer     arg_1,
341
 
                                                     gpointer     data2);
342
 
  register GMarshalFunc_BOOLEAN__POINTER callback;
343
 
  register GCClosure *cc = (GCClosure*) closure;
344
 
  register gpointer data1, data2;
345
 
  gboolean v_return;
346
 
 
347
 
  g_return_if_fail (return_value != NULL);
348
 
  g_return_if_fail (n_param_values == 2);
349
 
 
350
 
  if (G_CCLOSURE_SWAP_DATA (closure))
351
 
    {
352
 
      data1 = closure->data;
353
 
      data2 = g_value_peek_pointer (param_values + 0);
354
 
    }
355
 
  else
356
 
    {
357
 
      data1 = g_value_peek_pointer (param_values + 0);
358
 
      data2 = closure->data;
359
 
    }
360
 
  callback = (GMarshalFunc_BOOLEAN__POINTER) (marshal_data ? marshal_data : cc->callback);
361
 
 
362
 
  v_return = callback (data1,
363
 
                       g_marshal_value_peek_pointer (param_values + 1),
364
 
                       data2);
365
 
 
366
 
  g_value_set_boolean (return_value, v_return);
367
 
}
368
 
 
369
 
/* VOID:DOUBLE (./rb-marshal.list:8) */
370
 
#define rb_marshal_VOID__DOUBLE g_cclosure_marshal_VOID__DOUBLE
371
 
 
372
 
/* VOID:POINTER,INT,POINTER (./rb-marshal.list:9) */
 
551
/* VOID:POINTER,INT (./rb-marshal.list:12) */
 
552
extern void rb_marshal_VOID__POINTER_INT (GClosure     *closure,
 
553
                                          GValue       *return_value,
 
554
                                          guint         n_param_values,
 
555
                                          const GValue *param_values,
 
556
                                          gpointer      invocation_hint,
 
557
                                          gpointer      marshal_data);
 
558
void
 
559
rb_marshal_VOID__POINTER_INT (GClosure     *closure,
 
560
                              GValue       *return_value,
 
561
                              guint         n_param_values,
 
562
                              const GValue *param_values,
 
563
                              gpointer      invocation_hint,
 
564
                              gpointer      marshal_data)
 
565
{
 
566
  typedef void (*GMarshalFunc_VOID__POINTER_INT) (gpointer     data1,
 
567
                                                  gpointer     arg_1,
 
568
                                                  gint         arg_2,
 
569
                                                  gpointer     data2);
 
570
  register GMarshalFunc_VOID__POINTER_INT callback;
 
571
  register GCClosure *cc = (GCClosure*) closure;
 
572
  register gpointer data1, data2;
 
573
 
 
574
  g_return_if_fail (n_param_values == 3);
 
575
 
 
576
  if (G_CCLOSURE_SWAP_DATA (closure))
 
577
    {
 
578
      data1 = closure->data;
 
579
      data2 = g_value_peek_pointer (param_values + 0);
 
580
    }
 
581
  else
 
582
    {
 
583
      data1 = g_value_peek_pointer (param_values + 0);
 
584
      data2 = closure->data;
 
585
    }
 
586
  callback = (GMarshalFunc_VOID__POINTER_INT) (marshal_data ? marshal_data : cc->callback);
 
587
 
 
588
  callback (data1,
 
589
            g_marshal_value_peek_pointer (param_values + 1),
 
590
            g_marshal_value_peek_int (param_values + 2),
 
591
            data2);
 
592
}
 
593
 
 
594
/* VOID:POINTER,INT,POINTER (./rb-marshal.list:13) */
373
595
extern void rb_marshal_VOID__POINTER_INT_POINTER (GClosure     *closure,
374
596
                                                  GValue       *return_value,
375
597
                                                  guint         n_param_values,
414
636
            data2);
415
637
}
416
638
 
417
 
/* VOID:INT,POINTER (./rb-marshal.list:10) */
418
 
extern void rb_marshal_VOID__INT_POINTER (GClosure     *closure,
419
 
                                          GValue       *return_value,
420
 
                                          guint         n_param_values,
421
 
                                          const GValue *param_values,
422
 
                                          gpointer      invocation_hint,
423
 
                                          gpointer      marshal_data);
424
 
void
425
 
rb_marshal_VOID__INT_POINTER (GClosure     *closure,
426
 
                              GValue       *return_value,
427
 
                              guint         n_param_values,
428
 
                              const GValue *param_values,
429
 
                              gpointer      invocation_hint,
430
 
                              gpointer      marshal_data)
431
 
{
432
 
  typedef void (*GMarshalFunc_VOID__INT_POINTER) (gpointer     data1,
433
 
                                                  gint         arg_1,
434
 
                                                  gpointer     arg_2,
435
 
                                                  gpointer     data2);
436
 
  register GMarshalFunc_VOID__INT_POINTER callback;
437
 
  register GCClosure *cc = (GCClosure*) closure;
438
 
  register gpointer data1, data2;
439
 
 
440
 
  g_return_if_fail (n_param_values == 3);
441
 
 
442
 
  if (G_CCLOSURE_SWAP_DATA (closure))
443
 
    {
444
 
      data1 = closure->data;
445
 
      data2 = g_value_peek_pointer (param_values + 0);
446
 
    }
447
 
  else
448
 
    {
449
 
      data1 = g_value_peek_pointer (param_values + 0);
450
 
      data2 = closure->data;
451
 
    }
452
 
  callback = (GMarshalFunc_VOID__INT_POINTER) (marshal_data ? marshal_data : cc->callback);
453
 
 
454
 
  callback (data1,
455
 
            g_marshal_value_peek_int (param_values + 1),
456
 
            g_marshal_value_peek_pointer (param_values + 2),
457
 
            data2);
458
 
}
459
 
 
460
 
/* VOID:POINTER,INT,POINTER,POINTER (./rb-marshal.list:11) */
 
639
/* VOID:POINTER,INT,POINTER,POINTER (./rb-marshal.list:14) */
461
640
extern void rb_marshal_VOID__POINTER_INT_POINTER_POINTER (GClosure     *closure,
462
641
                                                          GValue       *return_value,
463
642
                                                          guint         n_param_values,
504
683
            data2);
505
684
}
506
685
 
507
 
/* VOID:BOOLEAN,BOOLEAN (./rb-marshal.list:12) */
508
 
extern void rb_marshal_VOID__BOOLEAN_BOOLEAN (GClosure     *closure,
 
686
/* VOID:POINTER,POINTER (./rb-marshal.list:15) */
 
687
extern void rb_marshal_VOID__POINTER_POINTER (GClosure     *closure,
509
688
                                              GValue       *return_value,
510
689
                                              guint         n_param_values,
511
690
                                              const GValue *param_values,
512
691
                                              gpointer      invocation_hint,
513
692
                                              gpointer      marshal_data);
514
693
void
515
 
rb_marshal_VOID__BOOLEAN_BOOLEAN (GClosure     *closure,
 
694
rb_marshal_VOID__POINTER_POINTER (GClosure     *closure,
516
695
                                  GValue       *return_value,
517
696
                                  guint         n_param_values,
518
697
                                  const GValue *param_values,
519
698
                                  gpointer      invocation_hint,
520
699
                                  gpointer      marshal_data)
521
700
{
522
 
  typedef void (*GMarshalFunc_VOID__BOOLEAN_BOOLEAN) (gpointer     data1,
523
 
                                                      gboolean     arg_1,
524
 
                                                      gboolean     arg_2,
 
701
  typedef void (*GMarshalFunc_VOID__POINTER_POINTER) (gpointer     data1,
 
702
                                                      gpointer     arg_1,
 
703
                                                      gpointer     arg_2,
525
704
                                                      gpointer     data2);
526
 
  register GMarshalFunc_VOID__BOOLEAN_BOOLEAN callback;
527
 
  register GCClosure *cc = (GCClosure*) closure;
528
 
  register gpointer data1, data2;
529
 
 
530
 
  g_return_if_fail (n_param_values == 3);
531
 
 
532
 
  if (G_CCLOSURE_SWAP_DATA (closure))
533
 
    {
534
 
      data1 = closure->data;
535
 
      data2 = g_value_peek_pointer (param_values + 0);
536
 
    }
537
 
  else
538
 
    {
539
 
      data1 = g_value_peek_pointer (param_values + 0);
540
 
      data2 = closure->data;
541
 
    }
542
 
  callback = (GMarshalFunc_VOID__BOOLEAN_BOOLEAN) (marshal_data ? marshal_data : cc->callback);
543
 
 
544
 
  callback (data1,
545
 
            g_marshal_value_peek_boolean (param_values + 1),
 
705
  register GMarshalFunc_VOID__POINTER_POINTER callback;
 
706
  register GCClosure *cc = (GCClosure*) closure;
 
707
  register gpointer data1, data2;
 
708
 
 
709
  g_return_if_fail (n_param_values == 3);
 
710
 
 
711
  if (G_CCLOSURE_SWAP_DATA (closure))
 
712
    {
 
713
      data1 = closure->data;
 
714
      data2 = g_value_peek_pointer (param_values + 0);
 
715
    }
 
716
  else
 
717
    {
 
718
      data1 = g_value_peek_pointer (param_values + 0);
 
719
      data2 = closure->data;
 
720
    }
 
721
  callback = (GMarshalFunc_VOID__POINTER_POINTER) (marshal_data ? marshal_data : cc->callback);
 
722
 
 
723
  callback (data1,
 
724
            g_marshal_value_peek_pointer (param_values + 1),
 
725
            g_marshal_value_peek_pointer (param_values + 2),
 
726
            data2);
 
727
}
 
728
 
 
729
/* VOID:POINTER,ULONG (./rb-marshal.list:16) */
 
730
extern void rb_marshal_VOID__POINTER_ULONG (GClosure     *closure,
 
731
                                            GValue       *return_value,
 
732
                                            guint         n_param_values,
 
733
                                            const GValue *param_values,
 
734
                                            gpointer      invocation_hint,
 
735
                                            gpointer      marshal_data);
 
736
void
 
737
rb_marshal_VOID__POINTER_ULONG (GClosure     *closure,
 
738
                                GValue       *return_value,
 
739
                                guint         n_param_values,
 
740
                                const GValue *param_values,
 
741
                                gpointer      invocation_hint,
 
742
                                gpointer      marshal_data)
 
743
{
 
744
  typedef void (*GMarshalFunc_VOID__POINTER_ULONG) (gpointer     data1,
 
745
                                                    gpointer     arg_1,
 
746
                                                    gulong       arg_2,
 
747
                                                    gpointer     data2);
 
748
  register GMarshalFunc_VOID__POINTER_ULONG callback;
 
749
  register GCClosure *cc = (GCClosure*) closure;
 
750
  register gpointer data1, data2;
 
751
 
 
752
  g_return_if_fail (n_param_values == 3);
 
753
 
 
754
  if (G_CCLOSURE_SWAP_DATA (closure))
 
755
    {
 
756
      data1 = closure->data;
 
757
      data2 = g_value_peek_pointer (param_values + 0);
 
758
    }
 
759
  else
 
760
    {
 
761
      data1 = g_value_peek_pointer (param_values + 0);
 
762
      data2 = closure->data;
 
763
    }
 
764
  callback = (GMarshalFunc_VOID__POINTER_ULONG) (marshal_data ? marshal_data : cc->callback);
 
765
 
 
766
  callback (data1,
 
767
            g_marshal_value_peek_pointer (param_values + 1),
 
768
            g_marshal_value_peek_ulong (param_values + 2),
 
769
            data2);
 
770
}
 
771
 
 
772
/* VOID:STRING,DOUBLE (./rb-marshal.list:17) */
 
773
extern void rb_marshal_VOID__STRING_DOUBLE (GClosure     *closure,
 
774
                                            GValue       *return_value,
 
775
                                            guint         n_param_values,
 
776
                                            const GValue *param_values,
 
777
                                            gpointer      invocation_hint,
 
778
                                            gpointer      marshal_data);
 
779
void
 
780
rb_marshal_VOID__STRING_DOUBLE (GClosure     *closure,
 
781
                                GValue       *return_value,
 
782
                                guint         n_param_values,
 
783
                                const GValue *param_values,
 
784
                                gpointer      invocation_hint,
 
785
                                gpointer      marshal_data)
 
786
{
 
787
  typedef void (*GMarshalFunc_VOID__STRING_DOUBLE) (gpointer     data1,
 
788
                                                    gpointer     arg_1,
 
789
                                                    gdouble      arg_2,
 
790
                                                    gpointer     data2);
 
791
  register GMarshalFunc_VOID__STRING_DOUBLE callback;
 
792
  register GCClosure *cc = (GCClosure*) closure;
 
793
  register gpointer data1, data2;
 
794
 
 
795
  g_return_if_fail (n_param_values == 3);
 
796
 
 
797
  if (G_CCLOSURE_SWAP_DATA (closure))
 
798
    {
 
799
      data1 = closure->data;
 
800
      data2 = g_value_peek_pointer (param_values + 0);
 
801
    }
 
802
  else
 
803
    {
 
804
      data1 = g_value_peek_pointer (param_values + 0);
 
805
      data2 = closure->data;
 
806
    }
 
807
  callback = (GMarshalFunc_VOID__STRING_DOUBLE) (marshal_data ? marshal_data : cc->callback);
 
808
 
 
809
  callback (data1,
 
810
            g_marshal_value_peek_string (param_values + 1),
 
811
            g_marshal_value_peek_double (param_values + 2),
 
812
            data2);
 
813
}
 
814
 
 
815
/* VOID:STRING,INT (./rb-marshal.list:18) */
 
816
extern void rb_marshal_VOID__STRING_INT (GClosure     *closure,
 
817
                                         GValue       *return_value,
 
818
                                         guint         n_param_values,
 
819
                                         const GValue *param_values,
 
820
                                         gpointer      invocation_hint,
 
821
                                         gpointer      marshal_data);
 
822
void
 
823
rb_marshal_VOID__STRING_INT (GClosure     *closure,
 
824
                             GValue       *return_value,
 
825
                             guint         n_param_values,
 
826
                             const GValue *param_values,
 
827
                             gpointer      invocation_hint,
 
828
                             gpointer      marshal_data)
 
829
{
 
830
  typedef void (*GMarshalFunc_VOID__STRING_INT) (gpointer     data1,
 
831
                                                 gpointer     arg_1,
 
832
                                                 gint         arg_2,
 
833
                                                 gpointer     data2);
 
834
  register GMarshalFunc_VOID__STRING_INT callback;
 
835
  register GCClosure *cc = (GCClosure*) closure;
 
836
  register gpointer data1, data2;
 
837
 
 
838
  g_return_if_fail (n_param_values == 3);
 
839
 
 
840
  if (G_CCLOSURE_SWAP_DATA (closure))
 
841
    {
 
842
      data1 = closure->data;
 
843
      data2 = g_value_peek_pointer (param_values + 0);
 
844
    }
 
845
  else
 
846
    {
 
847
      data1 = g_value_peek_pointer (param_values + 0);
 
848
      data2 = closure->data;
 
849
    }
 
850
  callback = (GMarshalFunc_VOID__STRING_INT) (marshal_data ? marshal_data : cc->callback);
 
851
 
 
852
  callback (data1,
 
853
            g_marshal_value_peek_string (param_values + 1),
 
854
            g_marshal_value_peek_int (param_values + 2),
 
855
            data2);
 
856
}
 
857
 
 
858
/* VOID:STRING,POINTER (./rb-marshal.list:19) */
 
859
extern void rb_marshal_VOID__STRING_POINTER (GClosure     *closure,
 
860
                                             GValue       *return_value,
 
861
                                             guint         n_param_values,
 
862
                                             const GValue *param_values,
 
863
                                             gpointer      invocation_hint,
 
864
                                             gpointer      marshal_data);
 
865
void
 
866
rb_marshal_VOID__STRING_POINTER (GClosure     *closure,
 
867
                                 GValue       *return_value,
 
868
                                 guint         n_param_values,
 
869
                                 const GValue *param_values,
 
870
                                 gpointer      invocation_hint,
 
871
                                 gpointer      marshal_data)
 
872
{
 
873
  typedef void (*GMarshalFunc_VOID__STRING_POINTER) (gpointer     data1,
 
874
                                                     gpointer     arg_1,
 
875
                                                     gpointer     arg_2,
 
876
                                                     gpointer     data2);
 
877
  register GMarshalFunc_VOID__STRING_POINTER callback;
 
878
  register GCClosure *cc = (GCClosure*) closure;
 
879
  register gpointer data1, data2;
 
880
 
 
881
  g_return_if_fail (n_param_values == 3);
 
882
 
 
883
  if (G_CCLOSURE_SWAP_DATA (closure))
 
884
    {
 
885
      data1 = closure->data;
 
886
      data2 = g_value_peek_pointer (param_values + 0);
 
887
    }
 
888
  else
 
889
    {
 
890
      data1 = g_value_peek_pointer (param_values + 0);
 
891
      data2 = closure->data;
 
892
    }
 
893
  callback = (GMarshalFunc_VOID__STRING_POINTER) (marshal_data ? marshal_data : cc->callback);
 
894
 
 
895
  callback (data1,
 
896
            g_marshal_value_peek_string (param_values + 1),
 
897
            g_marshal_value_peek_pointer (param_values + 2),
 
898
            data2);
 
899
}
 
900
 
 
901
/* VOID:STRING,STRING (./rb-marshal.list:20) */
 
902
extern void rb_marshal_VOID__STRING_STRING (GClosure     *closure,
 
903
                                            GValue       *return_value,
 
904
                                            guint         n_param_values,
 
905
                                            const GValue *param_values,
 
906
                                            gpointer      invocation_hint,
 
907
                                            gpointer      marshal_data);
 
908
void
 
909
rb_marshal_VOID__STRING_STRING (GClosure     *closure,
 
910
                                GValue       *return_value,
 
911
                                guint         n_param_values,
 
912
                                const GValue *param_values,
 
913
                                gpointer      invocation_hint,
 
914
                                gpointer      marshal_data)
 
915
{
 
916
  typedef void (*GMarshalFunc_VOID__STRING_STRING) (gpointer     data1,
 
917
                                                    gpointer     arg_1,
 
918
                                                    gpointer     arg_2,
 
919
                                                    gpointer     data2);
 
920
  register GMarshalFunc_VOID__STRING_STRING callback;
 
921
  register GCClosure *cc = (GCClosure*) closure;
 
922
  register gpointer data1, data2;
 
923
 
 
924
  g_return_if_fail (n_param_values == 3);
 
925
 
 
926
  if (G_CCLOSURE_SWAP_DATA (closure))
 
927
    {
 
928
      data1 = closure->data;
 
929
      data2 = g_value_peek_pointer (param_values + 0);
 
930
    }
 
931
  else
 
932
    {
 
933
      data1 = g_value_peek_pointer (param_values + 0);
 
934
      data2 = closure->data;
 
935
    }
 
936
  callback = (GMarshalFunc_VOID__STRING_STRING) (marshal_data ? marshal_data : cc->callback);
 
937
 
 
938
  callback (data1,
 
939
            g_marshal_value_peek_string (param_values + 1),
 
940
            g_marshal_value_peek_string (param_values + 2),
 
941
            data2);
 
942
}
 
943
 
 
944
/* VOID:STRING,STRING,STRING (./rb-marshal.list:21) */
 
945
extern void rb_marshal_VOID__STRING_STRING_STRING (GClosure     *closure,
 
946
                                                   GValue       *return_value,
 
947
                                                   guint         n_param_values,
 
948
                                                   const GValue *param_values,
 
949
                                                   gpointer      invocation_hint,
 
950
                                                   gpointer      marshal_data);
 
951
void
 
952
rb_marshal_VOID__STRING_STRING_STRING (GClosure     *closure,
 
953
                                       GValue       *return_value,
 
954
                                       guint         n_param_values,
 
955
                                       const GValue *param_values,
 
956
                                       gpointer      invocation_hint,
 
957
                                       gpointer      marshal_data)
 
958
{
 
959
  typedef void (*GMarshalFunc_VOID__STRING_STRING_STRING) (gpointer     data1,
 
960
                                                           gpointer     arg_1,
 
961
                                                           gpointer     arg_2,
 
962
                                                           gpointer     arg_3,
 
963
                                                           gpointer     data2);
 
964
  register GMarshalFunc_VOID__STRING_STRING_STRING callback;
 
965
  register GCClosure *cc = (GCClosure*) closure;
 
966
  register gpointer data1, data2;
 
967
 
 
968
  g_return_if_fail (n_param_values == 4);
 
969
 
 
970
  if (G_CCLOSURE_SWAP_DATA (closure))
 
971
    {
 
972
      data1 = closure->data;
 
973
      data2 = g_value_peek_pointer (param_values + 0);
 
974
    }
 
975
  else
 
976
    {
 
977
      data1 = g_value_peek_pointer (param_values + 0);
 
978
      data2 = closure->data;
 
979
    }
 
980
  callback = (GMarshalFunc_VOID__STRING_STRING_STRING) (marshal_data ? marshal_data : cc->callback);
 
981
 
 
982
  callback (data1,
 
983
            g_marshal_value_peek_string (param_values + 1),
 
984
            g_marshal_value_peek_string (param_values + 2),
 
985
            g_marshal_value_peek_string (param_values + 3),
 
986
            data2);
 
987
}
 
988
 
 
989
/* VOID:STRING,STRING,STRING,UINT,BOOLEAN (./rb-marshal.list:22) */
 
990
extern void rb_marshal_VOID__STRING_STRING_STRING_UINT_BOOLEAN (GClosure     *closure,
 
991
                                                                GValue       *return_value,
 
992
                                                                guint         n_param_values,
 
993
                                                                const GValue *param_values,
 
994
                                                                gpointer      invocation_hint,
 
995
                                                                gpointer      marshal_data);
 
996
void
 
997
rb_marshal_VOID__STRING_STRING_STRING_UINT_BOOLEAN (GClosure     *closure,
 
998
                                                    GValue       *return_value,
 
999
                                                    guint         n_param_values,
 
1000
                                                    const GValue *param_values,
 
1001
                                                    gpointer      invocation_hint,
 
1002
                                                    gpointer      marshal_data)
 
1003
{
 
1004
  typedef void (*GMarshalFunc_VOID__STRING_STRING_STRING_UINT_BOOLEAN) (gpointer     data1,
 
1005
                                                                        gpointer     arg_1,
 
1006
                                                                        gpointer     arg_2,
 
1007
                                                                        gpointer     arg_3,
 
1008
                                                                        guint        arg_4,
 
1009
                                                                        gboolean     arg_5,
 
1010
                                                                        gpointer     data2);
 
1011
  register GMarshalFunc_VOID__STRING_STRING_STRING_UINT_BOOLEAN callback;
 
1012
  register GCClosure *cc = (GCClosure*) closure;
 
1013
  register gpointer data1, data2;
 
1014
 
 
1015
  g_return_if_fail (n_param_values == 6);
 
1016
 
 
1017
  if (G_CCLOSURE_SWAP_DATA (closure))
 
1018
    {
 
1019
      data1 = closure->data;
 
1020
      data2 = g_value_peek_pointer (param_values + 0);
 
1021
    }
 
1022
  else
 
1023
    {
 
1024
      data1 = g_value_peek_pointer (param_values + 0);
 
1025
      data2 = closure->data;
 
1026
    }
 
1027
  callback = (GMarshalFunc_VOID__STRING_STRING_STRING_UINT_BOOLEAN) (marshal_data ? marshal_data : cc->callback);
 
1028
 
 
1029
  callback (data1,
 
1030
            g_marshal_value_peek_string (param_values + 1),
 
1031
            g_marshal_value_peek_string (param_values + 2),
 
1032
            g_marshal_value_peek_string (param_values + 3),
 
1033
            g_marshal_value_peek_uint (param_values + 4),
 
1034
            g_marshal_value_peek_boolean (param_values + 5),
 
1035
            data2);
 
1036
}
 
1037
 
 
1038
/* VOID:ULONG,FLOAT (./rb-marshal.list:23) */
 
1039
extern void rb_marshal_VOID__ULONG_FLOAT (GClosure     *closure,
 
1040
                                          GValue       *return_value,
 
1041
                                          guint         n_param_values,
 
1042
                                          const GValue *param_values,
 
1043
                                          gpointer      invocation_hint,
 
1044
                                          gpointer      marshal_data);
 
1045
void
 
1046
rb_marshal_VOID__ULONG_FLOAT (GClosure     *closure,
 
1047
                              GValue       *return_value,
 
1048
                              guint         n_param_values,
 
1049
                              const GValue *param_values,
 
1050
                              gpointer      invocation_hint,
 
1051
                              gpointer      marshal_data)
 
1052
{
 
1053
  typedef void (*GMarshalFunc_VOID__ULONG_FLOAT) (gpointer     data1,
 
1054
                                                  gulong       arg_1,
 
1055
                                                  gfloat       arg_2,
 
1056
                                                  gpointer     data2);
 
1057
  register GMarshalFunc_VOID__ULONG_FLOAT callback;
 
1058
  register GCClosure *cc = (GCClosure*) closure;
 
1059
  register gpointer data1, data2;
 
1060
 
 
1061
  g_return_if_fail (n_param_values == 3);
 
1062
 
 
1063
  if (G_CCLOSURE_SWAP_DATA (closure))
 
1064
    {
 
1065
      data1 = closure->data;
 
1066
      data2 = g_value_peek_pointer (param_values + 0);
 
1067
    }
 
1068
  else
 
1069
    {
 
1070
      data1 = g_value_peek_pointer (param_values + 0);
 
1071
      data2 = closure->data;
 
1072
    }
 
1073
  callback = (GMarshalFunc_VOID__ULONG_FLOAT) (marshal_data ? marshal_data : cc->callback);
 
1074
 
 
1075
  callback (data1,
 
1076
            g_marshal_value_peek_ulong (param_values + 1),
 
1077
            g_marshal_value_peek_float (param_values + 2),
 
1078
            data2);
 
1079
}
 
1080
 
 
1081
/* VOID:OBJECT,BOOLEAN (./rb-marshal.list:24) */
 
1082
extern void rb_marshal_VOID__OBJECT_BOOLEAN (GClosure     *closure,
 
1083
                                             GValue       *return_value,
 
1084
                                             guint         n_param_values,
 
1085
                                             const GValue *param_values,
 
1086
                                             gpointer      invocation_hint,
 
1087
                                             gpointer      marshal_data);
 
1088
void
 
1089
rb_marshal_VOID__OBJECT_BOOLEAN (GClosure     *closure,
 
1090
                                 GValue       *return_value,
 
1091
                                 guint         n_param_values,
 
1092
                                 const GValue *param_values,
 
1093
                                 gpointer      invocation_hint,
 
1094
                                 gpointer      marshal_data)
 
1095
{
 
1096
  typedef void (*GMarshalFunc_VOID__OBJECT_BOOLEAN) (gpointer     data1,
 
1097
                                                     gpointer     arg_1,
 
1098
                                                     gboolean     arg_2,
 
1099
                                                     gpointer     data2);
 
1100
  register GMarshalFunc_VOID__OBJECT_BOOLEAN callback;
 
1101
  register GCClosure *cc = (GCClosure*) closure;
 
1102
  register gpointer data1, data2;
 
1103
 
 
1104
  g_return_if_fail (n_param_values == 3);
 
1105
 
 
1106
  if (G_CCLOSURE_SWAP_DATA (closure))
 
1107
    {
 
1108
      data1 = closure->data;
 
1109
      data2 = g_value_peek_pointer (param_values + 0);
 
1110
    }
 
1111
  else
 
1112
    {
 
1113
      data1 = g_value_peek_pointer (param_values + 0);
 
1114
      data2 = closure->data;
 
1115
    }
 
1116
  callback = (GMarshalFunc_VOID__OBJECT_BOOLEAN) (marshal_data ? marshal_data : cc->callback);
 
1117
 
 
1118
  callback (data1,
 
1119
            g_marshal_value_peek_object (param_values + 1),
546
1120
            g_marshal_value_peek_boolean (param_values + 2),
547
1121
            data2);
548
1122
}