← Back to branch summary

~ubuntu-branches/ubuntu/karmic/mergeant/karmic

« back to all changes in this revision

Viewing changes to src/marshal.c

  • Committer: Bazaar Package Importer
  • Author(s): Gustavo R. Montesino
  • Date: 2007-11-29 08:44:48 UTC
  • mfrom: (2.1.4 hardy)
  • Revision ID: james.westby@ubuntu.com-20071129084448-6aon73d22bv6hzfw
Tags: 0.67-3
* Re-enable installation of the mime files in mergeant.install
* mergeant.dirs: create usr/share/mime/packages to make dh_installmime add
  the update-mime-database code snippets

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/marshal.c
 
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
/* VOID:VOID (marshal.list:25) */
 
51
 
 
52
/* VOID:VOID,VOID (marshal.list:26) */
 
53
void
 
54
marshal_VOID__VOID_VOID (GClosure     *closure,
 
55
                         GValue       *return_value,
 
56
                         guint         n_param_values,
 
57
                         const GValue *param_values,
 
58
                         gpointer      invocation_hint,
 
59
                         gpointer      marshal_data)
 
60
{
 
61
  typedef void (*GMarshalFunc_VOID__VOID_VOID) (gpointer     data1,
 
62
                                                gpointer     data2);
 
63
  register GMarshalFunc_VOID__VOID_VOID callback;
 
64
  register GCClosure *cc = (GCClosure*) closure;
 
65
  register gpointer data1, data2;
 
66
 
 
67
  g_return_if_fail (n_param_values == 1);
 
68
 
 
69
  if (G_CCLOSURE_SWAP_DATA (closure))
 
70
    {
 
71
      data1 = closure->data;
 
72
      data2 = g_value_peek_pointer (param_values + 0);
 
73
    }
 
74
  else
 
75
    {
 
76
      data1 = g_value_peek_pointer (param_values + 0);
 
77
      data2 = closure->data;
 
78
    }
 
79
  callback = (GMarshalFunc_VOID__VOID_VOID) (marshal_data ? marshal_data : cc->callback);
 
80
 
 
81
  callback (data1,
 
82
            data2);
 
83
}
 
84
 
 
85
/* VOID:POINTER (marshal.list:27) */
 
86
 
 
87
/* VOID:POINTER,POINTER (marshal.list:28) */
 
88
void
 
89
marshal_VOID__POINTER_POINTER (GClosure     *closure,
 
90
                               GValue       *return_value,
 
91
                               guint         n_param_values,
 
92
                               const GValue *param_values,
 
93
                               gpointer      invocation_hint,
 
94
                               gpointer      marshal_data)
 
95
{
 
96
  typedef void (*GMarshalFunc_VOID__POINTER_POINTER) (gpointer     data1,
 
97
                                                      gpointer     arg_1,
 
98
                                                      gpointer     arg_2,
 
99
                                                      gpointer     data2);
 
100
  register GMarshalFunc_VOID__POINTER_POINTER callback;
 
101
  register GCClosure *cc = (GCClosure*) closure;
 
102
  register gpointer data1, data2;
 
103
 
 
104
  g_return_if_fail (n_param_values == 3);
 
105
 
 
106
  if (G_CCLOSURE_SWAP_DATA (closure))
 
107
    {
 
108
      data1 = closure->data;
 
109
      data2 = g_value_peek_pointer (param_values + 0);
 
110
    }
 
111
  else
 
112
    {
 
113
      data1 = g_value_peek_pointer (param_values + 0);
 
114
      data2 = closure->data;
 
115
    }
 
116
  callback = (GMarshalFunc_VOID__POINTER_POINTER) (marshal_data ? marshal_data : cc->callback);
 
117
 
 
118
  callback (data1,
 
119
            g_marshal_value_peek_pointer (param_values + 1),
 
120
            g_marshal_value_peek_pointer (param_values + 2),
 
121
            data2);
 
122
}
 
123
 
 
124
/* VOID:POINTER,UINT,UINT (marshal.list:29) */
 
125
void
 
126
marshal_VOID__POINTER_UINT_UINT (GClosure     *closure,
 
127
                                 GValue       *return_value,
 
128
                                 guint         n_param_values,
 
129
                                 const GValue *param_values,
 
130
                                 gpointer      invocation_hint,
 
131
                                 gpointer      marshal_data)
 
132
{
 
133
  typedef void (*GMarshalFunc_VOID__POINTER_UINT_UINT) (gpointer     data1,
 
134
                                                        gpointer     arg_1,
 
135
                                                        guint        arg_2,
 
136
                                                        guint        arg_3,
 
137
                                                        gpointer     data2);
 
138
  register GMarshalFunc_VOID__POINTER_UINT_UINT callback;
 
139
  register GCClosure *cc = (GCClosure*) closure;
 
140
  register gpointer data1, data2;
 
141
 
 
142
  g_return_if_fail (n_param_values == 4);
 
143
 
 
144
  if (G_CCLOSURE_SWAP_DATA (closure))
 
145
    {
 
146
      data1 = closure->data;
 
147
      data2 = g_value_peek_pointer (param_values + 0);
 
148
    }
 
149
  else
 
150
    {
 
151
      data1 = g_value_peek_pointer (param_values + 0);
 
152
      data2 = closure->data;
 
153
    }
 
154
  callback = (GMarshalFunc_VOID__POINTER_UINT_UINT) (marshal_data ? marshal_data : cc->callback);
 
155
 
 
156
  callback (data1,
 
157
            g_marshal_value_peek_pointer (param_values + 1),
 
158
            g_marshal_value_peek_uint (param_values + 2),
 
159
            g_marshal_value_peek_uint (param_values + 3),
 
160
            data2);
 
161
}
 
