gobject/gmarshal.c

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