Symaptic: os/ossrv/glib/gobject/gmarshal.c@260cb5ec6c19

     1 /*

     2 * Portions copyright (c) 2006-2009 Nokia Corporation.  All rights reserved.

     3 */

     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 */

    51 /* VOID:VOID (./gmarshal.list:26) */

    52 EXPORT_C void

    53 g_cclosure_marshal_VOID__VOID (GClosure     *closure,

    54                                GValue       *return_value G_GNUC_UNUSED,

    55                                guint         n_param_values,

    56                                const GValue *param_values,

    57                                gpointer      invocation_hint G_GNUC_UNUSED,

    58                                gpointer      marshal_data)

    59 {

    60   typedef void (*GMarshalFunc_VOID__VOID) (gpointer     data1,

    61                                            gpointer     data2);

    62   register GMarshalFunc_VOID__VOID callback;

    63   register GCClosure *cc = (GCClosure*) closure;

    64   register gpointer data1, data2;

    66   g_return_if_fail (n_param_values == 1);

    68   if (G_CCLOSURE_SWAP_DATA (closure))

    69     {

    70       data1 = closure->data;

    71       data2 = g_value_peek_pointer (param_values + 0);

    72     }

    73   else

    74     {

    75       data1 = g_value_peek_pointer (param_values + 0);

    76       data2 = closure->data;

    77     }

    78   callback = (GMarshalFunc_VOID__VOID) (marshal_data ? marshal_data : cc->callback);

    80   callback (data1,

    81             data2);

    82 }

    84 /* VOID:BOOLEAN (./gmarshal.list:27) */

    85 EXPORT_C void

    86 g_cclosure_marshal_VOID__BOOLEAN (GClosure     *closure,

    87                                   GValue       *return_value G_GNUC_UNUSED,

    88                                   guint         n_param_values,

    89                                   const GValue *param_values,

    90                                   gpointer      invocation_hint G_GNUC_UNUSED,

    91                                   gpointer      marshal_data)

    92 {

    93   typedef void (*GMarshalFunc_VOID__BOOLEAN) (gpointer     data1,

    94                                               gboolean     arg_1,

    95                                               gpointer     data2);

    96   register GMarshalFunc_VOID__BOOLEAN callback;

    97   register GCClosure *cc = (GCClosure*) closure;

    98   register gpointer data1, data2;

   100   g_return_if_fail (n_param_values == 2);

   102   if (G_CCLOSURE_SWAP_DATA (closure))

   103     {

   104       data1 = closure->data;

   105       data2 = g_value_peek_pointer (param_values + 0);

   106     }

   107   else

   108     {

   109       data1 = g_value_peek_pointer (param_values + 0);

   110       data2 = closure->data;

   111     }

   112   callback = (GMarshalFunc_VOID__BOOLEAN) (marshal_data ? marshal_data : cc->callback);

   114   callback (data1,

   115             g_marshal_value_peek_boolean (param_values + 1),

   116             data2);

   117 }

   119 /* VOID:CHAR (./gmarshal.list:28) */

   120 EXPORT_C void

   121 g_cclosure_marshal_VOID__CHAR (GClosure     *closure,

   122                                GValue       *return_value G_GNUC_UNUSED,

   123                                guint         n_param_values,

   124                                const GValue *param_values,

   125                                gpointer      invocation_hint G_GNUC_UNUSED,

   126                                gpointer      marshal_data)

   127 {

   128   typedef void (*GMarshalFunc_VOID__CHAR) (gpointer     data1,

   129                                            gchar        arg_1,

   130                                            gpointer     data2);

   131   register GMarshalFunc_VOID__CHAR callback;

   132   register GCClosure *cc = (GCClosure*) closure;

   133   register gpointer data1, data2;

   135   g_return_if_fail (n_param_values == 2);

   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__CHAR) (marshal_data ? marshal_data : cc->callback);

   149   callback (data1,

   150             g_marshal_value_peek_char (param_values + 1),

   151             data2);

   152 }

   154 /* VOID:UCHAR (./gmarshal.list:29) */

   155 EXPORT_C void

   156 g_cclosure_marshal_VOID__UCHAR (GClosure     *closure,

   157                                 GValue       *return_value G_GNUC_UNUSED,

   158                                 guint         n_param_values,

   159                                 const GValue *param_values,

   160                                 gpointer      invocation_hint G_GNUC_UNUSED,

   161                                 gpointer      marshal_data)

   162 {

   163   typedef void (*GMarshalFunc_VOID__UCHAR) (gpointer     data1,

   164                                             guchar       arg_1,

   165                                             gpointer     data2);

   166   register GMarshalFunc_VOID__UCHAR callback;

   167   register GCClosure *cc = (GCClosure*) closure;

   168   register gpointer data1, data2;

   170   g_return_if_fail (n_param_values == 2);

   172   if (G_CCLOSURE_SWAP_DATA (closure))

   173     {

   174       data1 = closure->data;

   175       data2 = g_value_peek_pointer (param_values + 0);

   176     }

   177   else

   178     {

   179       data1 = g_value_peek_pointer (param_values + 0);

   180       data2 = closure->data;

   181     }

   182   callback = (GMarshalFunc_VOID__UCHAR) (marshal_data ? marshal_data : cc->callback);

   184   callback (data1,

   185             g_marshal_value_peek_uchar (param_values + 1),

   186             data2);

   187 }

   189 /* VOID:INT (./gmarshal.list:30) */

   190 EXPORT_C void

   191 g_cclosure_marshal_VOID__INT (GClosure     *closure,

   192                               GValue       *return_value G_GNUC_UNUSED,

   193                               guint         n_param_values,

   194                               const GValue *param_values,

   195                               gpointer      invocation_hint G_GNUC_UNUSED,

   196                               gpointer      marshal_data)

   197 {

   198   typedef void (*GMarshalFunc_VOID__INT) (gpointer     data1,

   199                                           gint         arg_1,

   200                                           gpointer     data2);

   201   register GMarshalFunc_VOID__INT callback;

   202   register GCClosure *cc = (GCClosure*) closure;

   203   register gpointer data1, data2;

   205   g_return_if_fail (n_param_values == 2);

   207   if (G_CCLOSURE_SWAP_DATA (closure))

   208     {

   209       data1 = closure->data;

   210       data2 = g_value_peek_pointer (param_values + 0);

   211     }

   212   else

   213     {

   214       data1 = g_value_peek_pointer (param_values + 0);

   215       data2 = closure->data;

   216     }

   217   callback = (GMarshalFunc_VOID__INT) (marshal_data ? marshal_data : cc->callback);

   219   callback (data1,

   220             g_marshal_value_peek_int (param_values + 1),

   221             data2);

   222 }

   224 /* VOID:UINT (./gmarshal.list:31) */

   225 EXPORT_C void

   226 g_cclosure_marshal_VOID__UINT (GClosure     *closure,

   227                                GValue       *return_value G_GNUC_UNUSED,

   228                                guint         n_param_values,

   229                                const GValue *param_values,

   230                                gpointer      invocation_hint G_GNUC_UNUSED,

   231                                gpointer      marshal_data)

   232 {

   233   typedef void (*GMarshalFunc_VOID__UINT) (gpointer     data1,

   234                                            guint        arg_1,

   235                                            gpointer     data2);

   236   register GMarshalFunc_VOID__UINT callback;

   237   register GCClosure *cc = (GCClosure*) closure;

   238   register gpointer data1, data2;

   240   g_return_if_fail (n_param_values == 2);

   242   if (G_CCLOSURE_SWAP_DATA (closure))

   243     {

   244       data1 = closure->data;

   245       data2 = g_value_peek_pointer (param_values + 0);

   246     }

   247   else

   248     {

   249       data1 = g_value_peek_pointer (param_values + 0);

   250       data2 = closure->data;

   251     }

   252   callback = (GMarshalFunc_VOID__UINT) (marshal_data ? marshal_data : cc->callback);

   254   callback (data1,

   255             g_marshal_value_peek_uint (param_values + 1),

   256             data2);

   257 }

   259 /* VOID:LONG (./gmarshal.list:32) */

   260 EXPORT_C void

   261 g_cclosure_marshal_VOID__LONG (GClosure     *closure,

   262                                GValue       *return_value G_GNUC_UNUSED,

   263                                guint         n_param_values,

   264                                const GValue *param_values,

   265                                gpointer      invocation_hint G_GNUC_UNUSED,

   266                                gpointer      marshal_data)

   267 {

   268   typedef void (*GMarshalFunc_VOID__LONG) (gpointer     data1,

   269                                            glong        arg_1,

   270                                            gpointer     data2);

   271   register GMarshalFunc_VOID__LONG callback;

   272   register GCClosure *cc = (GCClosure*) closure;

   273   register gpointer data1, data2;

   275   g_return_if_fail (n_param_values == 2);

   277   if (G_CCLOSURE_SWAP_DATA (closure))

   278     {

   279       data1 = closure->data;

   280       data2 = g_value_peek_pointer (param_values + 0);

   281     }

   282   else

   283     {

   284       data1 = g_value_peek_pointer (param_values + 0);

   285       data2 = closure->data;

   286     }

   287   callback = (GMarshalFunc_VOID__LONG) (marshal_data ? marshal_data : cc->callback);

   289   callback (data1,

   290             g_marshal_value_peek_long (param_values + 1),

   291             data2);

   292 }

   294 /* VOID:ULONG (./gmarshal.list:33) */

   295 EXPORT_C void

   296 g_cclosure_marshal_VOID__ULONG (GClosure     *closure,

   297                                 GValue       *return_value G_GNUC_UNUSED,

   298                                 guint         n_param_values,

   299                                 const GValue *param_values,

   300                                 gpointer      invocation_hint G_GNUC_UNUSED,

   301                                 gpointer      marshal_data)

   302 {

   303   typedef void (*GMarshalFunc_VOID__ULONG) (gpointer     data1,

   304                                             gulong       arg_1,

   305                                             gpointer     data2);

   306   register GMarshalFunc_VOID__ULONG callback;

   307   register GCClosure *cc = (GCClosure*) closure;

   308   register gpointer data1, data2;

   310   g_return_if_fail (n_param_values == 2);

   312   if (G_CCLOSURE_SWAP_DATA (closure))

   313     {

   314       data1 = closure->data;

   315       data2 = g_value_peek_pointer (param_values + 0);

   316     }

   317   else

   318     {

   319       data1 = g_value_peek_pointer (param_values + 0);

   320       data2 = closure->data;

   321     }

   322   callback = (GMarshalFunc_VOID__ULONG) (marshal_data ? marshal_data : cc->callback);

   324   callback (data1,

   325             g_marshal_value_peek_ulong (param_values + 1),

   326             data2);

   327 }

   329 /* VOID:ENUM (./gmarshal.list:34) */

   330 EXPORT_C void

   331 g_cclosure_marshal_VOID__ENUM (GClosure     *closure,

   332                                GValue       *return_value G_GNUC_UNUSED,

   333                                guint         n_param_values,

   334                                const GValue *param_values,

   335                                gpointer      invocation_hint G_GNUC_UNUSED,

   336                                gpointer      marshal_data)

   337 {

   338   typedef void (*GMarshalFunc_VOID__ENUM) (gpointer     data1,

   339                                            gint         arg_1,

   340                                            gpointer     data2);

   341   register GMarshalFunc_VOID__ENUM callback;

   342   register GCClosure *cc = (GCClosure*) closure;

   343   register gpointer data1, data2;

   345   g_return_if_fail (n_param_values == 2);

   347   if (G_CCLOSURE_SWAP_DATA (closure))

   348     {

   349       data1 = closure->data;

   350       data2 = g_value_peek_pointer (param_values + 0);

   351     }

   352   else

   353     {

   354       data1 = g_value_peek_pointer (param_values + 0);

   355       data2 = closure->data;

   356     }

   357   callback = (GMarshalFunc_VOID__ENUM) (marshal_data ? marshal_data : cc->callback);

   359   callback (data1,

   360             g_marshal_value_peek_enum (param_values + 1),

   361             data2);

   362 }

   364 /* VOID:FLAGS (./gmarshal.list:35) */

   365 EXPORT_C void

   366 g_cclosure_marshal_VOID__FLAGS (GClosure     *closure,

   367                                 GValue       *return_value G_GNUC_UNUSED,

   368                                 guint         n_param_values,

   369                                 const GValue *param_values,

   370                                 gpointer      invocation_hint G_GNUC_UNUSED,

   371                                 gpointer      marshal_data)

   372 {

   373   typedef void (*GMarshalFunc_VOID__FLAGS) (gpointer     data1,

   374                                             guint        arg_1,

   375                                             gpointer     data2);

   376   register GMarshalFunc_VOID__FLAGS callback;

   377   register GCClosure *cc = (GCClosure*) closure;

   378   register gpointer data1, data2;

   380   g_return_if_fail (n_param_values == 2);

   382   if (G_CCLOSURE_SWAP_DATA (closure))

   383     {

   384       data1 = closure->data;

   385       data2 = g_value_peek_pointer (param_values + 0);

   386     }

   387   else

   388     {

   389       data1 = g_value_peek_pointer (param_values + 0);

   390       data2 = closure->data;

   391     }

   392   callback = (GMarshalFunc_VOID__FLAGS) (marshal_data ? marshal_data : cc->callback);

   394   callback (data1,

   395             g_marshal_value_peek_flags (param_values + 1),

   396             data2);

   397 }

   399 /* VOID:FLOAT (./gmarshal.list:36) */

   400 EXPORT_C void

   401 g_cclosure_marshal_VOID__FLOAT (GClosure     *closure,

   402                                 GValue       *return_value G_GNUC_UNUSED,

   403                                 guint         n_param_values,

   404                                 const GValue *param_values,

   405                                 gpointer      invocation_hint G_GNUC_UNUSED,

   406                                 gpointer      marshal_data)

   407 {

   408   typedef void (*GMarshalFunc_VOID__FLOAT) (gpointer     data1,

   409                                             gfloat       arg_1,

   410                                             gpointer     data2);

   411   register GMarshalFunc_VOID__FLOAT callback;

   412   register GCClosure *cc = (GCClosure*) closure;

   413   register gpointer data1, data2;

   415   g_return_if_fail (n_param_values == 2);

   417   if (G_CCLOSURE_SWAP_DATA (closure))

   418     {

   419       data1 = closure->data;

   420       data2 = g_value_peek_pointer (param_values + 0);

   421     }

   422   else

   423     {

   424       data1 = g_value_peek_pointer (param_values + 0);

   425       data2 = closure->data;

   426     }

   427   callback = (GMarshalFunc_VOID__FLOAT) (marshal_data ? marshal_data : cc->callback);

   429   callback (data1,

   430             g_marshal_value_peek_float (param_values + 1),

   431             data2);

   432 }

   434 /* VOID:DOUBLE (./gmarshal.list:37) */

   435 EXPORT_C void

   436 g_cclosure_marshal_VOID__DOUBLE (GClosure     *closure,

   437                                  GValue       *return_value G_GNUC_UNUSED,

   438                                  guint         n_param_values,

   439                                  const GValue *param_values,

   440                                  gpointer      invocation_hint G_GNUC_UNUSED,

   441                                  gpointer      marshal_data)

   442 {

   443   typedef void (*GMarshalFunc_VOID__DOUBLE) (gpointer     data1,

   444                                              gdouble      arg_1,

   445                                              gpointer     data2);

   446   register GMarshalFunc_VOID__DOUBLE callback;

   447   register GCClosure *cc = (GCClosure*) closure;

   448   register gpointer data1, data2;

   450   g_return_if_fail (n_param_values == 2);

   452   if (G_CCLOSURE_SWAP_DATA (closure))

   453     {

   454       data1 = closure->data;

   455       data2 = g_value_peek_pointer (param_values + 0);

   456     }

   457   else

   458     {

   459       data1 = g_value_peek_pointer (param_values + 0);

   460       data2 = closure->data;

   461     }

   462   callback = (GMarshalFunc_VOID__DOUBLE) (marshal_data ? marshal_data : cc->callback);

   464   callback (data1,

   465             g_marshal_value_peek_double (param_values + 1),

   466             data2);

   467 }

   469 /* VOID:STRING (./gmarshal.list:38) */

   470 EXPORT_C void

   471 g_cclosure_marshal_VOID__STRING (GClosure     *closure,

   472                                  GValue       *return_value G_GNUC_UNUSED,

   473                                  guint         n_param_values,

   474                                  const GValue *param_values,

   475                                  gpointer      invocation_hint G_GNUC_UNUSED,

   476                                  gpointer      marshal_data)

   477 {

   478   typedef void (*GMarshalFunc_VOID__STRING) (gpointer     data1,

   479                                              gpointer     arg_1,

   480                                              gpointer     data2);

   481   register GMarshalFunc_VOID__STRING callback;

   482   register GCClosure *cc = (GCClosure*) closure;

   483   register gpointer data1, data2;

   485   g_return_if_fail (n_param_values == 2);

   487   if (G_CCLOSURE_SWAP_DATA (closure))

   488     {

   489       data1 = closure->data;

   490       data2 = g_value_peek_pointer (param_values + 0);

   491     }

   492   else

   493     {

   494       data1 = g_value_peek_pointer (param_values + 0);

   495       data2 = closure->data;

   496     }

   497   callback = (GMarshalFunc_VOID__STRING) (marshal_data ? marshal_data : cc->callback);

   499   callback (data1,

   500             g_marshal_value_peek_string (param_values + 1),

   501             data2);

   502 }

   504 /* VOID:PARAM (./gmarshal.list:39) */

   505 EXPORT_C void

   506 g_cclosure_marshal_VOID__PARAM (GClosure     *closure,

   507                                 GValue       *return_value G_GNUC_UNUSED,

   508                                 guint         n_param_values,

   509                                 const GValue *param_values,

   510                                 gpointer      invocation_hint G_GNUC_UNUSED,

   511                                 gpointer      marshal_data)

   512 {

   513   typedef void (*GMarshalFunc_VOID__PARAM) (gpointer     data1,

   514                                             gpointer     arg_1,

   515                                             gpointer     data2);

   516   register GMarshalFunc_VOID__PARAM callback;

   517   register GCClosure *cc = (GCClosure*) closure;

   518   register gpointer data1, data2;

   520   g_return_if_fail (n_param_values == 2);

   522   if (G_CCLOSURE_SWAP_DATA (closure))

   523     {

   524       data1 = closure->data;

   525       data2 = g_value_peek_pointer (param_values + 0);

   526     }

   527   else

   528     {

   529       data1 = g_value_peek_pointer (param_values + 0);

   530       data2 = closure->data;

   531     }

   532   callback = (GMarshalFunc_VOID__PARAM) (marshal_data ? marshal_data : cc->callback);

   534   callback (data1,

   535             g_marshal_value_peek_param (param_values + 1),

   536             data2);

   537 }

   539 /* VOID:BOXED (./gmarshal.list:40) */

   540 EXPORT_C void

   541 g_cclosure_marshal_VOID__BOXED (GClosure     *closure,

   542                                 GValue       *return_value G_GNUC_UNUSED,

   543                                 guint         n_param_values,

   544                                 const GValue *param_values,

   545                                 gpointer      invocation_hint G_GNUC_UNUSED,

   546                                 gpointer      marshal_data)

   547 {

   548   typedef void (*GMarshalFunc_VOID__BOXED) (gpointer     data1,

   549                                             gpointer     arg_1,

   550                                             gpointer     data2);

   551   register GMarshalFunc_VOID__BOXED callback;

   552   register GCClosure *cc = (GCClosure*) closure;

   553   register gpointer data1, data2;

   555   g_return_if_fail (n_param_values == 2);

   557   if (G_CCLOSURE_SWAP_DATA (closure))

   558     {

   559       data1 = closure->data;

   560       data2 = g_value_peek_pointer (param_values + 0);

   561     }

   562   else

   563     {

   564       data1 = g_value_peek_pointer (param_values + 0);

   565       data2 = closure->data;

   566     }

   567   callback = (GMarshalFunc_VOID__BOXED) (marshal_data ? marshal_data : cc->callback);

   569   callback (data1,

   570             g_marshal_value_peek_boxed (param_values + 1),

   571             data2);

   572 }

   574 /* VOID:POINTER (./gmarshal.list:41) */

   575 EXPORT_C void

   576 g_cclosure_marshal_VOID__POINTER (GClosure     *closure,

   577                                   GValue       *return_value G_GNUC_UNUSED,

   578                                   guint         n_param_values,

   579                                   const GValue *param_values,

   580                                   gpointer      invocation_hint G_GNUC_UNUSED,

   581                                   gpointer      marshal_data)

   582 {

   583   typedef void (*GMarshalFunc_VOID__POINTER) (gpointer     data1,

   584                                               gpointer     arg_1,

   585                                               gpointer     data2);

   586   register GMarshalFunc_VOID__POINTER callback;

   587   register GCClosure *cc = (GCClosure*) closure;

   588   register gpointer data1, data2;

   590   g_return_if_fail (n_param_values == 2);

   592   if (G_CCLOSURE_SWAP_DATA (closure))

   593     {

   594       data1 = closure->data;

   595       data2 = g_value_peek_pointer (param_values + 0);

   596     }

   597   else

   598     {

   599       data1 = g_value_peek_pointer (param_values + 0);

   600       data2 = closure->data;

   601     }

   602   callback = (GMarshalFunc_VOID__POINTER) (marshal_data ? marshal_data : cc->callback);

   604   callback (data1,

   605             g_marshal_value_peek_pointer (param_values + 1),

   606             data2);

   607 }

   609 /* VOID:OBJECT (./gmarshal.list:42) */

   610 EXPORT_C void

   611 g_cclosure_marshal_VOID__OBJECT (GClosure     *closure,

   612                                  GValue       *return_value G_GNUC_UNUSED,

   613                                  guint         n_param_values,

   614                                  const GValue *param_values,

   615                                  gpointer      invocation_hint G_GNUC_UNUSED,

   616                                  gpointer      marshal_data)

   617 {

   618   typedef void (*GMarshalFunc_VOID__OBJECT) (gpointer     data1,

   619                                              gpointer     arg_1,

   620                                              gpointer     data2);

   621   register GMarshalFunc_VOID__OBJECT callback;

   622   register GCClosure *cc = (GCClosure*) closure;

   623   register gpointer data1, data2;

   625   g_return_if_fail (n_param_values == 2);

   627   if (G_CCLOSURE_SWAP_DATA (closure))

   628     {

   629       data1 = closure->data;

   630       data2 = g_value_peek_pointer (param_values + 0);

   631     }

   632   else

   633     {

   634       data1 = g_value_peek_pointer (param_values + 0);

   635       data2 = closure->data;

   636     }

   637   callback = (GMarshalFunc_VOID__OBJECT) (marshal_data ? marshal_data : cc->callback);

   639   callback (data1,

   640             g_marshal_value_peek_object (param_values + 1),

   641             data2);

   642 }

   644 /* VOID:UINT,POINTER (./gmarshal.list:45) */

   645 EXPORT_C void

   646 g_cclosure_marshal_VOID__UINT_POINTER (GClosure     *closure,

   647                                        GValue       *return_value G_GNUC_UNUSED,

   648                                        guint         n_param_values,

   649                                        const GValue *param_values,

   650                                        gpointer      invocation_hint G_GNUC_UNUSED,

   651                                        gpointer      marshal_data)

   652 {

   653   typedef void (*GMarshalFunc_VOID__UINT_POINTER) (gpointer     data1,

   654                                                    guint        arg_1,

   655                                                    gpointer     arg_2,

   656                                                    gpointer     data2);

   657   register GMarshalFunc_VOID__UINT_POINTER callback;

   658   register GCClosure *cc = (GCClosure*) closure;

   659   register gpointer data1, data2;

   661   g_return_if_fail (n_param_values == 3);

   663   if (G_CCLOSURE_SWAP_DATA (closure))

   664     {

   665       data1 = closure->data;

   666       data2 = g_value_peek_pointer (param_values + 0);

   667     }

   668   else

   669     {

   670       data1 = g_value_peek_pointer (param_values + 0);

   671       data2 = closure->data;

   672     }

   673   callback = (GMarshalFunc_VOID__UINT_POINTER) (marshal_data ? marshal_data : cc->callback);

   675   callback (data1,

   676             g_marshal_value_peek_uint (param_values + 1),

   677             g_marshal_value_peek_pointer (param_values + 2),

   678             data2);

   679 }

   681 /* BOOL:FLAGS (./gmarshal.list:46) */

   682 EXPORT_C void

   683 g_cclosure_marshal_BOOLEAN__FLAGS (GClosure     *closure,

   684                                    GValue       *return_value G_GNUC_UNUSED,

   685                                    guint         n_param_values,

   686                                    const GValue *param_values,

   687                                    gpointer      invocation_hint G_GNUC_UNUSED,

   688                                    gpointer      marshal_data)

   689 {

   690   typedef gboolean (*GMarshalFunc_BOOLEAN__FLAGS) (gpointer     data1,

   691                                                    guint        arg_1,

   692                                                    gpointer     data2);

   693   register GMarshalFunc_BOOLEAN__FLAGS callback;

   694   register GCClosure *cc = (GCClosure*) closure;

   695   register gpointer data1, data2;

   696   gboolean v_return;

   698   g_return_if_fail (return_value != NULL);

   699   g_return_if_fail (n_param_values == 2);

   701   if (G_CCLOSURE_SWAP_DATA (closure))

   702     {

   703       data1 = closure->data;

   704       data2 = g_value_peek_pointer (param_values + 0);

   705     }

   706   else

   707     {

   708       data1 = g_value_peek_pointer (param_values + 0);

   709       data2 = closure->data;

   710     }

   711   callback = (GMarshalFunc_BOOLEAN__FLAGS) (marshal_data ? marshal_data : cc->callback);

   713   v_return = callback (data1,

   714                        g_marshal_value_peek_flags (param_values + 1),

   715                        data2);

   717   g_value_set_boolean (return_value, v_return);

   718 }

   720 /* STRING:OBJECT,POINTER (./gmarshal.list:47) */

   721 EXPORT_C void

   722 g_cclosure_marshal_STRING__OBJECT_POINTER (GClosure     *closure,

   723                                            GValue       *return_value G_GNUC_UNUSED,

   724                                            guint         n_param_values,

   725                                            const GValue *param_values,

   726                                            gpointer      invocation_hint G_GNUC_UNUSED,

   727                                            gpointer      marshal_data)

   728 {

   729   typedef gchar* (*GMarshalFunc_STRING__OBJECT_POINTER) (gpointer     data1,

   730                                                          gpointer     arg_1,

   731                                                          gpointer     arg_2,

   732                                                          gpointer     data2);

   733   register GMarshalFunc_STRING__OBJECT_POINTER callback;

   734   register GCClosure *cc = (GCClosure*) closure;

   735   register gpointer data1, data2;

   736   gchar* v_return;

   738   g_return_if_fail (return_value != NULL);

   739   g_return_if_fail (n_param_values == 3);

   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_STRING__OBJECT_POINTER) (marshal_data ? marshal_data : cc->callback);

   753   v_return = callback (data1,

   754                        g_marshal_value_peek_object (param_values + 1),

   755                        g_marshal_value_peek_pointer (param_values + 2),

   756                        data2);

   758   g_value_take_string (return_value, v_return);

   759 }

author	sl
	Tue, 10 Jun 2014 14:32:02 +0200 (2014-06-10)
changeset 1	260cb5ec6c19
permissions	-rw-r--r--