src/helper/sp-marshal.cpp.mingw

   1
   2 #include "helper/sp-marshal.h"
   3 #include        <glib-object.h>
   4
   5
   6 #ifdef G_ENABLE_DEBUG
   7 #define g_marshal_value_peek_boolean(v)  g_value_get_boolean (v)
   8 #define g_marshal_value_peek_char(v)     g_value_get_char (v)
   9 #define g_marshal_value_peek_uchar(v)    g_value_get_uchar (v)
  10 #define g_marshal_value_peek_int(v)      g_value_get_int (v)
  11 #define g_marshal_value_peek_uint(v)     g_value_get_uint (v)
  12 #define g_marshal_value_peek_long(v)     g_value_get_long (v)
  13 #define g_marshal_value_peek_ulong(v)    g_value_get_ulong (v)
  14 #define g_marshal_value_peek_int64(v)    g_value_get_int64 (v)
  15 #define g_marshal_value_peek_uint64(v)   g_value_get_uint64 (v)
  16 #define g_marshal_value_peek_enum(v)     g_value_get_enum (v)
  17 #define g_marshal_value_peek_flags(v)    g_value_get_flags (v)
  18 #define g_marshal_value_peek_float(v)    g_value_get_float (v)
  19 #define g_marshal_value_peek_double(v)   g_value_get_double (v)
  20 #define g_marshal_value_peek_string(v)   (char*) g_value_get_string (v)
  21 #define g_marshal_value_peek_param(v)    g_value_get_param (v)
  22 #define g_marshal_value_peek_boxed(v)    g_value_get_boxed (v)
  23 #define g_marshal_value_peek_pointer(v)  g_value_get_pointer (v)
  24 #define g_marshal_value_peek_object(v)   g_value_get_object (v)
  25 #else /* !G_ENABLE_DEBUG */
  26 /* WARNING: This code accesses GValues directly, which is UNSUPPORTED API.
  27  *          Do not access GValues directly in your code. Instead, use the
  28  *          g_value_get_*() functions
  29  */
  30 #define g_marshal_value_peek_boolean(v)  (v)->data[0].v_int
  31 #define g_marshal_value_peek_char(v)     (v)->data[0].v_int
  32 #define g_marshal_value_peek_uchar(v)    (v)->data[0].v_uint
  33 #define g_marshal_value_peek_int(v)      (v)->data[0].v_int
  34 #define g_marshal_value_peek_uint(v)     (v)->data[0].v_uint
  35 #define g_marshal_value_peek_long(v)     (v)->data[0].v_long
  36 #define g_marshal_value_peek_ulong(v)    (v)->data[0].v_ulong
  37 #define g_marshal_value_peek_int64(v)    (v)->data[0].v_int64
  38 #define g_marshal_value_peek_uint64(v)   (v)->data[0].v_uint64
  39 #define g_marshal_value_peek_enum(v)     (v)->data[0].v_long
  40 #define g_marshal_value_peek_flags(v)    (v)->data[0].v_ulong
  41 #define g_marshal_value_peek_float(v)    (v)->data[0].v_float
  42 #define g_marshal_value_peek_double(v)   (v)->data[0].v_double
  43 #define g_marshal_value_peek_string(v)   (v)->data[0].v_pointer
  44 #define g_marshal_value_peek_param(v)    (v)->data[0].v_pointer
  45 #define g_marshal_value_peek_boxed(v)    (v)->data[0].v_pointer
  46 #define g_marshal_value_peek_pointer(v)  (v)->data[0].v_pointer
  47 #define g_marshal_value_peek_object(v)   (v)->data[0].v_pointer
  48 #endif /* !G_ENABLE_DEBUG */
  49
  50
  51 /* NONE:NONE (sp-marshal.list:2) */
  52
  53 /* NONE:UINT (sp-marshal.list:3) */
  54
  55 /* NONE:POINTER (sp-marshal.list:4) */
  56
  57 /* NONE:POINTER,BOOLEAN (sp-marshal.list:5) */
  58 void
  59 sp_marshal_VOID__POINTER_BOOLEAN (GClosure     *closure,
  60                                   GValue       *return_value G_GNUC_UNUSED,
  61                                   guint         n_param_values,
  62                                   const GValue *param_values,
  63                                   gpointer      invocation_hint G_GNUC_UNUSED,
  64                                   gpointer      marshal_data)
  65 {
  66   typedef void (*GMarshalFunc_VOID__POINTER_BOOLEAN) (gpointer     data1,
  67                                                       gpointer     arg_1,
  68                                                       gboolean     arg_2,
  69                                                       gpointer     data2);
  70   register GMarshalFunc_VOID__POINTER_BOOLEAN callback;
  71   register GCClosure *cc = (GCClosure*) closure;
  72   register gpointer data1, data2;
  73
  74   g_return_if_fail (n_param_values == 3);
  75
  76   if (G_CCLOSURE_SWAP_DATA (closure))
  77     {
  78       data1 = closure->data;
  79       data2 = g_value_peek_pointer (param_values + 0);
  80     }
  81   else
  82     {
  83       data1 = g_value_peek_pointer (param_values + 0);
  84       data2 = closure->data;
  85     }
  86   callback = (GMarshalFunc_VOID__POINTER_BOOLEAN) (marshal_data ? marshal_data : cc->callback);
  87
  88   callback (data1,
  89             g_marshal_value_peek_pointer (param_values + 1),
  90             g_marshal_value_peek_boolean (param_values + 2),
  91             data2);
  92 }
  93
  94 /* NONE:POINTER,UINT (sp-marshal.list:6) */
  95 void
  96 sp_marshal_VOID__POINTER_UINT (GClosure     *closure,
  97                                GValue       *return_value G_GNUC_UNUSED,
  98                                guint         n_param_values,
  99                                const GValue *param_values,
 100                                gpointer      invocation_hint G_GNUC_UNUSED,
 101                                gpointer      marshal_data)
 102 {
 103   typedef void (*GMarshalFunc_VOID__POINTER_UINT) (gpointer     data1,
 104                                                    gpointer     arg_1,
 105                                                    guint        arg_2,
 106                                                    gpointer     data2);
 107   register GMarshalFunc_VOID__POINTER_UINT callback;
 108   register GCClosure *cc = (GCClosure*) closure;
 109   register gpointer data1, data2;
 110
 111   g_return_if_fail (n_param_values == 3);
 112
 113   if (G_CCLOSURE_SWAP_DATA (closure))
 114     {
 115       data1 = closure->data;
 116       data2 = g_value_peek_pointer (param_values + 0);
 117     }
 118   else
 119     {
 120       data1 = g_value_peek_pointer (param_values + 0);
 121       data2 = closure->data;
 122     }
 123   callback = (GMarshalFunc_VOID__POINTER_UINT) (marshal_data ? marshal_data : cc->callback);
 124
 125   callback (data1,
 126             g_marshal_value_peek_pointer (param_values + 1),
 127             g_marshal_value_peek_uint (param_values + 2),
 128             data2);
 129 }
 130
 131 /* NONE:POINTER,DOUBLE (sp-marshal.list:7) */
 132 void
 133 sp_marshal_VOID__POINTER_DOUBLE (GClosure     *closure,
 134                                  GValue       *return_value G_GNUC_UNUSED,
 135                                  guint         n_param_values,
 136                                  const GValue *param_values,
 137                                  gpointer      invocation_hint G_GNUC_UNUSED,
 138                                  gpointer      marshal_data)
 139 {
 140   typedef void (*GMarshalFunc_VOID__POINTER_DOUBLE) (gpointer     data1,
 141                                                      gpointer     arg_1,
 142                                                      gdouble      arg_2,
 143                                                      gpointer     data2);
 144   register GMarshalFunc_VOID__POINTER_DOUBLE callback;
 145   register GCClosure *cc = (GCClosure*) closure;
 146   register gpointer data1, data2;
 147
 148   g_return_if_fail (n_param_values == 3);
 149
 150   if (G_CCLOSURE_SWAP_DATA (closure))
 151     {
 152       data1 = closure->data;
 153       data2 = g_value_peek_pointer (param_values + 0);
 154     }
 155   else
 156     {
 157       data1 = g_value_peek_pointer (param_values + 0);
 158       data2 = closure->data;
 159     }
 160   callback = (GMarshalFunc_VOID__POINTER_DOUBLE) (marshal_data ? marshal_data : cc->callback);
 161
 162   callback (data1,
 163             g_marshal_value_peek_pointer (param_values + 1),
 164             g_marshal_value_peek_double (param_values + 2),
 165             data2);
 166 }
 167
 168 /* NONE:DOUBLE,DOUBLE (sp-marshal.list:8) */
 169 void
 170 sp_marshal_VOID__DOUBLE_DOUBLE (GClosure     *closure,
 171                                 GValue       *return_value G_GNUC_UNUSED,
 172                                 guint         n_param_values,
 173                                 const GValue *param_values,
 174                                 gpointer      invocation_hint G_GNUC_UNUSED,
 175                                 gpointer      marshal_data)
 176 {
 177   typedef void (*GMarshalFunc_VOID__DOUBLE_DOUBLE) (gpointer     data1,
 178                                                     gdouble      arg_1,
 179                                                     gdouble      arg_2,
 180                                                     gpointer     data2);
 181   register GMarshalFunc_VOID__DOUBLE_DOUBLE callback;
 182   register GCClosure *cc = (GCClosure*) closure;
 183   register gpointer data1, data2;
 184
 185   g_return_if_fail (n_param_values == 3);
 186
 187   if (G_CCLOSURE_SWAP_DATA (closure))
 188     {
 189       data1 = closure->data;
 190       data2 = g_value_peek_pointer (param_values + 0);
 191     }
 192   else
 193     {
 194       data1 = g_value_peek_pointer (param_values + 0);
 195       data2 = closure->data;
 196     }
 197   callback = (GMarshalFunc_VOID__DOUBLE_DOUBLE) (marshal_data ? marshal_data : cc->callback);
 198
 199   callback (data1,
 200             g_marshal_value_peek_double (param_values + 1),
 201             g_marshal_value_peek_double (param_values + 2),
 202             data2);
 203 }
 204
 205 /* NONE:STRING,BOOL (sp-marshal.list:9) */
 206 void
 207 sp_marshal_VOID__STRING_BOOLEAN (GClosure     *closure,
 208                                  GValue       *return_value G_GNUC_UNUSED,
 209                                  guint         n_param_values,
 210                                  const GValue *param_values,
 211                                  gpointer      invocation_hint G_GNUC_UNUSED,
 212                                  gpointer      marshal_data)
 213 {
 214   typedef void (*GMarshalFunc_VOID__STRING_BOOLEAN) (gpointer     data1,
 215                                                      gpointer     arg_1,
 216                                                      gboolean     arg_2,
 217                                                      gpointer     data2);
 218   register GMarshalFunc_VOID__STRING_BOOLEAN callback;
 219   register GCClosure *cc = (GCClosure*) closure;
 220   register gpointer data1, data2;
 221
 222   g_return_if_fail (n_param_values == 3);
 223
 224   if (G_CCLOSURE_SWAP_DATA (closure))
 225     {
 226       data1 = closure->data;
 227       data2 = g_value_peek_pointer (param_values + 0);
 228     }
 229   else
 230     {
 231       data1 = g_value_peek_pointer (param_values + 0);
 232       data2 = closure->data;
 233     }
 234   callback = (GMarshalFunc_VOID__STRING_BOOLEAN) (marshal_data ? marshal_data : cc->callback);
 235
 236   callback (data1,
 237             g_marshal_value_peek_string (param_values + 1),
 238             g_marshal_value_peek_boolean (param_values + 2),
 239             data2);
 240 }
 241
 242 /* BOOLEAN:NONE (sp-marshal.list:10) */
 243 void
 244 sp_marshal_BOOLEAN__VOID (GClosure     *closure,
 245                           GValue       *return_value G_GNUC_UNUSED,
 246                           guint         n_param_values,
 247                           const GValue *param_values,
 248                           gpointer      invocation_hint G_GNUC_UNUSED,
 249                           gpointer      marshal_data)
 250 {
 251   typedef gboolean (*GMarshalFunc_BOOLEAN__VOID) (gpointer     data1,
 252                                                   gpointer     data2);
 253   register GMarshalFunc_BOOLEAN__VOID callback;
 254   register GCClosure *cc = (GCClosure*) closure;
 255   register gpointer data1, data2;
 256   gboolean v_return;
 257
 258   g_return_if_fail (return_value != NULL);
 259   g_return_if_fail (n_param_values == 1);
 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_BOOLEAN__VOID) (marshal_data ? marshal_data : cc->callback);
 272
 273   v_return = callback (data1,
 274                        data2);
 275
 276   g_value_set_boolean (return_value, v_return);
 277 }
 278
 279 /* BOOLEAN:UINT (sp-marshal.list:11) */
 280 void
 281 sp_marshal_BOOLEAN__UINT (GClosure     *closure,
 282                           GValue       *return_value G_GNUC_UNUSED,
 283                           guint         n_param_values,
 284                           const GValue *param_values,
 285                           gpointer      invocation_hint G_GNUC_UNUSED,
 286                           gpointer      marshal_data)
 287 {
 288   typedef gboolean (*GMarshalFunc_BOOLEAN__UINT) (gpointer     data1,
 289                                                   guint        arg_1,
 290                                                   gpointer     data2);
 291   register GMarshalFunc_BOOLEAN__UINT callback;
 292   register GCClosure *cc = (GCClosure*) closure;
 293   register gpointer data1, data2;
 294   gboolean v_return;
 295
 296   g_return_if_fail (return_value != NULL);
 297   g_return_if_fail (n_param_values == 2);
 298
 299   if (G_CCLOSURE_SWAP_DATA (closure))
 300     {
 301       data1 = closure->data;
 302       data2 = g_value_peek_pointer (param_values + 0);
 303     }
 304   else
 305     {
 306       data1 = g_value_peek_pointer (param_values + 0);
 307       data2 = closure->data;
 308     }
 309   callback = (GMarshalFunc_BOOLEAN__UINT) (marshal_data ? marshal_data : cc->callback);
 310
 311   v_return = callback (data1,
 312                        g_marshal_value_peek_uint (param_values + 1),
 313                        data2);
 314
 315   g_value_set_boolean (return_value, v_return);
 316 }
 317
 318 /* BOOLEAN:POINTER (sp-marshal.list:12) */
 319 void
 320 sp_marshal_BOOLEAN__POINTER (GClosure     *closure,
 321                              GValue       *return_value G_GNUC_UNUSED,
 322                              guint         n_param_values,
 323                              const GValue *param_values,
 324                              gpointer      invocation_hint G_GNUC_UNUSED,
 325                              gpointer      marshal_data)
 326 {
 327   typedef gboolean (*GMarshalFunc_BOOLEAN__POINTER) (gpointer     data1,
 328                                                      gpointer     arg_1,
 329                                                      gpointer     data2);
 330   register GMarshalFunc_BOOLEAN__POINTER callback;
 331   register GCClosure *cc = (GCClosure*) closure;
 332   register gpointer data1, data2;
 333   gboolean v_return;
 334
 335   g_return_if_fail (return_value != NULL);
 336   g_return_if_fail (n_param_values == 2);
 337
 338   if (G_CCLOSURE_SWAP_DATA (closure))
 339     {
 340       data1 = closure->data;
 341       data2 = g_value_peek_pointer (param_values + 0);
 342     }
 343   else
 344     {
 345       data1 = g_value_peek_pointer (param_values + 0);
 346       data2 = closure->data;
 347     }
 348   callback = (GMarshalFunc_BOOLEAN__POINTER) (marshal_data ? marshal_data : cc->callback);
 349
 350   v_return = callback (data1,
 351                        g_marshal_value_peek_pointer (param_values + 1),
 352                        data2);
 353
 354   g_value_set_boolean (return_value, v_return);
 355 }
 356
 357 /* BOOLEAN:POINTER,UINT (sp-marshal.list:13) */
 358 void
 359 sp_marshal_BOOLEAN__POINTER_UINT (GClosure     *closure,
 360                                   GValue       *return_value G_GNUC_UNUSED,
 361                                   guint         n_param_values,
 362                                   const GValue *param_values,
 363                                   gpointer      invocation_hint G_GNUC_UNUSED,
 364                                   gpointer      marshal_data)
 365 {
 366   typedef gboolean (*GMarshalFunc_BOOLEAN__POINTER_UINT) (gpointer     data1,
 367                                                           gpointer     arg_1,
 368                                                           guint        arg_2,
 369                                                           gpointer     data2);
 370   register GMarshalFunc_BOOLEAN__POINTER_UINT callback;
 371   register GCClosure *cc = (GCClosure*) closure;
 372   register gpointer data1, data2;
 373   gboolean v_return;
 374
 375   g_return_if_fail (return_value != NULL);
 376   g_return_if_fail (n_param_values == 3);
 377
 378   if (G_CCLOSURE_SWAP_DATA (closure))
 379     {
 380       data1 = closure->data;
 381       data2 = g_value_peek_pointer (param_values + 0);
 382     }
 383   else
 384     {
 385       data1 = g_value_peek_pointer (param_values + 0);
 386       data2 = closure->data;
 387     }
 388   callback = (GMarshalFunc_BOOLEAN__POINTER_UINT) (marshal_data ? marshal_data : cc->callback);
 389
 390   v_return = callback (data1,
 391                        g_marshal_value_peek_pointer (param_values + 1),
 392                        g_marshal_value_peek_uint (param_values + 2),
 393                        data2);
 394
 395   g_value_set_boolean (return_value, v_return);
 396 }
 397
 398 /* BOOLEAN:POINTER,POINTER (sp-marshal.list:14) */
 399 void
 400 sp_marshal_BOOLEAN__POINTER_POINTER (GClosure     *closure,
 401                                      GValue       *return_value G_GNUC_UNUSED,
 402                                      guint         n_param_values,
 403                                      const GValue *param_values,
 404                                      gpointer      invocation_hint G_GNUC_UNUSED,
 405                                      gpointer      marshal_data)
 406 {
 407   typedef gboolean (*GMarshalFunc_BOOLEAN__POINTER_POINTER) (gpointer     data1,
 408                                                              gpointer     arg_1,
 409                                                              gpointer     arg_2,
 410                                                              gpointer     data2);
 411   register GMarshalFunc_BOOLEAN__POINTER_POINTER callback;
 412   register GCClosure *cc = (GCClosure*) closure;
 413   register gpointer data1, data2;
 414   gboolean v_return;
 415
 416   g_return_if_fail (return_value != NULL);
 417   g_return_if_fail (n_param_values == 3);
 418
 419   if (G_CCLOSURE_SWAP_DATA (closure))
 420     {
 421       data1 = closure->data;
 422       data2 = g_value_peek_pointer (param_values + 0);
 423     }
 424   else
 425     {
 426       data1 = g_value_peek_pointer (param_values + 0);
 427       data2 = closure->data;
 428     }
 429   callback = (GMarshalFunc_BOOLEAN__POINTER_POINTER) (marshal_data ? marshal_data : cc->callback);
 430
 431   v_return = callback (data1,
 432                        g_marshal_value_peek_pointer (param_values + 1),
 433                        g_marshal_value_peek_pointer (param_values + 2),
 434                        data2);
 435
 436   g_value_set_boolean (return_value, v_return);
 437 }
 438
 439 /* INT:POINTER,POINTER (sp-marshal.list:15) */
 440 void
 441 sp_marshal_INT__POINTER_POINTER (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 gint (*GMarshalFunc_INT__POINTER_POINTER) (gpointer     data1,
 449                                                      gpointer     arg_1,
 450                                                      gpointer     arg_2,
 451                                                      gpointer     data2);
 452   register GMarshalFunc_INT__POINTER_POINTER callback;
 453   register GCClosure *cc = (GCClosure*) closure;
 454   register gpointer data1, data2;
 455   gint v_return;
 456
 457   g_return_if_fail (return_value != NULL);
 458   g_return_if_fail (n_param_values == 3);
 459
 460   if (G_CCLOSURE_SWAP_DATA (closure))
 461     {
 462       data1 = closure->data;
 463       data2 = g_value_peek_pointer (param_values + 0);
 464     }
 465   else
 466     {
 467       data1 = g_value_peek_pointer (param_values + 0);
 468       data2 = closure->data;
 469     }
 470   callback = (GMarshalFunc_INT__POINTER_POINTER) (marshal_data ? marshal_data : cc->callback);
 471
 472   v_return = callback (data1,
 473                        g_marshal_value_peek_pointer (param_values + 1),
 474                        g_marshal_value_peek_pointer (param_values + 2),
 475                        data2);
 476
 477   g_value_set_int (return_value, v_return);
 478 }
 479
 480 /* DOUBLE:POINTER,UINT (sp-marshal.list:16) */
 481 void
 482 sp_marshal_DOUBLE__POINTER_UINT (GClosure     *closure,
 483                                  GValue       *return_value G_GNUC_UNUSED,
 484                                  guint         n_param_values,
 485                                  const GValue *param_values,
 486                                  gpointer      invocation_hint G_GNUC_UNUSED,
 487                                  gpointer      marshal_data)
 488 {
 489   typedef gdouble (*GMarshalFunc_DOUBLE__POINTER_UINT) (gpointer     data1,
 490                                                         gpointer     arg_1,
 491                                                         guint        arg_2,
 492                                                         gpointer     data2);
 493   register GMarshalFunc_DOUBLE__POINTER_UINT callback;
 494   register GCClosure *cc = (GCClosure*) closure;
 495   register gpointer data1, data2;
 496   gdouble v_return;
 497
 498   g_return_if_fail (return_value != NULL);
 499   g_return_if_fail (n_param_values == 3);
 500
 501   if (G_CCLOSURE_SWAP_DATA (closure))
 502     {
 503       data1 = closure->data;
 504       data2 = g_value_peek_pointer (param_values + 0);
 505     }
 506   else
 507     {
 508       data1 = g_value_peek_pointer (param_values + 0);
 509       data2 = closure->data;
 510     }
 511   callback = (GMarshalFunc_DOUBLE__POINTER_UINT) (marshal_data ? marshal_data : cc->callback);
 512
 513   v_return = callback (data1,
 514                        g_marshal_value_peek_pointer (param_values + 1),
 515                        g_marshal_value_peek_uint (param_values + 2),
 516                        data2);
 517
 518   g_value_set_double (return_value, v_return);
 519 }
 520