git.sur5r.net Git - bacula/bacula/blob - bacula/src/tray-monitor/eggmarshalers.c

   1 /*
   2    Bacula® - The Network Backup Solution
   3
   4    Copyright (C) 2004-2006 Free Software Foundation Europe e.V.
   5
   6    The main author of Bacula is Kern Sibbald, with contributions from
   7    many others, a complete list can be found in the file AUTHORS.
   8    This program is Free Software; you can redistribute it and/or
   9    modify it under the terms of version two of the GNU General Public
  10    License as published by the Free Software Foundation plus additions
  11    that are listed in the file LICENSE.
  12
  13    This program is distributed in the hope that it will be useful, but
  14    WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16    General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  21    02110-1301, USA.
  22
  23    Bacula® is a registered trademark of John Walker.
  24    The licensor of Bacula is the Free Software Foundation Europe
  25    (FSFE), Fiduciary Program, Sumatrastrasse 25, 8006 Zürich,
  26    Switzerland, email:ftf@fsfeurope.org.
  27 */
  28
  29 extern "C" {
  30
  31 #include <glib-object.h>
  32
  33
  34 #ifdef G_ENABLE_DEBUG
  35 #define g_marshal_value_peek_boolean(v)  g_value_get_boolean (v)
  36 #define g_marshal_value_peek_char(v)     g_value_get_char (v)
  37 #define g_marshal_value_peek_uchar(v)    g_value_get_uchar (v)
  38 #define g_marshal_value_peek_int(v)      g_value_get_int (v)
  39 #define g_marshal_value_peek_uint(v)     g_value_get_uint (v)
  40 #define g_marshal_value_peek_long(v)     g_value_get_long (v)
  41 #define g_marshal_value_peek_ulong(v)    g_value_get_ulong (v)
  42 #define g_marshal_value_peek_int64(v)    g_value_get_int64 (v)
  43 #define g_marshal_value_peek_uint64(v)   g_value_get_uint64 (v)
  44 #define g_marshal_value_peek_enum(v)     g_value_get_enum (v)
  45 #define g_marshal_value_peek_flags(v)    g_value_get_flags (v)
  46 #define g_marshal_value_peek_float(v)    g_value_get_float (v)
  47 #define g_marshal_value_peek_double(v)   g_value_get_double (v)
  48 #define g_marshal_value_peek_string(v)   (char*) g_value_get_string (v)
  49 #define g_marshal_value_peek_param(v)    g_value_get_param (v)
  50 #define g_marshal_value_peek_boxed(v)    g_value_get_boxed (v)
  51 #define g_marshal_value_peek_pointer(v)  g_value_get_pointer (v)
  52 #define g_marshal_value_peek_object(v)   g_value_get_object (v)
  53 #else /* !G_ENABLE_DEBUG */
  54 /* WARNING: This code accesses GValues directly, which is UNSUPPORTED API.
  55  *          Do not access GValues directly in your code. Instead, use the
  56  *          g_value_get_*() functions
  57  */
  58 #define g_marshal_value_peek_boolean(v)  (v)->data[0].v_int
  59 #define g_marshal_value_peek_char(v)     (v)->data[0].v_int
  60 #define g_marshal_value_peek_uchar(v)    (v)->data[0].v_uint
  61 #define g_marshal_value_peek_int(v)      (v)->data[0].v_int
  62 #define g_marshal_value_peek_uint(v)     (v)->data[0].v_uint
  63 #define g_marshal_value_peek_long(v)     (v)->data[0].v_long
  64 #define g_marshal_value_peek_ulong(v)    (v)->data[0].v_ulong
  65 #define g_marshal_value_peek_int64(v)    (v)->data[0].v_int64
  66 #define g_marshal_value_peek_uint64(v)   (v)->data[0].v_uint64
  67 #define g_marshal_value_peek_enum(v)     (v)->data[0].v_int
  68 #define g_marshal_value_peek_flags(v)    (v)->data[0].v_uint
  69 #define g_marshal_value_peek_float(v)    (v)->data[0].v_float
  70 #define g_marshal_value_peek_double(v)   (v)->data[0].v_double
  71 #define g_marshal_value_peek_string(v)   (v)->data[0].v_pointer
  72 #define g_marshal_value_peek_param(v)    (v)->data[0].v_pointer
  73 #define g_marshal_value_peek_boxed(v)    (v)->data[0].v_pointer
  74 #define g_marshal_value_peek_pointer(v)  (v)->data[0].v_pointer
  75 #define g_marshal_value_peek_object(v)   (v)->data[0].v_pointer
  76 #endif /* !G_ENABLE_DEBUG */
  77
  78
  79 /* VOID:OBJECT,OBJECT (eggmarshalers.list:1) */
  80 void
  81 _egg_marshal_VOID__OBJECT_OBJECT (GClosure     *closure,
  82                                   GValue       *return_value,
  83                                   guint         n_param_values,
  84                                   const GValue *param_values,
  85                                   gpointer      invocation_hint,
  86                                   gpointer      marshal_data)
  87 {
  88   typedef void (*GMarshalFunc_VOID__OBJECT_OBJECT) (gpointer     data1,
  89                                                     gpointer     arg_1,
  90                                                     gpointer     arg_2,
  91                                                     gpointer     data2);
  92   register GMarshalFunc_VOID__OBJECT_OBJECT callback;
  93   register GCClosure *cc = (GCClosure*) closure;
  94   register gpointer data1, data2;
  95
  96   g_return_if_fail (n_param_values == 3);
  97
  98   if (G_CCLOSURE_SWAP_DATA (closure))
  99     {
 100       data1 = closure->data;
 101       data2 = g_value_peek_pointer (param_values + 0);
 102     }
 103   else
 104     {
 105       data1 = g_value_peek_pointer (param_values + 0);
 106       data2 = closure->data;
 107     }
 108   callback = (GMarshalFunc_VOID__OBJECT_OBJECT) (marshal_data ? marshal_data : cc->callback);
 109
 110   callback (data1,
 111             g_marshal_value_peek_object (param_values + 1),
 112             g_marshal_value_peek_object (param_values + 2),
 113             data2);
 114 }
 115
 116 /* VOID:OBJECT,STRING,LONG,LONG (eggmarshalers.list:2) */
 117 void
 118 _egg_marshal_VOID__OBJECT_STRING_LONG_LONG (GClosure     *closure,
 119                                             GValue       *return_value,
 120                                             guint         n_param_values,
 121                                             const GValue *param_values,
 122                                             gpointer      invocation_hint,
 123                                             gpointer      marshal_data)
 124 {
 125   typedef void (*GMarshalFunc_VOID__OBJECT_STRING_LONG_LONG) (gpointer     data1,
 126                                                               gpointer     arg_1,
 127                                                               gpointer     arg_2,
 128                                                               glong        arg_3,
 129                                                               glong        arg_4,
 130                                                               gpointer     data2);
 131   register GMarshalFunc_VOID__OBJECT_STRING_LONG_LONG callback;
 132   register GCClosure *cc = (GCClosure*) closure;
 133   register gpointer data1, data2;
 134
 135   g_return_if_fail (n_param_values == 5);
 136
 137   if (G_CCLOSURE_SWAP_DATA (closure))
 138     {
 139       data1 = closure->data;
 140       data2 = g_value_peek_pointer (param_values + 0);
 141     }
 142   else
 143     {
 144       data1 = g_value_peek_pointer (param_values + 0);
 145       data2 = closure->data;
 146     }
 147   callback = (GMarshalFunc_VOID__OBJECT_STRING_LONG_LONG) (marshal_data ? marshal_data : cc->callback);
 148
 149   callback (data1,
 150             g_marshal_value_peek_object (param_values + 1),
 151             g_marshal_value_peek_string (param_values + 2),
 152             g_marshal_value_peek_long (param_values + 3),
 153             g_marshal_value_peek_long (param_values + 4),
 154             data2);
 155 }
 156
 157 /* VOID:OBJECT,LONG (eggmarshalers.list:3) */
 158 void
 159 _egg_marshal_VOID__OBJECT_LONG (GClosure     *closure,
 160                                 GValue       *return_value,
 161                                 guint         n_param_values,
 162                                 const GValue *param_values,
 163                                 gpointer      invocation_hint,
 164                                 gpointer      marshal_data)
 165 {
 166   typedef void (*GMarshalFunc_VOID__OBJECT_LONG) (gpointer     data1,
 167                                                   gpointer     arg_1,
 168                                                   glong        arg_2,
 169                                                   gpointer     data2);
 170   register GMarshalFunc_VOID__OBJECT_LONG callback;
 171   register GCClosure *cc = (GCClosure*) closure;
 172   register gpointer data1, data2;
 173
 174   g_return_if_fail (n_param_values == 3);
 175
 176   if (G_CCLOSURE_SWAP_DATA (closure))
 177     {
 178       data1 = closure->data;
 179       data2 = g_value_peek_pointer (param_values + 0);
 180     }
 181   else
 182     {
 183       data1 = g_value_peek_pointer (param_values + 0);
 184       data2 = closure->data;
 185     }
 186   callback = (GMarshalFunc_VOID__OBJECT_LONG) (marshal_data ? marshal_data : cc->callback);
 187
 188   callback (data1,
 189             g_marshal_value_peek_object (param_values + 1),
 190             g_marshal_value_peek_long (param_values + 2),
 191             data2);
 192 }
 193
 194 /* VOID:OBJECT,STRING,STRING (eggmarshalers.list:4) */
 195 void
 196 _egg_marshal_VOID__OBJECT_STRING_STRING (GClosure     *closure,
 197                                          GValue       *return_value,
 198                                          guint         n_param_values,
 199                                          const GValue *param_values,
 200                                          gpointer      invocation_hint,
 201                                          gpointer      marshal_data)
 202 {
 203   typedef void (*GMarshalFunc_VOID__OBJECT_STRING_STRING) (gpointer     data1,
 204                                                            gpointer     arg_1,
 205                                                            gpointer     arg_2,
 206                                                            gpointer     arg_3,
 207                                                            gpointer     data2);
 208   register GMarshalFunc_VOID__OBJECT_STRING_STRING callback;
 209   register GCClosure *cc = (GCClosure*) closure;
 210   register gpointer data1, data2;
 211
 212   g_return_if_fail (n_param_values == 4);
 213
 214   if (G_CCLOSURE_SWAP_DATA (closure))
 215     {
 216       data1 = closure->data;
 217       data2 = g_value_peek_pointer (param_values + 0);
 218     }
 219   else
 220     {
 221       data1 = g_value_peek_pointer (param_values + 0);
 222       data2 = closure->data;
 223     }
 224   callback = (GMarshalFunc_VOID__OBJECT_STRING_STRING) (marshal_data ? marshal_data : cc->callback);
 225
 226   callback (data1,
 227             g_marshal_value_peek_object (param_values + 1),
 228             g_marshal_value_peek_string (param_values + 2),
 229             g_marshal_value_peek_string (param_values + 3),
 230             data2);
 231 }
 232
 233 /* VOID:UINT,UINT (eggmarshalers.list:5) */
 234 void
 235 _egg_marshal_VOID__UINT_UINT (GClosure     *closure,
 236                               GValue       *return_value,
 237                               guint         n_param_values,
 238                               const GValue *param_values,
 239                               gpointer      invocation_hint,
 240                               gpointer      marshal_data)
 241 {
 242   typedef void (*GMarshalFunc_VOID__UINT_UINT) (gpointer     data1,
 243                                                 guint        arg_1,
 244                                                 guint        arg_2,
 245                                                 gpointer     data2);
 246   register GMarshalFunc_VOID__UINT_UINT callback;
 247   register GCClosure *cc = (GCClosure*) closure;
 248   register gpointer data1, data2;
 249
 250   g_return_if_fail (n_param_values == 3);
 251
 252   if (G_CCLOSURE_SWAP_DATA (closure))
 253     {
 254       data1 = closure->data;
 255       data2 = g_value_peek_pointer (param_values + 0);
 256     }
 257   else
 258     {
 259       data1 = g_value_peek_pointer (param_values + 0);
 260       data2 = closure->data;
 261     }
 262   callback = (GMarshalFunc_VOID__UINT_UINT) (marshal_data ? marshal_data : cc->callback);
 263
 264   callback (data1,
 265             g_marshal_value_peek_uint (param_values + 1),
 266             g_marshal_value_peek_uint (param_values + 2),
 267             data2);
 268 }
 269
 270 /* BOOLEAN:INT (eggmarshalers.list:6) */
 271 void
 272 _egg_marshal_BOOLEAN__INT (GClosure     *closure,
 273                            GValue       *return_value,
 274                            guint         n_param_values,
 275                            const GValue *param_values,
 276                            gpointer      invocation_hint,
 277                            gpointer      marshal_data)
 278 {
 279   typedef gboolean (*GMarshalFunc_BOOLEAN__INT) (gpointer     data1,
 280                                                  gint         arg_1,
 281                                                  gpointer     data2);
 282   register GMarshalFunc_BOOLEAN__INT callback;
 283   register GCClosure *cc = (GCClosure*) closure;
 284   register gpointer data1, data2;
 285   gboolean v_return;
 286
 287   g_return_if_fail (return_value != NULL);
 288   g_return_if_fail (n_param_values == 2);
 289
 290   if (G_CCLOSURE_SWAP_DATA (closure))
 291     {
 292       data1 = closure->data;
 293       data2 = g_value_peek_pointer (param_values + 0);
 294     }
 295   else
 296     {
 297       data1 = g_value_peek_pointer (param_values + 0);
 298       data2 = closure->data;
 299     }
 300   callback = (GMarshalFunc_BOOLEAN__INT) (marshal_data ? marshal_data : cc->callback);
 301
 302   v_return = callback (data1,
 303                        g_marshal_value_peek_int (param_values + 1),
 304                        data2);
 305
 306   g_value_set_boolean (return_value, v_return);
 307 }
 308
 309 /* BOOLEAN:ENUM (eggmarshalers.list:7) */
 310 void
 311 _egg_marshal_BOOLEAN__ENUM (GClosure     *closure,
 312                             GValue       *return_value,
 313                             guint         n_param_values,
 314                             const GValue *param_values,
 315                             gpointer      invocation_hint,
 316                             gpointer      marshal_data)
 317 {
 318   typedef gboolean (*GMarshalFunc_BOOLEAN__ENUM) (gpointer     data1,
 319                                                   gint         arg_1,
 320                                                   gpointer     data2);
 321   register GMarshalFunc_BOOLEAN__ENUM callback;
 322   register GCClosure *cc = (GCClosure*) closure;
 323   register gpointer data1, data2;
 324   gboolean v_return;
 325
 326   g_return_if_fail (return_value != NULL);
 327   g_return_if_fail (n_param_values == 2);
 328
 329   if (G_CCLOSURE_SWAP_DATA (closure))
 330     {
 331       data1 = closure->data;
 332       data2 = g_value_peek_pointer (param_values + 0);
 333     }
 334   else
 335     {
 336       data1 = g_value_peek_pointer (param_values + 0);
 337       data2 = closure->data;
 338     }
 339   callback = (GMarshalFunc_BOOLEAN__ENUM) (marshal_data ? marshal_data : cc->callback);
 340
 341   v_return = callback (data1,
 342                        g_marshal_value_peek_enum (param_values + 1),
 343                        data2);
 344
 345   g_value_set_boolean (return_value, v_return);
 346 }
 347
 348 /* BOOLEAN:VOID (eggmarshalers.list:8) */
 349 void
 350 _egg_marshal_BOOLEAN__VOID (GClosure     *closure,
 351                             GValue       *return_value,
 352                             guint         n_param_values,
 353                             const GValue *param_values,
 354                             gpointer      invocation_hint,
 355                             gpointer      marshal_data)
 356 {
 357   typedef gboolean (*GMarshalFunc_BOOLEAN__VOID) (gpointer     data1,
 358                                                   gpointer     data2);
 359   register GMarshalFunc_BOOLEAN__VOID callback;
 360   register GCClosure *cc = (GCClosure*) closure;
 361   register gpointer data1, data2;
 362   gboolean v_return;
 363
 364   g_return_if_fail (return_value != NULL);
 365   g_return_if_fail (n_param_values == 1);
 366
 367   if (G_CCLOSURE_SWAP_DATA (closure))
 368     {
 369       data1 = closure->data;
 370       data2 = g_value_peek_pointer (param_values + 0);
 371     }
 372   else
 373     {
 374       data1 = g_value_peek_pointer (param_values + 0);
 375       data2 = closure->data;
 376     }
 377   callback = (GMarshalFunc_BOOLEAN__VOID) (marshal_data ? marshal_data : cc->callback);
 378
 379   v_return = callback (data1,
 380                        data2);
 381
 382   g_value_set_boolean (return_value, v_return);
 383 }
 384
 385 /* OBJECT:VOID (eggmarshalers.list:9) */
 386 void
 387 _egg_marshal_OBJECT__VOID (GClosure     *closure,
 388                            GValue       *return_value,
 389                            guint         n_param_values,
 390                            const GValue *param_values,
 391                            gpointer      invocation_hint,
 392                            gpointer      marshal_data)
 393 {
 394   typedef GObject* (*GMarshalFunc_OBJECT__VOID) (gpointer     data1,
 395                                                  gpointer     data2);
 396   register GMarshalFunc_OBJECT__VOID callback;
 397   register GCClosure *cc = (GCClosure*) closure;
 398   register gpointer data1, data2;
 399   GObject* v_return;
 400
 401   g_return_if_fail (return_value != NULL);
 402   g_return_if_fail (n_param_values == 1);
 403
 404   if (G_CCLOSURE_SWAP_DATA (closure))
 405     {
 406       data1 = closure->data;
 407       data2 = g_value_peek_pointer (param_values + 0);
 408     }
 409   else
 410     {
 411       data1 = g_value_peek_pointer (param_values + 0);
 412       data2 = closure->data;
 413     }
 414   callback = (GMarshalFunc_OBJECT__VOID) (marshal_data ? marshal_data : cc->callback);
 415
 416   v_return = callback (data1,
 417                        data2);
 418
 419   g_value_set_object_take_ownership (return_value, v_return);
 420 }
 421
 422 /* VOID:VOID (eggmarshalers.list:10) */
 423
 424 /* VOID:INT,INT (eggmarshalers.list:11) */
 425 void
 426 _egg_marshal_VOID__INT_INT (GClosure     *closure,
 427                             GValue       *return_value,
 428                             guint         n_param_values,
 429                             const GValue *param_values,
 430                             gpointer      invocation_hint,
 431                             gpointer      marshal_data)
 432 {
 433   typedef void (*GMarshalFunc_VOID__INT_INT) (gpointer     data1,
 434                                               gint         arg_1,
 435                                               gint         arg_2,
 436                                               gpointer     data2);
 437   register GMarshalFunc_VOID__INT_INT callback;
 438   register GCClosure *cc = (GCClosure*) closure;
 439   register gpointer data1, data2;
 440
 441   g_return_if_fail (n_param_values == 3);
 442
 443   if (G_CCLOSURE_SWAP_DATA (closure))
 444     {
 445       data1 = closure->data;
 446       data2 = g_value_peek_pointer (param_values + 0);
 447     }
 448   else
 449     {
 450       data1 = g_value_peek_pointer (param_values + 0);
 451       data2 = closure->data;
 452     }
 453   callback = (GMarshalFunc_VOID__INT_INT) (marshal_data ? marshal_data : cc->callback);
 454
 455   callback (data1,
 456             g_marshal_value_peek_int (param_values + 1),
 457             g_marshal_value_peek_int (param_values + 2),
 458             data2);
 459 }
 460
 461 /* VOID:UINT,UINT (eggmarshalers.list:12) */
 462
 463 /* VOID:BOOLEAN (eggmarshalers.list:13) */
 464
 465 /* VOID:OBJECT,ENUM,BOXED (eggmarshalers.list:14) */
 466 void
 467 _egg_marshal_VOID__OBJECT_ENUM_BOXED (GClosure     *closure,
 468                                       GValue       *return_value,
 469                                       guint         n_param_values,
 470                                       const GValue *param_values,
 471                                       gpointer      invocation_hint,
 472                                       gpointer      marshal_data)
 473 {
 474   typedef void (*GMarshalFunc_VOID__OBJECT_ENUM_BOXED) (gpointer     data1,
 475                                                         gpointer     arg_1,
 476                                                         gint         arg_2,
 477                                                         gpointer     arg_3,
 478                                                         gpointer     data2);
 479   register GMarshalFunc_VOID__OBJECT_ENUM_BOXED callback;
 480   register GCClosure *cc = (GCClosure*) closure;
 481   register gpointer data1, data2;
 482
 483   g_return_if_fail (n_param_values == 4);
 484
 485   if (G_CCLOSURE_SWAP_DATA (closure))
 486     {
 487       data1 = closure->data;
 488       data2 = g_value_peek_pointer (param_values + 0);
 489     }
 490   else
 491     {
 492       data1 = g_value_peek_pointer (param_values + 0);
 493       data2 = closure->data;
 494     }
 495   callback = (GMarshalFunc_VOID__OBJECT_ENUM_BOXED) (marshal_data ? marshal_data : cc->callback);
 496
 497   callback (data1,
 498             g_marshal_value_peek_object (param_values + 1),
 499             g_marshal_value_peek_enum (param_values + 2),
 500             g_marshal_value_peek_boxed (param_values + 3),
 501             data2);
 502 }
 503
 504 /* VOID:BOXED (eggmarshalers.list:15) */
 505
 506 /* BOOLEAN:BOOLEAN (eggmarshalers.list:16) */
 507 void
 508 _egg_marshal_BOOLEAN__BOOLEAN (GClosure     *closure,
 509                                GValue       *return_value,
 510                                guint         n_param_values,
 511                                const GValue *param_values,
 512                                gpointer      invocation_hint,
 513                                gpointer      marshal_data)
 514 {
 515   typedef gboolean (*GMarshalFunc_BOOLEAN__BOOLEAN) (gpointer     data1,
 516                                                      gboolean     arg_1,
 517                                                      gpointer     data2);
 518   register GMarshalFunc_BOOLEAN__BOOLEAN callback;
 519   register GCClosure *cc = (GCClosure*) closure;
 520   register gpointer data1, data2;
 521   gboolean v_return;
 522
 523   g_return_if_fail (return_value != NULL);
 524   g_return_if_fail (n_param_values == 2);
 525
 526   if (G_CCLOSURE_SWAP_DATA (closure))
 527     {
 528       data1 = closure->data;
 529       data2 = g_value_peek_pointer (param_values + 0);
 530     }
 531   else
 532     {
 533       data1 = g_value_peek_pointer (param_values + 0);
 534       data2 = closure->data;
 535     }
 536   callback = (GMarshalFunc_BOOLEAN__BOOLEAN) (marshal_data ? marshal_data : cc->callback);
 537
 538   v_return = callback (data1,
 539                        g_marshal_value_peek_boolean (param_values + 1),
 540                        data2);
 541
 542   g_value_set_boolean (return_value, v_return);
 543 }
 544
 545 /* BOOLEAN:OBJECT,STRING,STRING (eggmarshalers.list:17) */
 546 void
 547 _egg_marshal_BOOLEAN__OBJECT_STRING_STRING (GClosure     *closure,
 548                                             GValue       *return_value,
 549                                             guint         n_param_values,
 550                                             const GValue *param_values,
 551                                             gpointer      invocation_hint,
 552                                             gpointer      marshal_data)
 553 {
 554   typedef gboolean (*GMarshalFunc_BOOLEAN__OBJECT_STRING_STRING) (gpointer     data1,
 555                                                                   gpointer     arg_1,
 556                                                                   gpointer     arg_2,
 557                                                                   gpointer     arg_3,
 558                                                                   gpointer     data2);
 559   register GMarshalFunc_BOOLEAN__OBJECT_STRING_STRING callback;
 560   register GCClosure *cc = (GCClosure*) closure;
 561   register gpointer data1, data2;
 562   gboolean v_return;
 563
 564   g_return_if_fail (return_value != NULL);
 565   g_return_if_fail (n_param_values == 4);
 566
 567   if (G_CCLOSURE_SWAP_DATA (closure))
 568     {
 569       data1 = closure->data;
 570       data2 = g_value_peek_pointer (param_values + 0);
 571     }
 572   else
 573     {
 574       data1 = g_value_peek_pointer (param_values + 0);
 575       data2 = closure->data;
 576     }
 577   callback = (GMarshalFunc_BOOLEAN__OBJECT_STRING_STRING) (marshal_data ? marshal_data : cc->callback);
 578
 579   v_return = callback (data1,
 580                        g_marshal_value_peek_object (param_values + 1),
 581                        g_marshal_value_peek_string (param_values + 2),
 582                        g_marshal_value_peek_string (param_values + 3),
 583                        data2);
 584
 585   g_value_set_boolean (return_value, v_return);
 586 }
 587
 588 } // extern "C"