← Back to branch summary

~ubuntu-branches/ubuntu/hardy/vala/hardy

« back to all changes in this revision

Viewing changes to vala/valainterface.c

  • Committer: Bazaar Package Importer
  • Author(s): Sebastian Dröge, Marc-Andre Lureau, Sebastian Dröge
  • Date: 2007-10-15 14:37:51 UTC
  • mfrom: (1.1.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20071015143751-zy7hqcyjutdyfkg3
Tags: 0.1.4-1
[ Marc-Andre Lureau ]
* New Upstream Version
* debian/patches:
  + Remove patch no longer needed in 0.1.4
* debian/rules
  + Add xsltproc build dependency for the Vala manual.
  + Add libenchant-dev build dependency for enchant test case.
* debian/control, debian/vala-doc.install:
  + Add a "vala-doc" documentation package.

[ Sebastian Dröge ]
* debian/control:
  + Let vala-doc suggest valac/devhelp and don't depend on libvala0.
* debian/libvala-dev.install:
  + Add the new vapicheck utility.

Show diffs side-by-side

added added

removed removed

Lines of Context:
vala/valainterface.c
5
5
 * This library is free software; you can redistribute it and/or
6
6
 * modify it under the terms of the GNU Lesser General Public
7
7
 * License as published by the Free Software Foundation; either
8
 
 * version 2 of the License, or (at your option) any later version.
 
8
 * version 2.1 of the License, or (at your option) any later version.
9
9
 
10
10
 * This library is distributed in the hope that it will be useful,
11
11
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
20
20
 *      Jürg Billeter <j@bitron.ch>
21
21
 */
22
22
 
23
 
#include "valainterface.h"
 
23
#include <vala/valainterface.h>
24
24
#include <gee/arraylist.h>
25
25
#include <gee/list.h>
26
26
#include <gee/readonlycollection.h>
27
27
#include <vala/valasourcereference.h>
28
28
#include <vala/valasymbol.h>
29
29
#include <vala/valatypeparameter.h>
30
 
#include <vala/valainterface.h>
31
30
#include <vala/valascope.h>
32
31
#include <vala/valatypereference.h>
33
32
#include <vala/valamethod.h>
42
41
 
43
42
struct _ValaInterfacePrivate {
44
43
        gboolean _is_static;
 
44
        gboolean _declaration_only;
45
45
        GeeList* type_parameters;
46
46
        GeeList* prerequisites;
47
47
        GeeList* methods;
56
56
#define VALA_INTERFACE_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), VALA_TYPE_INTERFACE, ValaInterfacePrivate))
57
57
enum  {
58
58
        VALA_INTERFACE_DUMMY_PROPERTY,
59
 
        VALA_INTERFACE_IS_STATIC
 
59
        VALA_INTERFACE_IS_STATIC,
 
60
        VALA_INTERFACE_DECLARATION_ONLY
60
61
};
61
62
static char* vala_interface_real_get_cname (ValaDataType* base, gboolean const_type);
62
63
static char* vala_interface_real_get_lower_case_cname (ValaSymbol* base, const char* infix);
70
71
static char* vala_interface_real_get_unref_function (ValaDataType* base);
71
72
static gboolean vala_interface_real_is_subtype_of (ValaDataType* base, ValaDataType* t);
72
73
static void vala_interface_process_ccode_attribute (ValaInterface* self, ValaAttribute* a);
 
74
static void vala_interface_process_dbus_interface_attribute (ValaInterface* self, ValaAttribute* a);
73
75
static char* vala_interface_real_get_marshaller_type_name (ValaDataType* base);
74
76
static char* vala_interface_real_get_get_value_function (ValaDataType* base);
75
77
static char* vala_interface_real_get_set_value_function (ValaDataType* base);
77
79
static gint vala_interface_real_get_type_parameter_index (ValaDataType* base, const char* name);
78
80
static gpointer vala_interface_parent_class = NULL;
79
81
static void vala_interface_dispose (GObject * obj);
 
82
static void _vala_array_free (gpointer array, gint array_length, GDestroyNotify destroy_func);
80
83
 
81
84
 
82
85
/**
86
89
 * @param source reference to source code
87
90
 * @return       newly created interface
88
91
 */
89
 
ValaInterface* vala_interface_new (const char* name, ValaSourceReference* source_reference)
90
 
{
 
92
ValaInterface* vala_interface_new (const char* name, ValaSourceReference* source_reference) {
91
93
        ValaInterface * self;
92
94
        g_return_val_if_fail (name != NULL, NULL);
93
95
        g_return_val_if_fail (source_reference == NULL || VALA_IS_SOURCE_REFERENCE (source_reference), NULL);
103
105
 *
104
106
 * @param p a type parameter
105
107
 */
106
 
void vala_interface_add_type_parameter (ValaInterface* self, ValaTypeParameter* p)
107
 
{
 
108
void vala_interface_add_type_parameter (ValaInterface* self, ValaTypeParameter* p) {
108
109
        g_return_if_fail (VALA_IS_INTERFACE (self));
109
110
        g_return_if_fail (VALA_IS_TYPE_PARAMETER (p));
110
111
        gee_collection_add (GEE_COLLECTION (self->priv->type_parameters), p);
111
112
        p->type = VALA_DATA_TYPE (self);
112
 
        vala_scope_add (vala_symbol_get_scope (((ValaSymbol*) self)), vala_symbol_get_name (((ValaSymbol*) p)), VALA_SYMBOL (p));
 
113
        vala_scope_add (vala_symbol_get_scope (VALA_SYMBOL (self)), vala_symbol_get_name (VALA_SYMBOL (p)), VALA_SYMBOL (p));
113
114
}
114
115
 
115
116
 
118
119
 *
119
120
 * @return list of type parameters
120
121
 */
121
 
GeeCollection* vala_interface_get_type_parameters (ValaInterface* self)
122
 
{
 
122
GeeCollection* vala_interface_get_type_parameters (ValaInterface* self) {
123
123
        g_return_val_if_fail (VALA_IS_INTERFACE (self), NULL);
124
124
        return GEE_COLLECTION (gee_read_only_collection_new (g_object_ref, g_object_unref, GEE_COLLECTION (self->priv->type_parameters)));
125
125
}
131
131
 *
132
132
 * @param type an interface or class reference
133
133
 */
134
 
void vala_interface_add_prerequisite (ValaInterface* self, ValaTypeReference* type)
135
 
{
 
134
void vala_interface_add_prerequisite (ValaInterface* self, ValaTypeReference* type) {
136
135
        g_return_if_fail (VALA_IS_INTERFACE (self));
137
136
        g_return_if_fail (VALA_IS_TYPE_REFERENCE (type));
138
137
        gee_collection_add (GEE_COLLECTION (self->priv->prerequisites), type);
145
144
 *
146
145
 * @param type an interface or class reference
147
146
 */
148
 
void vala_interface_prepend_prerequisite (ValaInterface* self, ValaTypeReference* type)
149
 
{
 
147
void vala_interface_prepend_prerequisite (ValaInterface* self, ValaTypeReference* type) {
150
148
        g_return_if_fail (VALA_IS_INTERFACE (self));
151
149
        g_return_if_fail (VALA_IS_TYPE_REFERENCE (type));
152
150
        gee_list_insert (self->priv->prerequisites, 0, type);
158
156
 *
159
157
 * @return list of base types
160
158
 */
161
 
GeeCollection* vala_interface_get_prerequisites (ValaInterface* self)
162
 
{
 
159
GeeCollection* vala_interface_get_prerequisites (ValaInterface* self) {
163
160
        g_return_val_if_fail (VALA_IS_INTERFACE (self), NULL);
164
161
        return GEE_COLLECTION (gee_read_only_collection_new (g_object_ref, g_object_unref, GEE_COLLECTION (self->priv->prerequisites)));
165
162
}
170
167
 *
171
168
 * @param m a method
172
169
 */
173
 
void vala_interface_add_method (ValaInterface* self, ValaMethod* m)
174
 
{
 
170
void vala_interface_add_method (ValaInterface* self, ValaMethod* m) {
175
171
        g_return_if_fail (VALA_IS_INTERFACE (self));
176
172
        g_return_if_fail (VALA_IS_METHOD (m));
177
173
        if (VALA_IS_CREATION_METHOD (m)) {
178
 
                vala_report_error (vala_code_node_get_source_reference (((ValaCodeNode*) m)), "construction methods may only be declared within classes and structs");
 
174
                vala_report_error (vala_code_node_get_source_reference (VALA_CODE_NODE (m)), "construction methods may only be declared within classes and structs");
179
175
                vala_code_node_set_error (VALA_CODE_NODE (m), TRUE);
180
176
                return;
181
177
        }
182
178
        if (vala_method_get_instance (m)) {
183
 
                ValaFormalParameter* __temp3;
184
 
                ValaTypeReference* __temp2;
185
 
                __temp3 = NULL;
186
 
                __temp2 = NULL;
187
 
                vala_method_set_this_parameter (m, (__temp3 = vala_formal_parameter_new ("this", (__temp2 = vala_type_reference_new ()), NULL)));
188
 
                (__temp3 == NULL ? NULL : (__temp3 = (g_object_unref (__temp3), NULL)));
189
 
                (__temp2 == NULL ? NULL : (__temp2 = (g_object_unref (__temp2), NULL)));
 
179
                ValaFormalParameter* _tmp1;
 
180
                ValaTypeReference* _tmp0;
 
181
                _tmp1 = NULL;
 
182
                _tmp0 = NULL;
 
183
                vala_method_set_this_parameter (m, (_tmp1 = vala_formal_parameter_new ("this", (_tmp0 = vala_type_reference_new ()), NULL)));
 
184
                (_tmp1 == NULL ? NULL : (_tmp1 = (g_object_unref (_tmp1), NULL)));
 
185
                (_tmp0 == NULL ? NULL : (_tmp0 = (g_object_unref (_tmp0), NULL)));
190
186
                vala_type_reference_set_data_type (vala_formal_parameter_get_type_reference (vala_method_get_this_parameter (m)), VALA_DATA_TYPE (self));
191
 
                vala_scope_add (vala_symbol_get_scope (((ValaSymbol*) m)), vala_symbol_get_name (((ValaSymbol*) vala_method_get_this_parameter (m))), VALA_SYMBOL (vala_method_get_this_parameter (m)));
 
187
                vala_scope_add (vala_symbol_get_scope (VALA_SYMBOL (m)), vala_symbol_get_name (VALA_SYMBOL (vala_method_get_this_parameter (m))), VALA_SYMBOL (vala_method_get_this_parameter (m)));
192
188
        }
193
189
        gee_collection_add (GEE_COLLECTION (self->priv->methods), m);
194
 
        vala_scope_add (vala_symbol_get_scope (((ValaSymbol*) self)), vala_symbol_get_name (((ValaSymbol*) m)), VALA_SYMBOL (m));
 
190
        vala_scope_add (vala_symbol_get_scope (VALA_SYMBOL (self)), vala_symbol_get_name (VALA_SYMBOL (m)), VALA_SYMBOL (m));
195
191
}
196
192
 
197
193
 
200
196
 *
201
197
 * @return list of methods
202
198
 */
203
 
GeeCollection* vala_interface_get_methods (ValaInterface* self)
204
 
{
 
199
GeeCollection* vala_interface_get_methods (ValaInterface* self) {
205
200
        g_return_val_if_fail (VALA_IS_INTERFACE (self), NULL);
206
201
        return GEE_COLLECTION (gee_read_only_collection_new (g_object_ref, g_object_unref, GEE_COLLECTION (self->priv->methods)));
207
202
}
213
208
 *
214
209
 * @param f a field
215
210
 */
216
 
void vala_interface_add_field (ValaInterface* self, ValaField* f)
217
 
{
 
211
void vala_interface_add_field (ValaInterface* self, ValaField* f) {
218
212
        g_return_if_fail (VALA_IS_INTERFACE (self));
219
213
        g_return_if_fail (VALA_IS_FIELD (f));
220
214
        /* non_null fields not yet supported due to initialization issues*/
221
215
        vala_type_reference_set_non_null (vala_field_get_type_reference (f), FALSE);
222
216
        gee_collection_add (GEE_COLLECTION (self->priv->fields), f);
223
 
        vala_scope_add (vala_symbol_get_scope (((ValaSymbol*) self)), vala_symbol_get_name (((ValaSymbol*) f)), VALA_SYMBOL (f));
 
217
        vala_scope_add (vala_symbol_get_scope (VALA_SYMBOL (self)), vala_symbol_get_name (VALA_SYMBOL (f)), VALA_SYMBOL (f));
224
218
}
225
219
 
226
220
 
229
223
 *
230
224
 * @return list of fields
231
225
 */
232
 
GeeCollection* vala_interface_get_fields (ValaInterface* self)
233
 
{
 
226
GeeCollection* vala_interface_get_fields (ValaInterface* self) {
234
227
        g_return_val_if_fail (VALA_IS_INTERFACE (self), NULL);
235
228
        return GEE_COLLECTION (gee_read_only_collection_new (g_object_ref, g_object_unref, GEE_COLLECTION (self->priv->fields)));
236
229
}
241
234
 *
242
235
 * @param prop a property
243
236
 */
244
 
void vala_interface_add_property (ValaInterface* self, ValaProperty* prop)
245
 
{
 
237
void vala_interface_add_property (ValaInterface* self, ValaProperty* prop) {
246
238
        g_return_if_fail (VALA_IS_INTERFACE (self));
247
239
        g_return_if_fail (VALA_IS_PROPERTY (prop));
248
240
        gee_collection_add (GEE_COLLECTION (self->priv->properties), prop);
249
 
        vala_scope_add (vala_symbol_get_scope (((ValaSymbol*) self)), vala_symbol_get_name (((ValaSymbol*) prop)), VALA_SYMBOL (prop));
 
241
        vala_scope_add (vala_symbol_get_scope (VALA_SYMBOL (self)), vala_symbol_get_name (VALA_SYMBOL (prop)), VALA_SYMBOL (prop));
250
242
}
251
243
 
252
244
 
255
247
 *
256
248
 * @return list of properties
257
249
 */
258
 
GeeCollection* vala_interface_get_properties (ValaInterface* self)
259
 
{
 
250
GeeCollection* vala_interface_get_properties (ValaInterface* self) {
260
251
        g_return_val_if_fail (VALA_IS_INTERFACE (self), NULL);
261
252
        return GEE_COLLECTION (gee_read_only_collection_new (g_object_ref, g_object_unref, GEE_COLLECTION (self->priv->properties)));
262
253
}
267
258
 *
268
259
 * @param sig a signal
269
260
 */
270
 
void vala_interface_add_signal (ValaInterface* self, ValaSignal* sig)
271
 
{
 
261
void vala_interface_add_signal (ValaInterface* self, ValaSignal* sig) {
272
262
        g_return_if_fail (VALA_IS_INTERFACE (self));
273
263
        g_return_if_fail (VALA_IS_SIGNAL (sig));
274
264
        gee_collection_add (GEE_COLLECTION (self->priv->signals), sig);
275
 
        vala_scope_add (vala_symbol_get_scope (((ValaSymbol*) self)), vala_symbol_get_name (((ValaSymbol*) sig)), VALA_SYMBOL (sig));
 
265
        vala_scope_add (vala_symbol_get_scope (VALA_SYMBOL (self)), vala_symbol_get_name (VALA_SYMBOL (sig)), VALA_SYMBOL (sig));
276
266
}
277
267
 
278
268
 
281
271
 *
282
272
 * @return list of signals
283
273
 */
284
 
GeeCollection* vala_interface_get_signals (ValaInterface* self)
285
 
{
 
274
GeeCollection* vala_interface_get_signals (ValaInterface* self) {
286
275
        g_return_val_if_fail (VALA_IS_INTERFACE (self), NULL);
287
276
        return GEE_COLLECTION (gee_read_only_collection_new (g_object_ref, g_object_unref, GEE_COLLECTION (self->priv->signals)));
288
277
}
289
278
 
290
279
 
291
 
static char* vala_interface_real_get_cname (ValaDataType* base, gboolean const_type)
292
 
{
 
280
static char* vala_interface_real_get_cname (ValaDataType* base, gboolean const_type) {
293
281
        ValaInterface * self;
294
 
        const char* __temp10;
295
 
        self = ((ValaInterface*) base);
 
282
        const char* _tmp2;
 
283
        self = VALA_INTERFACE (base);
296
284
        if (self->priv->cname == NULL) {
297
 
                char* __temp9;
298
 
                char* __temp8;
299
 
                __temp9 = NULL;
300
 
                __temp8 = NULL;
301
 
                self->priv->cname = (__temp9 = g_strdup_printf ("%s%s", (__temp8 = vala_symbol_get_cprefix (vala_symbol_get_parent_symbol (((ValaSymbol*) self)))), vala_symbol_get_name (((ValaSymbol*) self))), (self->priv->cname = (g_free (self->priv->cname), NULL)), __temp9);
302
 
                (__temp8 = (g_free (__temp8), NULL));
 
285
                char* _tmp1;
 
286
                char* _tmp0;
 
287
                _tmp1 = NULL;
 
288
                _tmp0 = NULL;
 
289
                self->priv->cname = (_tmp1 = g_strdup_printf ("%s%s", (_tmp0 = vala_symbol_get_cprefix (vala_symbol_get_parent_symbol (VALA_SYMBOL (self)))), vala_symbol_get_name (VALA_SYMBOL (self))), (self->priv->cname = (g_free (self->priv->cname), NULL)), _tmp1);
 
290
                (_tmp0 = (g_free (_tmp0), NULL));
303
291
        }
304
 
        __temp10 = NULL;
305
 
        return (__temp10 = self->priv->cname, (__temp10 == NULL ? NULL : g_strdup (__temp10)));
 
292
        _tmp2 = NULL;
 
293
        return (_tmp2 = self->priv->cname, (_tmp2 == NULL ? NULL : g_strdup (_tmp2)));
306
294
}
307
295
 
308
296
 
312
300
 *
313
301
 * @return the suffix to be used in C code
314
302
 */
315
 
char* vala_interface_get_lower_case_csuffix (ValaInterface* self)
316
 
{
317
 
        const char* __temp13;
 
303
char* vala_interface_get_lower_case_csuffix (ValaInterface* self) {
 
304
        const char* _tmp1;
318
305
        g_return_val_if_fail (VALA_IS_INTERFACE (self), NULL);
319
306
        if (self->priv->lower_case_csuffix == NULL) {
320
 
                char* __temp12;
321
 
                __temp12 = NULL;
322
 
                self->priv->lower_case_csuffix = (__temp12 = vala_symbol_camel_case_to_lower_case (vala_symbol_get_name (((ValaSymbol*) self))), (self->priv->lower_case_csuffix = (g_free (self->priv->lower_case_csuffix), NULL)), __temp12);
 
307
                char* _tmp0;
 
308
                _tmp0 = NULL;
 
309
                self->priv->lower_case_csuffix = (_tmp0 = vala_symbol_camel_case_to_lower_case (vala_symbol_get_name (VALA_SYMBOL (self))), (self->priv->lower_case_csuffix = (g_free (self->priv->lower_case_csuffix), NULL)), _tmp0);
323
310
        }
324
 
        __temp13 = NULL;
325
 
        return (__temp13 = self->priv->lower_case_csuffix, (__temp13 == NULL ? NULL : g_strdup (__temp13)));
 
311
        _tmp1 = NULL;
 
312
        return (_tmp1 = self->priv->lower_case_csuffix, (_tmp1 == NULL ? NULL : g_strdup (_tmp1)));
326
313
}
327
314
 
328
315
 
332
319
 *
333
320
 * @param csuffix the suffix to be used in C code
334
321
 */
335
 
void vala_interface_set_lower_case_csuffix (ValaInterface* self, const char* csuffix)
336
 
{
337
 
        char* __temp15;
 
322
void vala_interface_set_lower_case_csuffix (ValaInterface* self, const char* csuffix) {
 
323
        char* _tmp0;
338
324
        g_return_if_fail (VALA_IS_INTERFACE (self));
339
325
        g_return_if_fail (csuffix != NULL);
340
 
        __temp15 = NULL;
341
 
        self->priv->lower_case_csuffix = (__temp15 = g_strdup (csuffix), (self->priv->lower_case_csuffix = (g_free (self->priv->lower_case_csuffix), NULL)), __temp15);
 
326
        _tmp0 = NULL;
 
327
        self->priv->lower_case_csuffix = (_tmp0 = g_strdup (csuffix), (self->priv->lower_case_csuffix = (g_free (self->priv->lower_case_csuffix), NULL)), _tmp0);
342
328
}
343
329
 
344
330
 
345
 
static char* vala_interface_real_get_lower_case_cname (ValaSymbol* base, const char* infix)
346
 
{
 
331
static char* vala_interface_real_get_lower_case_cname (ValaSymbol* base, const char* infix) {
347
332
        ValaInterface * self;
348
 
        char* __temp17;
349
 
        char* __temp16;
350
 
        char* __temp18;
351
 
        self = ((ValaInterface*) base);
 
333
        char* _tmp1;
 
334
        char* _tmp0;
 
335
        char* _tmp2;
 
336
        self = VALA_INTERFACE (base);
352
337
        if (infix == NULL) {
353
338
                infix = "";
354
339
        }
355
 
        __temp17 = NULL;
356
 
        __temp16 = NULL;
357
 
        __temp18 = NULL;
358
 
        return (__temp18 = g_strdup_printf ("%s%s%s", (__temp16 = vala_symbol_get_lower_case_cprefix (vala_symbol_get_parent_symbol (((ValaSymbol*) self)))), infix, (__temp17 = vala_interface_get_lower_case_csuffix (self))), (__temp17 = (g_free (__temp17), NULL)), (__temp16 = (g_free (__temp16), NULL)), __temp18);
359
 
}
360
 
 
361
 
 
362
 
static char* vala_interface_real_get_lower_case_cprefix (ValaSymbol* base)
363
 
{
364
 
        ValaInterface * self;
365
 
        char* __temp20;
366
 
        char* __temp21;
367
 
        self = ((ValaInterface*) base);
368
 
        __temp20 = NULL;
369
 
        __temp21 = NULL;
370
 
        return (__temp21 = g_strdup_printf ("%s_", (__temp20 = vala_symbol_get_lower_case_cname (VALA_SYMBOL (self), NULL))), (__temp20 = (g_free (__temp20), NULL)), __temp21);
371
 
}
372
 
 
373
 
 
374
 
static char* vala_interface_real_get_upper_case_cname (ValaDataType* base, const char* infix)
375
 
{
376
 
        ValaInterface * self;
377
 
        char* __temp23;
378
 
        char* __temp24;
379
 
        self = ((ValaInterface*) base);
380
 
        __temp23 = NULL;
381
 
        __temp24 = NULL;
382
 
        return (__temp24 = g_utf8_strup ((__temp23 = vala_symbol_get_lower_case_cname (VALA_SYMBOL (self), infix)), -1), (__temp23 = (g_free (__temp23), NULL)), __temp24);
383
 
}
384
 
 
385
 
 
386
 
static void vala_interface_real_accept (ValaCodeNode* base, ValaCodeVisitor* visitor)
387
 
{
388
 
        ValaInterface * self;
389
 
        self = ((ValaInterface*) base);
 
340
        _tmp1 = NULL;
 
341
        _tmp0 = NULL;
 
342
        _tmp2 = NULL;
 
343
        return (_tmp2 = g_strdup_printf ("%s%s%s", (_tmp0 = vala_symbol_get_lower_case_cprefix (vala_symbol_get_parent_symbol (VALA_SYMBOL (self)))), infix, (_tmp1 = vala_interface_get_lower_case_csuffix (self))), (_tmp1 = (g_free (_tmp1), NULL)), (_tmp0 = (g_free (_tmp0), NULL)), _tmp2);
 
344
}
 
345
 
 
346
 
 
347
static char* vala_interface_real_get_lower_case_cprefix (ValaSymbol* base) {
 
348
        ValaInterface * self;
 
349
        char* _tmp0;
 
350
        char* _tmp1;
 
351
        self = VALA_INTERFACE (base);
 
352
        _tmp0 = NULL;
 
353
        _tmp1 = NULL;
 
354
        return (_tmp1 = g_strdup_printf ("%s_", (_tmp0 = vala_symbol_get_lower_case_cname (VALA_SYMBOL (self), NULL))), (_tmp0 = (g_free (_tmp0), NULL)), _tmp1);
 
355
}
 
356
 
 
357
 
 
358
static char* vala_interface_real_get_upper_case_cname (ValaDataType* base, const char* infix) {
 
359
        ValaInterface * self;
 
360
        char* _tmp0;
 
361
        char* _tmp1;
 
362
        self = VALA_INTERFACE (base);
 
363
        _tmp0 = NULL;
 
364
        _tmp1 = NULL;
 
365
        return (_tmp1 = g_utf8_strup ((_tmp0 = vala_symbol_get_lower_case_cname (VALA_SYMBOL (self), infix)), -1), (_tmp0 = (g_free (_tmp0), NULL)), _tmp1);
 
366
}
 
367
 
 
368
 
 
369
static void vala_interface_real_accept (ValaCodeNode* base, ValaCodeVisitor* visitor) {
 
370
        ValaInterface * self;
 
371
        self = VALA_INTERFACE (base);
390
372
        g_return_if_fail (VALA_IS_CODE_VISITOR (visitor));
391
373
        vala_code_visitor_visit_interface (visitor, self);
392
374
}
393
375
 
394
376
 
395
 
static void vala_interface_real_accept_children (ValaCodeNode* base, ValaCodeVisitor* visitor)
396
 
{
 
377
static void vala_interface_real_accept_children (ValaCodeNode* base, ValaCodeVisitor* visitor) {
397
378
        ValaInterface * self;
398
 
        self = ((ValaInterface*) base);
 
379
        self = VALA_INTERFACE (base);
399
380
        g_return_if_fail (VALA_IS_CODE_VISITOR (visitor));
400
381
        {
401
382
                GeeList* type_collection;
490
471
}
491
472
 
492
473
 
493
 
static gboolean vala_interface_real_is_reference_type (ValaDataType* base)
494
 
{
495
 
        ValaInterface * self;
496
 
        self = ((ValaInterface*) base);
497
 
        return TRUE;
498
 
}
499
 
 
500
 
 
501
 
static gboolean vala_interface_real_is_reference_counting (ValaDataType* base)
502
 
{
503
 
        ValaInterface * self;
504
 
        self = ((ValaInterface*) base);
505
 
        return TRUE;
506
 
}
507
 
 
508
 
 
509
 
static char* vala_interface_real_get_ref_function (ValaDataType* base)
510
 
{
511
 
        ValaInterface * self;
512
 
        self = ((ValaInterface*) base);
 
474
static gboolean vala_interface_real_is_reference_type (ValaDataType* base) {
 
475
        ValaInterface * self;
 
476
        self = VALA_INTERFACE (base);
 
477
        return TRUE;
 
478
}
 
479
 
 
480
 
 
481
static gboolean vala_interface_real_is_reference_counting (ValaDataType* base) {
 
482
        ValaInterface * self;
 
483
        self = VALA_INTERFACE (base);
 
484
        return TRUE;
 
485
}
 
486
 
 
487
 
 
488
static char* vala_interface_real_get_ref_function (ValaDataType* base) {
 
489
        ValaInterface * self;
 
490
        self = VALA_INTERFACE (base);
513
491
        return g_strdup ("g_object_ref");
514
492
}
515
493
 
516
494
 
517
 
static char* vala_interface_real_get_unref_function (ValaDataType* base)
518
 
{
 
495
static char* vala_interface_real_get_unref_function (ValaDataType* base) {
519
496
        ValaInterface * self;
520
 
        self = ((ValaInterface*) base);
 
497
        self = VALA_INTERFACE (base);
521
498
        return g_strdup ("g_object_unref");
522
499
}
523
500
 
524
501
 
525
 
static gboolean vala_interface_real_is_subtype_of (ValaDataType* base, ValaDataType* t)
526
 
{
 
502
static gboolean vala_interface_real_is_subtype_of (ValaDataType* base, ValaDataType* t) {
527
503
        ValaInterface * self;
528
 
        self = ((ValaInterface*) base);
 
504
        self = VALA_INTERFACE (base);
529
505
        g_return_val_if_fail (VALA_IS_DATA_TYPE (t), FALSE);
 
506
        if (VALA_DATA_TYPE (self) == t) {
 
507
                return TRUE;
 
508
        }
530
509
        {
531
510
                GeeList* prerequisite_collection;
532
511
                GeeIterator* prerequisite_it;
536
515
                        ValaTypeReference* prerequisite;
537
516
                        prerequisite = gee_iterator_get (prerequisite_it);
538
517
                        {
539
 
                                if (vala_type_reference_get_data_type (prerequisite) == t || vala_data_type_is_subtype_of (vala_type_reference_get_data_type (prerequisite), t)) {
540
 
                                        gboolean __temp30;
541
 
                                        return (__temp30 = TRUE, (prerequisite == NULL ? NULL : (prerequisite = (g_object_unref (prerequisite), NULL))), (prerequisite_it == NULL ? NULL : (prerequisite_it = (g_object_unref (prerequisite_it), NULL))), __temp30);
 
518
                                if (vala_type_reference_get_data_type (prerequisite) != NULL && vala_data_type_is_subtype_of (vala_type_reference_get_data_type (prerequisite), t)) {
 
519
                                        gboolean _tmp1;
 
520
                                        return (_tmp1 = TRUE, (prerequisite == NULL ? NULL : (prerequisite = (g_object_unref (prerequisite), NULL))), (prerequisite_it == NULL ? NULL : (prerequisite_it = (g_object_unref (prerequisite_it), NULL))), _tmp1);
542
521
                                }
543
522
                                (prerequisite == NULL ? NULL : (prerequisite = (g_object_unref (prerequisite), NULL)));
544
523
                        }
549
528
}
550
529
 
551
530
 
552
 
static void vala_interface_process_ccode_attribute (ValaInterface* self, ValaAttribute* a)
553
 
{
 
531
static void vala_interface_process_ccode_attribute (ValaInterface* self, ValaAttribute* a) {
554
532
        g_return_if_fail (VALA_IS_INTERFACE (self));
555
533
        g_return_if_fail (VALA_IS_ATTRIBUTE (a));
556
534
        if (vala_attribute_has_argument (a, "type_cname")) {
557
 
                char* __temp32;
558
 
                __temp32 = NULL;
559
 
                vala_interface_set_type_cname (self, (__temp32 = vala_attribute_get_string (a, "type_cname")));
560
 
                (__temp32 = (g_free (__temp32), NULL));
 
535
                char* _tmp0;
 
536
                _tmp0 = NULL;
 
537
                vala_interface_set_type_cname (self, (_tmp0 = vala_attribute_get_string (a, "type_cname")));
 
538
                (_tmp0 = (g_free (_tmp0), NULL));
561
539
        }
562
540
        if (vala_attribute_has_argument (a, "cheader_filename")) {
563
541
                char* val;
565
543
                {
566
544
                        char** filename_collection;
567
545
                        char** filename_it;
 
546
                        int filename_collection_length1;
568
547
                        filename_collection = g_strsplit (val, ",", 0);
 
548
                        filename_collection_length1 = -1;
569
549
                        for (filename_it = filename_collection; *filename_it != NULL; filename_it = filename_it + 1) {
570
 
                                const char* __temp33;
 
550
                                const char* _tmp1;
571
551
                                char* filename;
572
 
                                __temp33 = NULL;
573
 
                                filename = (__temp33 = *filename_it, (__temp33 == NULL ? NULL : g_strdup (__temp33)));
 
552
                                _tmp1 = NULL;
 
553
                                filename = (_tmp1 = *filename_it, (_tmp1 == NULL ? NULL : g_strdup (_tmp1)));
574
554
                                {
575
555
                                        vala_data_type_add_cheader_filename (VALA_DATA_TYPE (self), filename);
576
556
                                        (filename = (g_free (filename), NULL));
577
557
                                }
578
558
                        }
579
 
                        (filename_collection = (g_strfreev (filename_collection), NULL));
 
559
                        (filename_collection = (_vala_array_free (filename_collection, filename_collection_length1, ((GDestroyNotify) g_free)), NULL));
580
560
                }
581
561
                (val = (g_free (val), NULL));
582
562
        }
583
563
}
584
564
 
585
565
 
 
566
static void vala_interface_process_dbus_interface_attribute (ValaInterface* self, ValaAttribute* a) {
 
567
        g_return_if_fail (VALA_IS_INTERFACE (self));
 
568
        g_return_if_fail (VALA_IS_ATTRIBUTE (a));
 
569
        if (vala_interface_get_declaration_only (self)) {
 
570
                char* _tmp0;
 
571
                _tmp0 = NULL;
 
572
                self->priv->cname = (_tmp0 = g_strdup ("DBusGProxy"), (self->priv->cname = (g_free (self->priv->cname), NULL)), _tmp0);
 
573
        }
 
574
}
 
575
 
 
576
 
586
577
/**
587
578
 * Process all associated attributes.
588
579
 */
589
 
void vala_interface_process_attributes (ValaInterface* self)
590
 
{
 
580
void vala_interface_process_attributes (ValaInterface* self) {
591
581
        g_return_if_fail (VALA_IS_INTERFACE (self));
592
582
        {
593
583
                GList* a_collection;
594
584
                GList* a_it;
595
 
                a_collection = ((ValaCodeNode*) self)->attributes;
 
585
                a_collection = VALA_CODE_NODE (self)->attributes;
596
586
                for (a_it = a_collection; a_it != NULL; a_it = a_it->next) {
597
 
                        ValaAttribute* __temp34;
 
587
                        ValaAttribute* _tmp0;
598
588
                        ValaAttribute* a;
599
 
                        __temp34 = NULL;
600
 
                        a = (__temp34 = a_it->data, (__temp34 == NULL ? NULL : g_object_ref (__temp34)));
 
589
                        _tmp0 = NULL;
 
590
                        a = (_tmp0 = a_it->data, (_tmp0 == NULL ? NULL : g_object_ref (_tmp0)));
601
591
                        {
602
592
                                if (g_utf8_collate (vala_attribute_get_name (a), "CCode") == 0) {
603
593
                                        vala_interface_process_ccode_attribute (self, a);
 
594
                                } else {
 
595
                                        if (g_utf8_collate (vala_attribute_get_name (a), "DBusInterface") == 0) {
 
596
                                                vala_interface_process_dbus_interface_attribute (self, a);
 
597
                                        }
604
598
                                }
605
599
                                (a == NULL ? NULL : (a = (g_object_unref (a), NULL)));
606
600
                        }
614
608
 *
615
609
 * @return the type struct name to be used in C code
616
610
 */
617
 
char* vala_interface_get_type_cname (ValaInterface* self)
618
 
{
619
 
        const char* __temp37;
 
611
char* vala_interface_get_type_cname (ValaInterface* self) {
 
612
        const char* _tmp2;
620
613
        g_return_val_if_fail (VALA_IS_INTERFACE (self), NULL);
621
614
        if (self->priv->type_cname == NULL) {
622
 
                char* __temp36;
623
 
                char* __temp35;
624
 
                __temp36 = NULL;
625
 
                __temp35 = NULL;
626
 
                self->priv->type_cname = (__temp36 = g_strdup_printf ("%sIface", (__temp35 = vala_data_type_get_cname (VALA_DATA_TYPE (self), FALSE))), (self->priv->type_cname = (g_free (self->priv->type_cname), NULL)), __temp36);
627
 
                (__temp35 = (g_free (__temp35), NULL));
 
615
                char* _tmp1;
 
616
                char* _tmp0;
 
617
                _tmp1 = NULL;
 
618
                _tmp0 = NULL;
 
619
                self->priv->type_cname = (_tmp1 = g_strdup_printf ("%sIface", (_tmp0 = vala_data_type_get_cname (VALA_DATA_TYPE (self), FALSE))), (self->priv->type_cname = (g_free (self->priv->type_cname), NULL)), _tmp1);
 
620
                (_tmp0 = (g_free (_tmp0), NULL));
628
621
        }
629
 
        __temp37 = NULL;
630
 
        return (__temp37 = self->priv->type_cname, (__temp37 == NULL ? NULL : g_strdup (__temp37)));
 
622
        _tmp2 = NULL;
 
623
        return (_tmp2 = self->priv->type_cname, (_tmp2 == NULL ? NULL : g_strdup (_tmp2)));
631
624
}
632
625
 
633
626
 
636
629
 *
637
630
 * @param type_cname the type struct name to be used in C code
638
631
 */
639
 
void vala_interface_set_type_cname (ValaInterface* self, const char* type_cname)
640
 
{
641
 
        char* __temp39;
 
632
void vala_interface_set_type_cname (ValaInterface* self, const char* type_cname) {
 
633
        char* _tmp0;
642
634
        g_return_if_fail (VALA_IS_INTERFACE (self));
643
635
        g_return_if_fail (type_cname != NULL);
644
 
        __temp39 = NULL;
645
 
        self->priv->type_cname = (__temp39 = g_strdup (type_cname), (self->priv->type_cname = (g_free (self->priv->type_cname), NULL)), __temp39);
 
636
        _tmp0 = NULL;
 
637
        self->priv->type_cname = (_tmp0 = g_strdup (type_cname), (self->priv->type_cname = (g_free (self->priv->type_cname), NULL)), _tmp0);
646
638
}
647
639
 
648
640
 
649
 
static char* vala_interface_real_get_marshaller_type_name (ValaDataType* base)
650
 
{
 
641
static char* vala_interface_real_get_marshaller_type_name (ValaDataType* base) {
651
642
        ValaInterface * self;
652
 
        self = ((ValaInterface*) base);
 
643
        self = VALA_INTERFACE (base);
653
644
        return g_strdup ("OBJECT");
654
645
}
655
646
 
656
647
 
657
 
static char* vala_interface_real_get_get_value_function (ValaDataType* base)
658
 
{
 
648
static char* vala_interface_real_get_get_value_function (ValaDataType* base) {
659
649
        ValaInterface * self;
660
 
        self = ((ValaInterface*) base);
 
650
        self = VALA_INTERFACE (base);
661
651
        return g_strdup ("g_value_get_object");
662
652
}
663
653
 
664
654
 
665
 
static char* vala_interface_real_get_set_value_function (ValaDataType* base)
666
 
{
 
655
static char* vala_interface_real_get_set_value_function (ValaDataType* base) {
667
656
        ValaInterface * self;
668
 
        self = ((ValaInterface*) base);
 
657
        self = VALA_INTERFACE (base);
669
658
        return g_strdup ("g_value_set_object");
670
659
}
671
660
 
672
661
 
673
 
static char* vala_interface_real_get_type_id (ValaDataType* base)
674
 
{
 
662
static char* vala_interface_real_get_type_id (ValaDataType* base) {
675
663
        ValaInterface * self;
676
 
        const char* __temp44;
677
 
        self = ((ValaInterface*) base);
 
664
        const char* _tmp1;
 
665
        self = VALA_INTERFACE (base);
678
666
        if (self->priv->type_id == NULL) {
679
 
                char* __temp43;
680
 
                __temp43 = NULL;
681
 
                self->priv->type_id = (__temp43 = vala_data_type_get_upper_case_cname (VALA_DATA_TYPE (self), "TYPE_"), (self->priv->type_id = (g_free (self->priv->type_id), NULL)), __temp43);
 
667
                char* _tmp0;
 
668
                _tmp0 = NULL;
 
669
                self->priv->type_id = (_tmp0 = vala_data_type_get_upper_case_cname (VALA_DATA_TYPE (self), "TYPE_"), (self->priv->type_id = (g_free (self->priv->type_id), NULL)), _tmp0);
682
670
        }
683
 
        __temp44 = NULL;
684
 
        return (__temp44 = self->priv->type_id, (__temp44 == NULL ? NULL : g_strdup (__temp44)));
 
671
        _tmp1 = NULL;
 
672
        return (_tmp1 = self->priv->type_id, (_tmp1 == NULL ? NULL : g_strdup (_tmp1)));
685
673
}
686
674
 
687
675
 
688
 
static gint vala_interface_real_get_type_parameter_index (ValaDataType* base, const char* name)
689
 
{
 
676
static gint vala_interface_real_get_type_parameter_index (ValaDataType* base, const char* name) {
690
677
        ValaInterface * self;
691
678
        gint i;
692
 
        self = ((ValaInterface*) base);
 
679
        self = VALA_INTERFACE (base);
693
680
        g_return_val_if_fail (name != NULL, 0);
694
681
        i = 0;
695
682
        {
701
688
                        ValaTypeParameter* parameter;
702
689
                        parameter = gee_iterator_get (parameter_it);
703
690
                        {
704
 
                                if (g_utf8_collate (vala_symbol_get_name (((ValaSymbol*) parameter)), name) == 0) {
705
 
                                        gint __temp46;
706
 
                                        return (__temp46 = i, (parameter == NULL ? NULL : (parameter = (g_object_unref (parameter), NULL))), (parameter_it == NULL ? NULL : (parameter_it = (g_object_unref (parameter_it), NULL))), __temp46);
 
691
                                if (g_utf8_collate (vala_symbol_get_name (VALA_SYMBOL (parameter)), name) == 0) {
 
692
                                        gint _tmp0;
 
693
                                        return (_tmp0 = i, (parameter == NULL ? NULL : (parameter = (g_object_unref (parameter), NULL))), (parameter_it == NULL ? NULL : (parameter_it = (g_object_unref (parameter_it), NULL))), _tmp0);
707
694
                                }
708
695
                                i++;
709
696
                                (parameter == NULL ? NULL : (parameter = (g_object_unref (parameter), NULL)));
715
702
}
716
703
 
717
704
 
718
 
gboolean vala_interface_get_is_static (ValaInterface* self)
719
 
{
 
705
gboolean vala_interface_get_is_static (ValaInterface* self) {
720
706
        g_return_val_if_fail (VALA_IS_INTERFACE (self), FALSE);
721
707
        return self->priv->_is_static;
722
708
}
723
709
 
724
710
 
725
 
void vala_interface_set_is_static (ValaInterface* self, gboolean value)
726
 
{
 
711
void vala_interface_set_is_static (ValaInterface* self, gboolean value) {
727
712
        g_return_if_fail (VALA_IS_INTERFACE (self));
728
713
        self->priv->_is_static = value;
729
714
}
730
715
 
731
716
 
732
 
static void vala_interface_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec)
733
 
{
 
717
gboolean vala_interface_get_declaration_only (ValaInterface* self) {
 
718
        g_return_val_if_fail (VALA_IS_INTERFACE (self), FALSE);
 
719
        return self->priv->_declaration_only;
 
720
}
 
721
 
 
722
 
 
723
void vala_interface_set_declaration_only (ValaInterface* self, gboolean value) {
 
724
        g_return_if_fail (VALA_IS_INTERFACE (self));
 
725
        self->priv->_declaration_only = value;
 
726
}
 
727
 
 
728
 
 
729
static void vala_interface_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec) {
734
730
        ValaInterface * self;
735
731
        self = VALA_INTERFACE (object);
736
732
        switch (property_id) {
737
733
                case VALA_INTERFACE_IS_STATIC:
738
734
                g_value_set_boolean (value, vala_interface_get_is_static (self));
739
735
                break;
 
736
                case VALA_INTERFACE_DECLARATION_ONLY:
 
737
                g_value_set_boolean (value, vala_interface_get_declaration_only (self));
 
738
                break;
 
739
                default:
 
740
                G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
 
741
                break;
740
742
        }
741
743
}
742
744
 
743
745
 
744
 
static void vala_interface_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec)
745
 
{
 
746
static void vala_interface_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec) {
746
747
        ValaInterface * self;
747
748
        self = VALA_INTERFACE (object);
748
749
        switch (property_id) {
749
750
                case VALA_INTERFACE_IS_STATIC:
750
751
                vala_interface_set_is_static (self, g_value_get_boolean (value));
751
752
                break;
 
753
                case VALA_INTERFACE_DECLARATION_ONLY:
 
754
                vala_interface_set_declaration_only (self, g_value_get_boolean (value));
 
755
                break;
 
756
                default:
 
757
                G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
 
758
                break;
752
759
        }
753
760
}
754
761
 
755
762
 
756
 
static void vala_interface_class_init (ValaInterfaceClass * klass)
757
 
{
 
763
static void vala_interface_class_init (ValaInterfaceClass * klass) {
758
764
        vala_interface_parent_class = g_type_class_peek_parent (klass);
759
765
        g_type_class_add_private (klass, sizeof (ValaInterfacePrivate));
760
766
        G_OBJECT_CLASS (klass)->get_property = vala_interface_get_property;
776
782
        VALA_DATA_TYPE_CLASS (klass)->get_set_value_function = vala_interface_real_get_set_value_function;
777
783
        VALA_DATA_TYPE_CLASS (klass)->get_type_id = vala_interface_real_get_type_id;
778
784
        VALA_DATA_TYPE_CLASS (klass)->get_type_parameter_index = vala_interface_real_get_type_parameter_index;
779
 
        g_object_class_install_property (G_OBJECT_CLASS (klass), VALA_INTERFACE_IS_STATIC, g_param_spec_boolean ("is-static", "foo", "bar", FALSE, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE | G_PARAM_WRITABLE));
 
785
        g_object_class_install_property (G_OBJECT_CLASS (klass), VALA_INTERFACE_IS_STATIC, g_param_spec_boolean ("is-static", "is-static", "is-static", FALSE, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE | G_PARAM_WRITABLE));
 
786
        g_object_class_install_property (G_OBJECT_CLASS (klass), VALA_INTERFACE_DECLARATION_ONLY, g_param_spec_boolean ("declaration-only", "declaration-only", "declaration-only", FALSE, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE | G_PARAM_WRITABLE));
780
787
}
781
788
 
782
789
 
783
 
static void vala_interface_init (ValaInterface * self)
784
 
{
 
790
static void vala_interface_init (ValaInterface * self) {
785
791
        self->priv = VALA_INTERFACE_GET_PRIVATE (self);
786
792
        self->priv->type_parameters = GEE_LIST (gee_array_list_new (g_object_ref, g_object_unref, g_direct_equal));
787
793
        self->priv->prerequisites = GEE_LIST (gee_array_list_new (g_object_ref, g_object_unref, g_direct_equal));
792
798
}
793
799
 
794
800
 
795
 
static void vala_interface_dispose (GObject * obj)
796
 
{
 
801
static void vala_interface_dispose (GObject * obj) {
797
802
        ValaInterface * self;
798
 
        ValaInterfaceClass * klass;
799
 
        GObjectClass * parent_class;
800
803
        self = VALA_INTERFACE (obj);
801
804
        (self->priv->type_parameters == NULL ? NULL : (self->priv->type_parameters = (g_object_unref (self->priv->type_parameters), NULL)));
802
805
        (self->priv->prerequisites == NULL ? NULL : (self->priv->prerequisites = (g_object_unref (self->priv->prerequisites), NULL)));
808
811
        (self->priv->lower_case_csuffix = (g_free (self->priv->lower_case_csuffix), NULL));
809
812
        (self->priv->type_cname = (g_free (self->priv->type_cname), NULL));
810
813
        (self->priv->type_id = (g_free (self->priv->type_id), NULL));
811
 
        klass = VALA_INTERFACE_CLASS (g_type_class_peek (VALA_TYPE_INTERFACE));
812
 
        parent_class = G_OBJECT_CLASS (g_type_class_peek_parent (klass));
813
 
        parent_class->dispose (obj);
 
814
        G_OBJECT_CLASS (vala_interface_parent_class)->dispose (obj);
814
815
}
815
816
 
816
817
 
817
 
GType vala_interface_get_type (void)
818
 
{
 
818
GType vala_interface_get_type (void) {
819
819
        static GType vala_interface_type_id = 0;
820
820
        if (G_UNLIKELY (vala_interface_type_id == 0)) {
821
821
                static const GTypeInfo g_define_type_info = { sizeof (ValaInterfaceClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) vala_interface_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ValaInterface), 0, (GInstanceInitFunc) vala_interface_init };
825
825
}
826
826
 
827
827
 
 
828
static void _vala_array_free (gpointer array, gint array_length, GDestroyNotify destroy_func) {
 
829
        if (array != NULL && destroy_func != NULL) {
 
830
                int i;
 
831
                if (array_length >= 0)
 
832
                for (i = 0; i < array_length; i = i + 1) {
 
833
                        if (((gpointer*) array)[i] != NULL)
 
834
                        destroy_func (((gpointer*) array)[i]);
 
835
                }
 
836
                else
 
837
                for (i = 0; ((gpointer*) array)[i] != NULL; i = i + 1) {
 
838
                        destroy_func (((gpointer*) array)[i]);
 
839
                }
 
840
        }
 
841
        g_free (array);
 
842
}
 
843
 
 
844
 
828
845
 
829
846