← Back to branch summary

~ubuntu-branches/ubuntu/maverick/radare/maverick

« back to all changes in this revision

Viewing changes to src/rsc/gtk/SetRegister.c

  • Committer: Bazaar Package Importer
  • Author(s): SevenMachines
  • Date: 2010-09-07 15:44:27 UTC
  • mfrom: (1.1.3 upstream) (2.1.4 sid)
  • Revision ID: james.westby@ubuntu.com-20100907154427-37u92vu12tqabqqz
Tags: 1:1.5.2-3ubuntu1
https://launchpad.net/bugs/621016
https://launchpad.net/bugs/618809
* Merge from debian testing (LP: #621016)
* debian/control:
     + libvala-dev transition to libval-0.10-dev (LP: #618809) 

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/rsc/gtk/SetRegister.c
 
1
/* SetRegister.c generated by valac, the Vala compiler
 
2
 * generated from SetRegister.vala, do not modify */
 
3
 
 
4
 
 
5
#include <glib.h>
 
6
#include <glib-object.h>
 
7
#include <gtk/gtk.h>
 
8
#include <stdlib.h>
 
9
#include <string.h>
 
10
#include <gio/gio.h>
 
11
#include <stdio.h>
 
12
 
 
13
 
 
14
#define TYPE_SET_REGISTER (set_register_get_type ())
 
15
#define SET_REGISTER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_SET_REGISTER, SetRegister))
 
16
#define SET_REGISTER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_SET_REGISTER, SetRegisterClass))
 
17
#define IS_SET_REGISTER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_SET_REGISTER))
 
18
#define IS_SET_REGISTER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_SET_REGISTER))
 
19
#define SET_REGISTER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_SET_REGISTER, SetRegisterClass))
 
20
 
 
21
typedef struct _SetRegister SetRegister;
 
22
typedef struct _SetRegisterClass SetRegisterClass;
 
23
typedef struct _SetRegisterPrivate SetRegisterPrivate;
 
24
#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
 
25
#define _g_free0(var) (var = (g_free (var), NULL))
 
26
#define _g_hash_table_unref0(var) ((var == NULL) ? NULL : (var = (g_hash_table_unref (var), NULL)))
 
27
#define _g_error_free0(var) ((var == NULL) ? NULL : (var = (g_error_free (var), NULL)))
 
28
#define _g_list_free0(var) ((var == NULL) ? NULL : (var = (g_list_free (var), NULL)))
 
29
#define __g_list_free_g_free0(var) ((var == NULL) ? NULL : (var = (_g_list_free_g_free (var), NULL)))
 
30
 
 
31
struct _SetRegister {
 
32
        GtkDialog parent_instance;
 
33
        SetRegisterPrivate * priv;
 
34
};
 
35
 
 
36
struct _SetRegisterClass {
 
37
        GtkDialogClass parent_class;
 
38
};
 
39
 
 
40
struct _SetRegisterPrivate {
 
41
        GtkComboBoxEntry* cbe;
 
42
        GtkEntry* regvalue;
 
43
        char* regname;
 
44
        GHashTable* regs;
 
45
};
 
46
 
 
47
 
 
48
static gpointer set_register_parent_class = NULL;
 
49
 
 
50
GType set_register_get_type (void);
 
51
#define SET_REGISTER_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), TYPE_SET_REGISTER, SetRegisterPrivate))
 
52
enum  {
 
53
        SET_REGISTER_DUMMY_PROPERTY
 
54
};
 
55
SetRegister* set_register_new (void);
 
56
SetRegister* set_register_construct (GType object_type);
 
57
static void set_register_init_regs (SetRegister* self);
 
58
static void _g_list_free_g_free (GList* self);
 
59
static void set_register_fill_comboboxentry (SetRegister* self);
 
60
static char* set_register_get_reg_value (SetRegister* self);
 
61
static void set_register_on_combobox_changed (SetRegister* self);
 
62
static void set_register_ok_clicked (SetRegister* self);
 
63
static void set_register_on_response (SetRegister* self, GtkDialog* source, gint response_id);
 
64
static gint set_register_main (char** args, int args_length1);
 
65
static void _set_register_on_response_gtk_dialog_response (SetRegister* _sender, gint response_id, gpointer self);
 
66
static void _gtk_main_quit_gtk_object_destroy (SetRegister* _sender, gpointer self);
 
67
static void _lambda0_ (GtkComboBoxEntry* target, SetRegister* self);
 
68
static void __lambda0__gtk_combo_box_changed (GtkComboBoxEntry* _sender, gpointer self);
 
69
static GObject * set_register_constructor (GType type, guint n_construct_properties, GObjectConstructParam * construct_properties);
 
70
static void set_register_finalize (GObject* obj);
 
71
static void _vala_array_destroy (gpointer array, gint array_length, GDestroyNotify destroy_func);
 
72
static void _vala_array_free (gpointer array, gint array_length, GDestroyNotify destroy_func);
 
73
static gint _vala_array_length (gpointer array);
 
74
 
 
75
 
 
76
 
 
77
SetRegister* set_register_construct (GType object_type) {
 
78
        SetRegister * self;
 
79
        self = g_object_newv (object_type, 0, NULL);
 
80
        gtk_dialog_add_button ((GtkDialog*) self, GTK_STOCK_CANCEL, (gint) GTK_RESPONSE_CANCEL);
 
81
        gtk_dialog_add_button ((GtkDialog*) self, GTK_STOCK_OK, (gint) GTK_RESPONSE_OK);
 
82
        return self;
 
83
}
 
84
 
 
85
 
 
86
SetRegister* set_register_new (void) {
 
87
        return set_register_construct (TYPE_SET_REGISTER);
 
88
}
 
89
 
 
90
 
 
91
static char* string_substring (const char* self, glong offset, glong len) {
 
92
        char* result;
 
93
        glong string_length;
 
94
        const char* start;
 
95
        g_return_val_if_fail (self != NULL, NULL);
 
96
        string_length = g_utf8_strlen (self, -1);
 
97
        if (offset < 0) {
 
98
                offset = string_length + offset;
 
99
                g_return_val_if_fail (offset >= 0, NULL);
 
100
        } else {
 
101
                g_return_val_if_fail (offset <= string_length, NULL);
 
102
        }
 
103
        if (len < 0) {
 
104
                len = string_length - offset;
 
105
        }
 
106
        g_return_val_if_fail ((offset + len) <= string_length, NULL);
 
107
        start = g_utf8_offset_to_pointer (self, offset);
 
108
        result = g_strndup (start, ((gchar*) g_utf8_offset_to_pointer (start, len)) - ((gchar*) start));
 
109
        return result;
 
110
}
 
111
 
 
112
 
 
113
static void set_register_init_regs (SetRegister* self) {
 
114
        GError * _inner_error_;
 
115
        GHashTable* _tmp0_;
 
116
        g_return_if_fail (self != NULL);
 
117
        _inner_error_ = NULL;
 
118
        self->priv->regs = (_tmp0_ = g_hash_table_new (g_str_hash, g_str_equal), _g_hash_table_unref0 (self->priv->regs), _tmp0_);
 
119
        {
 
120
                GFile* file;
 
121
                GFileInputStream* _tmp1_;
 
122
                GFileInputStream* _tmp2_;
 
123
                GDataInputStream* _tmp3_;
 
124
                GDataInputStream* in_stream;
 
125
                char* line;
 
126
                file = g_file_new_for_path ("/tmp/.regs");
 
127
                _tmp1_ = g_file_read (file, NULL, &_inner_error_);
 
128
                if (_inner_error_ != NULL) {
 
129
                        _g_object_unref0 (file);
 
130
                        goto __catch0_g_error;
 
131
                        goto __finally0;
 
132
                }
 
133
                in_stream = (_tmp3_ = g_data_input_stream_new ((GInputStream*) (_tmp2_ = _tmp1_)), _g_object_unref0 (_tmp2_), _tmp3_);
 
134
                line = NULL;
 
135
                while (TRUE) {
 
136
                        const char* _tmp4_;
 
137
                        char* _tmp5_;
 
138
                        char** _tmp9_;
 
139
                        gint arr_size;
 
140
                        gint arr_length1;
 
141
                        char** _tmp7_;
 
142
                        char* _tmp6_;
 
143
                        char** _tmp8_;
 
144
                        char** arr;
 
145
                        _tmp4_ = g_data_input_stream_read_line (in_stream, NULL, NULL, &_inner_error_);
 
146
                        if (_inner_error_ != NULL) {
 
147
                                _g_object_unref0 (file);
 
148
                                _g_object_unref0 (in_stream);
 
149
                                _g_free0 (line);
 
150
                                goto __catch0_g_error;
 
151
                                goto __finally0;
 
152
                        }
 
153
                        if (!((line = (_tmp5_ = g_strdup (_tmp4_), _g_free0 (line), _tmp5_)) != NULL)) {
 
154
                                break;
 
155
                        }
 
156
                        arr = (_tmp9_ = (_tmp8_ = _tmp7_ = g_regex_split_simple (" @ ", _tmp6_ = string_substring (line, (glong) 2, (glong) (-1)), 0, 0), _g_free0 (_tmp6_), _tmp8_), arr_length1 = _vala_array_length (_tmp7_), arr_size = arr_length1, _tmp9_);
 
157
                        if (arr_length1 < 2) {
 
158
                                arr = (_vala_array_free (arr, arr_length1, (GDestroyNotify) g_free), NULL);
 
159
                                break;
 
160
                        }
 
161
                        g_hash_table_insert (self->priv->regs, g_strdup (arr[0]), g_strdup (arr[1]));
 
162
                        arr = (_vala_array_free (arr, arr_length1, (GDestroyNotify) g_free), NULL);
 
163
                }
 
164
                _g_object_unref0 (file);
 
165
                _g_object_unref0 (in_stream);
 
166
                _g_free0 (line);
 
167
        }
 
168
        goto __finally0;
 
169
        __catch0_g_error:
 
170
        {
 
171
                GError * e;
 
172
                e = _inner_error_;
 
173
                _inner_error_ = NULL;
 
174
                {
 
175
                        fprintf (stderr, "Error: %s\n", e->message);
 
176
                        fprintf (stderr, "File: '/tmp/.regs'!\n");
 
177
                        _g_error_free0 (e);
 
178
                }
 
179
        }
 
180
        __finally0:
 
181
        if (_inner_error_ != NULL) {
 
182
                g_critical ("file %s: line %d: uncaught error: %s", __FILE__, __LINE__, _inner_error_->message);
 
183
                g_clear_error (&_inner_error_);
 
184
                return;
 
185
        }
 
186
}
 
187
 
 
188
 
 
189
static void _g_list_free_g_free (GList* self) {
 
190
        g_list_foreach (self, (GFunc) g_free, NULL);
 
191
        g_list_free (self);
 
192
}
 
193
 
 
194
 
 
195
static void set_register_fill_comboboxentry (SetRegister* self) {
 
196
        GList* list;
 
197
        g_return_if_fail (self != NULL);
 
198
        list = NULL;
 
199
        {
 
200
                GList* reg_collection;
 
201
                GList* reg_it;
 
202
                reg_collection = g_hash_table_get_keys (self->priv->regs);
 
203
                for (reg_it = reg_collection; reg_it != NULL; reg_it = reg_it->next) {
 
204
                        char* reg;
 
205
                        reg = g_strdup ((const char*) reg_it->data);
 
206
                        {
 
207
                                list = g_list_append (list, g_strdup (reg));
 
208
                                _g_free0 (reg);
 
209
                        }
 
210
                }
 
211
                _g_list_free0 (reg_collection);
 
212
        }
 
213
        list = g_list_sort (list, strcmp);
 
214
        {
 
215
                gint i;
 
216
                i = 0;
 
217
                {
 
218
                        gboolean _tmp0_;
 
219
                        _tmp0_ = TRUE;
 
220
                        while (TRUE) {
 
221
                                if (!_tmp0_) {
 
222
                                        i++;
 
223
                                }
 
224
                                _tmp0_ = FALSE;
 
225
                                if (!(i < g_list_length (list))) {
 
226
                                        break;
 
227
                                }
 
228
                                gtk_combo_box_append_text ((GtkComboBox*) self->priv->cbe, (const char*) g_list_nth_data (list, (guint) i));
 
229
                        }
 
230
                }
 
231
        }
 
232
        __g_list_free_g_free0 (list);
 
233
}
 
234
 
 
235
 
 
236
static glong string_get_length (const char* self) {
 
237
        glong result;
 
238
        g_return_val_if_fail (self != NULL, 0L);
 
239
        result = g_utf8_strlen (self, -1);
 
240
        return result;
 
241
}
 
242
 
 
243
 
 
244
static void set_register_on_combobox_changed (SetRegister* self) {
 
245
        char* _tmp0_;
 
246
        gboolean _tmp1_ = FALSE;
 
247
        g_return_if_fail (self != NULL);
 
248
        self->priv->regname = (_tmp0_ = g_strdup (gtk_combo_box_get_active_text ((GtkComboBox*) self->priv->cbe)), _g_free0 (self->priv->regname), _tmp0_);
 
249
        if (string_get_length (self->priv->regname) > 2) {
 
250
                char* _tmp2_;
 
251
                _tmp1_ = (_tmp2_ = set_register_get_reg_value (self)) != NULL;
 
252
                _g_free0 (_tmp2_);
 
253
        } else {
 
254
                _tmp1_ = FALSE;
 
255
        }
 
256
        if (_tmp1_) {
 
257
                char* _tmp3_;
 
258
                gtk_entry_set_text (self->priv->regvalue, _tmp3_ = set_register_get_reg_value (self));
 
259
                _g_free0 (_tmp3_);
 
260
        }
 
261
}
 
262
 
 
263
 
 
264
static char* set_register_get_reg_value (SetRegister* self) {
 
265
        char* result;
 
266
        g_return_val_if_fail (self != NULL, NULL);
 
267
        result = g_strdup ((const char*) g_hash_table_lookup (self->priv->regs, self->priv->regname));
 
268
        return result;
 
269
}
 
270
 
 
271
 
 
272
static void set_register_on_response (SetRegister* self, GtkDialog* source, gint response_id) {
 
273
        g_return_if_fail (self != NULL);
 
274
        g_return_if_fail (source != NULL);
 
275
        switch (response_id) {
 
276
                case GTK_RESPONSE_CANCEL:
 
277
                {
 
278
                        gtk_object_destroy ((GtkObject*) self);
 
279
                        break;
 
280
                }
 
281
                case GTK_RESPONSE_OK:
 
282
                {
 
283
                        set_register_ok_clicked (self);
 
284
                        gtk_object_destroy ((GtkObject*) self);
 
285
                        break;
 
286
                }
 
287
        }
 
288
}
 
289
 
 
290
 
 
291
static void set_register_ok_clicked (SetRegister* self) {
 
292
        g_return_if_fail (self != NULL);
 
293
        fprintf (stdout, ":!reg %s=%s\n", self->priv->regname, gtk_entry_get_text (self->priv->regvalue));
 
294
}
 
295
 
 
296
 
 
297
static gint set_register_main (char** args, int args_length1) {
 
298
        gint result;
 
299
        SetRegister* dialog;
 
300
        gtk_init (&args_length1, &args);
 
301
        dialog = g_object_ref_sink (set_register_new ());
 
302
        gtk_widget_show_all ((GtkWidget*) dialog);
 
303
        set_register_init_regs (dialog);
 
304
        set_register_fill_comboboxentry (dialog);
 
305
        gtk_main ();
 
306
        result = 0;
 
307
        _g_object_unref0 (dialog);
 
308
        return result;
 
309
}
 
310
 
 
311
 
 
312
int main (int argc, char ** argv) {
 
313
        g_type_init ();
 
314
        return set_register_main (argv, argc);
 
315
}
 
316
 
 
317
 
 
318
static void _set_register_on_response_gtk_dialog_response (SetRegister* _sender, gint response_id, gpointer self) {
 
319
        set_register_on_response (self, _sender, response_id);
 
320
}
 
321
 
 
322
 
 
323
static void _gtk_main_quit_gtk_object_destroy (SetRegister* _sender, gpointer self) {
 
324
        gtk_main_quit ();
 
325
}
 
326
 
 
327
 
 
328
static void _lambda0_ (GtkComboBoxEntry* target, SetRegister* self) {
 
329
        g_return_if_fail (target != NULL);
 
330
        set_register_on_combobox_changed (self);
 
331
}
 
332
 
 
333
 
 
334
static void __lambda0__gtk_combo_box_changed (GtkComboBoxEntry* _sender, gpointer self) {
 
335
        _lambda0_ (_sender, self);
 
336
}
 
337
 
 
338
 
 
339
static GObject * set_register_constructor (GType type, guint n_construct_properties, GObjectConstructParam * construct_properties) {
 
340
        GObject * obj;
 
341
        GObjectClass * parent_class;
 
342
        SetRegister * self;
 
343
        parent_class = G_OBJECT_CLASS (set_register_parent_class);
 
344
        obj = parent_class->constructor (type, n_construct_properties, construct_properties);
 
345
        self = SET_REGISTER (obj);
 
346
        {
 
347
                GtkHBox* _hbox0;
 
348
                GtkLabel* _label0;
 
349
                GtkHBox* _hbox1;
 
350
                GtkLabel* _label1;
 
351
                GtkHBox* _tmp0_;
 
352
                GtkLabel* _tmp1_;
 
353
                GtkComboBoxEntry* _tmp2_;
 
354
                GtkHBox* _tmp3_;
 
355
                GtkLabel* _tmp4_;
 
356
                GtkEntry* _tmp5_;
 
357
                GtkVBox* _tmp6_;
 
358
                GtkVBox* _tmp7_;
 
359
                GtkVBox* _tmp8_;
 
360
                _hbox0 = NULL;
 
361
                _label0 = NULL;
 
362
                _hbox1 = NULL;
 
363
                _label1 = NULL;
 
364
                _hbox0 = (_tmp0_ = g_object_ref_sink ((GtkHBox*) gtk_hbox_new (FALSE, 10)), _g_object_unref0 (_hbox0), _tmp0_);
 
365
                _label0 = (_tmp1_ = g_object_ref_sink ((GtkLabel*) gtk_label_new_with_mnemonic ("Register:")), _g_object_unref0 (_label0), _tmp1_);
 
366
                self->priv->cbe = (_tmp2_ = g_object_ref_sink ((GtkComboBoxEntry*) gtk_combo_box_entry_new_text ()), _g_object_unref0 (self->priv->cbe), _tmp2_);
 
367
                _hbox1 = (_tmp3_ = g_object_ref_sink ((GtkHBox*) gtk_hbox_new (FALSE, 10)), _g_object_unref0 (_hbox1), _tmp3_);
 
368
                _label1 = (_tmp4_ = g_object_ref_sink ((GtkLabel*) gtk_label_new_with_mnemonic ("Value:")), _g_object_unref0 (_label1), _tmp4_);
 
369
                self->priv->regvalue = (_tmp5_ = g_object_ref_sink ((GtkEntry*) gtk_entry_new ()), _g_object_unref0 (self->priv->regvalue), _tmp5_);
 
370
                gtk_window_set_title ((GtkWindow*) self, "Set Register");
 
371
                gtk_dialog_set_has_separator ((GtkDialog*) self, FALSE);
 
372
                gtk_container_set_border_width ((GtkContainer*) self, (guint) 5);
 
373
                g_object_set ((GtkWindow*) self, "default-width", 300, NULL);
 
374
                g_object_set ((GtkWindow*) self, "default-height", 80, NULL);
 
375
                g_signal_connect_object ((GtkDialog*) self, "response", (GCallback) _set_register_on_response_gtk_dialog_response, self, 0);
 
376
                g_signal_connect ((GtkObject*) self, "destroy", (GCallback) _gtk_main_quit_gtk_object_destroy, NULL);
 
377
                gtk_label_set_mnemonic_widget (_label0, (GtkWidget*) self->priv->cbe);
 
378
                gtk_box_pack_start ((GtkBox*) _hbox0, (GtkWidget*) _label0, FALSE, TRUE, (guint) 0);
 
379
                g_signal_connect_object ((GtkComboBox*) self->priv->cbe, "changed", (GCallback) __lambda0__gtk_combo_box_changed, self, 0);
 
380
                gtk_container_add ((GtkContainer*) _hbox0, (GtkWidget*) self->priv->cbe);
 
381
                gtk_box_pack_start ((GtkBox*) (_tmp6_ = ((GtkDialog*) self)->vbox, GTK_IS_VBOX (_tmp6_) ? ((GtkVBox*) _tmp6_) : NULL), (GtkWidget*) _hbox0, FALSE, TRUE, (guint) 0);
 
382
                gtk_label_set_mnemonic_widget (_label1, (GtkWidget*) self->priv->regvalue);
 
383
                gtk_box_pack_start ((GtkBox*) _hbox1, (GtkWidget*) _label1, FALSE, TRUE, (guint) 0);
 
384
                gtk_container_add ((GtkContainer*) _hbox1, (GtkWidget*) self->priv->regvalue);
 
385
                gtk_box_pack_start ((GtkBox*) (_tmp7_ = ((GtkDialog*) self)->vbox, GTK_IS_VBOX (_tmp7_) ? ((GtkVBox*) _tmp7_) : NULL), (GtkWidget*) _hbox1, FALSE, TRUE, (guint) 0);
 
386
                gtk_box_set_spacing ((GtkBox*) (_tmp8_ = ((GtkDialog*) self)->vbox, GTK_IS_VBOX (_tmp8_) ? ((GtkVBox*) _tmp8_) : NULL), 10);
 
387
                _g_object_unref0 (_hbox0);
 
388
                _g_object_unref0 (_label0);
 
389
                _g_object_unref0 (_hbox1);
 
390
                _g_object_unref0 (_label1);
 
391
        }
 
392
        return obj;
 
393
}
 
394
 
 
395
 
 
396
static void set_register_class_init (SetRegisterClass * klass) {
 
397
        set_register_parent_class = g_type_class_peek_parent (klass);
 
398
        g_type_class_add_private (klass, sizeof (SetRegisterPrivate));
 
399
        G_OBJECT_CLASS (klass)->constructor = set_register_constructor;
 
400
        G_OBJECT_CLASS (klass)->finalize = set_register_finalize;
 
401
}
 
402
 
 
403
 
 
404
static void set_register_instance_init (SetRegister * self) {
 
405
        self->priv = SET_REGISTER_GET_PRIVATE (self);
 
406
}
 
407
 
 
408
 
 
409
static void set_register_finalize (GObject* obj) {
 
410
        SetRegister * self;
 
411
        self = SET_REGISTER (obj);
 
412
        _g_object_unref0 (self->priv->cbe);
 
413
        _g_object_unref0 (self->priv->regvalue);
 
414
        _g_free0 (self->priv->regname);
 
415
        _g_hash_table_unref0 (self->priv->regs);
 
416
        G_OBJECT_CLASS (set_register_parent_class)->finalize (obj);
 
417
}
 
418
 
 
419
 
 
420
GType set_register_get_type (void) {
 
421
        static GType set_register_type_id = 0;
 
422
        if (set_register_type_id == 0) {
 
423
                static const GTypeInfo g_define_type_info = { sizeof (SetRegisterClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) set_register_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (SetRegister), 0, (GInstanceInitFunc) set_register_instance_init, NULL };
 
424
                set_register_type_id = g_type_register_static (GTK_TYPE_DIALOG, "SetRegister", &g_define_type_info, 0);
 
425
        }
 
426
        return set_register_type_id;
 
427
}
 
428
 
 
429
 
 
430
static void _vala_array_destroy (gpointer array, gint array_length, GDestroyNotify destroy_func) {
 
431
        if ((array != NULL) && (destroy_func != NULL)) {
 
432
                int i;
 
433
                for (i = 0; i < array_length; i = i + 1) {
 
434
                        if (((gpointer*) array)[i] != NULL) {
 
435
                                destroy_func (((gpointer*) array)[i]);
 
436
                        }
 
437
                }
 
438
        }
 
439
}
 
440
 
 
441
 
 
442
static void _vala_array_free (gpointer array, gint array_length, GDestroyNotify destroy_func) {
 
443
        _vala_array_destroy (array, array_length, destroy_func);
 
444
        g_free (array);
 
445
}
 
446
 
 
447
 
 
448
static gint _vala_array_length (gpointer array) {
 
449
        int length;
 
450
        length = 0;
 
451
        if (array) {
 
452
                while (((gpointer*) array)[length]) {
 
453
                        length++;
 
454
                }
 
455
        }
 
456
        return length;
 
457
}
 
458
 
 
459
 
 
460
 
 
461