Debian Codegraph @

tools/krcfile.c

raw
1 /* krcfile.c generated by valac 0.56.19, the Vala compiler
2 * generated from krcfile.vala, do not modify */
3
4 /* vim:set et sts=4 sw=4:
5 *
6 * ibus - The Input Bus
7 *
8 * Copyright(c) 2024 Takao Fujiwara <[email protected]>
9 *
10 * This library is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU Lesser General Public
12 * License as published by the Free Software Foundation; either
13 * version 2.1 of the License, or (at your option) any later version.
14 *
15 * This library is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 * Lesser General Public License for more details.
19 *
20 * You should have received a copy of the GNU Lesser General Public
21 * License along with this library; if not, write to the Free Software
22 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301
23 * USA
24 */
25
26 #include <glib-object.h>
27 #include <stdlib.h>
28 #include <string.h>
29 #include <glib.h>
30 #include <limits.h>
31 #include <glib/gstdio.h>
32 #include <gobject/gvaluecollector.h>
33
34 #if !defined(VALA_STRICT_C)
35 #if !defined(__clang__) && defined(__GNUC__) && (__GNUC__ >= 14)
36 #pragma GCC diagnostic warning "-Wincompatible-pointer-types"
37 #elif defined(__clang__) && (__clang_major__ >= 16)
38 #pragma clang diagnostic ignored "-Wincompatible-function-pointer-types"
39 #pragma clang diagnostic ignored "-Wincompatible-pointer-types"
40 #endif
41 #endif
42 #if !defined(VALA_EXTERN)
43 #if defined(_MSC_VER)
44 #define VALA_EXTERN __declspec(dllexport) extern
45 #elif __GNUC__ >= 4
46 #define VALA_EXTERN __attribute__((visibility("default"))) extern
47 #else
48 #define VALA_EXTERN extern
49 #endif
50 #endif
51
52 #define TYPE_KRC_FILE_KEY_VALUE_PAIR (krc_file_key_value_pair_get_type ())
53 typedef struct _KRcFileKeyValuePair KRcFileKeyValuePair;
54 #define _g_free0(var) (var = (g_free (var), NULL))
55
56 #define TYPE_KRC_FILE_GROUP (krc_file_group_get_type ())
57 typedef struct _KRcFileGroup KRcFileGroup;
58
59 #define TYPE_KRC_FILE (krc_file_get_type ())
60 #define KRC_FILE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_KRC_FILE, KRcFile))
61 #define KRC_FILE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_KRC_FILE, KRcFileClass))
62 #define IS_KRC_FILE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_KRC_FILE))
63 #define IS_KRC_FILE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_KRC_FILE))
64 #define KRC_FILE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_KRC_FILE, KRcFileClass))
65
66 typedef struct _KRcFile KRcFile;
67 typedef struct _KRcFileClass KRcFileClass;
68 typedef struct _KRcFilePrivate KRcFilePrivate;
69 #define _krc_file_group_free0(var) ((var == NULL) ? NULL : (var = (krc_file_group_free (var), NULL)))
70 #define _g_error_free0(var) ((var == NULL) ? NULL : (var = (g_error_free (var), NULL)))
71 #define _krc_file_key_value_pair_free0(var) ((var == NULL) ? NULL : (var = (krc_file_key_value_pair_free (var), NULL)))
72 #define _g_string_free0(var) ((var == NULL) ? NULL : (var = (g_string_free (var, TRUE), NULL)))
73 typedef struct _ParamSpecKRcFile ParamSpecKRcFile;
74 #define _vala_assert(expr, msg) if G_LIKELY (expr) ; else g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, msg);
75 #define _vala_return_if_fail(expr, msg) if G_LIKELY (expr) ; else { g_return_if_fail_warning (G_LOG_DOMAIN, G_STRFUNC, msg); return; }
76 #define _vala_return_val_if_fail(expr, msg, val) if G_LIKELY (expr) ; else { g_return_if_fail_warning (G_LOG_DOMAIN, G_STRFUNC, msg); return val; }
77 #define _vala_warn_if_fail(expr, msg) if G_LIKELY (expr) ; else g_warn_message (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, msg);
78
79 struct _KRcFileKeyValuePair {
80 gchar* key;
81 gchar* value;
82 };
83
84 struct _KRcFileGroup {
85 gchar* name;
86 GList* key_value_pairs;
87 };
88
89 struct _KRcFile {
90 GTypeInstance parent_instance;
91 volatile int ref_count;
92 KRcFilePrivate * priv;
93 };
94
95 struct _KRcFileClass {
96 GTypeClass parent_class;
97 void (*finalize) (KRcFile *self);
98 };
99
100 struct _KRcFilePrivate {
101 KRcFileGroup* m_current_group;
102 GList* m_groups;
103 };
104
105 struct _ParamSpecKRcFile {
106 GParamSpec parent_instance;
107 };
108
109 static gint KRcFile_private_offset;
110 static gpointer krc_file_parent_class = NULL;
111
112 VALA_EXTERN GType krc_file_key_value_pair_get_type (void) G_GNUC_CONST ;
113 VALA_EXTERN KRcFileKeyValuePair* krc_file_key_value_pair_dup (const KRcFileKeyValuePair* self);
114 VALA_EXTERN void krc_file_key_value_pair_free (KRcFileKeyValuePair* self);
115 VALA_EXTERN void krc_file_key_value_pair_copy (const KRcFileKeyValuePair* self,
116 KRcFileKeyValuePair* dest);
117 VALA_EXTERN void krc_file_key_value_pair_destroy (KRcFileKeyValuePair* self);
118 G_DEFINE_AUTO_CLEANUP_CLEAR_FUNC (KRcFileKeyValuePair, krc_file_key_value_pair_destroy)
119 VALA_EXTERN GType krc_file_group_get_type (void) G_GNUC_CONST ;
120 VALA_EXTERN KRcFileGroup* krc_file_group_dup (const KRcFileGroup* self);
121 VALA_EXTERN void krc_file_group_free (KRcFileGroup* self);
122 VALA_EXTERN void krc_file_group_copy (const KRcFileGroup* self,
123 KRcFileGroup* dest);
124 VALA_EXTERN void krc_file_group_destroy (KRcFileGroup* self);
125 G_DEFINE_AUTO_CLEANUP_CLEAR_FUNC (KRcFileGroup, krc_file_group_destroy)
126 VALA_EXTERN gpointer krc_file_ref (gpointer instance);
127 VALA_EXTERN void krc_file_unref (gpointer instance);
128 VALA_EXTERN GParamSpec* param_spec_krc_file (const gchar* name,
129 const gchar* nick,
130 const gchar* blurb,
131 GType object_type,
132 GParamFlags flags);
133 VALA_EXTERN void value_set_krc_file (GValue* value,
134 gpointer v_object);
135 VALA_EXTERN void value_take_krc_file (GValue* value,
136 gpointer v_object);
137 VALA_EXTERN gpointer value_get_krc_file (const GValue* value);
138 VALA_EXTERN GType krc_file_get_type (void) G_GNUC_CONST ;
139 G_DEFINE_AUTOPTR_CLEANUP_FUNC (KRcFile, krc_file_unref)
140 static void _krc_file_group_free0_ (gpointer var);
141 static inline void _g_list_free__krc_file_group_free0_ (GList* self);
142 VALA_EXTERN KRcFile* krc_file_new (void);
143 VALA_EXTERN KRcFile* krc_file_construct (GType object_type);
144 static gboolean krc_file_is_comment (KRcFile* self,
145 const gchar* line);
146 static gboolean krc_file_is_group (KRcFile* self,
147 const gchar* line);
148 static gboolean krc_file_is_group_name (KRcFile* self,
149 const gchar* name);
150 static gboolean krc_file_is_key_value_pair (KRcFile* self,
151 const gchar* line);
152 static gboolean krc_file_is_key_name (KRcFile* self,
153 const gchar* line,
154 gsize length);
155 static gint krc_file_find_group (KRcFileGroup* group1,
156 KRcFileGroup* group2);
157 static GList* krc_file_get_group_node_with_name (KRcFile* self,
158 const gchar* group_name,
159 gboolean if_throw_error,
160 GError** error);
161 static void krc_file_add_key_value_pair (KRcFile* self,
162 KRcFileGroup* group,
163 KRcFileKeyValuePair* pair,
164 GList* sibling);
165 static void krc_file_add_key (KRcFile* self,
166 KRcFileGroup* group,
167 const gchar* key,
168 const gchar* value);
169 static void krc_file_parse_comment (KRcFile* self,
170 const gchar* line,
171 glong length);
172 static void krc_file_parse_group (KRcFile* self,
173 const gchar* line,
174 glong length,
175 GError** error);
176 static void krc_file_parse_key_value_pair (KRcFile* self,
177 const gchar* line,
178 glong length,
179 GError** error);
180 static void krc_file_parse_line (KRcFile* self,
181 const gchar* line,
182 glong length,
183 GError** error);
184 static gboolean krc_file_parse_data (KRcFile* self,
185 const gchar* data,
186 gsize length);
187 VALA_EXTERN gboolean krc_file_load_from_file (KRcFile* self,
188 const gchar* path,
189 GKeyFileFlags flags,
190 GError** error);
191 VALA_EXTERN gboolean krc_file_has_group (KRcFile* self,
192 const gchar* group_name);
193 VALA_EXTERN gchar** krc_file_get_keys (KRcFile* self,
194 const gchar* group_name,
195 gint* result_length1,
196 GError** error);
197 static void _vala_array_add1 (gchar** * array,
198 gint* length,
199 gint* size,
200 gchar* value);
201 VALA_EXTERN gboolean krc_file_has_key (KRcFile* self,
202 const gchar* group_name,
203 const gchar* key,
204 GError** error);
205 VALA_EXTERN gboolean krc_file_remove_group (KRcFile* self,
206 const gchar* group_name,
207 GError** error);
208 VALA_EXTERN gboolean krc_file_remove_key (KRcFile* self,
209 const gchar* group_name,
210 const gchar* key,
211 GError** error);
212 VALA_EXTERN gchar* krc_file_to_data (KRcFile* self,
213 gssize* length);
214 VALA_EXTERN gboolean krc_file_save_to_file (KRcFile* self,
215 const gchar* filename,
216 GError** error);
217 VALA_EXTERN gchar* krc_file_get_value (KRcFile* self,
218 const gchar* group_name,
219 const gchar* key,
220 GError** error);
221 VALA_EXTERN void krc_file_set_value (KRcFile* self,
222 const gchar* group_name,
223 const gchar* key,
224 const gchar* value);
225 static void krc_file_finalize (KRcFile * obj);
226 static GType krc_file_get_type_once (void);
227 static void _vala_array_destroy (gpointer array,
228 gssize array_length,
229 GDestroyNotify destroy_func);
230 static void _vala_array_free (gpointer array,
231 gssize array_length,
232 GDestroyNotify destroy_func);
233
234 void
235 krc_file_key_value_pair_copy (const KRcFileKeyValuePair* self,
236 KRcFileKeyValuePair* dest)
237 {
238 const gchar* _tmp0_;
239 gchar* _tmp1_;
240 const gchar* _tmp2_;
241 gchar* _tmp3_;
242 _tmp0_ = (*self).key;
243 _tmp1_ = g_strdup (_tmp0_);
244 _g_free0 ((*dest).key);
245 (*dest).key = _tmp1_;
246 _tmp2_ = (*self).value;
247 _tmp3_ = g_strdup (_tmp2_);
248 _g_free0 ((*dest).value);
249 (*dest).value = _tmp3_;
250 }
251
252 void
253 krc_file_key_value_pair_destroy (KRcFileKeyValuePair* self)
254 {
255 _g_free0 ((*self).key);
256 _g_free0 ((*self).value);
257 }
258
259 KRcFileKeyValuePair*
260 krc_file_key_value_pair_dup (const KRcFileKeyValuePair* self)
261 {
262 KRcFileKeyValuePair* dup;
263 dup = g_new0 (KRcFileKeyValuePair, 1);
264 krc_file_key_value_pair_copy (self, dup);
265 return dup;
266 }
267
268 void
269 krc_file_key_value_pair_free (KRcFileKeyValuePair* self)
270 {
271 krc_file_key_value_pair_destroy (self);
272 g_free (self);
273 }
274
275 static GType
276 krc_file_key_value_pair_get_type_once (void)
277 {
278 GType krc_file_key_value_pair_type_id;
279 krc_file_key_value_pair_type_id = g_boxed_type_register_static ("KRcFileKeyValuePair", (GBoxedCopyFunc) krc_file_key_value_pair_dup, (GBoxedFreeFunc) krc_file_key_value_pair_free);
280 return krc_file_key_value_pair_type_id;
281 }
282
283 GType
284 krc_file_key_value_pair_get_type (void)
285 {
286 static volatile gsize krc_file_key_value_pair_type_id__once = 0;
287 if (g_once_init_enter (&krc_file_key_value_pair_type_id__once)) {
288 GType krc_file_key_value_pair_type_id;
289 krc_file_key_value_pair_type_id = krc_file_key_value_pair_get_type_once ();
290 g_once_init_leave (&krc_file_key_value_pair_type_id__once, krc_file_key_value_pair_type_id);
291 }
292 return krc_file_key_value_pair_type_id__once;
293 }
294
295 void
296 krc_file_group_copy (const KRcFileGroup* self,
297 KRcFileGroup* dest)
298 {
299 const gchar* _tmp0_;
300 gchar* _tmp1_;
301 GList* _tmp2_;
302 _tmp0_ = (*self).name;
303 _tmp1_ = g_strdup (_tmp0_);
304 _g_free0 ((*dest).name);
305 (*dest).name = _tmp1_;
306 _tmp2_ = (*self).key_value_pairs;
307 (*dest).key_value_pairs = _tmp2_;
308 }
309
310 void
311 krc_file_group_destroy (KRcFileGroup* self)
312 {
313 _g_free0 ((*self).name);
314 }
315
316 KRcFileGroup*
317 krc_file_group_dup (const KRcFileGroup* self)
318 {
319 KRcFileGroup* dup;
320 dup = g_new0 (KRcFileGroup, 1);
321 krc_file_group_copy (self, dup);
322 return dup;
323 }
324
325 void
326 krc_file_group_free (KRcFileGroup* self)
327 {
328 krc_file_group_destroy (self);
329 g_free (self);
330 }
331
332 static GType
333 krc_file_group_get_type_once (void)
334 {
335 GType krc_file_group_type_id;
336 krc_file_group_type_id = g_boxed_type_register_static ("KRcFileGroup", (GBoxedCopyFunc) krc_file_group_dup, (GBoxedFreeFunc) krc_file_group_free);
337 return krc_file_group_type_id;
338 }
339
340 GType
341 krc_file_group_get_type (void)
342 {
343 static volatile gsize krc_file_group_type_id__once = 0;
344 if (g_once_init_enter (&krc_file_group_type_id__once)) {
345 GType krc_file_group_type_id;
346 krc_file_group_type_id = krc_file_group_get_type_once ();
347 g_once_init_leave (&krc_file_group_type_id__once, krc_file_group_type_id);
348 }
349 return krc_file_group_type_id__once;
350 }
351
352 static inline gpointer
353 krc_file_get_instance_private (KRcFile* self)
354 {
355 return G_STRUCT_MEMBER_P (self, KRcFile_private_offset);
356 }
357
358 static void
359 _krc_file_group_free0_ (gpointer var)
360 {
361 (var == NULL) ? NULL : (var = (krc_file_group_free (var), NULL));
362 }
363
364 static inline void
365 _g_list_free__krc_file_group_free0_ (GList* self)
366 {
367 g_list_free_full (self, (GDestroyNotify) _krc_file_group_free0_);
368 }
369
370 static gpointer
371 _krc_file_group_dup0 (gpointer self)
372 {
373 return self ? krc_file_group_dup (self) : NULL;
374 }
375
376 KRcFile*
377 krc_file_construct (GType object_type)
378 {
379 KRcFile* self = NULL;
380 KRcFileGroup* group = NULL;
381 KRcFileGroup _tmp0_ = {0};
382 KRcFileGroup _tmp1_;
383 KRcFileGroup* _tmp2_;
384 KRcFileGroup* _tmp3_;
385 KRcFileGroup* _tmp4_;
386 GList* _tmp5_;
387 gconstpointer _tmp6_;
388 self = (KRcFile*) g_type_create_instance (object_type);
389 memset (&_tmp0_, 0, sizeof (KRcFileGroup));
390 _tmp1_ = _tmp0_;
391 _tmp2_ = _krc_file_group_dup0 (&_tmp1_);
392 _tmp3_ = _tmp2_;
393 krc_file_group_destroy (&_tmp1_);
394 group = _tmp3_;
395 _tmp4_ = _krc_file_group_dup0 (group);
396 self->priv->m_groups = g_list_prepend (self->priv->m_groups, _tmp4_);
397 _tmp5_ = self->priv->m_groups;
398 _tmp6_ = _tmp5_->data;
399 self->priv->m_current_group = (KRcFileGroup*) ((KRcFileGroup*) _tmp6_);
400 _krc_file_group_free0 (group);
401 return self;
402 }
403
404 KRcFile*
405 krc_file_new (void)
406 {
407 return krc_file_construct (TYPE_KRC_FILE);
408 }
409
410 static gunichar
411 string_get_char (const gchar* self,
412 glong index)
413 {
414 gunichar result;
415 g_return_val_if_fail (self != NULL, 0U);
416 result = g_utf8_get_char (((gchar*) self) + index);
417 return result;
418 }
419
420 static gboolean
421 krc_file_is_comment (KRcFile* self,
422 const gchar* line)
423 {
424 gunichar ch = 0U;
425 gboolean _tmp0_ = FALSE;
426 gboolean _tmp1_ = FALSE;
427 gboolean result;
428 g_return_val_if_fail (self != NULL, FALSE);
429 g_return_val_if_fail (line != NULL, FALSE);
430 ch = string_get_char (line, (glong) 0);
431 if (ch == ((gunichar) '#')) {
432 _tmp1_ = TRUE;
433 } else {
434 _tmp1_ = ch == ((gunichar) '\0');
435 }
436 if (_tmp1_) {
437 _tmp0_ = TRUE;
438 } else {
439 _tmp0_ = ch == ((gunichar) '\n');
440 }
441 result = _tmp0_;
442 return result;
443 }
444
445 static gboolean
446 krc_file_is_group (KRcFile* self,
447 const gchar* line)
448 {
449 gint i = 0;
450 gint length = 0;
451 gboolean result;
452 g_return_val_if_fail (self != NULL, FALSE);
453 g_return_val_if_fail (line != NULL, FALSE);
454 if (string_get_char (line, (glong) 0) != ((gunichar) '[')) {
455 result = FALSE;
456 return result;
457 }
458 i = 1;
459 length = g_utf8_strlen (line, (gssize) -1);
460 while (TRUE) {
461 gunichar ch = 0U;
462 gint _tmp0_;
463 if (!(i < length)) {
464 break;
465 }
466 ch = string_get_char (line, (glong) i);
467 if (ch == ((gunichar) ']')) {
468 result = TRUE;
469 return result;
470 }
471 _tmp0_ = i;
472 i = _tmp0_ + 1;
473 }
474 result = FALSE;
475 return result;
476 }
477
478 static gboolean
479 krc_file_is_group_name (KRcFile* self,
480 const gchar* name)
481 {
482 gint i = 0;
483 gint length = 0;
484 gunichar ch = 0U;
485 gboolean _tmp2_ = FALSE;
486 gboolean result;
487 g_return_val_if_fail (self != NULL, FALSE);
488 g_return_val_if_fail (name != NULL, FALSE);
489 i = 0;
490 length = g_utf8_strlen (name, (gssize) -1);
491 ch = (gunichar) 0;
492 while (TRUE) {
493 gboolean _tmp0_ = FALSE;
494 gint _tmp1_;
495 if (!(i < length)) {
496 break;
497 }
498 ch = string_get_char (name, (glong) i);
499 if (ch == ((gunichar) '\0')) {
500 _tmp0_ = TRUE;
501 } else {
502 _tmp0_ = g_unichar_iscntrl (ch);
503 }
504 if (_tmp0_) {
505 break;
506 }
507 _tmp1_ = i;
508 i = _tmp1_ + 1;
509 }
510 if (i != 0) {
511 gboolean _tmp3_ = FALSE;
512 if (i == length) {
513 _tmp3_ = TRUE;
514 } else {
515 _tmp3_ = ch == ((gunichar) '\0');
516 }
517 _tmp2_ = _tmp3_;
518 } else {
519 _tmp2_ = FALSE;
520 }
521 if (_tmp2_) {
522 result = TRUE;
523 return result;
524 }
525 result = FALSE;
526 return result;
527 }
528
529 static gint
530 string_index_of_char (const gchar* self,
531 gunichar c,
532 gint start_index)
533 {
534 gchar* _result_ = NULL;
535 gchar* _tmp0_;
536 gchar* _tmp1_;
537 gint result;
538 g_return_val_if_fail (self != NULL, -1);
539 _tmp0_ = g_utf8_strchr (((gchar*) self) + start_index, (gssize) -1, c);
540 _result_ = _tmp0_;
541 _tmp1_ = _result_;
542 if (_tmp1_ != NULL) {
543 gchar* _tmp2_;
544 _tmp2_ = _result_;
545 result = (gint) (_tmp2_ - ((gchar*) self));
546 return result;
547 } else {
548 result = -1;
549 return result;
550 }
551 }
552
553 static gboolean
554 krc_file_is_key_value_pair (KRcFile* self,
555 const gchar* line)
556 {
557 gint pos = 0;
558 gboolean _tmp0_ = FALSE;
559 gboolean result;
560 g_return_val_if_fail (self != NULL, FALSE);
561 g_return_val_if_fail (line != NULL, FALSE);
562 pos = string_index_of_char (line, (gunichar) '=', 0);
563 if (pos == -1) {
564 _tmp0_ = TRUE;
565 } else {
566 _tmp0_ = pos == 0;
567 }
568 if (_tmp0_) {
569 result = FALSE;
570 return result;
571 }
572 result = TRUE;
573 return result;
574 }
575
576 static gchar
577 string_get (const gchar* self,
578 glong index)
579 {
580 gchar _tmp0_;
581 gchar result;
582 g_return_val_if_fail (self != NULL, '\0');
583 _tmp0_ = ((gchar*) self)[index];
584 result = _tmp0_;
585 return result;
586 }
587
588 static const gchar*
589 string_offset (const gchar* self,
590 glong offset)
591 {
592 const gchar* result;
593 g_return_val_if_fail (self != NULL, NULL);
594 result = (const gchar*) (((gchar*) self) + offset);
595 return result;
596 }
597
598 static gboolean
599 krc_file_is_key_name (KRcFile* self,
600 const gchar* line,
601 gsize length)
602 {
603 glong i = 0L;
604 gboolean _tmp3_ = FALSE;
605 gboolean _tmp4_ = FALSE;
606 gboolean result;
607 g_return_val_if_fail (self != NULL, FALSE);
608 g_return_val_if_fail (line != NULL, FALSE);
609 i = (glong) 0;
610 _vala_assert (length < ((gsize) SSIZE_MAX), "length < Posix.Limits.SSIZE_MAX");
611 while (TRUE) {
612 gchar ch = '\0';
613 gboolean _tmp0_ = FALSE;
614 gboolean _tmp1_ = FALSE;
615 glong _tmp2_;
616 if (!(((gsize) i) < length)) {
617 break;
618 }
619 ch = string_get (line, i);
620 if (ch == '=') {
621 _tmp1_ = TRUE;
622 } else {
623 _tmp1_ = ch == '[';
624 }
625 if (_tmp1_) {
626 _tmp0_ = TRUE;
627 } else {
628 _tmp0_ = ch == ']';
629 }
630 if (_tmp0_) {
631 break;
632 }
633 if (ch == '\0') {
634 i = (glong) length;
635 break;
636 }
637 _tmp2_ = i;
638 i = _tmp2_ + 1;
639 }
640 if (i == ((glong) 0)) {
641 result = FALSE;
642 return result;
643 }
644 if (string_get (line, (glong) 0) == ' ') {
645 _tmp3_ = TRUE;
646 } else {
647 _tmp3_ = string_get (line, i - 1) == ' ';
648 }
649 if (_tmp3_) {
650 result = FALSE;
651 return result;
652 }
653 if (((gsize) i) < length) {
654 _tmp4_ = string_get (line, i) == '[';
655 } else {
656 _tmp4_ = FALSE;
657 }
658 if (_tmp4_) {
659 glong _tmp5_;
660 glong _tmp13_;
661 _tmp5_ = i;
662 i = _tmp5_ + 1;
663 while (TRUE) {
664 gunichar ch = 0U;
665 const gchar* _tmp6_;
666 gboolean _tmp7_ = FALSE;
667 gboolean _tmp8_ = FALSE;
668 gboolean _tmp9_ = FALSE;
669 gboolean _tmp10_ = FALSE;
670 gboolean _tmp11_ = FALSE;
671 glong _tmp12_;
672 if (!(((gsize) i) < length)) {
673 break;
674 }
675 _vala_assert (((gsize) SSIZE_MAX) > (length - i), "Posix.Limits.SSIZE_MAX > length - i");
676 _tmp6_ = string_offset (line, i);
677 ch = g_utf8_get_char_validated (_tmp6_, ((gssize) length) - i);
678 if (ch <= ((gunichar) 0)) {
679 break;
680 }
681 if (!g_unichar_isalnum (ch)) {
682 _tmp11_ = ch != ((gunichar) '-');
683 } else {
684 _tmp11_ = FALSE;
685 }
686 if (_tmp11_) {
687 _tmp10_ = ch != ((gunichar) '_');
688 } else {
689 _tmp10_ = FALSE;
690 }
691 if (_tmp10_) {
692 _tmp9_ = ch != ((gunichar) '.');
693 } else {
694 _tmp9_ = FALSE;
695 }
696 if (_tmp9_) {
697 _tmp8_ = ch != ((gunichar) '@');
698 } else {
699 _tmp8_ = FALSE;
700 }
701 if (_tmp8_) {
702 _tmp7_ = ch != ((gunichar) '$');
703 } else {
704 _tmp7_ = FALSE;
705 }
706 if (_tmp7_) {
707 break;
708 }
709 _tmp12_ = i;
710 i = _tmp12_ + 1;
711 }
712 if (((gsize) i) == length) {
713 result = FALSE;
714 return result;
715 }
716 if (string_get (line, i) != ']') {
717 result = FALSE;
718 return result;
719 }
720 _tmp13_ = i;
721 i = _tmp13_ + 1;
722 }
723 if (((gsize) i) < length) {
724 result = FALSE;
725 return result;
726 }
727 result = TRUE;
728 return result;
729 }
730
731 static gint
732 krc_file_find_group (KRcFileGroup* group1,
733 KRcFileGroup* group2)
734 {
735 KRcFileGroup _tmp0_;
736 const gchar* _tmp1_;
737 KRcFileGroup _tmp4_;
738 const gchar* _tmp5_;
739 KRcFileGroup _tmp6_;
740 const gchar* _tmp7_;
741 KRcFileGroup _tmp8_;
742 const gchar* _tmp9_;
743 gint result;
744 g_return_val_if_fail (group1 != NULL, -1);
745 g_return_val_if_fail (group2 != NULL, -1);
746 _tmp0_ = *group1;
747 _tmp1_ = _tmp0_.name;
748 if (_tmp1_ == NULL) {
749 KRcFileGroup _tmp2_;
750 const gchar* _tmp3_;
751 _tmp2_ = *group2;
752 _tmp3_ = _tmp2_.name;
753 if (_tmp3_ == NULL) {
754 result = 0;
755 return result;
756 }
757 result = -1;
758 return result;
759 }
760 _tmp4_ = *group2;
761 _tmp5_ = _tmp4_.name;
762 if (_tmp5_ == NULL) {
763 result = 1;
764 return result;
765 }
766 _tmp6_ = *group1;
767 _tmp7_ = _tmp6_.name;
768 _tmp8_ = *group2;
769 _tmp9_ = _tmp8_.name;
770 result = g_ascii_strcasecmp (_tmp7_, _tmp9_);
771 return result;
772 }
773
774 static GList*
775 krc_file_get_group_node_with_name (KRcFile* self,
776 const gchar* group_name,
777 gboolean if_throw_error,
778 GError** error)
779 {
780 KRcFileGroup tmp = {0};
781 gchar* _tmp0_;
782 GList* group_node = NULL;
783 GList* _tmp1_;
784 KRcFileGroup _tmp2_;
785 GList* _tmp3_;
786 gboolean _tmp4_ = FALSE;
787 GList* _tmp5_;
788 GList* _tmp7_;
789 GError* _inner_error0_ = NULL;
790 GList* result;
791 g_return_val_if_fail (self != NULL, NULL);
792 g_return_val_if_fail (group_name != NULL, NULL);
793 memset (&tmp, 0, sizeof (KRcFileGroup));
794 _tmp0_ = g_strdup (group_name);
795 _g_free0 (tmp.name);
796 tmp.name = _tmp0_;
797 _tmp1_ = self->priv->m_groups;
798 _tmp2_ = tmp;
799 _tmp3_ = g_list_find_custom (_tmp1_, &_tmp2_, (GCompareFunc) krc_file_find_group);
800 group_node = _tmp3_;
801 _tmp5_ = group_node;
802 if (_tmp5_ == NULL) {
803 _tmp4_ = if_throw_error;
804 } else {
805 _tmp4_ = FALSE;
806 }
807 if (_tmp4_) {
808 GError* _tmp6_;
809 _tmp6_ = g_error_new (G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_GROUP_NOT_FOUND, "Key file does not have group %s", group_name);
810 _inner_error0_ = _tmp6_;
811 if (_inner_error0_->domain == G_KEY_FILE_ERROR) {
812 g_propagate_error (error, _inner_error0_);
813 krc_file_group_destroy (&tmp);
814 return NULL;
815 } else {
816 krc_file_group_destroy (&tmp);
817 g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error0_->message, g_quark_to_string (_inner_error0_->domain), _inner_error0_->code);
818 g_clear_error (&_inner_error0_);
819 return NULL;
820 }
821 }
822 _tmp7_ = group_node;
823 result = _tmp7_;
824 krc_file_group_destroy (&tmp);
825 return result;
826 }
827
828 static gpointer
829 _krc_file_key_value_pair_dup0 (gpointer self)
830 {
831 return self ? krc_file_key_value_pair_dup (self) : NULL;
832 }
833
834 static void
835 krc_file_add_key_value_pair (KRcFile* self,
836 KRcFileGroup* group,
837 KRcFileKeyValuePair* pair,
838 GList* sibling)
839 {
840 KRcFileKeyValuePair _tmp0_;
841 KRcFileKeyValuePair _tmp1_;
842 KRcFileKeyValuePair* _tmp2_;
843 g_return_if_fail (self != NULL);
844 g_return_if_fail (pair != NULL);
845 _tmp0_ = *pair;
846 _tmp1_ = _tmp0_;
847 _tmp2_ = _krc_file_key_value_pair_dup0 (&_tmp1_);
848 (*group).key_value_pairs = g_list_insert_before ((*group).key_value_pairs, sibling, _tmp2_);
849 }
850
851 static void
852 krc_file_add_key (KRcFile* self,
853 KRcFileGroup* group,
854 const gchar* key,
855 const gchar* value)
856 {
857 KRcFileKeyValuePair pair = {0};
858 gchar* _tmp0_;
859 gchar* _tmp1_;
860 GList* lp = NULL;
861 GList* _tmp2_;
862 KRcFileKeyValuePair _tmp10_;
863 GList* _tmp11_;
864 g_return_if_fail (self != NULL);
865 g_return_if_fail (value != NULL);
866 memset (&pair, 0, sizeof (KRcFileKeyValuePair));
867 _tmp0_ = g_strdup (key);
868 _g_free0 (pair.key);
869 pair.key = _tmp0_;
870 _tmp1_ = g_strdup (value);
871 _g_free0 (pair.value);
872 pair.value = _tmp1_;
873 _tmp2_ = (*group).key_value_pairs;
874 lp = _tmp2_;
875 while (TRUE) {
876 gboolean _tmp3_ = FALSE;
877 GList* _tmp4_;
878 GList* _tmp8_;
879 GList* _tmp9_;
880 _tmp4_ = lp;
881 if (_tmp4_ != NULL) {
882 GList* _tmp5_;
883 gconstpointer _tmp6_;
884 const gchar* _tmp7_;
885 _tmp5_ = lp;
886 _tmp6_ = _tmp5_->data;
887 _tmp7_ = (*((KRcFileKeyValuePair*) _tmp6_)).key;
888 _tmp3_ = _tmp7_ == NULL;
889 } else {
890 _tmp3_ = FALSE;
891 }
892 if (!_tmp3_) {
893 break;
894 }
895 _tmp8_ = lp;
896 _tmp9_ = _tmp8_->next;
897 lp = _tmp9_;
898 }
899 _tmp10_ = pair;
900 _tmp11_ = lp;
901 krc_file_add_key_value_pair (self, group, &_tmp10_, _tmp11_);
902 krc_file_key_value_pair_destroy (&pair);
903 }
904
905 static glong
906 string_strnlen (gchar* str,
907 glong maxlen)
908 {
909 gchar* end = NULL;
910 gchar* _tmp0_;
911 gchar* _tmp1_;
912 glong result;
913 _tmp0_ = memchr (str, 0, (gsize) maxlen);
914 end = _tmp0_;
915 _tmp1_ = end;
916 if (_tmp1_ == NULL) {
917 result = maxlen;
918 return result;
919 } else {
920 gchar* _tmp2_;
921 _tmp2_ = end;
922 result = (glong) (_tmp2_ - str);
923 return result;
924 }
925 }
926
927 static gchar*
928 string_substring (const gchar* self,
929 glong offset,
930 glong len)
931 {
932 glong string_length = 0L;
933 gboolean _tmp0_ = FALSE;
934 gchar* _tmp3_;
935 gchar* result;
936 g_return_val_if_fail (self != NULL, NULL);
937 if (offset >= ((glong) 0)) {
938 _tmp0_ = len >= ((glong) 0);
939 } else {
940 _tmp0_ = FALSE;
941 }
942 if (_tmp0_) {
943 string_length = string_strnlen ((gchar*) self, offset + len);
944 } else {
945 gint _tmp1_;
946 gint _tmp2_;
947 _tmp1_ = strlen (self);
948 _tmp2_ = _tmp1_;
949 string_length = (glong) _tmp2_;
950 }
951 if (offset < ((glong) 0)) {
952 offset = string_length + offset;
953 g_return_val_if_fail (offset >= ((glong) 0), NULL);
954 } else {
955 g_return_val_if_fail (offset <= string_length, NULL);
956 }
957 if (len < ((glong) 0)) {
958 len = string_length - offset;
959 }
960 g_return_val_if_fail ((offset + len) <= string_length, NULL);
961 _tmp3_ = g_strndup (((gchar*) self) + offset, (gsize) len);
962 result = _tmp3_;
963 return result;
964 }
965
966 static void
967 krc_file_parse_comment (KRcFile* self,
968 const gchar* line,
969 glong length)
970 {
971 KRcFileKeyValuePair pair = {0};
972 gchar* _tmp0_;
973 KRcFileGroup* _tmp1_;
974 KRcFileKeyValuePair _tmp2_;
975 KRcFileKeyValuePair _tmp3_;
976 KRcFileKeyValuePair* _tmp4_;
977 g_return_if_fail (self != NULL);
978 g_return_if_fail (line != NULL);
979 memset (&pair, 0, sizeof (KRcFileKeyValuePair));
980 _g_free0 (pair.key);
981 pair.key = NULL;
982 _tmp0_ = string_substring (line, (glong) 0, length);
983 _g_free0 (pair.value);
984 pair.value = _tmp0_;
985 _tmp1_ = self->priv->m_current_group;
986 _tmp2_ = pair;
987 _tmp3_ = _tmp2_;
988 _tmp4_ = _krc_file_key_value_pair_dup0 (&_tmp3_);
989 (*_tmp1_).key_value_pairs = g_list_prepend ((*_tmp1_).key_value_pairs, _tmp4_);
990 krc_file_key_value_pair_destroy (&pair);
991 }
992
993 static gboolean
994 string_get_prev_char (const gchar* self,
995 gint* index,
996 gunichar* c)
997 {
998 gunichar _vala_c = 0U;
999 gboolean result;
1000 g_return_val_if_fail (self != NULL, FALSE);
1001 if (0 < (*index)) {
1002 gchar* _tmp0_;
1003 _tmp0_ = g_utf8_prev_char (((gchar*) self) + (*index));
1004 *index = (gint) (_tmp0_ - ((gchar*) self));
1005 _vala_c = g_utf8_get_char (((gchar*) self) + (*index));
1006 result = TRUE;
1007 if (c) {
1008 *c = _vala_c;
1009 }
1010 return result;
1011 } else {
1012 _vala_c = (gunichar) 0;
1013 result = FALSE;
1014 if (c) {
1015 *c = _vala_c;
1016 }
1017 return result;
1018 }
1019 }
1020
1021 static void
1022 krc_file_parse_group (KRcFile* self,
1023 const gchar* line,
1024 glong length,
1025 GError** error)
1026 {
1027 gint l = 0;
1028 gunichar ch = 0U;
1029 gchar* group_name = NULL;
1030 gchar* _tmp3_;
1031 GList* group_node = NULL;
1032 GList* _tmp5_;
1033 GList* _tmp6_;
1034 KRcFileGroup group = {0};
1035 gchar* _tmp9_;
1036 KRcFileGroup _tmp10_;
1037 KRcFileGroup _tmp11_;
1038 KRcFileGroup* _tmp12_;
1039 GList* _tmp13_;
1040 gconstpointer _tmp14_;
1041 GError* _inner_error0_ = NULL;
1042 g_return_if_fail (self != NULL);
1043 g_return_if_fail (line != NULL);
1044 l = (gint) length;
1045 if (l < 0) {
1046 GError* _tmp0_;
1047 _tmp0_ = g_error_new (G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_PARSE, "Too long group name %s against IMT_MAX", line);
1048 _inner_error0_ = _tmp0_;
1049 if (_inner_error0_->domain == G_KEY_FILE_ERROR) {
1050 g_propagate_error (error, _inner_error0_);
1051 return;
1052 } else {
1053 g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error0_->message, g_quark_to_string (_inner_error0_->domain), _inner_error0_->code);
1054 g_clear_error (&_inner_error0_);
1055 return;
1056 }
1057 }
1058 _vala_assert (l > 2, "l > 2");
1059 while (TRUE) {
1060 gunichar _tmp1_ = 0U;
1061 gboolean _tmp2_;
1062 _tmp2_ = string_get_prev_char (line, &l, &_tmp1_);
1063 ch = _tmp1_;
1064 if (!_tmp2_) {
1065 break;
1066 }
1067 if (ch != ((gunichar) ']')) {
1068 break;
1069 }
1070 }
1071 _tmp3_ = string_substring (line, (glong) 1, (glong) l);
1072 group_name = _tmp3_;
1073 if (!krc_file_is_group_name (self, group_name)) {
1074 GError* _tmp4_;
1075 _tmp4_ = g_error_new (G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_PARSE, "Invalid group name %s", group_name);
1076 _inner_error0_ = _tmp4_;
1077 if (_inner_error0_->domain == G_KEY_FILE_ERROR) {
1078 g_propagate_error (error, _inner_error0_);
1079 _g_free0 (group_name);
1080 return;
1081 } else {
1082 _g_free0 (group_name);
1083 g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error0_->message, g_quark_to_string (_inner_error0_->domain), _inner_error0_->code);
1084 g_clear_error (&_inner_error0_);
1085 return;
1086 }
1087 }
1088 _tmp5_ = krc_file_get_group_node_with_name (self, group_name, FALSE, &_inner_error0_);
1089 group_node = _tmp5_;
1090 if (G_UNLIKELY (_inner_error0_ != NULL)) {
1091 if (_inner_error0_->domain == G_KEY_FILE_ERROR) {
1092 g_propagate_error (error, _inner_error0_);
1093 _g_free0 (group_name);
1094 return;
1095 } else {
1096 _g_free0 (group_name);
1097 g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error0_->message, g_quark_to_string (_inner_error0_->domain), _inner_error0_->code);
1098 g_clear_error (&_inner_error0_);
1099 return;
1100 }
1101 }
1102 _tmp6_ = group_node;
1103 if (_tmp6_ != NULL) {
1104 GList* _tmp7_;
1105 gconstpointer _tmp8_;
1106 _tmp7_ = group_node;
1107 _tmp8_ = _tmp7_->data;
1108 self->priv->m_current_group = (KRcFileGroup*) ((KRcFileGroup*) _tmp8_);
1109 _g_free0 (group_name);
1110 return;
1111 }
1112 memset (&group, 0, sizeof (KRcFileGroup));
1113 _tmp9_ = g_strdup (group_name);
1114 _g_free0 (group.name);
1115 group.name = _tmp9_;
1116 _tmp10_ = group;
1117 _tmp11_ = _tmp10_;
1118 _tmp12_ = _krc_file_group_dup0 (&_tmp11_);
1119 self->priv->m_groups = g_list_prepend (self->priv->m_groups, _tmp12_);
1120 _tmp13_ = self->priv->m_groups;
1121 _tmp14_ = _tmp13_->data;
1122 self->priv->m_current_group = (KRcFileGroup*) ((KRcFileGroup*) _tmp14_);
1123 krc_file_group_destroy (&group);
1124 _g_free0 (group_name);
1125 }
1126
1127 static gchar*
1128 string_chomp (const gchar* self)
1129 {
1130 gchar* _result_ = NULL;
1131 gchar* _tmp0_;
1132 gchar* result;
1133 g_return_val_if_fail (self != NULL, NULL);
1134 _tmp0_ = g_strdup (self);
1135 _result_ = _tmp0_;
1136 g_strchomp (_result_);
1137 result = _result_;
1138 return result;
1139 }
1140
1141 static gchar*
1142 string_chug (const gchar* self)
1143 {
1144 gchar* _result_ = NULL;
1145 gchar* _tmp0_;
1146 gchar* result;
1147 g_return_val_if_fail (self != NULL, NULL);
1148 _tmp0_ = g_strdup (self);
1149 _result_ = _tmp0_;
1150 g_strchug (_result_);
1151 result = _result_;
1152 return result;
1153 }
1154
1155 static void
1156 krc_file_parse_key_value_pair (KRcFile* self,
1157 const gchar* line,
1158 glong length,
1159 GError** error)
1160 {
1161 KRcFileGroup* _tmp0_;
1162 const gchar* _tmp1_;
1163 gint key_end = 0;
1164 gint value_start = 0;
1165 gint _tmp3_;
1166 gint _tmp4_;
1167 gchar* key = NULL;
1168 gchar* _tmp5_;
1169 const gchar* _tmp6_;
1170 gchar* _tmp7_;
1171 gchar* value = NULL;
1172 gint _tmp10_;
1173 gint _tmp11_;
1174 gchar* _tmp12_;
1175 const gchar* _tmp13_;
1176 gchar* _tmp14_;
1177 KRcFileGroup* _tmp15_;
1178 const gchar* _tmp16_;
1179 gboolean _tmp17_ = FALSE;
1180 const gchar* _tmp18_;
1181 KRcFileKeyValuePair pair = {0};
1182 const gchar* _tmp22_;
1183 gchar* _tmp23_;
1184 const gchar* _tmp24_;
1185 gchar* _tmp25_;
1186 KRcFileGroup* _tmp26_;
1187 KRcFileKeyValuePair _tmp27_;
1188 KRcFileGroup* _tmp28_;
1189 GList* _tmp29_;
1190 GError* _inner_error0_ = NULL;
1191 g_return_if_fail (self != NULL);
1192 g_return_if_fail (line != NULL);
1193 _tmp0_ = self->priv->m_current_group;
1194 _tmp1_ = (*_tmp0_).name;
1195 if (_tmp1_ == NULL) {
1196 GError* _tmp2_;
1197 _tmp2_ = g_error_new_literal (G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_GROUP_NOT_FOUND, "Key file does not start with a group");
1198 _inner_error0_ = _tmp2_;
1199 if (_inner_error0_->domain == G_KEY_FILE_ERROR) {
1200 g_propagate_error (error, _inner_error0_);
1201 return;
1202 } else {
1203 g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error0_->message, g_quark_to_string (_inner_error0_->domain), _inner_error0_->code);
1204 g_clear_error (&_inner_error0_);
1205 return;
1206 }
1207 }
1208 key_end = string_index_of_char (line, (gunichar) '=', 0);
1209 value_start = key_end;
1210 g_warn_if_fail (key_end != -1);
1211 _tmp3_ = key_end;
1212 key_end = _tmp3_ - 1;
1213 _tmp4_ = value_start;
1214 value_start = _tmp4_ + 1;
1215 _tmp5_ = string_substring (line, (glong) 0, (glong) (key_end + 1));
1216 key = _tmp5_;
1217 _tmp6_ = key;
1218 _tmp7_ = string_chomp (_tmp6_);
1219 _g_free0 (key);
1220 key = _tmp7_;
1221 if (!krc_file_is_key_name (self, line, (gsize) (key_end + 1))) {
1222 const gchar* _tmp8_;
1223 GError* _tmp9_;
1224 _tmp8_ = key;
1225 _tmp9_ = g_error_new (G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_PARSE, "Invalid key name: %s", _tmp8_);
1226 _inner_error0_ = _tmp9_;
1227 if (_inner_error0_->domain == G_KEY_FILE_ERROR) {
1228 g_propagate_error (error, _inner_error0_);
1229 _g_free0 (key);
1230 return;
1231 } else {
1232 _g_free0 (key);
1233 g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error0_->message, g_quark_to_string (_inner_error0_->domain), _inner_error0_->code);
1234 g_clear_error (&_inner_error0_);
1235 return;
1236 }
1237 }
1238 _tmp10_ = strlen (line);
1239 _tmp11_ = _tmp10_;
1240 _tmp12_ = string_substring (line, (glong) value_start, (glong) (_tmp11_ - value_start));
1241 value = _tmp12_;
1242 _tmp13_ = value;
1243 _tmp14_ = string_chug (_tmp13_);
1244 _g_free0 (value);
1245 value = _tmp14_;
1246 _tmp15_ = self->priv->m_current_group;
1247 _tmp16_ = (*_tmp15_).name;
1248 _vala_assert (_tmp16_ != NULL, "m_current_group.name != null");
1249 _tmp18_ = key;
1250 if (g_strcmp0 (_tmp18_, "Encoding") == 0) {
1251 const gchar* _tmp19_;
1252 _tmp19_ = value;
1253 _tmp17_ = g_strcmp0 (_tmp19_, "UTF-8") != 0;
1254 } else {
1255 _tmp17_ = FALSE;
1256 }
1257 if (_tmp17_) {
1258 const gchar* _tmp20_;
1259 GError* _tmp21_;
1260 _tmp20_ = value;
1261 _tmp21_ = g_error_new (G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_UNKNOWN_ENCODING, "Key file contains unsupported encoding %s", _tmp20_);
1262 _inner_error0_ = _tmp21_;
1263 if (_inner_error0_->domain == G_KEY_FILE_ERROR) {
1264 g_propagate_error (error, _inner_error0_);
1265 _g_free0 (value);
1266 _g_free0 (key);
1267 return;
1268 } else {
1269 _g_free0 (value);
1270 _g_free0 (key);
1271 g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error0_->message, g_quark_to_string (_inner_error0_->domain), _inner_error0_->code);
1272 g_clear_error (&_inner_error0_);
1273 return;
1274 }
1275 }
1276 memset (&pair, 0, sizeof (KRcFileKeyValuePair));
1277 _tmp22_ = key;
1278 _tmp23_ = g_strdup (_tmp22_);
1279 _g_free0 (pair.key);
1280 pair.key = _tmp23_;
1281 _tmp24_ = value;
1282 _tmp25_ = g_strdup (_tmp24_);
1283 _g_free0 (pair.value);
1284 pair.value = _tmp25_;
1285 _tmp26_ = self->priv->m_current_group;
1286 _tmp27_ = pair;
1287 _tmp28_ = self->priv->m_current_group;
1288 _tmp29_ = (*_tmp28_).key_value_pairs;
1289 krc_file_add_key_value_pair (self, _tmp26_, &_tmp27_, _tmp29_);
1290 krc_file_key_value_pair_destroy (&pair);
1291 _g_free0 (value);
1292 _g_free0 (key);
1293 }
1294
1295 static void
1296 krc_file_parse_line (KRcFile* self,
1297 const gchar* line,
1298 glong length,
1299 GError** error)
1300 {
1301 gchar* _line = NULL;
1302 gchar* _tmp0_;
1303 const gchar* _tmp1_;
1304 gchar* _tmp2_;
1305 const gchar* _tmp3_;
1306 const gchar* _tmp4_;
1307 const gchar* _tmp9_;
1308 GError* _inner_error0_ = NULL;
1309 g_return_if_fail (self != NULL);
1310 g_return_if_fail (line != NULL);
1311 _tmp0_ = g_strdup (line);
1312 _line = _tmp0_;
1313 _tmp1_ = _line;
1314 _tmp2_ = string_chug (_tmp1_);
1315 _g_free0 (_line);
1316 _line = _tmp2_;
1317 _tmp3_ = _line;
1318 if (krc_file_is_comment (self, _tmp3_)) {
1319 krc_file_parse_comment (self, line, length);
1320 }
1321 _tmp4_ = _line;
1322 if (krc_file_is_group (self, _tmp4_)) {
1323 const gchar* _tmp5_;
1324 const gchar* _tmp6_;
1325 gint _tmp7_;
1326 gint _tmp8_;
1327 _tmp5_ = _line;
1328 _tmp6_ = _line;
1329 _tmp7_ = strlen (_tmp6_);
1330 _tmp8_ = _tmp7_;
1331 krc_file_parse_group (self, _tmp5_, length - (length - _tmp8_), &_inner_error0_);
1332 if (G_UNLIKELY (_inner_error0_ != NULL)) {
1333 if (_inner_error0_->domain == G_KEY_FILE_ERROR) {
1334 g_propagate_error (error, _inner_error0_);
1335 _g_free0 (_line);
1336 return;
1337 } else {
1338 _g_free0 (_line);
1339 g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error0_->message, g_quark_to_string (_inner_error0_->domain), _inner_error0_->code);
1340 g_clear_error (&_inner_error0_);
1341 return;
1342 }
1343 }
1344 }
1345 _tmp9_ = _line;
1346 if (krc_file_is_key_value_pair (self, _tmp9_)) {
1347 const gchar* _tmp10_;
1348 const gchar* _tmp11_;
1349 gint _tmp12_;
1350 gint _tmp13_;
1351 _tmp10_ = _line;
1352 _tmp11_ = _line;
1353 _tmp12_ = strlen (_tmp11_);
1354 _tmp13_ = _tmp12_;
1355 krc_file_parse_key_value_pair (self, _tmp10_, length - (length - _tmp13_), &_inner_error0_);
1356 if (G_UNLIKELY (_inner_error0_ != NULL)) {
1357 if (_inner_error0_->domain == G_KEY_FILE_ERROR) {
1358 g_propagate_error (error, _inner_error0_);
1359 _g_free0 (_line);
1360 return;
1361 } else {
1362 _g_free0 (_line);
1363 g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error0_->message, g_quark_to_string (_inner_error0_->domain), _inner_error0_->code);
1364 g_clear_error (&_inner_error0_);
1365 return;
1366 }
1367 }
1368 }
1369 _g_free0 (_line);
1370 }
1371
1372 static gboolean
1373 krc_file_parse_data (KRcFile* self,
1374 const gchar* data,
1375 gsize length)
1376 {
1377 glong i = 0L;
1378 glong offset = 0L;
1379 GError* _inner_error0_ = NULL;
1380 gboolean result;
1381 g_return_val_if_fail (self != NULL, FALSE);
1382 g_return_val_if_fail (data != NULL, FALSE);
1383 i = (glong) 0;
1384 offset = (glong) 0;
1385 while (TRUE) {
1386 gchar ch = '\0';
1387 glong _tmp20_;
1388 if (!(((gsize) i) < length)) {
1389 break;
1390 }
1391 ch = string_get (data, i);
1392 if (ch == '\n') {
1393 glong sub_length = 0L;
1394 gchar* sub = NULL;
1395 gchar* _tmp0_;
1396 gboolean _tmp1_ = FALSE;
1397 const gchar* _tmp2_;
1398 gint _tmp3_;
1399 gint _tmp4_;
1400 sub_length = i - offset;
1401 _tmp0_ = string_substring (data, offset, sub_length);
1402 sub = _tmp0_;
1403 offset = i + 1;
1404 _tmp2_ = sub;
1405 _tmp3_ = strlen (_tmp2_);
1406 _tmp4_ = _tmp3_;
1407 if (_tmp4_ > 0) {
1408 const gchar* _tmp5_;
1409 const gchar* _tmp6_;
1410 gint _tmp7_;
1411 gint _tmp8_;
1412 _tmp5_ = sub;
1413 _tmp6_ = sub;
1414 _tmp7_ = strlen (_tmp6_);
1415 _tmp8_ = _tmp7_;
1416 _tmp1_ = string_get (_tmp5_, (glong) (_tmp8_ - 1)) == '\r';
1417 } else {
1418 _tmp1_ = FALSE;
1419 }
1420 if (_tmp1_) {
1421 const gchar* _tmp9_;
1422 glong _tmp10_;
1423 gchar* _tmp11_;
1424 _tmp9_ = sub;
1425 sub_length = sub_length - 1;
1426 _tmp10_ = sub_length;
1427 _tmp11_ = string_substring (_tmp9_, (glong) 0, _tmp10_);
1428 _g_free0 (sub);
1429 sub = _tmp11_;
1430 }
1431 {
1432 const gchar* _tmp12_;
1433 gint _tmp13_;
1434 gint _tmp14_;
1435 _tmp12_ = sub;
1436 _tmp13_ = strlen (_tmp12_);
1437 _tmp14_ = _tmp13_;
1438 if (_tmp14_ == 0) {
1439 krc_file_parse_comment (self, "", (glong) 0);
1440 } else {
1441 const gchar* _tmp15_;
1442 _tmp15_ = sub;
1443 krc_file_parse_line (self, _tmp15_, sub_length, &_inner_error0_);
1444 if (G_UNLIKELY (_inner_error0_ != NULL)) {
1445 gboolean _tmp16_ = FALSE;
1446 if (_inner_error0_->domain == G_KEY_FILE_ERROR) {
1447 goto __catch0_g_key_file_error;
1448 }
1449 _g_free0 (sub);
1450 g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error0_->message, g_quark_to_string (_inner_error0_->domain), _inner_error0_->code);
1451 g_clear_error (&_inner_error0_);
1452 return _tmp16_;
1453 }
1454 }
1455 }
1456 goto __finally0;
1457 __catch0_g_key_file_error:
1458 {
1459 GError* e = NULL;
1460 GError* _tmp17_;
1461 const gchar* _tmp18_;
1462 e = _inner_error0_;
1463 _inner_error0_ = NULL;
1464 _tmp17_ = e;
1465 _tmp18_ = _tmp17_->message;
1466 g_warning ("krcfile.vala:279: Failed to load data: %s", _tmp18_);
1467 result = FALSE;
1468 _g_error_free0 (e);
1469 _g_free0 (sub);
1470 return result;
1471 }
1472 __finally0:
1473 if (G_UNLIKELY (_inner_error0_ != NULL)) {
1474 gboolean _tmp19_ = FALSE;
1475 _g_free0 (sub);
1476 g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error0_->message, g_quark_to_string (_inner_error0_->domain), _inner_error0_->code);
1477 g_clear_error (&_inner_error0_);
1478 return _tmp19_;
1479 }
1480 _g_free0 (sub);
1481 }
1482 _tmp20_ = i;
1483 i = _tmp20_ + 1;
1484 }
1485 result = TRUE;
1486 return result;
1487 }
1488
1489 gboolean
1490 krc_file_load_from_file (KRcFile* self,
1491 const gchar* path,
1492 GKeyFileFlags flags,
1493 GError** error)
1494 {
1495 gchar* contents = NULL;
1496 gsize length = 0UL;
1497 gboolean _tmp3_ = FALSE;
1498 gchar* _tmp4_ = NULL;
1499 gsize _tmp5_ = 0UL;
1500 gboolean _tmp6_;
1501 const gchar* _tmp9_;
1502 GError* _inner_error0_ = NULL;
1503 gboolean result;
1504 g_return_val_if_fail (self != NULL, FALSE);
1505 g_return_val_if_fail (path != NULL, FALSE);
1506 if (!g_file_test (path, G_FILE_TEST_EXISTS | G_FILE_TEST_IS_REGULAR)) {
1507 GError* _tmp0_;
1508 _tmp0_ = g_error_new (G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_PARSE, "Not a regular file %s", path);
1509 _inner_error0_ = _tmp0_;
1510 if ((_inner_error0_->domain == G_KEY_FILE_ERROR) || (_inner_error0_->domain == G_FILE_ERROR)) {
1511 gboolean _tmp1_ = FALSE;
1512 g_propagate_error (error, _inner_error0_);
1513 return _tmp1_;
1514 } else {
1515 gboolean _tmp2_ = FALSE;
1516 g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error0_->message, g_quark_to_string (_inner_error0_->domain), _inner_error0_->code);
1517 g_clear_error (&_inner_error0_);
1518 return _tmp2_;
1519 }
1520 }
1521 contents = NULL;
1522 length = (gsize) 0;
1523 _tmp6_ = g_file_get_contents (path, &_tmp4_, &_tmp5_, &_inner_error0_);
1524 _g_free0 (contents);
1525 contents = _tmp4_;
1526 length = _tmp5_;
1527 _tmp3_ = _tmp6_;
1528 if (G_UNLIKELY (_inner_error0_ != NULL)) {
1529 if ((_inner_error0_->domain == G_KEY_FILE_ERROR) || (_inner_error0_->domain == G_FILE_ERROR)) {
1530 gboolean _tmp7_ = FALSE;
1531 g_propagate_error (error, _inner_error0_);
1532 _g_free0 (contents);
1533 return _tmp7_;
1534 } else {
1535 gboolean _tmp8_ = FALSE;
1536 _g_free0 (contents);
1537 g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error0_->message, g_quark_to_string (_inner_error0_->domain), _inner_error0_->code);
1538 g_clear_error (&_inner_error0_);
1539 return _tmp8_;
1540 }
1541 }
1542 if (!_tmp3_) {
1543 g_warning ("krcfile.vala:300: Failed to load %s", path);
1544 result = FALSE;
1545 _g_free0 (contents);
1546 return result;
1547 }
1548 _tmp9_ = contents;
1549 result = krc_file_parse_data (self, _tmp9_, length);
1550 _g_free0 (contents);
1551 return result;
1552 }
1553
1554 gboolean
1555 krc_file_has_group (KRcFile* self,
1556 const gchar* group_name)
1557 {
1558 GError* _inner_error0_ = NULL;
1559 gboolean result;
1560 g_return_val_if_fail (self != NULL, FALSE);
1561 g_return_val_if_fail (group_name != NULL, FALSE);
1562 {
1563 GList* _tmp0_ = NULL;
1564 GList* _tmp1_;
1565 _tmp1_ = krc_file_get_group_node_with_name (self, group_name, FALSE, &_inner_error0_);
1566 _tmp0_ = _tmp1_;
1567 if (G_UNLIKELY (_inner_error0_ != NULL)) {
1568 gboolean _tmp2_ = FALSE;
1569 if (_inner_error0_->domain == G_KEY_FILE_ERROR) {
1570 goto __catch0_g_key_file_error;
1571 }
1572 g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error0_->message, g_quark_to_string (_inner_error0_->domain), _inner_error0_->code);
1573 g_clear_error (&_inner_error0_);
1574 return _tmp2_;
1575 }
1576 if (_tmp0_ != NULL) {
1577 result = TRUE;
1578 return result;
1579 }
1580 }
1581 goto __finally0;
1582 __catch0_g_key_file_error:
1583 {
1584 g_clear_error (&_inner_error0_);
1585 g_assert_not_reached ();
1586 }
1587 __finally0:
1588 if (G_UNLIKELY (_inner_error0_ != NULL)) {
1589 gboolean _tmp3_ = FALSE;
1590 g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error0_->message, g_quark_to_string (_inner_error0_->domain), _inner_error0_->code);
1591 g_clear_error (&_inner_error0_);
1592 return _tmp3_;
1593 }
1594 result = FALSE;
1595 return result;
1596 }
1597
1598 static void
1599 _vala_array_add1 (gchar** * array,
1600 gint* length,
1601 gint* size,
1602 gchar* value)
1603 {
1604 if ((*length) == (*size)) {
1605 *size = (*size) ? (2 * (*size)) : 4;
1606 *array = g_renew (gchar*, *array, (*size) + 1);
1607 }
1608 (*array)[(*length)++] = value;
1609 (*array)[*length] = NULL;
1610 }
1611
1612 gchar**
1613 krc_file_get_keys (KRcFile* self,
1614 const gchar* group_name,
1615 gint* result_length1,
1616 GError** error)
1617 {
1618 gchar** keys = NULL;
1619 gchar** _tmp0_;
1620 gint keys_length1;
1621 gint _keys_size_;
1622 GList* group_node = NULL;
1623 GList* _tmp1_;
1624 GList* tmp = NULL;
1625 gconstpointer _tmp2_;
1626 GList* _tmp3_;
1627 gchar** _tmp16_;
1628 gint _tmp16__length1;
1629 GError* _inner_error0_ = NULL;
1630 gchar** result;
1631 g_return_val_if_fail (self != NULL, NULL);
1632 g_return_val_if_fail (group_name != NULL, NULL);
1633 _tmp0_ = g_new0 (gchar*, 0 + 1);
1634 keys = _tmp0_;
1635 keys_length1 = 0;
1636 _keys_size_ = keys_length1;
1637 _tmp1_ = krc_file_get_group_node_with_name (self, group_name, TRUE, &_inner_error0_);
1638 group_node = _tmp1_;
1639 if (G_UNLIKELY (_inner_error0_ != NULL)) {
1640 if (_inner_error0_->domain == G_KEY_FILE_ERROR) {
1641 g_propagate_error (error, _inner_error0_);
1642 keys = (_vala_array_free (keys, keys_length1, (GDestroyNotify) g_free), NULL);
1643 return NULL;
1644 } else {
1645 keys = (_vala_array_free (keys, keys_length1, (GDestroyNotify) g_free), NULL);
1646 g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error0_->message, g_quark_to_string (_inner_error0_->domain), _inner_error0_->code);
1647 g_clear_error (&_inner_error0_);
1648 return NULL;
1649 }
1650 }
1651 _tmp2_ = group_node->data;
1652 _tmp3_ = (*((KRcFileGroup*) _tmp2_)).key_value_pairs;
1653 tmp = _tmp3_;
1654 while (TRUE) {
1655 GList* _tmp4_;
1656 KRcFileKeyValuePair pair = {0};
1657 GList* _tmp5_;
1658 gconstpointer _tmp6_;
1659 KRcFileKeyValuePair _tmp7_;
1660 KRcFileKeyValuePair _tmp8_ = {0};
1661 KRcFileKeyValuePair _tmp9_;
1662 const gchar* _tmp10_;
1663 GList* _tmp14_;
1664 GList* _tmp15_;
1665 _tmp4_ = tmp;
1666 if (!(_tmp4_ != NULL)) {
1667 break;
1668 }
1669 _tmp5_ = tmp;
1670 _tmp6_ = _tmp5_->data;
1671 _tmp7_ = *((KRcFileKeyValuePair*) _tmp6_);
1672 krc_file_key_value_pair_copy (&_tmp7_, &_tmp8_);
1673 pair = _tmp8_;
1674 _tmp9_ = pair;
1675 _tmp10_ = _tmp9_.key;
1676 if (_tmp10_ != NULL) {
1677 KRcFileKeyValuePair _tmp11_;
1678 const gchar* _tmp12_;
1679 gchar* _tmp13_;
1680 _tmp11_ = pair;
1681 _tmp12_ = _tmp11_.key;
1682 _tmp13_ = g_strdup (_tmp12_);
1683 _vala_array_add1 (&keys, &keys_length1, &_keys_size_, _tmp13_);
1684 }
1685 _tmp14_ = tmp;
1686 _tmp15_ = _tmp14_->next;
1687 tmp = _tmp15_;
1688 krc_file_key_value_pair_destroy (&pair);
1689 }
1690 _tmp16_ = keys;
1691 _tmp16__length1 = keys_length1;
1692 if (result_length1) {
1693 *result_length1 = _tmp16__length1;
1694 }
1695 result = _tmp16_;
1696 return result;
1697 }
1698
1699 gboolean
1700 krc_file_has_key (KRcFile* self,
1701 const gchar* group_name,
1702 const gchar* key,
1703 GError** error)
1704 {
1705 GList* group_node = NULL;
1706 GList* _tmp0_;
1707 GList* tmp = NULL;
1708 GList* _tmp3_;
1709 gconstpointer _tmp4_;
1710 GList* _tmp5_;
1711 GError* _inner_error0_ = NULL;
1712 gboolean result;
1713 g_return_val_if_fail (self != NULL, FALSE);
1714 g_return_val_if_fail (group_name != NULL, FALSE);
1715 g_return_val_if_fail (key != NULL, FALSE);
1716 _tmp0_ = krc_file_get_group_node_with_name (self, group_name, TRUE, &_inner_error0_);
1717 group_node = _tmp0_;
1718 if (G_UNLIKELY (_inner_error0_ != NULL)) {
1719 if (_inner_error0_->domain == G_KEY_FILE_ERROR) {
1720 gboolean _tmp1_ = FALSE;
1721 g_propagate_error (error, _inner_error0_);
1722 return _tmp1_;
1723 } else {
1724 gboolean _tmp2_ = FALSE;
1725 g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error0_->message, g_quark_to_string (_inner_error0_->domain), _inner_error0_->code);
1726 g_clear_error (&_inner_error0_);
1727 return _tmp2_;
1728 }
1729 }
1730 _tmp3_ = group_node;
1731 _tmp4_ = _tmp3_->data;
1732 _tmp5_ = (*((KRcFileGroup*) _tmp4_)).key_value_pairs;
1733 tmp = _tmp5_;
1734 while (TRUE) {
1735 GList* _tmp6_;
1736 KRcFileKeyValuePair pair = {0};
1737 GList* _tmp7_;
1738 gconstpointer _tmp8_;
1739 KRcFileKeyValuePair _tmp9_;
1740 KRcFileKeyValuePair _tmp10_ = {0};
1741 KRcFileKeyValuePair _tmp11_;
1742 const gchar* _tmp12_;
1743 GList* _tmp13_;
1744 GList* _tmp14_;
1745 _tmp6_ = tmp;
1746 if (!(_tmp6_ != NULL)) {
1747 break;
1748 }
1749 _tmp7_ = tmp;
1750 _tmp8_ = _tmp7_->data;
1751 _tmp9_ = *((KRcFileKeyValuePair*) _tmp8_);
1752 krc_file_key_value_pair_copy (&_tmp9_, &_tmp10_);
1753 pair = _tmp10_;
1754 _tmp11_ = pair;
1755 _tmp12_ = _tmp11_.key;
1756 if (g_strcmp0 (_tmp12_, key) == 0) {
1757 result = TRUE;
1758 krc_file_key_value_pair_destroy (&pair);
1759 return result;
1760 }
1761 _tmp13_ = tmp;
1762 _tmp14_ = _tmp13_->next;
1763 tmp = _tmp14_;
1764 krc_file_key_value_pair_destroy (&pair);
1765 }
1766 result = FALSE;
1767 return result;
1768 }
1769
1770 gboolean
1771 krc_file_remove_group (KRcFile* self,
1772 const gchar* group_name,
1773 GError** error)
1774 {
1775 GList* group_node = NULL;
1776 GList* _tmp0_;
1777 GList* tmp = NULL;
1778 gconstpointer _tmp3_;
1779 GList* _tmp4_;
1780 GError* _inner_error0_ = NULL;
1781 gboolean result;
1782 g_return_val_if_fail (self != NULL, FALSE);
1783 g_return_val_if_fail (group_name != NULL, FALSE);
1784 _tmp0_ = krc_file_get_group_node_with_name (self, group_name, TRUE, &_inner_error0_);
1785 group_node = _tmp0_;
1786 if (G_UNLIKELY (_inner_error0_ != NULL)) {
1787 if (_inner_error0_->domain == G_KEY_FILE_ERROR) {
1788 gboolean _tmp1_ = FALSE;
1789 g_propagate_error (error, _inner_error0_);
1790 return _tmp1_;
1791 } else {
1792 gboolean _tmp2_ = FALSE;
1793 g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error0_->message, g_quark_to_string (_inner_error0_->domain), _inner_error0_->code);
1794 g_clear_error (&_inner_error0_);
1795 return _tmp2_;
1796 }
1797 }
1798 _tmp3_ = group_node->data;
1799 _tmp4_ = (*((KRcFileGroup*) _tmp3_)).key_value_pairs;
1800 tmp = _tmp4_;
1801 while (TRUE) {
1802 GList* _tmp5_;
1803 GList* _tmp6_;
1804 GList* _tmp7_;
1805 _tmp5_ = tmp;
1806 if (!(_tmp5_ != NULL)) {
1807 break;
1808 }
1809 _tmp6_ = tmp;
1810 _krc_file_key_value_pair_free0 (_tmp6_->data);
1811 _tmp6_->data = NULL;
1812 _tmp7_ = tmp;
1813 tmp = g_list_delete_link (tmp, _tmp7_);
1814 }
1815 _krc_file_group_free0 (group_node->data);
1816 group_node->data = NULL;
1817 self->priv->m_groups = g_list_delete_link (self->priv->m_groups, group_node);
1818 result = TRUE;
1819 return result;
1820 }
1821
1822 gboolean
1823 krc_file_remove_key (KRcFile* self,
1824 const gchar* group_name,
1825 const gchar* key,
1826 GError** error)
1827 {
1828 GList* group_node = NULL;
1829 GList* _tmp0_;
1830 GList* tmp = NULL;
1831 GList* _tmp3_;
1832 gconstpointer _tmp4_;
1833 GList* _tmp5_;
1834 GList* _tmp14_;
1835 GList* _tmp18_;
1836 GList* _tmp19_;
1837 GError* _inner_error0_ = NULL;
1838 gboolean result;
1839 g_return_val_if_fail (self != NULL, FALSE);
1840 g_return_val_if_fail (group_name != NULL, FALSE);
1841 g_return_val_if_fail (key != NULL, FALSE);
1842 _tmp0_ = krc_file_get_group_node_with_name (self, group_name, TRUE, &_inner_error0_);
1843 group_node = _tmp0_;
1844 if (G_UNLIKELY (_inner_error0_ != NULL)) {
1845 if (_inner_error0_->domain == G_KEY_FILE_ERROR) {
1846 gboolean _tmp1_ = FALSE;
1847 g_propagate_error (error, _inner_error0_);
1848 return _tmp1_;
1849 } else {
1850 gboolean _tmp2_ = FALSE;
1851 g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error0_->message, g_quark_to_string (_inner_error0_->domain), _inner_error0_->code);
1852 g_clear_error (&_inner_error0_);
1853 return _tmp2_;
1854 }
1855 }
1856 _tmp3_ = group_node;
1857 _tmp4_ = _tmp3_->data;
1858 _tmp5_ = (*((KRcFileGroup*) _tmp4_)).key_value_pairs;
1859 tmp = _tmp5_;
1860 while (TRUE) {
1861 GList* _tmp6_;
1862 KRcFileKeyValuePair* pair = NULL;
1863 GList* _tmp7_;
1864 gconstpointer _tmp8_;
1865 KRcFileKeyValuePair* _tmp9_;
1866 KRcFileKeyValuePair* _tmp10_;
1867 const gchar* _tmp11_;
1868 GList* _tmp12_;
1869 GList* _tmp13_;
1870 _tmp6_ = tmp;
1871 if (!(_tmp6_ != NULL)) {
1872 break;
1873 }
1874 _tmp7_ = tmp;
1875 _tmp8_ = _tmp7_->data;
1876 _tmp9_ = _krc_file_key_value_pair_dup0 ((KRcFileKeyValuePair*) _tmp8_);
1877 pair = _tmp9_;
1878 _tmp10_ = pair;
1879 _tmp11_ = (*_tmp10_).key;
1880 if (g_strcmp0 (_tmp11_, key) == 0) {
1881 _krc_file_key_value_pair_free0 (pair);
1882 break;
1883 }
1884 _tmp12_ = tmp;
1885 _tmp13_ = _tmp12_->next;
1886 tmp = _tmp13_;
1887 _krc_file_key_value_pair_free0 (pair);
1888 }
1889 _tmp14_ = tmp;
1890 if (_tmp14_ == NULL) {
1891 GError* _tmp15_;
1892 _tmp15_ = g_error_new (G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_KEY_NOT_FOUND, "Key file does not have key %s in group %s", key, group_name);
1893 _inner_error0_ = _tmp15_;
1894 if (_inner_error0_->domain == G_KEY_FILE_ERROR) {
1895 gboolean _tmp16_ = FALSE;
1896 g_propagate_error (error, _inner_error0_);
1897 return _tmp16_;
1898 } else {
1899 gboolean _tmp17_ = FALSE;
1900 g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error0_->message, g_quark_to_string (_inner_error0_->domain), _inner_error0_->code);
1901 g_clear_error (&_inner_error0_);
1902 return _tmp17_;
1903 }
1904 }
1905 _tmp18_ = tmp;
1906 _krc_file_key_value_pair_free0 (_tmp18_->data);
1907 _tmp18_->data = NULL;
1908 _tmp19_ = tmp;
1909 tmp = g_list_delete_link (tmp, _tmp19_);
1910 result = TRUE;
1911 return result;
1912 }
1913
1914 gchar*
1915 krc_file_to_data (KRcFile* self,
1916 gssize* length)
1917 {
1918 gssize _vala_length = 0L;
1919 GString* data_string = NULL;
1920 GString* _tmp0_;
1921 GString* _tmp36_;
1922 GString* _tmp37_;
1923 const gchar* _tmp38_;
1924 gchar* _tmp39_;
1925 gchar* result;
1926 g_return_val_if_fail (self != NULL, NULL);
1927 _tmp0_ = g_string_new ("");
1928 data_string = _tmp0_;
1929 {
1930 GList* group_node = NULL;
1931 GList* _tmp1_;
1932 GList* _tmp2_;
1933 _tmp1_ = self->priv->m_groups;
1934 _tmp2_ = g_list_last (_tmp1_);
1935 group_node = _tmp2_;
1936 {
1937 gboolean _tmp3_ = FALSE;
1938 _tmp3_ = TRUE;
1939 while (TRUE) {
1940 GList* _tmp6_;
1941 KRcFileGroup* group = NULL;
1942 GList* _tmp7_;
1943 gconstpointer _tmp8_;
1944 KRcFileGroup* _tmp9_;
1945 KRcFileGroup* _tmp10_;
1946 const gchar* _tmp11_;
1947 if (!_tmp3_) {
1948 GList* _tmp4_;
1949 GList* _tmp5_;
1950 _tmp4_ = group_node;
1951 _tmp5_ = _tmp4_->prev;
1952 group_node = _tmp5_;
1953 }
1954 _tmp3_ = FALSE;
1955 _tmp6_ = group_node;
1956 if (!(_tmp6_ != NULL)) {
1957 break;
1958 }
1959 _tmp7_ = group_node;
1960 _tmp8_ = _tmp7_->data;
1961 _tmp9_ = _krc_file_group_dup0 ((KRcFileGroup*) _tmp8_);
1962 group = _tmp9_;
1963 _tmp10_ = group;
1964 _tmp11_ = (*_tmp10_).name;
1965 if (_tmp11_ != NULL) {
1966 GString* _tmp12_;
1967 KRcFileGroup* _tmp13_;
1968 const gchar* _tmp14_;
1969 _tmp12_ = data_string;
1970 _tmp13_ = group;
1971 _tmp14_ = (*_tmp13_).name;
1972 g_string_append_printf (_tmp12_, "[%s]\n", _tmp14_);
1973 }
1974 {
1975 GList* key_file_node = NULL;
1976 KRcFileGroup* _tmp15_;
1977 GList* _tmp16_;
1978 GList* _tmp17_;
1979 _tmp15_ = group;
1980 _tmp16_ = (*_tmp15_).key_value_pairs;
1981 _tmp17_ = g_list_last (_tmp16_);
1982 key_file_node = _tmp17_;
1983 {
1984 gboolean _tmp18_ = FALSE;
1985 _tmp18_ = TRUE;
1986 while (TRUE) {
1987 GList* _tmp21_;
1988 KRcFileKeyValuePair pair = {0};
1989 GList* _tmp22_;
1990 gconstpointer _tmp23_;
1991 KRcFileKeyValuePair _tmp24_;
1992 KRcFileKeyValuePair _tmp25_ = {0};
1993 KRcFileKeyValuePair _tmp26_;
1994 const gchar* _tmp27_;
1995 if (!_tmp18_) {
1996 GList* _tmp19_;
1997 GList* _tmp20_;
1998 _tmp19_ = key_file_node;
1999 _tmp20_ = _tmp19_->prev;
2000 key_file_node = _tmp20_;
2001 }
2002 _tmp18_ = FALSE;
2003 _tmp21_ = key_file_node;
2004 if (!(_tmp21_ != NULL)) {
2005 break;
2006 }
2007 _tmp22_ = key_file_node;
2008 _tmp23_ = _tmp22_->data;
2009 _tmp24_ = *((KRcFileKeyValuePair*) _tmp23_);
2010 krc_file_key_value_pair_copy (&_tmp24_, &_tmp25_);
2011 pair = _tmp25_;
2012 _tmp26_ = pair;
2013 _tmp27_ = _tmp26_.key;
2014 if (_tmp27_ != NULL) {
2015 GString* _tmp28_;
2016 KRcFileKeyValuePair _tmp29_;
2017 const gchar* _tmp30_;
2018 KRcFileKeyValuePair _tmp31_;
2019 const gchar* _tmp32_;
2020 _tmp28_ = data_string;
2021 _tmp29_ = pair;
2022 _tmp30_ = _tmp29_.key;
2023 _tmp31_ = pair;
2024 _tmp32_ = _tmp31_.value;
2025 g_string_append_printf (_tmp28_, "%s=%s\n", _tmp30_, _tmp32_);
2026 } else {
2027 GString* _tmp33_;
2028 KRcFileKeyValuePair _tmp34_;
2029 const gchar* _tmp35_;
2030 _tmp33_ = data_string;
2031 _tmp34_ = pair;
2032 _tmp35_ = _tmp34_.value;
2033 g_string_append_printf (_tmp33_, "%s\n", _tmp35_);
2034 }
2035 krc_file_key_value_pair_destroy (&pair);
2036 }
2037 }
2038 }
2039 _krc_file_group_free0 (group);
2040 }
2041 }
2042 }
2043 _tmp36_ = data_string;
2044 _vala_length = _tmp36_->len;
2045 _tmp37_ = data_string;
2046 _tmp38_ = _tmp37_->str;
2047 _tmp39_ = g_strdup (_tmp38_);
2048 result = _tmp39_;
2049 _g_string_free0 (data_string);
2050 if (length) {
2051 *length = _vala_length;
2052 }
2053 return result;
2054 }
2055
2056 gboolean
2057 krc_file_save_to_file (KRcFile* self,
2058 const gchar* filename,
2059 GError** error)
2060 {
2061 gssize length = 0L;
2062 gchar* contents = NULL;
2063 gssize _tmp0_ = 0L;
2064 gchar* _tmp1_;
2065 gboolean retval = FALSE;
2066 GError* _inner_error0_ = NULL;
2067 gboolean result;
2068 g_return_val_if_fail (self != NULL, FALSE);
2069 g_return_val_if_fail (filename != NULL, FALSE);
2070 length = (gssize) 0;
2071 _tmp1_ = krc_file_to_data (self, &_tmp0_);
2072 length = _tmp0_;
2073 contents = _tmp1_;
2074 retval = g_file_set_contents (filename, contents, length, &_inner_error0_);
2075 if (G_UNLIKELY (_inner_error0_ != NULL)) {
2076 if (_inner_error0_->domain == G_FILE_ERROR) {
2077 gboolean _tmp2_ = FALSE;
2078 g_propagate_error (error, _inner_error0_);
2079 _g_free0 (contents);
2080 return _tmp2_;
2081 } else {
2082 gboolean _tmp3_ = FALSE;
2083 _g_free0 (contents);
2084 g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error0_->message, g_quark_to_string (_inner_error0_->domain), _inner_error0_->code);
2085 g_clear_error (&_inner_error0_);
2086 return _tmp3_;
2087 }
2088 }
2089 result = retval;
2090 _g_free0 (contents);
2091 return result;
2092 }
2093
2094 gchar*
2095 krc_file_get_value (KRcFile* self,
2096 const gchar* group_name,
2097 const gchar* key,
2098 GError** error)
2099 {
2100 GList* group_node = NULL;
2101 GList* _tmp0_;
2102 GList* tmp = NULL;
2103 GList* _tmp1_;
2104 gconstpointer _tmp2_;
2105 GList* _tmp3_;
2106 GError* _tmp15_;
2107 GError* _inner_error0_ = NULL;
2108 gchar* result;
2109 g_return_val_if_fail (self != NULL, NULL);
2110 g_return_val_if_fail (group_name != NULL, NULL);
2111 g_return_val_if_fail (key != NULL, NULL);
2112 _tmp0_ = krc_file_get_group_node_with_name (self, group_name, TRUE, &_inner_error0_);
2113 group_node = _tmp0_;
2114 if (G_UNLIKELY (_inner_error0_ != NULL)) {
2115 if (_inner_error0_->domain == G_KEY_FILE_ERROR) {
2116 g_propagate_error (error, _inner_error0_);
2117 return NULL;
2118 } else {
2119 g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error0_->message, g_quark_to_string (_inner_error0_->domain), _inner_error0_->code);
2120 g_clear_error (&_inner_error0_);
2121 return NULL;
2122 }
2123 }
2124 _tmp1_ = group_node;
2125 _tmp2_ = _tmp1_->data;
2126 _tmp3_ = (*((KRcFileGroup*) _tmp2_)).key_value_pairs;
2127 tmp = _tmp3_;
2128 while (TRUE) {
2129 GList* _tmp4_;
2130 KRcFileKeyValuePair* pair = NULL;
2131 GList* _tmp5_;
2132 gconstpointer _tmp6_;
2133 KRcFileKeyValuePair* _tmp7_;
2134 KRcFileKeyValuePair* _tmp8_;
2135 const gchar* _tmp9_;
2136 GList* _tmp13_;
2137 GList* _tmp14_;
2138 _tmp4_ = tmp;
2139 if (!(_tmp4_ != NULL)) {
2140 break;
2141 }
2142 _tmp5_ = tmp;
2143 _tmp6_ = _tmp5_->data;
2144 _tmp7_ = _krc_file_key_value_pair_dup0 ((KRcFileKeyValuePair*) _tmp6_);
2145 pair = _tmp7_;
2146 _tmp8_ = pair;
2147 _tmp9_ = (*_tmp8_).key;
2148 if (g_strcmp0 (_tmp9_, key) == 0) {
2149 KRcFileKeyValuePair* _tmp10_;
2150 const gchar* _tmp11_;
2151 gchar* _tmp12_;
2152 _tmp10_ = pair;
2153 _tmp11_ = (*_tmp10_).value;
2154 _tmp12_ = g_strdup (_tmp11_);
2155 result = _tmp12_;
2156 _krc_file_key_value_pair_free0 (pair);
2157 return result;
2158 }
2159 _tmp13_ = tmp;
2160 _tmp14_ = _tmp13_->next;
2161 tmp = _tmp14_;
2162 _krc_file_key_value_pair_free0 (pair);
2163 }
2164 _tmp15_ = g_error_new (G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_KEY_NOT_FOUND, "Key file does not have key %s in group %s", key, group_name);
2165 _inner_error0_ = _tmp15_;
2166 if (_inner_error0_->domain == G_KEY_FILE_ERROR) {
2167 g_propagate_error (error, _inner_error0_);
2168 return NULL;
2169 } else {
2170 g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error0_->message, g_quark_to_string (_inner_error0_->domain), _inner_error0_->code);
2171 g_clear_error (&_inner_error0_);
2172 return NULL;
2173 }
2174 }
2175
2176 void
2177 krc_file_set_value (KRcFile* self,
2178 const gchar* group_name,
2179 const gchar* key,
2180 const gchar* value)
2181 {
2182 gint _tmp0_;
2183 gint _tmp1_;
2184 GList* group_node = NULL;
2185 GError* _inner_error0_ = NULL;
2186 g_return_if_fail (self != NULL);
2187 g_return_if_fail (group_name != NULL);
2188 g_return_if_fail (key != NULL);
2189 g_return_if_fail (value != NULL);
2190 g_return_if_fail (krc_file_is_group_name (self, group_name));
2191 _tmp0_ = strlen (key);
2192 _tmp1_ = _tmp0_;
2193 g_return_if_fail (krc_file_is_key_name (self, key, (gsize) _tmp1_));
2194 {
2195 GList* _tmp2_ = NULL;
2196 GList* _tmp3_;
2197 _tmp3_ = krc_file_get_group_node_with_name (self, group_name, FALSE, &_inner_error0_);
2198 _tmp2_ = _tmp3_;
2199 if (G_UNLIKELY (_inner_error0_ != NULL)) {
2200 if (_inner_error0_->domain == G_KEY_FILE_ERROR) {
2201 goto __catch0_g_key_file_error;
2202 }
2203 g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error0_->message, g_quark_to_string (_inner_error0_->domain), _inner_error0_->code);
2204 g_clear_error (&_inner_error0_);
2205 return;
2206 }
2207 group_node = _tmp2_;
2208 }
2209 goto __finally0;
2210 __catch0_g_key_file_error:
2211 {
2212 g_clear_error (&_inner_error0_);
2213 g_assert_not_reached ();
2214 }
2215 __finally0:
2216 if (G_UNLIKELY (_inner_error0_ != NULL)) {
2217 g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error0_->message, g_quark_to_string (_inner_error0_->domain), _inner_error0_->code);
2218 g_clear_error (&_inner_error0_);
2219 return;
2220 }
2221 if (group_node == NULL) {
2222 KRcFileGroup* last_group = NULL;
2223 GList* _tmp4_;
2224 gconstpointer _tmp5_;
2225 KRcFileGroup* _tmp6_;
2226 GList* _tmp7_;
2227 KRcFileGroup group = {0};
2228 gchar* _tmp12_;
2229 KRcFileGroup _tmp13_;
2230 KRcFileGroup _tmp14_;
2231 KRcFileGroup* _tmp15_;
2232 GList* _tmp16_;
2233 gconstpointer _tmp17_;
2234 KRcFileGroup* _tmp18_;
2235 _tmp4_ = self->priv->m_groups;
2236 _tmp5_ = _tmp4_->data;
2237 last_group = (KRcFileGroup*) _tmp5_;
2238 _tmp6_ = last_group;
2239 _tmp7_ = (*_tmp6_).key_value_pairs;
2240 if (_tmp7_ != NULL) {
2241 KRcFileGroup* _tmp8_;
2242 GList* _tmp9_;
2243 gconstpointer _tmp10_;
2244 const gchar* _tmp11_;
2245 _tmp8_ = last_group;
2246 _tmp9_ = (*_tmp8_).key_value_pairs;
2247 _tmp10_ = _tmp9_->data;
2248 _tmp11_ = (*((KRcFileKeyValuePair*) _tmp10_)).key;
2249 if (_tmp11_ != NULL) {
2250 krc_file_parse_comment (self, "", (glong) 0);
2251 }
2252 }
2253 memset (&group, 0, sizeof (KRcFileGroup));
2254 _tmp12_ = g_strdup (group_name);
2255 _g_free0 (group.name);
2256 group.name = _tmp12_;
2257 _tmp13_ = group;
2258 _tmp14_ = _tmp13_;
2259 _tmp15_ = _krc_file_group_dup0 (&_tmp14_);
2260 self->priv->m_groups = g_list_prepend (self->priv->m_groups, _tmp15_);
2261 _tmp16_ = self->priv->m_groups;
2262 _tmp17_ = _tmp16_->data;
2263 self->priv->m_current_group = (KRcFileGroup*) ((KRcFileGroup*) _tmp17_);
2264 _tmp18_ = self->priv->m_current_group;
2265 krc_file_add_key (self, _tmp18_, key, value);
2266 krc_file_group_destroy (&group);
2267 } else {
2268 GList* tmp = NULL;
2269 gconstpointer _tmp19_;
2270 GList* _tmp20_;
2271 GList* _tmp29_;
2272 _tmp19_ = group_node->data;
2273 _tmp20_ = (*((KRcFileGroup*) _tmp19_)).key_value_pairs;
2274 tmp = _tmp20_;
2275 while (TRUE) {
2276 GList* _tmp21_;
2277 KRcFileKeyValuePair* pair = NULL;
2278 GList* _tmp22_;
2279 gconstpointer _tmp23_;
2280 KRcFileKeyValuePair* _tmp24_;
2281 KRcFileKeyValuePair* _tmp25_;
2282 const gchar* _tmp26_;
2283 GList* _tmp27_;
2284 GList* _tmp28_;
2285 _tmp21_ = tmp;
2286 if (!(_tmp21_ != NULL)) {
2287 break;
2288 }
2289 _tmp22_ = tmp;
2290 _tmp23_ = _tmp22_->data;
2291 _tmp24_ = _krc_file_key_value_pair_dup0 ((KRcFileKeyValuePair*) _tmp23_);
2292 pair = _tmp24_;
2293 _tmp25_ = pair;
2294 _tmp26_ = (*_tmp25_).key;
2295 if (g_strcmp0 (_tmp26_, key) == 0) {
2296 _krc_file_key_value_pair_free0 (pair);
2297 break;
2298 }
2299 _tmp27_ = tmp;
2300 _tmp28_ = _tmp27_->next;
2301 tmp = _tmp28_;
2302 _krc_file_key_value_pair_free0 (pair);
2303 }
2304 _tmp29_ = tmp;
2305 if (_tmp29_ != NULL) {
2306 GList* _tmp30_;
2307 gconstpointer _tmp31_;
2308 gchar* _tmp32_;
2309 _tmp30_ = tmp;
2310 _tmp31_ = _tmp30_->data;
2311 _tmp32_ = g_strdup (value);
2312 _g_free0 ((*((KRcFileKeyValuePair*) _tmp31_)).value);
2313 (*((KRcFileKeyValuePair*) _tmp31_)).value = _tmp32_;
2314 } else {
2315 gconstpointer _tmp33_;
2316 _tmp33_ = group_node->data;
2317 krc_file_add_key (self, (KRcFileGroup*) _tmp33_, key, value);
2318 }
2319 }
2320 }
2321
2322 static void
2323 value_krc_file_init (GValue* value)
2324 {
2325 value->data[0].v_pointer = NULL;
2326 }
2327
2328 static void
2329 value_krc_file_free_value (GValue* value)
2330 {
2331 if (value->data[0].v_pointer) {
2332 krc_file_unref (value->data[0].v_pointer);
2333 }
2334 }
2335
2336 static void
2337 value_krc_file_copy_value (const GValue* src_value,
2338 GValue* dest_value)
2339 {
2340 if (src_value->data[0].v_pointer) {
2341 dest_value->data[0].v_pointer = krc_file_ref (src_value->data[0].v_pointer);
2342 } else {
2343 dest_value->data[0].v_pointer = NULL;
2344 }
2345 }
2346
2347 static gpointer
2348 value_krc_file_peek_pointer (const GValue* value)
2349 {
2350 return value->data[0].v_pointer;
2351 }
2352
2353 static gchar*
2354 value_krc_file_collect_value (GValue* value,
2355 guint n_collect_values,
2356 GTypeCValue* collect_values,
2357 guint collect_flags)
2358 {
2359 if (collect_values[0].v_pointer) {
2360 KRcFile * object;
2361 object = collect_values[0].v_pointer;
2362 if (object->parent_instance.g_class == NULL) {
2363 return g_strconcat ("invalid unclassed object pointer for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
2364 } else if (!g_value_type_compatible (G_TYPE_FROM_INSTANCE (object), G_VALUE_TYPE (value))) {
2365 return g_strconcat ("invalid object type `", g_type_name (G_TYPE_FROM_INSTANCE (object)), "' for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
2366 }
2367 value->data[0].v_pointer = krc_file_ref (object);
2368 } else {
2369 value->data[0].v_pointer = NULL;
2370 }
2371 return NULL;
2372 }
2373
2374 static gchar*
2375 value_krc_file_lcopy_value (const GValue* value,
2376 guint n_collect_values,
2377 GTypeCValue* collect_values,
2378 guint collect_flags)
2379 {
2380 KRcFile ** object_p;
2381 object_p = collect_values[0].v_pointer;
2382 if (!object_p) {
2383 return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));
2384 }
2385 if (!value->data[0].v_pointer) {
2386 *object_p = NULL;
2387 } else if (collect_flags & G_VALUE_NOCOPY_CONTENTS) {
2388 *object_p = value->data[0].v_pointer;
2389 } else {
2390 *object_p = krc_file_ref (value->data[0].v_pointer);
2391 }
2392 return NULL;
2393 }
2394
2395 GParamSpec*
2396 param_spec_krc_file (const gchar* name,
2397 const gchar* nick,
2398 const gchar* blurb,
2399 GType object_type,
2400 GParamFlags flags)
2401 {
2402 ParamSpecKRcFile* spec;
2403 g_return_val_if_fail (g_type_is_a (object_type, TYPE_KRC_FILE), NULL);
2404 spec = g_param_spec_internal (G_TYPE_PARAM_OBJECT, name, nick, blurb, flags);
2405 G_PARAM_SPEC (spec)->value_type = object_type;
2406 return G_PARAM_SPEC (spec);
2407 }
2408
2409 gpointer
2410 value_get_krc_file (const GValue* value)
2411 {
2412 g_return_val_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_KRC_FILE), NULL);
2413 return value->data[0].v_pointer;
2414 }
2415
2416 void
2417 value_set_krc_file (GValue* value,
2418 gpointer v_object)
2419 {
2420 KRcFile * old;
2421 g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_KRC_FILE));
2422 old = value->data[0].v_pointer;
2423 if (v_object) {
2424 g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, TYPE_KRC_FILE));
2425 g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
2426 value->data[0].v_pointer = v_object;
2427 krc_file_ref (value->data[0].v_pointer);
2428 } else {
2429 value->data[0].v_pointer = NULL;
2430 }
2431 if (old) {
2432 krc_file_unref (old);
2433 }
2434 }
2435
2436 void
2437 value_take_krc_file (GValue* value,
2438 gpointer v_object)
2439 {
2440 KRcFile * old;
2441 g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_KRC_FILE));
2442 old = value->data[0].v_pointer;
2443 if (v_object) {
2444 g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, TYPE_KRC_FILE));
2445 g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
2446 value->data[0].v_pointer = v_object;
2447 } else {
2448 value->data[0].v_pointer = NULL;
2449 }
2450 if (old) {
2451 krc_file_unref (old);
2452 }
2453 }
2454
2455 static void
2456 krc_file_class_init (KRcFileClass * klass,
2457 gpointer klass_data)
2458 {
2459 krc_file_parent_class = g_type_class_peek_parent (klass);
2460 ((KRcFileClass *) klass)->finalize = krc_file_finalize;
2461 g_type_class_adjust_private_offset (klass, &KRcFile_private_offset);
2462 }
2463
2464 static void
2465 krc_file_instance_init (KRcFile * self,
2466 gpointer klass)
2467 {
2468 self->priv = krc_file_get_instance_private (self);
2469 self->ref_count = 1;
2470 }
2471
2472 static void
2473 krc_file_finalize (KRcFile * obj)
2474 {
2475 KRcFile * self;
2476 self = G_TYPE_CHECK_INSTANCE_CAST (obj, TYPE_KRC_FILE, KRcFile);
2477 g_signal_handlers_destroy (self);
2478 (self->priv->m_groups == NULL) ? NULL : (self->priv->m_groups = (_g_list_free__krc_file_group_free0_ (self->priv->m_groups), NULL));
2479 }
2480
2481 static GType
2482 krc_file_get_type_once (void)
2483 {
2484 static const GTypeValueTable g_define_type_value_table = { value_krc_file_init, value_krc_file_free_value, value_krc_file_copy_value, value_krc_file_peek_pointer, "p", value_krc_file_collect_value, "p", value_krc_file_lcopy_value };
2485 static const GTypeInfo g_define_type_info = { sizeof (KRcFileClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) krc_file_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (KRcFile), 0, (GInstanceInitFunc) krc_file_instance_init, &g_define_type_value_table };
2486 static const GTypeFundamentalInfo g_define_type_fundamental_info = { (G_TYPE_FLAG_CLASSED | G_TYPE_FLAG_INSTANTIATABLE | G_TYPE_FLAG_DERIVABLE | G_TYPE_FLAG_DEEP_DERIVABLE) };
2487 GType krc_file_type_id;
2488 krc_file_type_id = g_type_register_fundamental (g_type_fundamental_next (), "KRcFile", &g_define_type_info, &g_define_type_fundamental_info, 0);
2489 KRcFile_private_offset = g_type_add_instance_private (krc_file_type_id, sizeof (KRcFilePrivate));
2490 return krc_file_type_id;
2491 }
2492
2493 GType
2494 krc_file_get_type (void)
2495 {
2496 static volatile gsize krc_file_type_id__once = 0;
2497 if (g_once_init_enter (&krc_file_type_id__once)) {
2498 GType krc_file_type_id;
2499 krc_file_type_id = krc_file_get_type_once ();
2500 g_once_init_leave (&krc_file_type_id__once, krc_file_type_id);
2501 }
2502 return krc_file_type_id__once;
2503 }
2504
2505 gpointer
2506 krc_file_ref (gpointer instance)
2507 {
2508 KRcFile * self;
2509 self = instance;
2510 g_atomic_int_inc (&self->ref_count);
2511 return instance;
2512 }
2513
2514 void
2515 krc_file_unref (gpointer instance)
2516 {
2517 KRcFile * self;
2518 self = instance;
2519 if (g_atomic_int_dec_and_test (&self->ref_count)) {
2520 KRC_FILE_GET_CLASS (self)->finalize (self);
2521 g_type_free_instance ((GTypeInstance *) self);
2522 }
2523 }
2524
2525 static void
2526 _vala_array_destroy (gpointer array,
2527 gssize array_length,
2528 GDestroyNotify destroy_func)
2529 {
2530 if ((array != NULL) && (destroy_func != NULL)) {
2531 gssize i;
2532 for (i = 0; i < array_length; i = i + 1) {
2533 if (((gpointer*) array)[i] != NULL) {
2534 destroy_func (((gpointer*) array)[i]);
2535 }
2536 }
2537 }
2538 }
2539
2540 static void
2541 _vala_array_free (gpointer array,
2542 gssize array_length,
2543 GDestroyNotify destroy_func)
2544 {
2545 _vala_array_destroy (array, array_length, destroy_func);
2546 g_free (array);
2547 }
2548