source: gmarshal_funcs.c @ 06e04a9

release-1.10
Last change on this file since 06e04a9 was 06e04a9, checked in by David Benjamin <davidben@mit.edu>, 14 years ago
perlvariables - iteration N Later commits reworked a lot of this, but the use of GValue over void* was kept.
  • Property mode set to 100644
File size: 14.5 KB
Line 
1
2#include        <glib-object.h>
3
4
5#ifdef G_ENABLE_DEBUG
6#define g_marshal_value_peek_boolean(v)  g_value_get_boolean (v)
7#define g_marshal_value_peek_char(v)     g_value_get_char (v)
8#define g_marshal_value_peek_uchar(v)    g_value_get_uchar (v)
9#define g_marshal_value_peek_int(v)      g_value_get_int (v)
10#define g_marshal_value_peek_uint(v)     g_value_get_uint (v)
11#define g_marshal_value_peek_long(v)     g_value_get_long (v)
12#define g_marshal_value_peek_ulong(v)    g_value_get_ulong (v)
13#define g_marshal_value_peek_int64(v)    g_value_get_int64 (v)
14#define g_marshal_value_peek_uint64(v)   g_value_get_uint64 (v)
15#define g_marshal_value_peek_enum(v)     g_value_get_enum (v)
16#define g_marshal_value_peek_flags(v)    g_value_get_flags (v)
17#define g_marshal_value_peek_float(v)    g_value_get_float (v)
18#define g_marshal_value_peek_double(v)   g_value_get_double (v)
19#define g_marshal_value_peek_string(v)   (char*) g_value_get_string (v)
20#define g_marshal_value_peek_param(v)    g_value_get_param (v)
21#define g_marshal_value_peek_boxed(v)    g_value_get_boxed (v)
22#define g_marshal_value_peek_pointer(v)  g_value_get_pointer (v)
23#define g_marshal_value_peek_object(v)   g_value_get_object (v)
24#else /* !G_ENABLE_DEBUG */
25/* WARNING: This code accesses GValues directly, which is UNSUPPORTED API.
26 *          Do not access GValues directly in your code. Instead, use the
27 *          g_value_get_*() functions
28 */
29#define g_marshal_value_peek_boolean(v)  (v)->data[0].v_int
30#define g_marshal_value_peek_char(v)     (v)->data[0].v_int
31#define g_marshal_value_peek_uchar(v)    (v)->data[0].v_uint
32#define g_marshal_value_peek_int(v)      (v)->data[0].v_int
33#define g_marshal_value_peek_uint(v)     (v)->data[0].v_uint
34#define g_marshal_value_peek_long(v)     (v)->data[0].v_long
35#define g_marshal_value_peek_ulong(v)    (v)->data[0].v_ulong
36#define g_marshal_value_peek_int64(v)    (v)->data[0].v_int64
37#define g_marshal_value_peek_uint64(v)   (v)->data[0].v_uint64
38#define g_marshal_value_peek_enum(v)     (v)->data[0].v_long
39#define g_marshal_value_peek_flags(v)    (v)->data[0].v_ulong
40#define g_marshal_value_peek_float(v)    (v)->data[0].v_float
41#define g_marshal_value_peek_double(v)   (v)->data[0].v_double
42#define g_marshal_value_peek_string(v)   (v)->data[0].v_pointer
43#define g_marshal_value_peek_param(v)    (v)->data[0].v_pointer
44#define g_marshal_value_peek_boxed(v)    (v)->data[0].v_pointer
45#define g_marshal_value_peek_pointer(v)  (v)->data[0].v_pointer
46#define g_marshal_value_peek_object(v)   (v)->data[0].v_pointer
47#endif /* !G_ENABLE_DEBUG */
48
49
50/* INT:STRING (marshal_types:2) */
51void
52g_cclosure_user_marshal_INT__STRING (GClosure     *closure,
53                                     GValue       *return_value G_GNUC_UNUSED,
54                                     guint         n_param_values,
55                                     const GValue *param_values,
56                                     gpointer      invocation_hint G_GNUC_UNUSED,
57                                     gpointer      marshal_data)
58{
59  typedef gint (*GMarshalFunc_INT__STRING) (gpointer     data1,
60                                            gpointer     arg_1,
61                                            gpointer     data2);
62  register GMarshalFunc_INT__STRING callback;
63  register GCClosure *cc = (GCClosure*) closure;
64  register gpointer data1, data2;
65  gint v_return;
66
67  g_return_if_fail (return_value != NULL);
68  g_return_if_fail (n_param_values == 2);
69
70  if (G_CCLOSURE_SWAP_DATA (closure))
71    {
72      data1 = closure->data;
73      data2 = g_value_peek_pointer (param_values + 0);
74    }
75  else
76    {
77      data1 = g_value_peek_pointer (param_values + 0);
78      data2 = closure->data;
79    }
80  callback = (GMarshalFunc_INT__STRING) (marshal_data ? marshal_data : cc->callback);
81
82  v_return = callback (data1,
83                       g_marshal_value_peek_string (param_values + 1),
84                       data2);
85
86  g_value_set_int (return_value, v_return);
87}
88
89/* INT:INT (marshal_types:3) */
90void
91g_cclosure_user_marshal_INT__INT (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 gint (*GMarshalFunc_INT__INT) (gpointer     data1,
99                                         gint         arg_1,
100                                         gpointer     data2);
101  register GMarshalFunc_INT__INT callback;
102  register GCClosure *cc = (GCClosure*) closure;
103  register gpointer data1, data2;
104  gint v_return;
105
106  g_return_if_fail (return_value != NULL);
107  g_return_if_fail (n_param_values == 2);
108
109  if (G_CCLOSURE_SWAP_DATA (closure))
110    {
111      data1 = closure->data;
112      data2 = g_value_peek_pointer (param_values + 0);
113    }
114  else
115    {
116      data1 = g_value_peek_pointer (param_values + 0);
117      data2 = closure->data;
118    }
119  callback = (GMarshalFunc_INT__INT) (marshal_data ? marshal_data : cc->callback);
120
121  v_return = callback (data1,
122                       g_marshal_value_peek_int (param_values + 1),
123                       data2);
124
125  g_value_set_int (return_value, v_return);
126}
127
128/* INT:BOOL (marshal_types:4) */
129void
130g_cclosure_user_marshal_INT__BOOLEAN (GClosure     *closure,
131                                      GValue       *return_value G_GNUC_UNUSED,
132                                      guint         n_param_values,
133                                      const GValue *param_values,
134                                      gpointer      invocation_hint G_GNUC_UNUSED,
135                                      gpointer      marshal_data)
136{
137  typedef gint (*GMarshalFunc_INT__BOOLEAN) (gpointer     data1,
138                                             gboolean     arg_1,
139                                             gpointer     data2);
140  register GMarshalFunc_INT__BOOLEAN callback;
141  register GCClosure *cc = (GCClosure*) closure;
142  register gpointer data1, data2;
143  gint v_return;
144
145  g_return_if_fail (return_value != NULL);
146  g_return_if_fail (n_param_values == 2);
147
148  if (G_CCLOSURE_SWAP_DATA (closure))
149    {
150      data1 = closure->data;
151      data2 = g_value_peek_pointer (param_values + 0);
152    }
153  else
154    {
155      data1 = g_value_peek_pointer (param_values + 0);
156      data2 = closure->data;
157    }
158  callback = (GMarshalFunc_INT__BOOLEAN) (marshal_data ? marshal_data : cc->callback);
159
160  v_return = callback (data1,
161                       g_marshal_value_peek_boolean (param_values + 1),
162                       data2);
163
164  g_value_set_int (return_value, v_return);
165}
166
167/* INT:VOID (marshal_types:6) */
168void
169g_cclosure_user_marshal_INT__VOID (GClosure     *closure,
170                                   GValue       *return_value G_GNUC_UNUSED,
171                                   guint         n_param_values,
172                                   const GValue *param_values,
173                                   gpointer      invocation_hint G_GNUC_UNUSED,
174                                   gpointer      marshal_data)
175{
176  typedef gint (*GMarshalFunc_INT__VOID) (gpointer     data1,
177                                          gpointer     data2);
178  register GMarshalFunc_INT__VOID callback;
179  register GCClosure *cc = (GCClosure*) closure;
180  register gpointer data1, data2;
181  gint v_return;
182
183  g_return_if_fail (return_value != NULL);
184  g_return_if_fail (n_param_values == 1);
185
186  if (G_CCLOSURE_SWAP_DATA (closure))
187    {
188      data1 = closure->data;
189      data2 = g_value_peek_pointer (param_values + 0);
190    }
191  else
192    {
193      data1 = g_value_peek_pointer (param_values + 0);
194      data2 = closure->data;
195    }
196  callback = (GMarshalFunc_INT__VOID) (marshal_data ? marshal_data : cc->callback);
197
198  v_return = callback (data1,
199                       data2);
200
201  g_value_set_int (return_value, v_return);
202}
203
204/* BOOL:VOID (marshal_types:7) */
205void
206g_cclosure_user_marshal_BOOLEAN__VOID (GClosure     *closure,
207                                       GValue       *return_value G_GNUC_UNUSED,
208                                       guint         n_param_values,
209                                       const GValue *param_values,
210                                       gpointer      invocation_hint G_GNUC_UNUSED,
211                                       gpointer      marshal_data)
212{
213  typedef gboolean (*GMarshalFunc_BOOLEAN__VOID) (gpointer     data1,
214                                                  gpointer     data2);
215  register GMarshalFunc_BOOLEAN__VOID callback;
216  register GCClosure *cc = (GCClosure*) closure;
217  register gpointer data1, data2;
218  gboolean v_return;
219
220  g_return_if_fail (return_value != NULL);
221  g_return_if_fail (n_param_values == 1);
222
223  if (G_CCLOSURE_SWAP_DATA (closure))
224    {
225      data1 = closure->data;
226      data2 = g_value_peek_pointer (param_values + 0);
227    }
228  else
229    {
230      data1 = g_value_peek_pointer (param_values + 0);
231      data2 = closure->data;
232    }
233  callback = (GMarshalFunc_BOOLEAN__VOID) (marshal_data ? marshal_data : cc->callback);
234
235  v_return = callback (data1,
236                       data2);
237
238  g_value_set_boolean (return_value, v_return);
239}
240
241/* STRING:VOID (marshal_types:8) */
242void
243g_cclosure_user_marshal_STRING__VOID (GClosure     *closure,
244                                      GValue       *return_value G_GNUC_UNUSED,
245                                      guint         n_param_values,
246                                      const GValue *param_values,
247                                      gpointer      invocation_hint G_GNUC_UNUSED,
248                                      gpointer      marshal_data)
249{
250  typedef gchar* (*GMarshalFunc_STRING__VOID) (gpointer     data1,
251                                               gpointer     data2);
252  register GMarshalFunc_STRING__VOID callback;
253  register GCClosure *cc = (GCClosure*) closure;
254  register gpointer data1, data2;
255  gchar* v_return;
256
257  g_return_if_fail (return_value != NULL);
258  g_return_if_fail (n_param_values == 1);
259
260  if (G_CCLOSURE_SWAP_DATA (closure))
261    {
262      data1 = closure->data;
263      data2 = g_value_peek_pointer (param_values + 0);
264    }
265  else
266    {
267      data1 = g_value_peek_pointer (param_values + 0);
268      data2 = closure->data;
269    }
270  callback = (GMarshalFunc_STRING__VOID) (marshal_data ? marshal_data : cc->callback);
271
272  v_return = callback (data1,
273                       data2);
274
275  g_value_take_string (return_value, v_return);
276}
277
278/* INT:STRING (marshal_types:11) */
279
280/* STRING:BOOL (marshal_types:13) */
281void
282g_cclosure_user_marshal_STRING__BOOLEAN (GClosure     *closure,
283                                         GValue       *return_value G_GNUC_UNUSED,
284                                         guint         n_param_values,
285                                         const GValue *param_values,
286                                         gpointer      invocation_hint G_GNUC_UNUSED,
287                                         gpointer      marshal_data)
288{
289  typedef gchar* (*GMarshalFunc_STRING__BOOLEAN) (gpointer     data1,
290                                                  gboolean     arg_1,
291                                                  gpointer     data2);
292  register GMarshalFunc_STRING__BOOLEAN callback;
293  register GCClosure *cc = (GCClosure*) closure;
294  register gpointer data1, data2;
295  gchar* v_return;
296
297  g_return_if_fail (return_value != NULL);
298  g_return_if_fail (n_param_values == 2);
299
300  if (G_CCLOSURE_SWAP_DATA (closure))
301    {
302      data1 = closure->data;
303      data2 = g_value_peek_pointer (param_values + 0);
304    }
305  else
306    {
307      data1 = g_value_peek_pointer (param_values + 0);
308      data2 = closure->data;
309    }
310  callback = (GMarshalFunc_STRING__BOOLEAN) (marshal_data ? marshal_data : cc->callback);
311
312  v_return = callback (data1,
313                       g_marshal_value_peek_boolean (param_values + 1),
314                       data2);
315
316  g_value_take_string (return_value, v_return);
317}
318
319/* STRING:INT (marshal_types:14) */
320void
321g_cclosure_user_marshal_STRING__INT (GClosure     *closure,
322                                     GValue       *return_value G_GNUC_UNUSED,
323                                     guint         n_param_values,
324                                     const GValue *param_values,
325                                     gpointer      invocation_hint G_GNUC_UNUSED,
326                                     gpointer      marshal_data)
327{
328  typedef gchar* (*GMarshalFunc_STRING__INT) (gpointer     data1,
329                                              gint         arg_1,
330                                              gpointer     data2);
331  register GMarshalFunc_STRING__INT callback;
332  register GCClosure *cc = (GCClosure*) closure;
333  register gpointer data1, data2;
334  gchar* v_return;
335
336  g_return_if_fail (return_value != NULL);
337  g_return_if_fail (n_param_values == 2);
338
339  if (G_CCLOSURE_SWAP_DATA (closure))
340    {
341      data1 = closure->data;
342      data2 = g_value_peek_pointer (param_values + 0);
343    }
344  else
345    {
346      data1 = g_value_peek_pointer (param_values + 0);
347      data2 = closure->data;
348    }
349  callback = (GMarshalFunc_STRING__INT) (marshal_data ? marshal_data : cc->callback);
350
351  v_return = callback (data1,
352                       g_marshal_value_peek_int (param_values + 1),
353                       data2);
354
355  g_value_take_string (return_value, v_return);
356}
357
358/* STRING:STRING (marshal_types:15) */
359void
360g_cclosure_user_marshal_STRING__STRING (GClosure     *closure,
361                                        GValue       *return_value G_GNUC_UNUSED,
362                                        guint         n_param_values,
363                                        const GValue *param_values,
364                                        gpointer      invocation_hint G_GNUC_UNUSED,
365                                        gpointer      marshal_data)
366{
367  typedef gchar* (*GMarshalFunc_STRING__STRING) (gpointer     data1,
368                                                 gpointer     arg_1,
369                                                 gpointer     data2);
370  register GMarshalFunc_STRING__STRING callback;
371  register GCClosure *cc = (GCClosure*) closure;
372  register gpointer data1, data2;
373  gchar* v_return;
374
375  g_return_if_fail (return_value != NULL);
376  g_return_if_fail (n_param_values == 2);
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_STRING__STRING) (marshal_data ? marshal_data : cc->callback);
389
390  v_return = callback (data1,
391                       g_marshal_value_peek_string (param_values + 1),
392                       data2);
393
394  g_value_take_string (return_value, v_return);
395}
396
Note: See TracBrowser for help on using the repository browser.