162
 
 
163
/* VOID:BOOLEAN (marshal.list:30) */
 
164
 
 
165
/* VOID:ULONG (marshal.list:31) */
 
166
 
 
167
/* VOID:OBJECT (marshal.list:32) */
 
168
 
 
169
/* VOID:INT (marshal.list:33) */
 
170
 
 
171
/* VOID:STRING,STRING (marshal.list:34) */
 
172
void
 
173
marshal_VOID__STRING_STRING (GClosure     *closure,
 
174
                             GValue       *return_value,
 
175
                             guint         n_param_values,
 
176
                             const GValue *param_values,
 
177
                             gpointer      invocation_hint,
 
178
                             gpointer      marshal_data)
 
179
{
 
180
  typedef void (*GMarshalFunc_VOID__STRING_STRING) (gpointer     data1,
 
181
                                                    gpointer     arg_1,
 
182
                                                    gpointer     arg_2,
 
183
                                                    gpointer     data2);
 
184
  register GMarshalFunc_VOID__STRING_STRING callback;
 
185
  register GCClosure *cc = (GCClosure*) closure;
 
186
  register gpointer data1, data2;
 
187
 
 
188
  g_return_if_fail (n_param_values == 3);
 
189
 
 
190
  if (G_CCLOSURE_SWAP_DATA (closure))
 
191
    {
 
192
      data1 = closure->data;
 
193
      data2 = g_value_peek_pointer (param_values + 0);
 
194
    }
 
195
  else
 
196
    {
 
197
      data1 = g_value_peek_pointer (param_values + 0);
 
198
      data2 = closure->data;
 
199
    }
 
200
  callback = (GMarshalFunc_VOID__STRING_STRING) (marshal_data ? marshal_data : cc->callback);
 
201
 
 
202
  callback (data1,
 
203
            g_marshal_value_peek_string (param_values + 1),
 
204
            g_marshal_value_peek_string (param_values + 2),
 
205
            data2);
 
206
}
 
207
 
 
208
/* VOID:STRING,POINTER (marshal.list:35) */
 
209
void
 
210
marshal_VOID__STRING_POINTER (GClosure     *closure,
 
211
                              GValue       *return_value,
 
212
                              guint         n_param_values,
 
213
                              const GValue *param_values,
 
214
                              gpointer      invocation_hint,
 
215
                              gpointer      marshal_data)
 
216
{
 
217
  typedef void (*GMarshalFunc_VOID__STRING_POINTER) (gpointer     data1,
 
218
                                                     gpointer     arg_1,
 
219
                                                     gpointer     arg_2,
 
220
                                                     gpointer     data2);
 
221
  register GMarshalFunc_VOID__STRING_POINTER callback;
 
222
  register GCClosure *cc = (GCClosure*) closure;
 
223
  register gpointer data1, data2;
 
224
 
 
225
  g_return_if_fail (n_param_values == 3);
 
226
 
 
227
  if (G_CCLOSURE_SWAP_DATA (closure))
 
228
    {
 
229
      data1 = closure->data;
 
230
      data2 = g_value_peek_pointer (param_values + 0);
 
231
    }
 
232
  else
 
233
    {
 
234
      data1 = g_value_peek_pointer (param_values + 0);
 
235
      data2 = closure->data;
 
236
    }
 
237
  callback = (GMarshalFunc_VOID__STRING_POINTER) (marshal_data ? marshal_data : cc->callback);
 
238
 
 
239
  callback (data1,
 
240
            g_marshal_value_peek_string (param_values + 1),
 
241
            g_marshal_value_peek_pointer (param_values + 2),
 
242
            data2);
 
243
}
 
244
 
 
245
/* VOID:STRING,UINT (marshal.list:36) */
 
246
void
 
247
marshal_VOID__STRING_UINT (GClosure     *closure,
 
248
                           GValue       *return_value,
 
249
                           guint         n_param_values,
 
250
                           const GValue *param_values,
 
251
                           gpointer      invocation_hint,
 
252
                           gpointer      marshal_data)
 
253
{
 
254
  typedef void (*GMarshalFunc_VOID__STRING_UINT) (gpointer     data1,
 
255
                                                  gpointer     arg_1,
 
256
                                                  guint        arg_2,
 
257
                                                  gpointer     data2);
 
258
  register GMarshalFunc_VOID__STRING_UINT callback;
 
259
  register GCClosure *cc = (GCClosure*) closure;
 
260
  register gpointer data1, data2;
 
261
 
 
262
  g_return_if_fail (n_param_values == 3);
 
263
 
 
264
  if (G_CCLOSURE_SWAP_DATA (closure))
 
265
    {
 
266
      data1 = closure->data;
 
267
      data2 = g_value_peek_pointer (param_values + 0);
 
268
    }
 
269
  else
 
270
    {
 
271
      data1 = g_value_peek_pointer (param_values + 0);
 
272
      data2 = closure->data;
 
273
    }
 
274
  callback = (GMarshalFunc_VOID__STRING_UINT) (marshal_data ? marshal_data : cc->callback);
 
275
 
 
276
  callback (data1,
 
277
            g_marshal_value_peek_string (param_values + 1),
 
278
            g_marshal_value_peek_uint (param_values + 2),
 
279
            data2);
 
280
}
 
281
 
 
282
/* VOID:STRING (marshal.list:37) */
 
283