~ubuntu-branches/ubuntu/precise/d-conf/precise-proposed

« back to all changes in this revision

Viewing changes to editor/dconf-schema.c

  • Committer: Package Import Robot
  • Author(s): Sebastien Bacher
  • Date: 2011-12-07 22:08:10 UTC
  • mfrom: (1.1.14)
  • Revision ID: package-import@ubuntu.com-20111207220810-jjel2x75ci4vldds
Tags: 0.11.2-0ubuntu1
* New upstream version:
  - improved editor geometry handling (lp: #715002, #840571, #848418)

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
/* dconf-schema.c generated by valac 0.12.0, the Vala compiler
 
1
/* dconf-schema.c generated by valac 0.14.0, the Vala compiler
2
2
 * generated from dconf-schema.vala, do not modify */
3
3
 
4
4
 
420
420
SchemaKey* schema_key_construct_from_xml (GType object_type, xmlNode* node, Schema* schema, const gchar* gettext_domain) {
421
421
        SchemaKey* self = NULL;
422
422
        Schema* _tmp0_;
423
 
        gchar* _tmp1_;
 
423
        Schema* _tmp1_;
 
424
        const gchar* _tmp2_;
 
425
        gchar* _tmp3_;
424
426
        GError * _inner_error_ = NULL;
425
427
        g_return_val_if_fail (schema != NULL, NULL);
426
428
        self = (SchemaKey*) g_type_create_instance (object_type);
427
 
        _tmp0_ = _schema_ref0 (schema);
 
429
        _tmp0_ = schema;
 
430
        _tmp1_ = _schema_ref0 (_tmp0_);
428
431
        _schema_unref0 (self->schema);
429
 
        self->schema = _tmp0_;
430
 
        _tmp1_ = g_strdup (gettext_domain);
 
432
        self->schema = _tmp1_;
 
433
        _tmp2_ = gettext_domain;
 
434
        _tmp3_ = g_strdup (_tmp2_);
431
435
        _g_free0 (self->gettext_domain);
432
 
        self->gettext_domain = _tmp1_;
 
436
        self->gettext_domain = _tmp3_;
433
437
        {
 
438
                xmlNode* _tmp4_;
 
439
                xmlAttr* _tmp5_;
434
440
                xmlAttr* prop;
435
 
                prop = node->properties;
 
441
                _tmp4_ = node;
 
442
                _tmp5_ = _tmp4_->properties;
 
443
                prop = _tmp5_;
436
444
                {
437
 
                        gboolean _tmp2_;
438
 
                        _tmp2_ = TRUE;
 
445
                        gboolean _tmp6_;
 
446
                        _tmp6_ = TRUE;
439
447
                        while (TRUE) {
440
 
                                if (!_tmp2_) {
441
 
                                        prop = prop->next;
 
448
                                gboolean _tmp7_;
 
449
                                xmlAttr* _tmp10_;
 
450
                                xmlAttr* _tmp11_;
 
451
                                const gchar* _tmp12_;
 
452
                                _tmp7_ = _tmp6_;
 
453
                                if (!_tmp7_) {
 
454
                                        xmlAttr* _tmp8_;
 
455
                                        xmlAttr* _tmp9_;
 
456
                                        _tmp8_ = prop;
 
457
                                        _tmp9_ = _tmp8_->next;
 
458
                                        prop = _tmp9_;
442
459
                                }
443
 
                                _tmp2_ = FALSE;
444
 
                                if (!(prop != NULL)) {
 
460
                                _tmp6_ = FALSE;
 
461
                                _tmp10_ = prop;
 
462
                                if (!(_tmp10_ != NULL)) {
445
463
                                        break;
446
464
                                }
447
 
                                if (g_strcmp0 (prop->name, "name") == 0) {
448
 
                                        gchar* _tmp3_;
449
 
                                        _tmp3_ = g_strdup (prop->children->content);
 
465
                                _tmp11_ = prop;
 
466
                                _tmp12_ = _tmp11_->name;
 
467
                                if (g_strcmp0 (_tmp12_, "name") == 0) {
 
468
                                        xmlAttr* _tmp13_;
 
469
                                        xmlNode* _tmp14_;
 
470
                                        const gchar* _tmp15_;
 
471
                                        gchar* _tmp16_;
 
472
                                        _tmp13_ = prop;
 
473
                                        _tmp14_ = _tmp13_->children;
 
474
                                        _tmp15_ = _tmp14_->content;
 
475
                                        _tmp16_ = g_strdup (_tmp15_);
450
476
                                        _g_free0 (self->name);
451
 
                                        self->name = _tmp3_;
 
477
                                        self->name = _tmp16_;
452
478
                                } else {
453
 
                                        if (g_strcmp0 (prop->name, "type") == 0) {
454
 
                                                gchar* _tmp4_;
455
 
                                                _tmp4_ = g_strdup (prop->children->content);
 
479
                                        xmlAttr* _tmp17_;
 
480
                                        const gchar* _tmp18_;
 
481
                                        _tmp17_ = prop;
 
482
                                        _tmp18_ = _tmp17_->name;
 
483
                                        if (g_strcmp0 (_tmp18_, "type") == 0) {
 
484
                                                xmlAttr* _tmp19_;
 
485
                                                xmlNode* _tmp20_;
 
486
                                                const gchar* _tmp21_;
 
487
                                                gchar* _tmp22_;
 
488
                                                _tmp19_ = prop;
 
489
                                                _tmp20_ = _tmp19_->children;
 
490
                                                _tmp21_ = _tmp20_->content;
 
491
                                                _tmp22_ = g_strdup (_tmp21_);
456
492
                                                _g_free0 (self->type);
457
 
                                                self->type = _tmp4_;
 
493
                                                self->type = _tmp22_;
458
494
                                        } else {
459
 
                                                if (g_strcmp0 (prop->name, "enum") == 0) {
460
 
                                                        gchar* _tmp5_;
461
 
                                                        gchar* _tmp6_;
462
 
                                                        _tmp5_ = g_strdup ("s");
 
495
                                                xmlAttr* _tmp23_;
 
496
                                                const gchar* _tmp24_;
 
497
                                                _tmp23_ = prop;
 
498
                                                _tmp24_ = _tmp23_->name;
 
499
                                                if (g_strcmp0 (_tmp24_, "enum") == 0) {
 
500
                                                        gchar* _tmp25_;
 
501
                                                        xmlAttr* _tmp26_;
 
502
                                                        xmlNode* _tmp27_;
 
503
                                                        const gchar* _tmp28_;
 
504
                                                        gchar* _tmp29_;
 
505
                                                        _tmp25_ = g_strdup ("s");
463
506
                                                        _g_free0 (self->type);
464
 
                                                        self->type = _tmp5_;
465
 
                                                        _tmp6_ = g_strdup (prop->children->content);
 
507
                                                        self->type = _tmp25_;
 
508
                                                        _tmp26_ = prop;
 
509
                                                        _tmp27_ = _tmp26_->children;
 
510
                                                        _tmp28_ = _tmp27_->content;
 
511
                                                        _tmp29_ = g_strdup (_tmp28_);
466
512
                                                        _g_free0 (self->enum_name);
467
 
                                                        self->enum_name = _tmp6_;
 
513
                                                        self->enum_name = _tmp29_;
468
514
                                                } else {
469
 
                                                        if (g_strcmp0 (prop->name, "flags") == 0) {
470
 
                                                                gchar* _tmp7_;
471
 
                                                                _tmp7_ = g_strdup ("as");
 
515
                                                        xmlAttr* _tmp30_;
 
516
                                                        const gchar* _tmp31_;
 
517
                                                        _tmp30_ = prop;
 
518
                                                        _tmp31_ = _tmp30_->name;
 
519
                                                        if (g_strcmp0 (_tmp31_, "flags") == 0) {
 
520
                                                                gchar* _tmp32_;
 
521
                                                                _tmp32_ = g_strdup ("as");
472
522
                                                                _g_free0 (self->type);
473
 
                                                                self->type = _tmp7_;
 
523
                                                                self->type = _tmp32_;
474
524
                                                        } else {
475
 
                                                                g_warning ("dconf-schema.vala:35: Unknown property on <key>, %s", prop->name);
 
525
                                                                xmlAttr* _tmp33_;
 
526
                                                                const gchar* _tmp34_;
 
527
                                                                _tmp33_ = prop;
 
528
                                                                _tmp34_ = _tmp33_->name;
 
529
                                                                g_warning ("dconf-schema.vala:35: Unknown property on <key>, %s", _tmp34_);
476
530
                                                        }
477
531
                                                }
478
532
                                        }
481
535
                }
482
536
        }
483
537
        {
 
538
                xmlNode* _tmp35_;
 
539
                xmlNode* _tmp36_;
484
540
                xmlNode* child;
485
 
                child = node->children;
 
541
                _tmp35_ = node;
 
542
                _tmp36_ = _tmp35_->children;
 
543
                child = _tmp36_;
486
544
                {
487
 
                        gboolean _tmp8_;
488
 
                        _tmp8_ = TRUE;
 
545
                        gboolean _tmp37_;
 
546
                        _tmp37_ = TRUE;
489
547
                        while (TRUE) {
490
 
                                if (!_tmp8_) {
491
 
                                        child = child->next;
 
548
                                gboolean _tmp38_;
 
549
                                xmlNode* _tmp41_;
 
550
                                xmlNode* _tmp42_;
 
551
                                const gchar* _tmp43_;
 
552
                                _tmp38_ = _tmp37_;
 
553
                                if (!_tmp38_) {
 
554
                                        xmlNode* _tmp39_;
 
555
                                        xmlNode* _tmp40_;
 
556
                                        _tmp39_ = child;
 
557
                                        _tmp40_ = _tmp39_->next;
 
558
                                        child = _tmp40_;
492
559
                                }
493
 
                                _tmp8_ = FALSE;
494
 
                                if (!(child != NULL)) {
 
560
                                _tmp37_ = FALSE;
 
561
                                _tmp41_ = child;
 
562
                                if (!(_tmp41_ != NULL)) {
495
563
                                        break;
496
564
                                }
497
 
                                if (g_strcmp0 (child->name, "default") == 0) {
498
 
                                        GVariantType* _tmp9_ = NULL;
499
 
                                        GVariantType* _tmp10_;
500
 
                                        GVariant* _tmp11_ = NULL;
501
 
                                        GVariant* _tmp12_;
502
 
                                        GVariant* _tmp13_;
503
 
                                        _tmp9_ = g_variant_type_new (self->type);
504
 
                                        _tmp10_ = _tmp9_;
505
 
                                        _tmp11_ = g_variant_parse (_tmp10_, child->children->content, NULL, NULL, &_inner_error_);
506
 
                                        _tmp12_ = _tmp11_;
507
 
                                        _g_variant_type_free0 (_tmp10_);
508
 
                                        _tmp13_ = _tmp12_;
509
 
                                        if (_inner_error_ != NULL) {
510
 
                                                if (_inner_error_->domain == G_VARIANT_PARSE_ERROR) {
511
 
                                                        goto __catch4_g_variant_parse_error;
 
565
                                _tmp42_ = child;
 
566
                                _tmp43_ = _tmp42_->name;
 
567
                                if (g_strcmp0 (_tmp43_, "default") == 0) {
 
568
                                        {
 
569
                                                const gchar* _tmp44_;
 
570
                                                GVariantType* _tmp45_;
 
571
                                                GVariantType* _tmp46_;
 
572
                                                xmlNode* _tmp47_;
 
573
                                                xmlNode* _tmp48_;
 
574
                                                const gchar* _tmp49_;
 
575
                                                GVariant* _tmp50_ = NULL;
 
576
                                                GVariant* _tmp51_;
 
577
                                                GVariant* _tmp52_;
 
578
                                                _tmp44_ = self->type;
 
579
                                                _tmp45_ = g_variant_type_new (_tmp44_);
 
580
                                                _tmp46_ = _tmp45_;
 
581
                                                _tmp47_ = child;
 
582
                                                _tmp48_ = _tmp47_->children;
 
583
                                                _tmp49_ = _tmp48_->content;
 
584
                                                _tmp50_ = g_variant_parse (_tmp46_, _tmp49_, NULL, NULL, &_inner_error_);
 
585
                                                _tmp51_ = _tmp50_;
 
586
                                                _g_variant_type_free0 (_tmp46_);
 
587
                                                _tmp52_ = _tmp51_;
 
588
                                                if (_inner_error_ != NULL) {
 
589
                                                        if (_inner_error_->domain == G_VARIANT_PARSE_ERROR) {
 
590
                                                                goto __catch5_g_variant_parse_error;
 
591
                                                        }
 
592
                                                        g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
 
593
                                                        g_clear_error (&_inner_error_);
 
594
                                                        return NULL;
512
595
                                                }
513
 
                                                g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
514
 
                                                g_clear_error (&_inner_error_);
515
 
                                                return NULL;
 
596
                                                _g_variant_unref0 (self->default_value);
 
597
                                                self->default_value = _tmp52_;
516
598
                                        }
517
 
                                        _g_variant_unref0 (self->default_value);
518
 
                                        self->default_value = _tmp13_;
519
 
                                        goto __finally4;
520
 
                                        __catch4_g_variant_parse_error:
 
599
                                        goto __finally5;
 
600
                                        __catch5_g_variant_parse_error:
521
601
                                        {
522
 
                                                GError * e;
 
602
                                                GError* e = NULL;
523
603
                                                e = _inner_error_;
524
604
                                                _inner_error_ = NULL;
525
605
                                                _g_error_free0 (e);
526
606
                                        }
527
 
                                        __finally4:
 
607
                                        __finally5:
528
608
                                        if (_inner_error_ != NULL) {
529
609
                                                g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
530
610
                                                g_clear_error (&_inner_error_);
531
611
                                                return NULL;
532
612
                                        }
533
613
                                } else {
534
 
                                        if (g_strcmp0 (child->name, "summary") == 0) {
535
 
                                                const gchar* _tmp14_ = NULL;
536
 
                                                gchar* _tmp15_;
537
 
                                                if (child->children == NULL) {
538
 
                                                        _tmp14_ = "";
 
614
                                        xmlNode* _tmp53_;
 
615
                                        const gchar* _tmp54_;
 
616
                                        _tmp53_ = child;
 
617
                                        _tmp54_ = _tmp53_->name;
 
618
                                        if (g_strcmp0 (_tmp54_, "summary") == 0) {
 
619
                                                const gchar* _tmp55_ = NULL;
 
620
                                                xmlNode* _tmp56_;
 
621
                                                xmlNode* _tmp57_;
 
622
                                                const gchar* _tmp61_;
 
623
                                                gchar* _tmp62_;
 
624
                                                _tmp56_ = child;
 
625
                                                _tmp57_ = _tmp56_->children;
 
626
                                                if (_tmp57_ == NULL) {
 
627
                                                        _tmp55_ = "";
539
628
                                                } else {
540
 
                                                        _tmp14_ = child->children->content;
 
629
                                                        xmlNode* _tmp58_;
 
630
                                                        xmlNode* _tmp59_;
 
631
                                                        const gchar* _tmp60_;
 
632
                                                        _tmp58_ = child;
 
633
                                                        _tmp59_ = _tmp58_->children;
 
634
                                                        _tmp60_ = _tmp59_->content;
 
635
                                                        _tmp55_ = _tmp60_;
541
636
                                                }
542
 
                                                _tmp15_ = g_strdup (_tmp14_);
 
637
                                                _tmp61_ = _tmp55_;
 
638
                                                _tmp62_ = g_strdup (_tmp61_);
543
639
                                                _g_free0 (self->summary);
544
 
                                                self->summary = _tmp15_;
 
640
                                                self->summary = _tmp62_;
545
641
                                        } else {
546
 
                                                if (g_strcmp0 (child->name, "description") == 0) {
547
 
                                                        const gchar* _tmp16_ = NULL;
548
 
                                                        gchar* _tmp17_;
549
 
                                                        if (child->children == NULL) {
550
 
                                                                _tmp16_ = "";
 
642
                                                xmlNode* _tmp63_;
 
643
                                                const gchar* _tmp64_;
 
644
                                                _tmp63_ = child;
 
645
                                                _tmp64_ = _tmp63_->name;
 
646
                                                if (g_strcmp0 (_tmp64_, "description") == 0) {
 
647
                                                        const gchar* _tmp65_ = NULL;
 
648
                                                        xmlNode* _tmp66_;
 
649
                                                        xmlNode* _tmp67_;
 
650
                                                        const gchar* _tmp71_;
 
651
                                                        gchar* _tmp72_;
 
652
                                                        _tmp66_ = child;
 
653
                                                        _tmp67_ = _tmp66_->children;
 
654
                                                        if (_tmp67_ == NULL) {
 
655
                                                                _tmp65_ = "";
551
656
                                                        } else {
552
 
                                                                _tmp16_ = child->children->content;
 
657
                                                                xmlNode* _tmp68_;
 
658
                                                                xmlNode* _tmp69_;
 
659
                                                                const gchar* _tmp70_;
 
660
                                                                _tmp68_ = child;
 
661
                                                                _tmp69_ = _tmp68_->children;
 
662
                                                                _tmp70_ = _tmp69_->content;
 
663
                                                                _tmp65_ = _tmp70_;
553
664
                                                        }
554
 
                                                        _tmp17_ = g_strdup (_tmp16_);
 
665
                                                        _tmp71_ = _tmp65_;
 
666
                                                        _tmp72_ = g_strdup (_tmp71_);
555
667
                                                        _g_free0 (self->description);
556
 
                                                        self->description = _tmp17_;
 
668
                                                        self->description = _tmp72_;
557
669
                                                } else {
558
 
                                                        if (g_strcmp0 (child->name, "range") == 0) {
559
 
                                                                SchemaValueRange* _tmp18_ = NULL;
560
 
                                                                _tmp18_ = schema_value_range_new_from_xml (self->type, child);
 
670
                                                        xmlNode* _tmp73_;
 
671
                                                        const gchar* _tmp74_;
 
672
                                                        _tmp73_ = child;
 
673
                                                        _tmp74_ = _tmp73_->name;
 
674
                                                        if (g_strcmp0 (_tmp74_, "range") == 0) {
 
675
                                                                const gchar* _tmp75_;
 
676
                                                                xmlNode* _tmp76_;
 
677
                                                                SchemaValueRange* _tmp77_;
 
678
                                                                _tmp75_ = self->type;
 
679
                                                                _tmp76_ = child;
 
680
                                                                _tmp77_ = schema_value_range_new_from_xml (_tmp75_, _tmp76_);
561
681
                                                                _schema_value_range_unref0 (self->range);
562
 
                                                                self->range = _tmp18_;
 
682
                                                                self->range = _tmp77_;
563
683
                                                        } else {
564
 
                                                                if (g_strcmp0 (child->name, "choices") == 0) {
 
684
                                                                xmlNode* _tmp78_;
 
685
                                                                const gchar* _tmp79_;
 
686
                                                                _tmp78_ = child;
 
687
                                                                _tmp79_ = _tmp78_->name;
 
688
                                                                if (g_strcmp0 (_tmp79_, "choices") == 0) {
565
689
                                                                        {
 
690
                                                                                xmlNode* _tmp80_;
 
691
                                                                                xmlNode* _tmp81_;
566
692
                                                                                xmlNode* n;
567
 
                                                                                n = child->children;
 
693
                                                                                _tmp80_ = child;
 
694
                                                                                _tmp81_ = _tmp80_->children;
 
695
                                                                                n = _tmp81_;
568
696
                                                                                {
569
 
                                                                                        gboolean _tmp19_;
570
 
                                                                                        _tmp19_ = TRUE;
 
697
                                                                                        gboolean _tmp82_;
 
698
                                                                                        _tmp82_ = TRUE;
571
699
                                                                                        while (TRUE) {
 
700
                                                                                                gboolean _tmp83_;
 
701
                                                                                                xmlNode* _tmp86_;
 
702
                                                                                                xmlNode* _tmp87_;
 
703
                                                                                                xmlElementType _tmp88_;
 
704
                                                                                                xmlNode* _tmp89_;
 
705
                                                                                                const gchar* _tmp90_;
572
706
                                                                                                gchar* value;
 
707
                                                                                                const gchar* _tmp108_;
573
708
                                                                                                GVariant* v = NULL;
574
 
                                                                                                GVariant* _tmp22_ = NULL;
575
 
                                                                                                SchemaChoice* _tmp23_ = NULL;
576
 
                                                                                                if (!_tmp19_) {
577
 
                                                                                                        n = n->next;
 
709
                                                                                                _tmp83_ = _tmp82_;
 
710
                                                                                                if (!_tmp83_) {
 
711
                                                                                                        xmlNode* _tmp84_;
 
712
                                                                                                        xmlNode* _tmp85_;
 
713
                                                                                                        _tmp84_ = n;
 
714
                                                                                                        _tmp85_ = _tmp84_->next;
 
715
                                                                                                        n = _tmp85_;
578
716
                                                                                                }
579
 
                                                                                                _tmp19_ = FALSE;
580
 
                                                                                                if (!(n != NULL)) {
 
717
                                                                                                _tmp82_ = FALSE;
 
718
                                                                                                _tmp86_ = n;
 
719
                                                                                                if (!(_tmp86_ != NULL)) {
581
720
                                                                                                        break;
582
721
                                                                                                }
583
 
                                                                                                if (n->type != XML_ELEMENT_NODE) {
 
722
                                                                                                _tmp87_ = n;
 
723
                                                                                                _tmp88_ = _tmp87_->type;
 
724
                                                                                                if (_tmp88_ != XML_ELEMENT_NODE) {
584
725
                                                                                                        continue;
585
726
                                                                                                }
586
 
                                                                                                if (g_strcmp0 (n->name, "choice") != 0) {
587
 
                                                                                                        g_warning ("dconf-schema.vala:68: Unknown child tag in <choices>, <%s>", n->name);
 
727
                                                                                                _tmp89_ = n;
 
728
                                                                                                _tmp90_ = _tmp89_->name;
 
729
                                                                                                if (g_strcmp0 (_tmp90_, "choice") != 0) {
 
730
                                                                                                        xmlNode* _tmp91_;
 
731
                                                                                                        const gchar* _tmp92_;
 
732
                                                                                                        _tmp91_ = n;
 
733
                                                                                                        _tmp92_ = _tmp91_->name;
 
734
                                                                                                        g_warning ("dconf-schema.vala:68: Unknown child tag in <choices>, <%s>", _tmp92_);
588
735
                                                                                                        continue;
589
736
                                                                                                }
590
737
                                                                                                value = NULL;
591
738
                                                                                                {
 
739
                                                                                                        xmlNode* _tmp93_;
 
740
                                                                                                        xmlAttr* _tmp94_;
592
741
                                                                                                        xmlAttr* prop;
593
 
                                                                                                        prop = n->properties;
 
742
                                                                                                        _tmp93_ = n;
 
743
                                                                                                        _tmp94_ = _tmp93_->properties;
 
744
                                                                                                        prop = _tmp94_;
594
745
                                                                                                        {
595
 
                                                                                                                gboolean _tmp20_;
596
 
                                                                                                                _tmp20_ = TRUE;
 
746
                                                                                                                gboolean _tmp95_;
 
747
                                                                                                                _tmp95_ = TRUE;
597
748
                                                                                                                while (TRUE) {
598
 
                                                                                                                        if (!_tmp20_) {
599
 
                                                                                                                                prop = prop->next;
 
749
                                                                                                                        gboolean _tmp96_;
 
750
                                                                                                                        xmlAttr* _tmp99_;
 
751
                                                                                                                        xmlAttr* _tmp100_;
 
752
                                                                                                                        const gchar* _tmp101_;
 
753
                                                                                                                        _tmp96_ = _tmp95_;
 
754
                                                                                                                        if (!_tmp96_) {
 
755
                                                                                                                                xmlAttr* _tmp97_;
 
756
                                                                                                                                xmlAttr* _tmp98_;
 
757
                                                                                                                                _tmp97_ = prop;
 
758
                                                                                                                                _tmp98_ = _tmp97_->next;
 
759
                                                                                                                                prop = _tmp98_;
600
760
                                                                                                                        }
601
 
                                                                                                                        _tmp20_ = FALSE;
602
 
                                                                                                                        if (!(prop != NULL)) {
 
761
                                                                                                                        _tmp95_ = FALSE;
 
762
                                                                                                                        _tmp99_ = prop;
 
763
                                                                                                                        if (!(_tmp99_ != NULL)) {
603
764
                                                                                                                                break;
604
765
                                                                                                                        }
605
 
                                                                                                                        if (g_strcmp0 (prop->name, "value") == 0) {
606
 
                                                                                                                                gchar* _tmp21_;
607
 
                                                                                                                                _tmp21_ = g_strdup (prop->children->content);
 
766
                                                                                                                        _tmp100_ = prop;
 
767
                                                                                                                        _tmp101_ = _tmp100_->name;
 
768
                                                                                                                        if (g_strcmp0 (_tmp101_, "value") == 0) {
 
769
                                                                                                                                xmlAttr* _tmp102_;
 
770
                                                                                                                                xmlNode* _tmp103_;
 
771
                                                                                                                                const gchar* _tmp104_;
 
772
                                                                                                                                gchar* _tmp105_;
 
773
                                                                                                                                _tmp102_ = prop;
 
774
                                                                                                                                _tmp103_ = _tmp102_->children;
 
775
                                                                                                                                _tmp104_ = _tmp103_->content;
 
776
                                                                                                                                _tmp105_ = g_strdup (_tmp104_);
608
777
                                                                                                                                _g_free0 (value);
609
 
                                                                                                                                value = _tmp21_;
 
778
                                                                                                                                value = _tmp105_;
610
779
                                                                                                                        } else {
611
 
                                                                                                                                g_warning ("dconf-schema.vala:78: Unknown property on <choice>, %s", prop->name);
 
780
                                                                                                                                xmlAttr* _tmp106_;
 
781
                                                                                                                                const gchar* _tmp107_;
 
782
                                                                                                                                _tmp106_ = prop;
 
783
                                                                                                                                _tmp107_ = _tmp106_->name;
 
784
                                                                                                                                g_warning ("dconf-schema.vala:78: Unknown property on <choice>, %s", _tmp107_);
612
785
                                                                                                                        }
613
786
                                                                                                                }
614
787
                                                                                                        }
615
788
                                                                                                }
616
 
                                                                                                if (value == NULL) {
 
789
                                                                                                _tmp108_ = value;
 
790
                                                                                                if (_tmp108_ == NULL) {
617
791
                                                                                                        g_warning ("dconf-schema.vala:83: Ignoring <choice> with no value");
618
792
                                                                                                        _g_free0 (value);
619
793
                                                                                                        continue;
620
794
                                                                                                }
621
 
                                                                                                _tmp22_ = g_variant_new_string (value);
622
 
                                                                                                _g_variant_unref0 (v);
623
 
                                                                                                v = g_variant_ref_sink (_tmp22_);
624
 
                                                                                                _tmp23_ = schema_choice_new (value, v);
625
 
                                                                                                self->choices = g_list_append (self->choices, _tmp23_);
626
 
                                                                                                goto __finally5;
627
 
                                                                                                __catch5_g_variant_parse_error:
628
 
                                                                                                {
629
 
                                                                                                        GError * e;
 
795
                                                                                                {
 
796
                                                                                                        const gchar* _tmp109_;
 
797
                                                                                                        GVariant* _tmp110_;
 
798
                                                                                                        GVariant* _tmp111_;
 
799
                                                                                                        const gchar* _tmp112_;
 
800
                                                                                                        GVariant* _tmp113_;
 
801
                                                                                                        SchemaChoice* _tmp114_;
 
802
                                                                                                        _tmp109_ = value;
 
803
                                                                                                        _tmp110_ = g_variant_new_string (_tmp109_);
 
804
                                                                                                        _tmp111_ = g_variant_ref_sink (_tmp110_);
 
805
                                                                                                        _g_variant_unref0 (v);
 
806
                                                                                                        v = _tmp111_;
 
807
                                                                                                        _tmp112_ = value;
 
808
                                                                                                        _tmp113_ = v;
 
809
                                                                                                        _tmp114_ = schema_choice_new (_tmp112_, _tmp113_);
 
810
                                                                                                        self->choices = g_list_append (self->choices, _tmp114_);
 
811
                                                                                                }
 
812
                                                                                                goto __finally6;
 
813
                                                                                                __catch6_g_variant_parse_error:
 
814
                                                                                                {
 
815
                                                                                                        GError* e = NULL;
 
816
                                                                                                        const gchar* _tmp115_;
630
817
                                                                                                        e = _inner_error_;
631
818
                                                                                                        _inner_error_ = NULL;
632
 
                                                                                                        g_warning ("dconf-schema.vala:95: Invalid choice value '%s'", value);
 
819
                                                                                                        _tmp115_ = value;
 
820
                                                                                                        g_warning ("dconf-schema.vala:95: Invalid choice value '%s'", _tmp115_);
633
821
                                                                                                        _g_error_free0 (e);
634
822
                                                                                                }
635
 
                                                                                                __finally5:
 
823
                                                                                                __finally6:
636
824
                                                                                                if (_inner_error_ != NULL) {
637
825
                                                                                                        _g_variant_unref0 (v);
638
826
                                                                                                        _g_free0 (value);
646
834
                                                                                }
647
835
                                                                        }
648
836
                                                                } else {
649
 
                                                                        if (g_strcmp0 (child->name, "aliases") == 0) {
 
837
                                                                        xmlNode* _tmp116_;
 
838
                                                                        const gchar* _tmp117_;
 
839
                                                                        _tmp116_ = child;
 
840
                                                                        _tmp117_ = _tmp116_->name;
 
841
                                                                        if (g_strcmp0 (_tmp117_, "aliases") == 0) {
650
842
                                                                                {
 
843
                                                                                        xmlNode* _tmp118_;
 
844
                                                                                        xmlNode* _tmp119_;
651
845
                                                                                        xmlNode* n;
652
 
                                                                                        n = child->children;
 
846
                                                                                        _tmp118_ = child;
 
847
                                                                                        _tmp119_ = _tmp118_->children;
 
848
                                                                                        n = _tmp119_;
653
849
                                                                                        {
654
 
                                                                                                gboolean _tmp24_;
655
 
                                                                                                _tmp24_ = TRUE;
 
850
                                                                                                gboolean _tmp120_;
 
851
                                                                                                _tmp120_ = TRUE;
656
852
                                                                                                while (TRUE) {
 
853
                                                                                                        gboolean _tmp121_;
 
854
                                                                                                        xmlNode* _tmp124_;
 
855
                                                                                                        xmlNode* _tmp125_;
 
856
                                                                                                        xmlElementType _tmp126_;
 
857
                                                                                                        xmlNode* _tmp127_;
 
858
                                                                                                        const gchar* _tmp128_;
657
859
                                                                                                        gchar* value;
658
860
                                                                                                        gchar* target;
 
861
                                                                                                        const gchar* _tmp152_;
 
862
                                                                                                        const gchar* _tmp153_;
659
863
                                                                                                        GVariant* v = NULL;
660
 
                                                                                                        GVariant* _tmp28_ = NULL;
661
 
                                                                                                        SchemaChoice* _tmp29_ = NULL;
662
 
                                                                                                        if (!_tmp24_) {
663
 
                                                                                                                n = n->next;
 
864
                                                                                                        _tmp121_ = _tmp120_;
 
865
                                                                                                        if (!_tmp121_) {
 
866
                                                                                                                xmlNode* _tmp122_;
 
867
                                                                                                                xmlNode* _tmp123_;
 
868
                                                                                                                _tmp122_ = n;
 
869
                                                                                                                _tmp123_ = _tmp122_->next;
 
870
                                                                                                                n = _tmp123_;
664
871
                                                                                                        }
665
 
                                                                                                        _tmp24_ = FALSE;
666
 
                                                                                                        if (!(n != NULL)) {
 
872
                                                                                                        _tmp120_ = FALSE;
 
873
                                                                                                        _tmp124_ = n;
 
874
                                                                                                        if (!(_tmp124_ != NULL)) {
667
875
                                                                                                                break;
668
876
                                                                                                        }
669
 
                                                                                                        if (n->type != XML_ELEMENT_NODE) {
 
877
                                                                                                        _tmp125_ = n;
 
878
                                                                                                        _tmp126_ = _tmp125_->type;
 
879
                                                                                                        if (_tmp126_ != XML_ELEMENT_NODE) {
670
880
                                                                                                                continue;
671
881
                                                                                                        }
672
 
                                                                                                        if (g_strcmp0 (n->name, "alias") != 0) {
673
 
                                                                                                                g_warning ("dconf-schema.vala:107: Unknown child tag in <aliases>, <%s>", n->name);
 
882
                                                                                                        _tmp127_ = n;
 
883
                                                                                                        _tmp128_ = _tmp127_->name;
 
884
                                                                                                        if (g_strcmp0 (_tmp128_, "alias") != 0) {
 
885
                                                                                                                xmlNode* _tmp129_;
 
886
                                                                                                                const gchar* _tmp130_;
 
887
                                                                                                                _tmp129_ = n;
 
888
                                                                                                                _tmp130_ = _tmp129_->name;
 
889
                                                                                                                g_warning ("dconf-schema.vala:107: Unknown child tag in <aliases>, <%s>", _tmp130_);
674
890
                                                                                                                continue;
675
891
                                                                                                        }
676
892
                                                                                                        value = NULL;
677
893
                                                                                                        target = NULL;
678
894
                                                                                                        {
 
895
                                                                                                                xmlNode* _tmp131_;
 
896
                                                                                                                xmlAttr* _tmp132_;
679
897
                                                                                                                xmlAttr* prop;
680
 
                                                                                                                prop = n->properties;
 
898
                                                                                                                _tmp131_ = n;
 
899
                                                                                                                _tmp132_ = _tmp131_->properties;
 
900
                                                                                                                prop = _tmp132_;
681
901
                                                                                                                {
682
 
                                                                                                                        gboolean _tmp25_;
683
 
                                                                                                                        _tmp25_ = TRUE;
 
902
                                                                                                                        gboolean _tmp133_;
 
903
                                                                                                                        _tmp133_ = TRUE;
684
904
                                                                                                                        while (TRUE) {
685
 
                                                                                                                                if (!_tmp25_) {
686
 
                                                                                                                                        prop = prop->next;
 
905
                                                                                                                                gboolean _tmp134_;
 
906
                                                                                                                                xmlAttr* _tmp137_;
 
907
                                                                                                                                xmlAttr* _tmp138_;
 
908
                                                                                                                                const gchar* _tmp139_;
 
909
                                                                                                                                _tmp134_ = _tmp133_;
 
910
                                                                                                                                if (!_tmp134_) {
 
911
                                                                                                                                        xmlAttr* _tmp135_;
 
912
                                                                                                                                        xmlAttr* _tmp136_;
 
913
                                                                                                                                        _tmp135_ = prop;
 
914
                                                                                                                                        _tmp136_ = _tmp135_->next;
 
915
                                                                                                                                        prop = _tmp136_;
687
916
                                                                                                                                }
688
 
                                                                                                                                _tmp25_ = FALSE;
689
 
                                                                                                                                if (!(prop != NULL)) {
 
917
                                                                                                                                _tmp133_ = FALSE;
 
918
                                                                                                                                _tmp137_ = prop;
 
919
                                                                                                                                if (!(_tmp137_ != NULL)) {
690
920
                                                                                                                                        break;
691
921
                                                                                                                                }
692
 
                                                                                                                                if (g_strcmp0 (prop->name, "value") == 0) {
693
 
                                                                                                                                        gchar* _tmp26_;
694
 
                                                                                                                                        _tmp26_ = g_strdup (prop->children->content);
 
922
                                                                                                                                _tmp138_ = prop;
 
923
                                                                                                                                _tmp139_ = _tmp138_->name;
 
924
                                                                                                                                if (g_strcmp0 (_tmp139_, "value") == 0) {
 
925
                                                                                                                                        xmlAttr* _tmp140_;
 
926
                                                                                                                                        xmlNode* _tmp141_;
 
927
                                                                                                                                        const gchar* _tmp142_;
 
928
                                                                                                                                        gchar* _tmp143_;
 
929
                                                                                                                                        _tmp140_ = prop;
 
930
                                                                                                                                        _tmp141_ = _tmp140_->children;
 
931
                                                                                                                                        _tmp142_ = _tmp141_->content;
 
932
                                                                                                                                        _tmp143_ = g_strdup (_tmp142_);
695
933
                                                                                                                                        _g_free0 (value);
696
 
                                                                                                                                        value = _tmp26_;
 
934
                                                                                                                                        value = _tmp143_;
697
935
                                                                                                                                } else {
698
 
                                                                                                                                        if (g_strcmp0 (prop->name, "target") == 0) {
699
 
                                                                                                                                                gchar* _tmp27_;
700
 
                                                                                                                                                _tmp27_ = g_strdup (prop->children->content);
 
936
                                                                                                                                        xmlAttr* _tmp144_;
 
937
                                                                                                                                        const gchar* _tmp145_;
 
938
                                                                                                                                        _tmp144_ = prop;
 
939
                                                                                                                                        _tmp145_ = _tmp144_->name;
 
940
                                                                                                                                        if (g_strcmp0 (_tmp145_, "target") == 0) {
 
941
                                                                                                                                                xmlAttr* _tmp146_;
 
942
                                                                                                                                                xmlNode* _tmp147_;
 
943
                                                                                                                                                const gchar* _tmp148_;
 
944
                                                                                                                                                gchar* _tmp149_;
 
945
                                                                                                                                                _tmp146_ = prop;
 
946
                                                                                                                                                _tmp147_ = _tmp146_->children;
 
947
                                                                                                                                                _tmp148_ = _tmp147_->content;
 
948
                                                                                                                                                _tmp149_ = g_strdup (_tmp148_);
701
949
                                                                                                                                                _g_free0 (target);
702
 
                                                                                                                                                target = _tmp27_;
 
950
                                                                                                                                                target = _tmp149_;
703
951
                                                                                                                                        } else {
704
 
                                                                                                                                                g_warning ("dconf-schema.vala:119: Unknown property on <alias>, %s", prop->name);
 
952
                                                                                                                                                xmlAttr* _tmp150_;
 
953
                                                                                                                                                const gchar* _tmp151_;
 
954
                                                                                                                                                _tmp150_ = prop;
 
955
                                                                                                                                                _tmp151_ = _tmp150_->name;
 
956
                                                                                                                                                g_warning ("dconf-schema.vala:119: Unknown property on <alias>, %s", _tmp151_);
705
957
                                                                                                                                        }
706
958
                                                                                                                                }
707
959
                                                                                                                        }
708
960
                                                                                                                }
709
961
                                                                                                        }
710
 
                                                                                                        if (value == NULL) {
 
962
                                                                                                        _tmp152_ = value;
 
963
                                                                                                        if (_tmp152_ == NULL) {
711
964
                                                                                                                g_warning ("dconf-schema.vala:124: Ignoring <alias> with no value");
712
965
                                                                                                                _g_free0 (target);
713
966
                                                                                                                _g_free0 (value);
714
967
                                                                                                                continue;
715
968
                                                                                                        }
716
 
                                                                                                        if (target == NULL) {
 
969
                                                                                                        _tmp153_ = target;
 
970
                                                                                                        if (_tmp153_ == NULL) {
717
971
                                                                                                                g_warning ("dconf-schema.vala:129: Ignoring <alias> with no target");
718
972
                                                                                                                _g_free0 (target);
719
973
                                                                                                                _g_free0 (value);
720
974
                                                                                                                continue;
721
975
                                                                                                        }
722
 
                                                                                                        _tmp28_ = g_variant_new_string (target);
723
 
                                                                                                        _g_variant_unref0 (v);
724
 
                                                                                                        v = g_variant_ref_sink (_tmp28_);
725
 
                                                                                                        _tmp29_ = schema_choice_new (value, v);
726
 
                                                                                                        self->choices = g_list_append (self->choices, _tmp29_);
727
 
                                                                                                        goto __finally6;
728
 
                                                                                                        __catch6_g_variant_parse_error:
729
 
                                                                                                        {
730
 
                                                                                                                GError * e;
 
976
                                                                                                        {
 
977
                                                                                                                const gchar* _tmp154_;
 
978
                                                                                                                GVariant* _tmp155_;
 
979
                                                                                                                GVariant* _tmp156_;
 
980
                                                                                                                const gchar* _tmp157_;
 
981
                                                                                                                GVariant* _tmp158_;
 
982
                                                                                                                SchemaChoice* _tmp159_;
 
983
                                                                                                                _tmp154_ = target;
 
984
                                                                                                                _tmp155_ = g_variant_new_string (_tmp154_);
 
985
                                                                                                                _tmp156_ = g_variant_ref_sink (_tmp155_);
 
986
                                                                                                                _g_variant_unref0 (v);
 
987
                                                                                                                v = _tmp156_;
 
988
                                                                                                                _tmp157_ = value;
 
989
                                                                                                                _tmp158_ = v;
 
990
                                                                                                                _tmp159_ = schema_choice_new (_tmp157_, _tmp158_);
 
991
                                                                                                                self->choices = g_list_append (self->choices, _tmp159_);
 
992
                                                                                                        }
 
993
                                                                                                        goto __finally7;
 
994
                                                                                                        __catch7_g_variant_parse_error:
 
995
                                                                                                        {
 
996
                                                                                                                GError* e = NULL;
 
997
                                                                                                                const gchar* _tmp160_;
731
998
                                                                                                                e = _inner_error_;
732
999
                                                                                                                _inner_error_ = NULL;
733
 
                                                                                                                g_warning ("dconf-schema.vala:141: Invalid alias value '%s'", target);
 
1000
                                                                                                                _tmp160_ = target;
 
1001
                                                                                                                g_warning ("dconf-schema.vala:141: Invalid alias value '%s'", _tmp160_);
734
1002
                                                                                                                _g_error_free0 (e);
735
1003
                                                                                                        }
736
 
                                                                                                        __finally6:
 
1004
                                                                                                        __finally7:
737
1005
                                                                                                        if (_inner_error_ != NULL) {
738
1006
                                                                                                                _g_variant_unref0 (v);
739
1007
                                                                                                                _g_free0 (target);
749
1017
                                                                                        }
750
1018
                                                                                }
751
1019
                                                                        } else {
752
 
                                                                                gboolean _tmp30_ = FALSE;
753
 
                                                                                if (child->type != XML_TEXT_NODE) {
754
 
                                                                                        _tmp30_ = child->type != XML_COMMENT_NODE;
 
1020
                                                                                gboolean _tmp161_ = FALSE;
 
1021
                                                                                xmlNode* _tmp162_;
 
1022
                                                                                xmlElementType _tmp163_;
 
1023
                                                                                gboolean _tmp166_;
 
1024
                                                                                _tmp162_ = child;
 
1025
                                                                                _tmp163_ = _tmp162_->type;
 
1026
                                                                                if (_tmp163_ != XML_TEXT_NODE) {
 
1027
                                                                                        xmlNode* _tmp164_;
 
1028
                                                                                        xmlElementType _tmp165_;
 
1029
                                                                                        _tmp164_ = child;
 
1030
                                                                                        _tmp165_ = _tmp164_->type;
 
1031
                                                                                        _tmp161_ = _tmp165_ != XML_COMMENT_NODE;
755
1032
                                                                                } else {
756
 
                                                                                        _tmp30_ = FALSE;
 
1033
                                                                                        _tmp161_ = FALSE;
757
1034
                                                                                }
758
 
                                                                                if (_tmp30_) {
759
 
                                                                                        g_warning ("dconf-schema.vala:146: Unknown child tag in <key>, <%s>", child->name);
 
1035
                                                                                _tmp166_ = _tmp161_;
 
1036
                                                                                if (_tmp166_) {
 
1037
                                                                                        xmlNode* _tmp167_;
 
1038
                                                                                        const gchar* _tmp168_;
 
1039
                                                                                        _tmp167_ = child;
 
1040
                                                                                        _tmp168_ = _tmp167_->name;
 
1041
                                                                                        g_warning ("dconf-schema.vala:146: Unknown child tag in <key>, <%s>", _tmp168_);
760
1042
                                                                                }
761
1043
                                                                        }
762
1044
                                                                }
960
1242
 
961
1243
SchemaValue* schema_value_construct (GType object_type, guint index, const gchar* nick, gint value) {
962
1244
        SchemaValue * self = NULL;
963
 
        gchar* _tmp0_;
 
1245
        guint _tmp0_;
 
1246
        const gchar* _tmp1_;
 
1247
        gchar* _tmp2_;
 
1248
        gint _tmp3_;
964
1249
        g_return_val_if_fail (nick != NULL, NULL);
965
1250
        self = (SchemaValue*) g_object_new (object_type, NULL);
966
 
        self->index = index;
967
 
        _tmp0_ = g_strdup (nick);
 
1251
        _tmp0_ = index;
 
1252
        self->index = _tmp0_;
 
1253
        _tmp1_ = nick;
 
1254
        _tmp2_ = g_strdup (_tmp1_);
968
1255
        _g_free0 (self->nick);
969
 
        self->nick = _tmp0_;
970
 
        self->value = value;
 
1256
        self->nick = _tmp2_;
 
1257
        _tmp3_ = value;
 
1258
        self->value = _tmp3_;
971
1259
        return self;
972
1260
}
973
1261
 
1014
1302
 
1015
1303
SchemaChoice* schema_choice_construct (GType object_type, const gchar* name, GVariant* value) {
1016
1304
        SchemaChoice* self = NULL;
1017
 
        gchar* _tmp0_;
1018
 
        GVariant* _tmp1_;
 
1305
        const gchar* _tmp0_;
 
1306
        gchar* _tmp1_;
 
1307
        GVariant* _tmp2_;
 
1308
        GVariant* _tmp3_;
1019
1309
        g_return_val_if_fail (name != NULL, NULL);
1020
1310
        g_return_val_if_fail (value != NULL, NULL);
1021
1311
        self = (SchemaChoice*) g_type_create_instance (object_type);
1022
 
        _tmp0_ = g_strdup (name);
 
1312
        _tmp0_ = name;
 
1313
        _tmp1_ = g_strdup (_tmp0_);
1023
1314
        _g_free0 (self->name);
1024
 
        self->name = _tmp0_;
1025
 
        _tmp1_ = _g_variant_ref0 (value);
 
1315
        self->name = _tmp1_;
 
1316
        _tmp2_ = value;
 
1317
        _tmp3_ = _g_variant_ref0 (_tmp2_);
1026
1318
        _g_variant_unref0 (self->value);
1027
 
        self->value = _tmp1_;
 
1319
        self->value = _tmp3_;
1028
1320
        return self;
1029
1321
}
1030
1322
 
1201
1493
        g_return_val_if_fail (type != NULL, NULL);
1202
1494
        self = (SchemaValueRange*) g_type_create_instance (object_type);
1203
1495
        {
 
1496
                xmlNode* _tmp0_;
 
1497
                xmlAttr* _tmp1_;
1204
1498
                xmlAttr* prop;
1205
 
                prop = node->properties;
 
1499
                _tmp0_ = node;
 
1500
                _tmp1_ = _tmp0_->properties;
 
1501
                prop = _tmp1_;
1206
1502
                {
1207
 
                        gboolean _tmp0_;
1208
 
                        _tmp0_ = TRUE;
 
1503
                        gboolean _tmp2_;
 
1504
                        _tmp2_ = TRUE;
1209
1505
                        while (TRUE) {
1210
 
                                if (!_tmp0_) {
1211
 
                                        prop = prop->next;
 
1506
                                gboolean _tmp3_;
 
1507
                                xmlAttr* _tmp6_;
 
1508
                                xmlAttr* _tmp7_;
 
1509
                                const gchar* _tmp8_;
 
1510
                                _tmp3_ = _tmp2_;
 
1511
                                if (!_tmp3_) {
 
1512
                                        xmlAttr* _tmp4_;
 
1513
                                        xmlAttr* _tmp5_;
 
1514
                                        _tmp4_ = prop;
 
1515
                                        _tmp5_ = _tmp4_->next;
 
1516
                                        prop = _tmp5_;
1212
1517
                                }
1213
 
                                _tmp0_ = FALSE;
1214
 
                                if (!(prop != NULL)) {
 
1518
                                _tmp2_ = FALSE;
 
1519
                                _tmp6_ = prop;
 
1520
                                if (!(_tmp6_ != NULL)) {
1215
1521
                                        break;
1216
1522
                                }
1217
 
                                if (g_strcmp0 (prop->name, "min") == 0) {
1218
 
                                        GVariantType* _tmp1_ = NULL;
1219
 
                                        GVariantType* _tmp2_;
1220
 
                                        GVariant* _tmp3_ = NULL;
1221
 
                                        GVariant* _tmp4_;
1222
 
                                        GVariant* _tmp5_;
1223
 
                                        _tmp1_ = g_variant_type_new (type);
1224
 
                                        _tmp2_ = _tmp1_;
1225
 
                                        _tmp3_ = g_variant_parse (_tmp2_, prop->children->content, NULL, NULL, &_inner_error_);
1226
 
                                        _tmp4_ = _tmp3_;
1227
 
                                        _g_variant_type_free0 (_tmp2_);
1228
 
                                        _tmp5_ = _tmp4_;
1229
 
                                        if (_inner_error_ != NULL) {
1230
 
                                                if (_inner_error_->domain == G_VARIANT_PARSE_ERROR) {
1231
 
                                                        goto __catch7_g_variant_parse_error;
1232
 
                                                }
1233
 
                                                g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
1234
 
                                                g_clear_error (&_inner_error_);
1235
 
                                                return NULL;
1236
 
                                        }
1237
 
                                        _g_variant_unref0 (self->min);
1238
 
                                        self->min = _tmp5_;
1239
 
                                        goto __finally7;
1240
 
                                        __catch7_g_variant_parse_error:
 
1523
                                _tmp7_ = prop;
 
1524
                                _tmp8_ = _tmp7_->name;
 
1525
                                if (g_strcmp0 (_tmp8_, "min") == 0) {
1241
1526
                                        {
1242
 
                                                GError * e;
1243
 
                                                e = _inner_error_;
1244
 
                                                _inner_error_ = NULL;
1245
 
                                                _g_error_free0 (e);
1246
 
                                        }
1247
 
                                        __finally7:
1248
 
                                        if (_inner_error_ != NULL) {
1249
 
                                                g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
1250
 
                                                g_clear_error (&_inner_error_);
1251
 
                                                return NULL;
1252
 
                                        }
1253
 
                                } else {
1254
 
                                        if (g_strcmp0 (prop->name, "max") == 0) {
1255
 
                                                GVariantType* _tmp6_ = NULL;
1256
 
                                                GVariantType* _tmp7_;
1257
 
                                                GVariant* _tmp8_ = NULL;
1258
 
                                                GVariant* _tmp9_;
1259
 
                                                GVariant* _tmp10_;
1260
 
                                                _tmp6_ = g_variant_type_new (type);
1261
 
                                                _tmp7_ = _tmp6_;
1262
 
                                                _tmp8_ = g_variant_parse (_tmp7_, prop->children->content, NULL, NULL, &_inner_error_);
1263
 
                                                _tmp9_ = _tmp8_;
1264
 
                                                _g_variant_type_free0 (_tmp7_);
1265
 
                                                _tmp10_ = _tmp9_;
 
1527
                                                const gchar* _tmp9_;
 
1528
                                                GVariantType* _tmp10_;
 
1529
                                                GVariantType* _tmp11_;
 
1530
                                                xmlAttr* _tmp12_;
 
1531
                                                xmlNode* _tmp13_;
 
1532
                                                const gchar* _tmp14_;
 
1533
                                                GVariant* _tmp15_ = NULL;
 
1534
                                                GVariant* _tmp16_;
 
1535
                                                GVariant* _tmp17_;
 
1536
                                                _tmp9_ = type;
 
1537
                                                _tmp10_ = g_variant_type_new (_tmp9_);
 
1538
                                                _tmp11_ = _tmp10_;
 
1539
                                                _tmp12_ = prop;
 
1540
                                                _tmp13_ = _tmp12_->children;
 
1541
                                                _tmp14_ = _tmp13_->content;
 
1542
                                                _tmp15_ = g_variant_parse (_tmp11_, _tmp14_, NULL, NULL, &_inner_error_);
 
1543
                                                _tmp16_ = _tmp15_;
 
1544
                                                _g_variant_type_free0 (_tmp11_);
 
1545
                                                _tmp17_ = _tmp16_;
1266
1546
                                                if (_inner_error_ != NULL) {
1267
1547
                                                        if (_inner_error_->domain == G_VARIANT_PARSE_ERROR) {
1268
1548
                                                                goto __catch8_g_variant_parse_error;
1271
1551
                                                        g_clear_error (&_inner_error_);
1272
1552
                                                        return NULL;
1273
1553
                                                }
1274
 
                                                _g_variant_unref0 (self->max);
1275
 
                                                self->max = _tmp10_;
1276
 
                                                goto __finally8;
1277
 
                                                __catch8_g_variant_parse_error:
1278
 
                                                {
1279
 
                                                        GError * e;
 
1554
                                                _g_variant_unref0 (self->min);
 
1555
                                                self->min = _tmp17_;
 
1556
                                        }
 
1557
                                        goto __finally8;
 
1558
                                        __catch8_g_variant_parse_error:
 
1559
                                        {
 
1560
                                                GError* e = NULL;
 
1561
                                                e = _inner_error_;
 
1562
                                                _inner_error_ = NULL;
 
1563
                                                _g_error_free0 (e);
 
1564
                                        }
 
1565
                                        __finally8:
 
1566
                                        if (_inner_error_ != NULL) {
 
1567
                                                g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
 
1568
                                                g_clear_error (&_inner_error_);
 
1569
                                                return NULL;
 
1570
                                        }
 
1571
                                } else {
 
1572
                                        xmlAttr* _tmp18_;
 
1573
                                        const gchar* _tmp19_;
 
1574
                                        _tmp18_ = prop;
 
1575
                                        _tmp19_ = _tmp18_->name;
 
1576
                                        if (g_strcmp0 (_tmp19_, "max") == 0) {
 
1577
                                                {
 
1578
                                                        const gchar* _tmp20_;
 
1579
                                                        GVariantType* _tmp21_;
 
1580
                                                        GVariantType* _tmp22_;
 
1581
                                                        xmlAttr* _tmp23_;
 
1582
                                                        xmlNode* _tmp24_;
 
1583
                                                        const gchar* _tmp25_;
 
1584
                                                        GVariant* _tmp26_ = NULL;
 
1585
                                                        GVariant* _tmp27_;
 
1586
                                                        GVariant* _tmp28_;
 
1587
                                                        _tmp20_ = type;
 
1588
                                                        _tmp21_ = g_variant_type_new (_tmp20_);
 
1589
                                                        _tmp22_ = _tmp21_;
 
1590
                                                        _tmp23_ = prop;
 
1591
                                                        _tmp24_ = _tmp23_->children;
 
1592
                                                        _tmp25_ = _tmp24_->content;
 
1593
                                                        _tmp26_ = g_variant_parse (_tmp22_, _tmp25_, NULL, NULL, &_inner_error_);
 
1594
                                                        _tmp27_ = _tmp26_;
 
1595
                                                        _g_variant_type_free0 (_tmp22_);
 
1596
                                                        _tmp28_ = _tmp27_;
 
1597
                                                        if (_inner_error_ != NULL) {
 
1598
                                                                if (_inner_error_->domain == G_VARIANT_PARSE_ERROR) {
 
1599
                                                                        goto __catch9_g_variant_parse_error;
 
1600
                                                                }
 
1601
                                                                g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
 
1602
                                                                g_clear_error (&_inner_error_);
 
1603
                                                                return NULL;
 
1604
                                                        }
 
1605
                                                        _g_variant_unref0 (self->max);
 
1606
                                                        self->max = _tmp28_;
 
1607
                                                }
 
1608
                                                goto __finally9;
 
1609
                                                __catch9_g_variant_parse_error:
 
1610
                                                {
 
1611
                                                        GError* e = NULL;
1280
1612
                                                        e = _inner_error_;
1281
1613
                                                        _inner_error_ = NULL;
1282
1614
                                                        _g_error_free0 (e);
1283
1615
                                                }
1284
 
                                                __finally8:
 
1616
                                                __finally9:
1285
1617
                                                if (_inner_error_ != NULL) {
1286
1618
                                                        g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
1287
1619
                                                        g_clear_error (&_inner_error_);
1288
1620
                                                        return NULL;
1289
1621
                                                }
1290
1622
                                        } else {
1291
 
                                                g_warning ("dconf-schema.vala:212: Unknown property in <range>, %s", prop->name);
 
1623
                                                xmlAttr* _tmp29_;
 
1624
                                                const gchar* _tmp30_;
 
1625
                                                _tmp29_ = prop;
 
1626
                                                _tmp30_ = _tmp29_->name;
 
1627
                                                g_warning ("dconf-schema.vala:212: Unknown property in <range>, %s", _tmp30_);
1292
1628
                                        }
1293
1629
                                }
1294
1630
                        }
1500
1836
SchemaEnum* schema_enum_construct_from_xml (GType object_type, SchemaList* list, xmlNode* node) {
1501
1837
        SchemaEnum* self = NULL;
1502
1838
        SchemaList* _tmp0_;
 
1839
        SchemaList* _tmp1_;
1503
1840
        g_return_val_if_fail (list != NULL, NULL);
1504
1841
        self = (SchemaEnum*) g_type_create_instance (object_type);
1505
 
        _tmp0_ = _schema_list_ref0 (list);
 
1842
        _tmp0_ = list;
 
1843
        _tmp1_ = _schema_list_ref0 (_tmp0_);
1506
1844
        _schema_list_unref0 (self->list);
1507
 
        self->list = _tmp0_;
 
1845
        self->list = _tmp1_;
1508
1846
        {
 
1847
                xmlNode* _tmp2_;
 
1848
                xmlAttr* _tmp3_;
1509
1849
                xmlAttr* prop;
1510
 
                prop = node->properties;
 
1850
                _tmp2_ = node;
 
1851
                _tmp3_ = _tmp2_->properties;
 
1852
                prop = _tmp3_;
1511
1853
                {
1512
 
                        gboolean _tmp1_;
1513
 
                        _tmp1_ = TRUE;
 
1854
                        gboolean _tmp4_;
 
1855
                        _tmp4_ = TRUE;
1514
1856
                        while (TRUE) {
1515
 
                                if (!_tmp1_) {
1516
 
                                        prop = prop->next;
 
1857
                                gboolean _tmp5_;
 
1858
                                xmlAttr* _tmp8_;
 
1859
                                xmlAttr* _tmp9_;
 
1860
                                const gchar* _tmp10_;
 
1861
                                _tmp5_ = _tmp4_;
 
1862
                                if (!_tmp5_) {
 
1863
                                        xmlAttr* _tmp6_;
 
1864
                                        xmlAttr* _tmp7_;
 
1865
                                        _tmp6_ = prop;
 
1866
                                        _tmp7_ = _tmp6_->next;
 
1867
                                        prop = _tmp7_;
1517
1868
                                }
1518
 
                                _tmp1_ = FALSE;
1519
 
                                if (!(prop != NULL)) {
 
1869
                                _tmp4_ = FALSE;
 
1870
                                _tmp8_ = prop;
 
1871
                                if (!(_tmp8_ != NULL)) {
1520
1872
                                        break;
1521
1873
                                }
1522
 
                                if (g_strcmp0 (prop->name, "id") == 0) {
1523
 
                                        gchar* _tmp2_;
1524
 
                                        _tmp2_ = g_strdup (prop->children->content);
 
1874
                                _tmp9_ = prop;
 
1875
                                _tmp10_ = _tmp9_->name;
 
1876
                                if (g_strcmp0 (_tmp10_, "id") == 0) {
 
1877
                                        xmlAttr* _tmp11_;
 
1878
                                        xmlNode* _tmp12_;
 
1879
                                        const gchar* _tmp13_;
 
1880
                                        gchar* _tmp14_;
 
1881
                                        _tmp11_ = prop;
 
1882
                                        _tmp12_ = _tmp11_->children;
 
1883
                                        _tmp13_ = _tmp12_->content;
 
1884
                                        _tmp14_ = g_strdup (_tmp13_);
1525
1885
                                        _g_free0 (self->id);
1526
 
                                        self->id = _tmp2_;
 
1886
                                        self->id = _tmp14_;
1527
1887
                                } else {
1528
 
                                        g_warning ("dconf-schema.vala:235: Unknown property in <enum>, %s", prop->name);
 
1888
                                        xmlAttr* _tmp15_;
 
1889
                                        const gchar* _tmp16_;
 
1890
                                        _tmp15_ = prop;
 
1891
                                        _tmp16_ = _tmp15_->name;
 
1892
                                        g_warning ("dconf-schema.vala:235: Unknown property in <enum>, %s", _tmp16_);
1529
1893
                                }
1530
1894
                        }
1531
1895
                }
1532
1896
        }
1533
1897
        {
 
1898
                xmlNode* _tmp17_;
 
1899
                xmlNode* _tmp18_;
1534
1900
                xmlNode* child;
1535
 
                child = node->children;
 
1901
                _tmp17_ = node;
 
1902
                _tmp18_ = _tmp17_->children;
 
1903
                child = _tmp18_;
1536
1904
                {
1537
 
                        gboolean _tmp3_;
1538
 
                        _tmp3_ = TRUE;
 
1905
                        gboolean _tmp19_;
 
1906
                        _tmp19_ = TRUE;
1539
1907
                        while (TRUE) {
1540
 
                                if (!_tmp3_) {
1541
 
                                        child = child->next;
 
1908
                                gboolean _tmp20_;
 
1909
                                xmlNode* _tmp23_;
 
1910
                                xmlNode* _tmp24_;
 
1911
                                const gchar* _tmp25_;
 
1912
                                _tmp20_ = _tmp19_;
 
1913
                                if (!_tmp20_) {
 
1914
                                        xmlNode* _tmp21_;
 
1915
                                        xmlNode* _tmp22_;
 
1916
                                        _tmp21_ = child;
 
1917
                                        _tmp22_ = _tmp21_->next;
 
1918
                                        child = _tmp22_;
1542
1919
                                }
1543
 
                                _tmp3_ = FALSE;
1544
 
                                if (!(child != NULL)) {
 
1920
                                _tmp19_ = FALSE;
 
1921
                                _tmp23_ = child;
 
1922
                                if (!(_tmp23_ != NULL)) {
1545
1923
                                        break;
1546
1924
                                }
1547
 
                                if (g_strcmp0 (child->name, "value") == 0) {
 
1925
                                _tmp24_ = child;
 
1926
                                _tmp25_ = _tmp24_->name;
 
1927
                                if (g_strcmp0 (_tmp25_, "value") == 0) {
1548
1928
                                        gchar* nick;
1549
1929
                                        gint value;
1550
 
                                        guint _tmp7_;
1551
 
                                        SchemaValue* _tmp8_ = NULL;
 
1930
                                        GList* _tmp47_;
 
1931
                                        guint _tmp48_ = 0U;
 
1932
                                        const gchar* _tmp49_;
 
1933
                                        gint _tmp50_;
 
1934
                                        SchemaValue* _tmp51_;
1552
1935
                                        SchemaValue* schema_value;
1553
 
                                        SchemaValue* _tmp9_;
 
1936
                                        SchemaValue* _tmp52_;
 
1937
                                        SchemaValue* _tmp53_;
1554
1938
                                        nick = NULL;
1555
1939
                                        value = -1;
1556
1940
                                        {
 
1941
                                                xmlNode* _tmp26_;
 
1942
                                                xmlAttr* _tmp27_;
1557
1943
                                                xmlAttr* prop;
1558
 
                                                prop = child->properties;
 
1944
                                                _tmp26_ = child;
 
1945
                                                _tmp27_ = _tmp26_->properties;
 
1946
                                                prop = _tmp27_;
1559
1947
                                                {
1560
 
                                                        gboolean _tmp4_;
1561
 
                                                        _tmp4_ = TRUE;
 
1948
                                                        gboolean _tmp28_;
 
1949
                                                        _tmp28_ = TRUE;
1562
1950
                                                        while (TRUE) {
1563
 
                                                                if (!_tmp4_) {
1564
 
                                                                        prop = prop->next;
 
1951
                                                                gboolean _tmp29_;
 
1952
                                                                xmlAttr* _tmp32_;
 
1953
                                                                xmlAttr* _tmp33_;
 
1954
                                                                const gchar* _tmp34_;
 
1955
                                                                _tmp29_ = _tmp28_;
 
1956
                                                                if (!_tmp29_) {
 
1957
                                                                        xmlAttr* _tmp30_;
 
1958
                                                                        xmlAttr* _tmp31_;
 
1959
                                                                        _tmp30_ = prop;
 
1960
                                                                        _tmp31_ = _tmp30_->next;
 
1961
                                                                        prop = _tmp31_;
1565
1962
                                                                }
1566
 
                                                                _tmp4_ = FALSE;
1567
 
                                                                if (!(prop != NULL)) {
 
1963
                                                                _tmp28_ = FALSE;
 
1964
                                                                _tmp32_ = prop;
 
1965
                                                                if (!(_tmp32_ != NULL)) {
1568
1966
                                                                        break;
1569
1967
                                                                }
1570
 
                                                                if (g_strcmp0 (prop->name, "value") == 0) {
1571
 
                                                                        gint _tmp5_;
1572
 
                                                                        _tmp5_ = atoi (prop->children->content);
1573
 
                                                                        value = _tmp5_;
 
1968
                                                                _tmp33_ = prop;
 
1969
                                                                _tmp34_ = _tmp33_->name;
 
1970
                                                                if (g_strcmp0 (_tmp34_, "value") == 0) {
 
1971
                                                                        xmlAttr* _tmp35_;
 
1972
                                                                        xmlNode* _tmp36_;
 
1973
                                                                        const gchar* _tmp37_;
 
1974
                                                                        gint _tmp38_ = 0;
 
1975
                                                                        _tmp35_ = prop;
 
1976
                                                                        _tmp36_ = _tmp35_->children;
 
1977
                                                                        _tmp37_ = _tmp36_->content;
 
1978
                                                                        _tmp38_ = atoi (_tmp37_);
 
1979
                                                                        value = _tmp38_;
1574
1980
                                                                } else {
1575
 
                                                                        if (g_strcmp0 (prop->name, "nick") == 0) {
1576
 
                                                                                gchar* _tmp6_;
1577
 
                                                                                _tmp6_ = g_strdup (prop->children->content);
 
1981
                                                                        xmlAttr* _tmp39_;
 
1982
                                                                        const gchar* _tmp40_;
 
1983
                                                                        _tmp39_ = prop;
 
1984
                                                                        _tmp40_ = _tmp39_->name;
 
1985
                                                                        if (g_strcmp0 (_tmp40_, "nick") == 0) {
 
1986
                                                                                xmlAttr* _tmp41_;
 
1987
                                                                                xmlNode* _tmp42_;
 
1988
                                                                                const gchar* _tmp43_;
 
1989
                                                                                gchar* _tmp44_;
 
1990
                                                                                _tmp41_ = prop;
 
1991
                                                                                _tmp42_ = _tmp41_->children;
 
1992
                                                                                _tmp43_ = _tmp42_->content;
 
1993
                                                                                _tmp44_ = g_strdup (_tmp43_);
1578
1994
                                                                                _g_free0 (nick);
1579
 
                                                                                nick = _tmp6_;
 
1995
                                                                                nick = _tmp44_;
1580
1996
                                                                        } else {
1581
 
                                                                                g_warning ("dconf-schema.vala:255: Unknown property in enum <value>, %s", prop->name);
 
1997
                                                                                xmlAttr* _tmp45_;
 
1998
                                                                                const gchar* _tmp46_;
 
1999
                                                                                _tmp45_ = prop;
 
2000
                                                                                _tmp46_ = _tmp45_->name;
 
2001
                                                                                g_warning ("dconf-schema.vala:255: Unknown property in enum <value>, %s", _tmp46_);
1582
2002
                                                                        }
1583
2003
                                                                }
1584
2004
                                                        }
1585
2005
                                                }
1586
2006
                                        }
1587
 
                                        _tmp7_ = g_list_length (self->values);
1588
 
                                        _tmp8_ = schema_value_new (_tmp7_, nick, value);
1589
 
                                        schema_value = _tmp8_;
1590
 
                                        _tmp9_ = _g_object_ref0 (schema_value);
1591
 
                                        self->values = g_list_append (self->values, _tmp9_);
 
2007
                                        _tmp47_ = self->values;
 
2008
                                        _tmp48_ = g_list_length (_tmp47_);
 
2009
                                        _tmp49_ = nick;
 
2010
                                        _tmp50_ = value;
 
2011
                                        _tmp51_ = schema_value_new (_tmp48_, _tmp49_, _tmp50_);
 
2012
                                        schema_value = _tmp51_;
 
2013
                                        _tmp52_ = schema_value;
 
2014
                                        _tmp53_ = _g_object_ref0 (_tmp52_);
 
2015
                                        self->values = g_list_append (self->values, _tmp53_);
1592
2016
                                        _g_object_unref0 (schema_value);
1593
2017
                                        _g_free0 (nick);
1594
2018
                                } else {
1595
 
                                        gboolean _tmp10_ = FALSE;
1596
 
                                        if (child->type != XML_TEXT_NODE) {
1597
 
                                                _tmp10_ = child->type != XML_COMMENT_NODE;
 
2019
                                        gboolean _tmp54_ = FALSE;
 
2020
                                        xmlNode* _tmp55_;
 
2021
                                        xmlElementType _tmp56_;
 
2022
                                        gboolean _tmp59_;
 
2023
                                        _tmp55_ = child;
 
2024
                                        _tmp56_ = _tmp55_->type;
 
2025
                                        if (_tmp56_ != XML_TEXT_NODE) {
 
2026
                                                xmlNode* _tmp57_;
 
2027
                                                xmlElementType _tmp58_;
 
2028
                                                _tmp57_ = child;
 
2029
                                                _tmp58_ = _tmp57_->type;
 
2030
                                                _tmp54_ = _tmp58_ != XML_COMMENT_NODE;
1598
2031
                                        } else {
1599
 
                                                _tmp10_ = FALSE;
 
2032
                                                _tmp54_ = FALSE;
1600
2033
                                        }
1601
 
                                        if (_tmp10_) {
1602
 
                                                g_warning ("dconf-schema.vala:265: Unknown tag in <enum>, <%s>", child->name);
 
2034
                                        _tmp59_ = _tmp54_;
 
2035
                                        if (_tmp59_) {
 
2036
                                                xmlNode* _tmp60_;
 
2037
                                                const gchar* _tmp61_;
 
2038
                                                _tmp60_ = child;
 
2039
                                                _tmp61_ = _tmp60_->name;
 
2040
                                                g_warning ("dconf-schema.vala:265: Unknown tag in <enum>, <%s>", _tmp61_);
1603
2041
                                        }
1604
2042
                                }
1605
2043
                        }
1792
2230
SchemaFlags* schema_flags_construct_from_xml (GType object_type, SchemaList* list, xmlNode* node) {
1793
2231
        SchemaFlags* self = NULL;
1794
2232
        SchemaList* _tmp0_;
 
2233
        SchemaList* _tmp1_;
1795
2234
        g_return_val_if_fail (list != NULL, NULL);
1796
2235
        self = (SchemaFlags*) g_type_create_instance (object_type);
1797
 
        _tmp0_ = _schema_list_ref0 (list);
 
2236
        _tmp0_ = list;
 
2237
        _tmp1_ = _schema_list_ref0 (_tmp0_);
1798
2238
        _schema_list_unref0 (self->list);
1799
 
        self->list = _tmp0_;
 
2239
        self->list = _tmp1_;
1800
2240
        {
 
2241
                xmlNode* _tmp2_;
 
2242
                xmlAttr* _tmp3_;
1801
2243
                xmlAttr* prop;
1802
 
                prop = node->properties;
 
2244
                _tmp2_ = node;
 
2245
                _tmp3_ = _tmp2_->properties;
 
2246
                prop = _tmp3_;
1803
2247
                {
1804
 
                        gboolean _tmp1_;
1805
 
                        _tmp1_ = TRUE;
 
2248
                        gboolean _tmp4_;
 
2249
                        _tmp4_ = TRUE;
1806
2250
                        while (TRUE) {
1807
 
                                if (!_tmp1_) {
1808
 
                                        prop = prop->next;
 
2251
                                gboolean _tmp5_;
 
2252
                                xmlAttr* _tmp8_;
 
2253
                                xmlAttr* _tmp9_;
 
2254
                                const gchar* _tmp10_;
 
2255
                                _tmp5_ = _tmp4_;
 
2256
                                if (!_tmp5_) {
 
2257
                                        xmlAttr* _tmp6_;
 
2258
                                        xmlAttr* _tmp7_;
 
2259
                                        _tmp6_ = prop;
 
2260
                                        _tmp7_ = _tmp6_->next;
 
2261
                                        prop = _tmp7_;
1809
2262
                                }
1810
 
                                _tmp1_ = FALSE;
1811
 
                                if (!(prop != NULL)) {
 
2263
                                _tmp4_ = FALSE;
 
2264
                                _tmp8_ = prop;
 
2265
                                if (!(_tmp8_ != NULL)) {
1812
2266
                                        break;
1813
2267
                                }
1814
 
                                if (g_strcmp0 (prop->name, "id") == 0) {
1815
 
                                        gchar* _tmp2_;
1816
 
                                        _tmp2_ = g_strdup (prop->children->content);
 
2268
                                _tmp9_ = prop;
 
2269
                                _tmp10_ = _tmp9_->name;
 
2270
                                if (g_strcmp0 (_tmp10_, "id") == 0) {
 
2271
                                        xmlAttr* _tmp11_;
 
2272
                                        xmlNode* _tmp12_;
 
2273
                                        const gchar* _tmp13_;
 
2274
                                        gchar* _tmp14_;
 
2275
                                        _tmp11_ = prop;
 
2276
                                        _tmp12_ = _tmp11_->children;
 
2277
                                        _tmp13_ = _tmp12_->content;
 
2278
                                        _tmp14_ = g_strdup (_tmp13_);
1817
2279
                                        _g_free0 (self->id);
1818
 
                                        self->id = _tmp2_;
 
2280
                                        self->id = _tmp14_;
1819
2281
                                } else {
1820
 
                                        g_warning ("dconf-schema.vala:288: Unknown property in <flags>, %s", prop->name);
 
2282
                                        xmlAttr* _tmp15_;
 
2283
                                        const gchar* _tmp16_;
 
2284
                                        _tmp15_ = prop;
 
2285
                                        _tmp16_ = _tmp15_->name;
 
2286
                                        g_warning ("dconf-schema.vala:288: Unknown property in <flags>, %s", _tmp16_);
1821
2287
                                }
1822
2288
                        }
1823
2289
                }
1824
2290
        }
1825
2291
        {
 
2292
                xmlNode* _tmp17_;
 
2293
                xmlNode* _tmp18_;
1826
2294
                xmlNode* child;
1827
 
                child = node->children;
 
2295
                _tmp17_ = node;
 
2296
                _tmp18_ = _tmp17_->children;
 
2297
                child = _tmp18_;
1828
2298
                {
1829
 
                        gboolean _tmp3_;
1830
 
                        _tmp3_ = TRUE;
 
2299
                        gboolean _tmp19_;
 
2300
                        _tmp19_ = TRUE;
1831
2301
                        while (TRUE) {
1832
 
                                if (!_tmp3_) {
1833
 
                                        child = child->next;
 
2302
                                gboolean _tmp20_;
 
2303
                                xmlNode* _tmp23_;
 
2304
                                xmlNode* _tmp24_;
 
2305
                                const gchar* _tmp25_;
 
2306
                                _tmp20_ = _tmp19_;
 
2307
                                if (!_tmp20_) {
 
2308
                                        xmlNode* _tmp21_;
 
2309
                                        xmlNode* _tmp22_;
 
2310
                                        _tmp21_ = child;
 
2311
                                        _tmp22_ = _tmp21_->next;
 
2312
                                        child = _tmp22_;
1834
2313
                                }
1835
 
                                _tmp3_ = FALSE;
1836
 
                                if (!(child != NULL)) {
 
2314
                                _tmp19_ = FALSE;
 
2315
                                _tmp23_ = child;
 
2316
                                if (!(_tmp23_ != NULL)) {
1837
2317
                                        break;
1838
2318
                                }
1839
 
                                if (g_strcmp0 (child->name, "value") == 0) {
 
2319
                                _tmp24_ = child;
 
2320
                                _tmp25_ = _tmp24_->name;
 
2321
                                if (g_strcmp0 (_tmp25_, "value") == 0) {
1840
2322
                                        gchar* nick;
1841
2323
                                        gint value;
1842
 
                                        guint _tmp7_;
1843
 
                                        SchemaValue* _tmp8_ = NULL;
 
2324
                                        GList* _tmp47_;
 
2325
                                        guint _tmp48_ = 0U;
 
2326
                                        const gchar* _tmp49_;
 
2327
                                        gint _tmp50_;
 
2328
                                        SchemaValue* _tmp51_;
1844
2329
                                        SchemaValue* schema_value;
1845
 
                                        SchemaValue* _tmp9_;
 
2330
                                        SchemaValue* _tmp52_;
 
2331
                                        SchemaValue* _tmp53_;
1846
2332
                                        nick = NULL;
1847
2333
                                        value = -1;
1848
2334
                                        {
 
2335
                                                xmlNode* _tmp26_;
 
2336
                                                xmlAttr* _tmp27_;
1849
2337
                                                xmlAttr* prop;
1850
 
                                                prop = child->properties;
 
2338
                                                _tmp26_ = child;
 
2339
                                                _tmp27_ = _tmp26_->properties;
 
2340
                                                prop = _tmp27_;
1851
2341
                                                {
1852
 
                                                        gboolean _tmp4_;
1853
 
                                                        _tmp4_ = TRUE;
 
2342
                                                        gboolean _tmp28_;
 
2343
                                                        _tmp28_ = TRUE;
1854
2344
                                                        while (TRUE) {
1855
 
                                                                if (!_tmp4_) {
1856
 
                                                                        prop = prop->next;
 
2345
                                                                gboolean _tmp29_;
 
2346
                                                                xmlAttr* _tmp32_;
 
2347
                                                                xmlAttr* _tmp33_;
 
2348
                                                                const gchar* _tmp34_;
 
2349
                                                                _tmp29_ = _tmp28_;
 
2350
                                                                if (!_tmp29_) {
 
2351
                                                                        xmlAttr* _tmp30_;
 
2352
                                                                        xmlAttr* _tmp31_;
 
2353
                                                                        _tmp30_ = prop;
 
2354
                                                                        _tmp31_ = _tmp30_->next;
 
2355
                                                                        prop = _tmp31_;
1857
2356
                                                                }
1858
 
                                                                _tmp4_ = FALSE;
1859
 
                                                                if (!(prop != NULL)) {
 
2357
                                                                _tmp28_ = FALSE;
 
2358
                                                                _tmp32_ = prop;
 
2359
                                                                if (!(_tmp32_ != NULL)) {
1860
2360
                                                                        break;
1861
2361
                                                                }
1862
 
                                                                if (g_strcmp0 (prop->name, "value") == 0) {
1863
 
                                                                        gint _tmp5_;
1864
 
                                                                        _tmp5_ = atoi (prop->children->content);
1865
 
                                                                        value = _tmp5_;
 
2362
                                                                _tmp33_ = prop;
 
2363
                                                                _tmp34_ = _tmp33_->name;
 
2364
                                                                if (g_strcmp0 (_tmp34_, "value") == 0) {
 
2365
                                                                        xmlAttr* _tmp35_;
 
2366
                                                                        xmlNode* _tmp36_;
 
2367
                                                                        const gchar* _tmp37_;
 
2368
                                                                        gint _tmp38_ = 0;
 
2369
                                                                        _tmp35_ = prop;
 
2370
                                                                        _tmp36_ = _tmp35_->children;
 
2371
                                                                        _tmp37_ = _tmp36_->content;
 
2372
                                                                        _tmp38_ = atoi (_tmp37_);
 
2373
                                                                        value = _tmp38_;
1866
2374
                                                                } else {
1867
 
                                                                        if (g_strcmp0 (prop->name, "nick") == 0) {
1868
 
                                                                                gchar* _tmp6_;
1869
 
                                                                                _tmp6_ = g_strdup (prop->children->content);
 
2375
                                                                        xmlAttr* _tmp39_;
 
2376
                                                                        const gchar* _tmp40_;
 
2377
                                                                        _tmp39_ = prop;
 
2378
                                                                        _tmp40_ = _tmp39_->name;
 
2379
                                                                        if (g_strcmp0 (_tmp40_, "nick") == 0) {
 
2380
                                                                                xmlAttr* _tmp41_;
 
2381
                                                                                xmlNode* _tmp42_;
 
2382
                                                                                const gchar* _tmp43_;
 
2383
                                                                                gchar* _tmp44_;
 
2384
                                                                                _tmp41_ = prop;
 
2385
                                                                                _tmp42_ = _tmp41_->children;
 
2386
                                                                                _tmp43_ = _tmp42_->content;
 
2387
                                                                                _tmp44_ = g_strdup (_tmp43_);
1870
2388
                                                                                _g_free0 (nick);
1871
 
                                                                                nick = _tmp6_;
 
2389
                                                                                nick = _tmp44_;
1872
2390
                                                                        } else {
1873
 
                                                                                g_warning ("dconf-schema.vala:308: Unknown property in flags <value>, %s", prop->name);
 
2391
                                                                                xmlAttr* _tmp45_;
 
2392
                                                                                const gchar* _tmp46_;
 
2393
                                                                                _tmp45_ = prop;
 
2394
                                                                                _tmp46_ = _tmp45_->name;
 
2395
                                                                                g_warning ("dconf-schema.vala:308: Unknown property in flags <value>, %s", _tmp46_);
1874
2396
                                                                        }
1875
2397
                                                                }
1876
2398
                                                        }
1877
2399
                                                }
1878
2400
                                        }
1879
 
                                        _tmp7_ = g_list_length (self->values);
1880
 
                                        _tmp8_ = schema_value_new (_tmp7_, nick, value);
1881
 
                                        schema_value = _tmp8_;
1882
 
                                        _tmp9_ = _g_object_ref0 (schema_value);
1883
 
                                        self->values = g_list_append (self->values, _tmp9_);
 
2401
                                        _tmp47_ = self->values;
 
2402
                                        _tmp48_ = g_list_length (_tmp47_);
 
2403
                                        _tmp49_ = nick;
 
2404
                                        _tmp50_ = value;
 
2405
                                        _tmp51_ = schema_value_new (_tmp48_, _tmp49_, _tmp50_);
 
2406
                                        schema_value = _tmp51_;
 
2407
                                        _tmp52_ = schema_value;
 
2408
                                        _tmp53_ = _g_object_ref0 (_tmp52_);
 
2409
                                        self->values = g_list_append (self->values, _tmp53_);
1884
2410
                                        _g_object_unref0 (schema_value);
1885
2411
                                        _g_free0 (nick);
1886
2412
                                } else {
1887
 
                                        gboolean _tmp10_ = FALSE;
1888
 
                                        if (child->type != XML_TEXT_NODE) {
1889
 
                                                _tmp10_ = child->type != XML_COMMENT_NODE;
 
2413
                                        gboolean _tmp54_ = FALSE;
 
2414
                                        xmlNode* _tmp55_;
 
2415
                                        xmlElementType _tmp56_;
 
2416
                                        gboolean _tmp59_;
 
2417
                                        _tmp55_ = child;
 
2418
                                        _tmp56_ = _tmp55_->type;
 
2419
                                        if (_tmp56_ != XML_TEXT_NODE) {
 
2420
                                                xmlNode* _tmp57_;
 
2421
                                                xmlElementType _tmp58_;
 
2422
                                                _tmp57_ = child;
 
2423
                                                _tmp58_ = _tmp57_->type;
 
2424
                                                _tmp54_ = _tmp58_ != XML_COMMENT_NODE;
1890
2425
                                        } else {
1891
 
                                                _tmp10_ = FALSE;
 
2426
                                                _tmp54_ = FALSE;
1892
2427
                                        }
1893
 
                                        if (_tmp10_) {
1894
 
                                                g_warning ("dconf-schema.vala:318: Unknown tag in <flags>, <%s>", child->name);
 
2428
                                        _tmp59_ = _tmp54_;
 
2429
                                        if (_tmp59_) {
 
2430
                                                xmlNode* _tmp60_;
 
2431
                                                const gchar* _tmp61_;
 
2432
                                                _tmp60_ = child;
 
2433
                                                _tmp61_ = _tmp60_->name;
 
2434
                                                g_warning ("dconf-schema.vala:318: Unknown tag in <flags>, <%s>", _tmp61_);
1895
2435
                                        }
1896
2436
                                }
1897
2437
                        }
2099
2639
Schema* schema_construct_from_xml (GType object_type, SchemaList* list, xmlNode* node, const gchar* gettext_domain) {
2100
2640
        Schema* self = NULL;
2101
2641
        SchemaList* _tmp0_;
 
2642
        SchemaList* _tmp1_;
2102
2643
        g_return_val_if_fail (list != NULL, NULL);
2103
2644
        self = (Schema*) g_type_create_instance (object_type);
2104
 
        _tmp0_ = _schema_list_ref0 (list);
 
2645
        _tmp0_ = list;
 
2646
        _tmp1_ = _schema_list_ref0 (_tmp0_);
2105
2647
        _schema_list_unref0 (self->list);
2106
 
        self->list = _tmp0_;
 
2648
        self->list = _tmp1_;
2107
2649
        {
 
2650
                xmlNode* _tmp2_;
 
2651
                xmlAttr* _tmp3_;
2108
2652
                xmlAttr* prop;
2109
 
                prop = node->properties;
 
2653
                _tmp2_ = node;
 
2654
                _tmp3_ = _tmp2_->properties;
 
2655
                prop = _tmp3_;
2110
2656
                {
2111
 
                        gboolean _tmp1_;
2112
 
                        _tmp1_ = TRUE;
 
2657
                        gboolean _tmp4_;
 
2658
                        _tmp4_ = TRUE;
2113
2659
                        while (TRUE) {
2114
 
                                if (!_tmp1_) {
2115
 
                                        prop = prop->next;
 
2660
                                gboolean _tmp5_;
 
2661
                                xmlAttr* _tmp8_;
 
2662
                                xmlAttr* _tmp9_;
 
2663
                                const gchar* _tmp10_;
 
2664
                                _tmp5_ = _tmp4_;
 
2665
                                if (!_tmp5_) {
 
2666
                                        xmlAttr* _tmp6_;
 
2667
                                        xmlAttr* _tmp7_;
 
2668
                                        _tmp6_ = prop;
 
2669
                                        _tmp7_ = _tmp6_->next;
 
2670
                                        prop = _tmp7_;
2116
2671
                                }
2117
 
                                _tmp1_ = FALSE;
2118
 
                                if (!(prop != NULL)) {
 
2672
                                _tmp4_ = FALSE;
 
2673
                                _tmp8_ = prop;
 
2674
                                if (!(_tmp8_ != NULL)) {
2119
2675
                                        break;
2120
2676
                                }
2121
 
                                if (g_strcmp0 (prop->name, "id") == 0) {
2122
 
                                        gchar* _tmp2_;
2123
 
                                        _tmp2_ = g_strdup (prop->children->content);
 
2677
                                _tmp9_ = prop;
 
2678
                                _tmp10_ = _tmp9_->name;
 
2679
                                if (g_strcmp0 (_tmp10_, "id") == 0) {
 
2680
                                        xmlAttr* _tmp11_;
 
2681
                                        xmlNode* _tmp12_;
 
2682
                                        const gchar* _tmp13_;
 
2683
                                        gchar* _tmp14_;
 
2684
                                        _tmp11_ = prop;
 
2685
                                        _tmp12_ = _tmp11_->children;
 
2686
                                        _tmp13_ = _tmp12_->content;
 
2687
                                        _tmp14_ = g_strdup (_tmp13_);
2124
2688
                                        _g_free0 (self->id);
2125
 
                                        self->id = _tmp2_;
 
2689
                                        self->id = _tmp14_;
2126
2690
                                } else {
2127
 
                                        if (g_strcmp0 (prop->name, "path") == 0) {
2128
 
                                                gchar* _tmp3_;
2129
 
                                                _tmp3_ = g_strdup (prop->children->content);
 
2691
                                        xmlAttr* _tmp15_;
 
2692
                                        const gchar* _tmp16_;
 
2693
                                        _tmp15_ = prop;
 
2694
                                        _tmp16_ = _tmp15_->name;
 
2695
                                        if (g_strcmp0 (_tmp16_, "path") == 0) {
 
2696
                                                xmlAttr* _tmp17_;
 
2697
                                                xmlNode* _tmp18_;
 
2698
                                                const gchar* _tmp19_;
 
2699
                                                gchar* _tmp20_;
 
2700
                                                _tmp17_ = prop;
 
2701
                                                _tmp18_ = _tmp17_->children;
 
2702
                                                _tmp19_ = _tmp18_->content;
 
2703
                                                _tmp20_ = g_strdup (_tmp19_);
2130
2704
                                                _g_free0 (self->path);
2131
 
                                                self->path = _tmp3_;
 
2705
                                                self->path = _tmp20_;
2132
2706
                                        } else {
2133
 
                                                if (g_strcmp0 (prop->name, "gettext-domain") == 0) {
2134
 
                                                        gettext_domain = prop->children->content;
 
2707
                                                xmlAttr* _tmp21_;
 
2708
                                                const gchar* _tmp22_;
 
2709
                                                _tmp21_ = prop;
 
2710
                                                _tmp22_ = _tmp21_->name;
 
2711
                                                if (g_strcmp0 (_tmp22_, "gettext-domain") == 0) {
 
2712
                                                        xmlAttr* _tmp23_;
 
2713
                                                        xmlNode* _tmp24_;
 
2714
                                                        const gchar* _tmp25_;
 
2715
                                                        _tmp23_ = prop;
 
2716
                                                        _tmp24_ = _tmp23_->children;
 
2717
                                                        _tmp25_ = _tmp24_->content;
 
2718
                                                        gettext_domain = _tmp25_;
2135
2719
                                                } else {
2136
 
                                                        g_warning ("dconf-schema.vala:346: Unknown property on <schema>, %s", prop->name);
 
2720
                                                        xmlAttr* _tmp26_;
 
2721
                                                        const gchar* _tmp27_;
 
2722
                                                        _tmp26_ = prop;
 
2723
                                                        _tmp27_ = _tmp26_->name;
 
2724
                                                        g_warning ("dconf-schema.vala:346: Unknown property on <schema>, %s", _tmp27_);
2137
2725
                                                }
2138
2726
                                        }
2139
2727
                                }
2141
2729
                }
2142
2730
        }
2143
2731
        {
 
2732
                xmlNode* _tmp28_;
 
2733
                xmlNode* _tmp29_;
2144
2734
                xmlNode* child;
2145
 
                child = node->children;
 
2735
                _tmp28_ = node;
 
2736
                _tmp29_ = _tmp28_->children;
 
2737
                child = _tmp29_;
2146
2738
                {
2147
 
                        gboolean _tmp4_;
2148
 
                        _tmp4_ = TRUE;
 
2739
                        gboolean _tmp30_;
 
2740
                        _tmp30_ = TRUE;
2149
2741
                        while (TRUE) {
2150
 
                                SchemaKey* _tmp5_ = NULL;
 
2742
                                gboolean _tmp31_;
 
2743
                                xmlNode* _tmp34_;
 
2744
                                xmlNode* _tmp35_;
 
2745
                                const gchar* _tmp36_;
 
2746
                                xmlNode* _tmp37_;
 
2747
                                const gchar* _tmp38_;
 
2748
                                SchemaKey* _tmp39_;
2151
2749
                                SchemaKey* key;
2152
 
                                gchar* _tmp6_;
2153
 
                                SchemaKey* _tmp7_;
2154
 
                                if (!_tmp4_) {
2155
 
                                        child = child->next;
 
2750
                                GHashTable* _tmp40_;
 
2751
                                SchemaKey* _tmp41_;
 
2752
                                const gchar* _tmp42_;
 
2753
                                gchar* _tmp43_;
 
2754
                                SchemaKey* _tmp44_;
 
2755
                                SchemaKey* _tmp45_;
 
2756
                                _tmp31_ = _tmp30_;
 
2757
                                if (!_tmp31_) {
 
2758
                                        xmlNode* _tmp32_;
 
2759
                                        xmlNode* _tmp33_;
 
2760
                                        _tmp32_ = child;
 
2761
                                        _tmp33_ = _tmp32_->next;
 
2762
                                        child = _tmp33_;
2156
2763
                                }
2157
 
                                _tmp4_ = FALSE;
2158
 
                                if (!(child != NULL)) {
 
2764
                                _tmp30_ = FALSE;
 
2765
                                _tmp34_ = child;
 
2766
                                if (!(_tmp34_ != NULL)) {
2159
2767
                                        break;
2160
2768
                                }
2161
 
                                if (g_strcmp0 (child->name, "key") != 0) {
 
2769
                                _tmp35_ = child;
 
2770
                                _tmp36_ = _tmp35_->name;
 
2771
                                if (g_strcmp0 (_tmp36_, "key") != 0) {
2162
2772
                                        continue;
2163
2773
                                }
2164
 
                                _tmp5_ = schema_key_new_from_xml (child, self, gettext_domain);
2165
 
                                key = _tmp5_;
2166
 
                                _tmp6_ = g_strdup (key->name);
2167
 
                                _tmp7_ = _schema_key_ref0 (key);
2168
 
                                g_hash_table_insert (self->keys, _tmp6_, _tmp7_);
 
2774
                                _tmp37_ = child;
 
2775
                                _tmp38_ = gettext_domain;
 
2776
                                _tmp39_ = schema_key_new_from_xml (_tmp37_, self, _tmp38_);
 
2777
                                key = _tmp39_;
 
2778
                                _tmp40_ = self->keys;
 
2779
                                _tmp41_ = key;
 
2780
                                _tmp42_ = _tmp41_->name;
 
2781
                                _tmp43_ = g_strdup (_tmp42_);
 
2782
                                _tmp44_ = key;
 
2783
                                _tmp45_ = _schema_key_ref0 (_tmp44_);
 
2784
                                g_hash_table_insert (_tmp40_, _tmp43_, _tmp45_);
2169
2785
                                _schema_key_unref0 (key);
2170
2786
                        }
2171
2787
                }
2308
2924
 
2309
2925
 
2310
2926
static void schema_instance_init (Schema * self) {
2311
 
        GHashTable* _tmp0_ = NULL;
2312
 
        _tmp0_ = g_hash_table_new_full (g_str_hash, g_str_equal, _g_free0_, _schema_key_unref0_);
2313
 
        self->keys = _tmp0_;
 
2927
        GHashFunc _tmp0_;
 
2928
        GEqualFunc _tmp1_;
 
2929
        GHashTable* _tmp2_;
 
2930
        _tmp0_ = g_str_hash;
 
2931
        _tmp1_ = g_str_equal;
 
2932
        _tmp2_ = g_hash_table_new_full (_tmp0_, _tmp1_, _g_free0_, _schema_key_unref0_);
 
2933
        self->keys = _tmp2_;
2314
2934
        self->ref_count = 1;
2315
2935
}
2316
2936
 
2389
3009
 
2390
3010
 
2391
3011
void schema_list_parse_file (SchemaList* self, const gchar* path) {
2392
 
        xmlDoc* _tmp0_ = NULL;
 
3012
        const gchar* _tmp0_;
 
3013
        xmlDoc* _tmp1_ = NULL;
2393
3014
        xmlDoc* doc;
2394
 
        xmlNode* _tmp1_ = NULL;
 
3015
        xmlDoc* _tmp2_;
 
3016
        xmlDoc* _tmp3_;
 
3017
        xmlNode* _tmp4_ = NULL;
2395
3018
        xmlNode* root;
 
3019
        xmlNode* _tmp5_;
 
3020
        xmlNode* _tmp6_;
 
3021
        const gchar* _tmp7_;
2396
3022
        gchar* gettext_domain;
 
3023
        xmlDoc* _tmp74_;
2397
3024
        g_return_if_fail (self != NULL);
2398
3025
        g_return_if_fail (path != NULL);
2399
 
        _tmp0_ = xmlParseFile (path);
2400
 
        doc = _tmp0_;
2401
 
        if (doc == NULL) {
2402
 
                return;
2403
 
        }
2404
 
        _tmp1_ = xmlDocGetRootElement (doc);
2405
 
        root = _tmp1_;
2406
 
        if (root == NULL) {
2407
 
                return;
2408
 
        }
2409
 
        if (g_strcmp0 (root->name, "schemalist") != 0) {
 
3026
        _tmp0_ = path;
 
3027
        _tmp1_ = xmlParseFile (_tmp0_);
 
3028
        doc = _tmp1_;
 
3029
        _tmp2_ = doc;
 
3030
        if (_tmp2_ == NULL) {
 
3031
                return;
 
3032
        }
 
3033
        _tmp3_ = doc;
 
3034
        _tmp4_ = xmlDocGetRootElement (_tmp3_);
 
3035
        root = _tmp4_;
 
3036
        _tmp5_ = root;
 
3037
        if (_tmp5_ == NULL) {
 
3038
                return;
 
3039
        }
 
3040
        _tmp6_ = root;
 
3041
        _tmp7_ = _tmp6_->name;
 
3042
        if (g_strcmp0 (_tmp7_, "schemalist") != 0) {
2410
3043
                return;
2411
3044
        }
2412
3045
        gettext_domain = NULL;
2413
3046
        {
 
3047
                xmlNode* _tmp8_;
 
3048
                xmlAttr* _tmp9_;
2414
3049
                xmlAttr* prop;
2415
 
                prop = root->properties;
 
3050
                _tmp8_ = root;
 
3051
                _tmp9_ = _tmp8_->properties;
 
3052
                prop = _tmp9_;
2416
3053
                {
2417
 
                        gboolean _tmp2_;
2418
 
                        _tmp2_ = TRUE;
 
3054
                        gboolean _tmp10_;
 
3055
                        _tmp10_ = TRUE;
2419
3056
                        while (TRUE) {
2420
 
                                if (!_tmp2_) {
2421
 
                                        prop = prop->next;
 
3057
                                gboolean _tmp11_;
 
3058
                                xmlAttr* _tmp14_;
 
3059
                                xmlAttr* _tmp15_;
 
3060
                                const gchar* _tmp16_;
 
3061
                                _tmp11_ = _tmp10_;
 
3062
                                if (!_tmp11_) {
 
3063
                                        xmlAttr* _tmp12_;
 
3064
                                        xmlAttr* _tmp13_;
 
3065
                                        _tmp12_ = prop;
 
3066
                                        _tmp13_ = _tmp12_->next;
 
3067
                                        prop = _tmp13_;
2422
3068
                                }
2423
 
                                _tmp2_ = FALSE;
2424
 
                                if (!(prop != NULL)) {
 
3069
                                _tmp10_ = FALSE;
 
3070
                                _tmp14_ = prop;
 
3071
                                if (!(_tmp14_ != NULL)) {
2425
3072
                                        break;
2426
3073
                                }
2427
 
                                if (g_strcmp0 (prop->name, "gettext-domain") == 0) {
2428
 
                                        gchar* _tmp3_;
2429
 
                                        _tmp3_ = g_strdup (prop->children->content);
 
3074
                                _tmp15_ = prop;
 
3075
                                _tmp16_ = _tmp15_->name;
 
3076
                                if (g_strcmp0 (_tmp16_, "gettext-domain") == 0) {
 
3077
                                        xmlAttr* _tmp17_;
 
3078
                                        xmlNode* _tmp18_;
 
3079
                                        const gchar* _tmp19_;
 
3080
                                        gchar* _tmp20_;
 
3081
                                        _tmp17_ = prop;
 
3082
                                        _tmp18_ = _tmp17_->children;
 
3083
                                        _tmp19_ = _tmp18_->content;
 
3084
                                        _tmp20_ = g_strdup (_tmp19_);
2430
3085
                                        _g_free0 (gettext_domain);
2431
 
                                        gettext_domain = _tmp3_;
 
3086
                                        gettext_domain = _tmp20_;
2432
3087
                                }
2433
3088
                        }
2434
3089
                }
2435
3090
        }
2436
3091
        {
 
3092
                xmlNode* _tmp21_;
 
3093
                xmlNode* _tmp22_;
2437
3094
                xmlNode* node;
2438
 
                node = root->children;
 
3095
                _tmp21_ = root;
 
3096
                _tmp22_ = _tmp21_->children;
 
3097
                node = _tmp22_;
2439
3098
                {
2440
 
                        gboolean _tmp4_;
2441
 
                        _tmp4_ = TRUE;
 
3099
                        gboolean _tmp23_;
 
3100
                        _tmp23_ = TRUE;
2442
3101
                        while (TRUE) {
2443
 
                                if (!_tmp4_) {
2444
 
                                        node = node->next;
 
3102
                                gboolean _tmp24_;
 
3103
                                xmlNode* _tmp27_;
 
3104
                                xmlNode* _tmp28_;
 
3105
                                const gchar* _tmp29_;
 
3106
                                _tmp24_ = _tmp23_;
 
3107
                                if (!_tmp24_) {
 
3108
                                        xmlNode* _tmp25_;
 
3109
                                        xmlNode* _tmp26_;
 
3110
                                        _tmp25_ = node;
 
3111
                                        _tmp26_ = _tmp25_->next;
 
3112
                                        node = _tmp26_;
2445
3113
                                }
2446
 
                                _tmp4_ = FALSE;
2447
 
                                if (!(node != NULL)) {
 
3114
                                _tmp23_ = FALSE;
 
3115
                                _tmp27_ = node;
 
3116
                                if (!(_tmp27_ != NULL)) {
2448
3117
                                        break;
2449
3118
                                }
2450
 
                                if (g_strcmp0 (node->name, "schema") == 0) {
2451
 
                                        Schema* _tmp5_ = NULL;
 
3119
                                _tmp28_ = node;
 
3120
                                _tmp29_ = _tmp28_->name;
 
3121
                                if (g_strcmp0 (_tmp29_, "schema") == 0) {
 
3122
                                        xmlNode* _tmp30_;
 
3123
                                        const gchar* _tmp31_;
 
3124
                                        Schema* _tmp32_;
2452
3125
                                        Schema* schema;
2453
 
                                        GList* _tmp6_ = NULL;
2454
 
                                        Schema* _tmp10_;
2455
 
                                        _tmp5_ = schema_new_from_xml (self, node, gettext_domain);
2456
 
                                        schema = _tmp5_;
2457
 
                                        if (schema->path == NULL) {
 
3126
                                        Schema* _tmp33_;
 
3127
                                        const gchar* _tmp34_;
 
3128
                                        Schema* _tmp35_;
 
3129
                                        GHashTable* _tmp36_;
 
3130
                                        GList* _tmp37_ = NULL;
 
3131
                                        Schema* _tmp48_;
 
3132
                                        Schema* _tmp49_;
 
3133
                                        _tmp30_ = node;
 
3134
                                        _tmp31_ = gettext_domain;
 
3135
                                        _tmp32_ = schema_new_from_xml (self, _tmp30_, _tmp31_);
 
3136
                                        schema = _tmp32_;
 
3137
                                        _tmp33_ = schema;
 
3138
                                        _tmp34_ = _tmp33_->path;
 
3139
                                        if (_tmp34_ == NULL) {
2458
3140
                                                _schema_unref0 (schema);
2459
3141
                                                continue;
2460
3142
                                        }
2461
 
                                        _tmp6_ = g_hash_table_get_values (schema->keys);
 
3143
                                        _tmp35_ = schema;
 
3144
                                        _tmp36_ = _tmp35_->keys;
 
3145
                                        _tmp37_ = g_hash_table_get_values (_tmp36_);
2462
3146
                                        {
2463
 
                                                GList* key_collection;
2464
 
                                                GList* key_it;
2465
 
                                                key_collection = _tmp6_;
 
3147
                                                GList* key_collection = NULL;
 
3148
                                                GList* key_it = NULL;
 
3149
                                                key_collection = _tmp37_;
2466
3150
                                                for (key_it = key_collection; key_it != NULL; key_it = key_it->next) {
2467
 
                                                        SchemaKey* key;
 
3151
                                                        SchemaKey* key = NULL;
2468
3152
                                                        key = (SchemaKey*) key_it->data;
2469
3153
                                                        {
2470
 
                                                                gchar* _tmp7_;
 
3154
                                                                Schema* _tmp38_;
 
3155
                                                                const gchar* _tmp39_;
 
3156
                                                                SchemaKey* _tmp40_;
 
3157
                                                                const gchar* _tmp41_;
 
3158
                                                                gchar* _tmp42_;
2471
3159
                                                                gchar* full_name;
2472
 
                                                                gchar* _tmp8_;
2473
 
                                                                SchemaKey* _tmp9_;
2474
 
                                                                _tmp7_ = g_strconcat (schema->path, key->name, NULL);
2475
 
                                                                full_name = _tmp7_;
2476
 
                                                                _tmp8_ = g_strdup (full_name);
2477
 
                                                                _tmp9_ = _schema_key_ref0 (key);
2478
 
                                                                g_hash_table_insert (self->keys, _tmp8_, _tmp9_);
 
3160
                                                                GHashTable* _tmp43_;
 
3161
                                                                const gchar* _tmp44_;
 
3162
                                                                gchar* _tmp45_;
 
3163
                                                                SchemaKey* _tmp46_;
 
3164
                                                                SchemaKey* _tmp47_;
 
3165
                                                                _tmp38_ = schema;
 
3166
                                                                _tmp39_ = _tmp38_->path;
 
3167
                                                                _tmp40_ = key;
 
3168
                                                                _tmp41_ = _tmp40_->name;
 
3169
                                                                _tmp42_ = g_strconcat (_tmp39_, _tmp41_, NULL);
 
3170
                                                                full_name = _tmp42_;
 
3171
                                                                _tmp43_ = self->keys;
 
3172
                                                                _tmp44_ = full_name;
 
3173
                                                                _tmp45_ = g_strdup (_tmp44_);
 
3174
                                                                _tmp46_ = key;
 
3175
                                                                _tmp47_ = _schema_key_ref0 (_tmp46_);
 
3176
                                                                g_hash_table_insert (_tmp43_, _tmp45_, _tmp47_);
2479
3177
                                                                _g_free0 (full_name);
2480
3178
                                                        }
2481
3179
                                                }
2482
3180
                                                _g_list_free0 (key_collection);
2483
3181
                                        }
2484
 
                                        _tmp10_ = _schema_ref0 (schema);
2485
 
                                        self->schemas = g_list_append (self->schemas, _tmp10_);
 
3182
                                        _tmp48_ = schema;
 
3183
                                        _tmp49_ = _schema_ref0 (_tmp48_);
 
3184
                                        self->schemas = g_list_append (self->schemas, _tmp49_);
2486
3185
                                        _schema_unref0 (schema);
2487
3186
                                } else {
2488
 
                                        if (g_strcmp0 (node->name, "enum") == 0) {
2489
 
                                                SchemaEnum* _tmp11_ = NULL;
 
3187
                                        xmlNode* _tmp50_;
 
3188
                                        const gchar* _tmp51_;
 
3189
                                        _tmp50_ = node;
 
3190
                                        _tmp51_ = _tmp50_->name;
 
3191
                                        if (g_strcmp0 (_tmp51_, "enum") == 0) {
 
3192
                                                xmlNode* _tmp52_;
 
3193
                                                SchemaEnum* _tmp53_;
2490
3194
                                                SchemaEnum* _enum_;
2491
 
                                                gchar* _tmp12_;
2492
 
                                                SchemaEnum* _tmp13_;
2493
 
                                                _tmp11_ = schema_enum_new_from_xml (self, node);
2494
 
                                                _enum_ = _tmp11_;
2495
 
                                                _tmp12_ = g_strdup (_enum_->id);
2496
 
                                                _tmp13_ = _schema_enum_ref0 (_enum_);
2497
 
                                                g_hash_table_insert (self->enums, _tmp12_, _tmp13_);
 
3195
                                                GHashTable* _tmp54_;
 
3196
                                                SchemaEnum* _tmp55_;
 
3197
                                                const gchar* _tmp56_;
 
3198
                                                gchar* _tmp57_;
 
3199
                                                SchemaEnum* _tmp58_;
 
3200
                                                SchemaEnum* _tmp59_;
 
3201
                                                _tmp52_ = node;
 
3202
                                                _tmp53_ = schema_enum_new_from_xml (self, _tmp52_);
 
3203
                                                _enum_ = _tmp53_;
 
3204
                                                _tmp54_ = self->enums;
 
3205
                                                _tmp55_ = _enum_;
 
3206
                                                _tmp56_ = _tmp55_->id;
 
3207
                                                _tmp57_ = g_strdup (_tmp56_);
 
3208
                                                _tmp58_ = _enum_;
 
3209
                                                _tmp59_ = _schema_enum_ref0 (_tmp58_);
 
3210
                                                g_hash_table_insert (_tmp54_, _tmp57_, _tmp59_);
2498
3211
                                                _schema_enum_unref0 (_enum_);
2499
3212
                                        } else {
2500
 
                                                if (g_strcmp0 (node->name, "flags") == 0) {
2501
 
                                                        SchemaFlags* _tmp14_ = NULL;
 
3213
                                                xmlNode* _tmp60_;
 
3214
                                                const gchar* _tmp61_;
 
3215
                                                _tmp60_ = node;
 
3216
                                                _tmp61_ = _tmp60_->name;
 
3217
                                                if (g_strcmp0 (_tmp61_, "flags") == 0) {
 
3218
                                                        xmlNode* _tmp62_;
 
3219
                                                        SchemaFlags* _tmp63_;
2502
3220
                                                        SchemaFlags* f;
2503
 
                                                        gchar* _tmp15_;
2504
 
                                                        SchemaFlags* _tmp16_;
2505
 
                                                        _tmp14_ = schema_flags_new_from_xml (self, node);
2506
 
                                                        f = _tmp14_;
2507
 
                                                        _tmp15_ = g_strdup (f->id);
2508
 
                                                        _tmp16_ = _schema_flags_ref0 (f);
2509
 
                                                        g_hash_table_insert (self->flags, _tmp15_, _tmp16_);
 
3221
                                                        GHashTable* _tmp64_;
 
3222
                                                        SchemaFlags* _tmp65_;
 
3223
                                                        const gchar* _tmp66_;
 
3224
                                                        gchar* _tmp67_;
 
3225
                                                        SchemaFlags* _tmp68_;
 
3226
                                                        SchemaFlags* _tmp69_;
 
3227
                                                        _tmp62_ = node;
 
3228
                                                        _tmp63_ = schema_flags_new_from_xml (self, _tmp62_);
 
3229
                                                        f = _tmp63_;
 
3230
                                                        _tmp64_ = self->flags;
 
3231
                                                        _tmp65_ = f;
 
3232
                                                        _tmp66_ = _tmp65_->id;
 
3233
                                                        _tmp67_ = g_strdup (_tmp66_);
 
3234
                                                        _tmp68_ = f;
 
3235
                                                        _tmp69_ = _schema_flags_ref0 (_tmp68_);
 
3236
                                                        g_hash_table_insert (_tmp64_, _tmp67_, _tmp69_);
2510
3237
                                                        _schema_flags_unref0 (f);
2511
3238
                                                } else {
2512
 
                                                        if (node->type != XML_TEXT_NODE) {
2513
 
                                                                g_warning ("dconf-schema.vala:417: Unknown tag <%s>", node->name);
 
3239
                                                        xmlNode* _tmp70_;
 
3240
                                                        xmlElementType _tmp71_;
 
3241
                                                        _tmp70_ = node;
 
3242
                                                        _tmp71_ = _tmp70_->type;
 
3243
                                                        if (_tmp71_ != XML_TEXT_NODE) {
 
3244
                                                                xmlNode* _tmp72_;
 
3245
                                                                const gchar* _tmp73_;
 
3246
                                                                _tmp72_ = node;
 
3247
                                                                _tmp73_ = _tmp72_->name;
 
3248
                                                                g_warning ("dconf-schema.vala:417: Unknown tag <%s>", _tmp73_);
2514
3249
                                                        }
2515
3250
                                                }
2516
3251
                                        }
2518
3253
                        }
2519
3254
                }
2520
3255
        }
2521
 
        xmlFreeDoc (doc);
 
3256
        _tmp74_ = doc;
 
3257
        xmlFreeDoc (_tmp74_);
2522
3258
        _g_free0 (gettext_domain);
2523
3259
}
2524
3260
 
2525
3261
 
2526
3262
void schema_list_load_directory (SchemaList* self, const gchar* dir, GError** error) {
2527
 
        GFile* _tmp0_ = NULL;
 
3263
        const gchar* _tmp0_;
 
3264
        GFile* _tmp1_ = NULL;
2528
3265
        GFile* directory;
2529
 
        GFileEnumerator* _tmp1_ = NULL;
 
3266
        GFile* _tmp2_;
 
3267
        GFileEnumerator* _tmp3_ = NULL;
2530
3268
        GFileEnumerator* i;
2531
3269
        GFileInfo* info = NULL;
2532
3270
        GError * _inner_error_ = NULL;
2533
3271
        g_return_if_fail (self != NULL);
2534
3272
        g_return_if_fail (dir != NULL);
2535
 
        _tmp0_ = g_file_new_for_path (dir);
2536
 
        directory = _tmp0_;
2537
 
        _tmp1_ = g_file_enumerate_children (directory, G_FILE_ATTRIBUTE_STANDARD_NAME, 0, NULL, &_inner_error_);
2538
 
        i = _tmp1_;
 
3273
        _tmp0_ = dir;
 
3274
        _tmp1_ = g_file_new_for_path (_tmp0_);
 
3275
        directory = _tmp1_;
 
3276
        _tmp2_ = directory;
 
3277
        _tmp3_ = g_file_enumerate_children (_tmp2_, G_FILE_ATTRIBUTE_STANDARD_NAME, 0, NULL, &_inner_error_);
 
3278
        i = _tmp3_;
2539
3279
        if (_inner_error_ != NULL) {
2540
3280
                g_propagate_error (error, _inner_error_);
2541
3281
                _g_object_unref0 (directory);
2542
3282
                return;
2543
3283
        }
2544
3284
        while (TRUE) {
2545
 
                GFileInfo* _tmp2_ = NULL;
2546
 
                GFileInfo* _tmp3_;
2547
 
                const gchar* _tmp4_ = NULL;
2548
 
                gchar* _tmp5_;
 
3285
                GFileEnumerator* _tmp4_;
 
3286
                GFileInfo* _tmp5_ = NULL;
 
3287
                GFileInfo* _tmp6_;
 
3288
                GFileInfo* _tmp7_;
 
3289
                GFileInfo* _tmp8_;
 
3290
                const gchar* _tmp9_ = NULL;
 
3291
                gchar* _tmp10_;
2549
3292
                gchar* name;
2550
 
                gboolean _tmp6_ = FALSE;
2551
 
                gboolean _tmp7_;
2552
 
                gchar* _tmp9_ = NULL;
 
3293
                gboolean _tmp11_ = FALSE;
 
3294
                const gchar* _tmp12_;
 
3295
                gboolean _tmp13_ = FALSE;
 
3296
                gboolean _tmp16_;
 
3297
                const gchar* _tmp17_;
 
3298
                const gchar* _tmp18_;
 
3299
                gchar* _tmp19_ = NULL;
2553
3300
                gchar* path;
2554
 
                _tmp2_ = g_file_enumerator_next_file (i, NULL, &_inner_error_);
2555
 
                _tmp3_ = _tmp2_;
 
3301
                const gchar* _tmp20_;
 
3302
                _tmp4_ = i;
 
3303
                _tmp5_ = g_file_enumerator_next_file (_tmp4_, NULL, &_inner_error_);
 
3304
                _tmp6_ = _tmp5_;
2556
3305
                if (_inner_error_ != NULL) {
2557
3306
                        g_propagate_error (error, _inner_error_);
2558
3307
                        _g_object_unref0 (info);
2561
3310
                        return;
2562
3311
                }
2563
3312
                _g_object_unref0 (info);
2564
 
                info = _tmp3_;
2565
 
                if (!(info != NULL)) {
 
3313
                info = _tmp6_;
 
3314
                _tmp7_ = info;
 
3315
                if (!(_tmp7_ != NULL)) {
2566
3316
                        break;
2567
3317
                }
2568
 
                _tmp4_ = g_file_info_get_name (info);
2569
 
                _tmp5_ = g_strdup (_tmp4_);
2570
 
                name = _tmp5_;
2571
 
                _tmp7_ = g_str_has_suffix (name, ".gschema.xml");
2572
 
                if (!_tmp7_) {
2573
 
                        gboolean _tmp8_;
2574
 
                        _tmp8_ = g_str_has_suffix (name, ".enums.xml");
2575
 
                        _tmp6_ = !_tmp8_;
 
3318
                _tmp8_ = info;
 
3319
                _tmp9_ = g_file_info_get_name (_tmp8_);
 
3320
                _tmp10_ = g_strdup (_tmp9_);
 
3321
                name = _tmp10_;
 
3322
                _tmp12_ = name;
 
3323
                _tmp13_ = g_str_has_suffix (_tmp12_, ".gschema.xml");
 
3324
                if (!_tmp13_) {
 
3325
                        const gchar* _tmp14_;
 
3326
                        gboolean _tmp15_ = FALSE;
 
3327
                        _tmp14_ = name;
 
3328
                        _tmp15_ = g_str_has_suffix (_tmp14_, ".enums.xml");
 
3329
                        _tmp11_ = !_tmp15_;
2576
3330
                } else {
2577
 
                        _tmp6_ = FALSE;
 
3331
                        _tmp11_ = FALSE;
2578
3332
                }
2579
 
                if (_tmp6_) {
 
3333
                _tmp16_ = _tmp11_;
 
3334
                if (_tmp16_) {
2580
3335
                        _g_free0 (name);
2581
3336
                        continue;
2582
3337
                }
2583
 
                _tmp9_ = g_build_filename (dir, name, NULL, NULL);
2584
 
                path = _tmp9_;
2585
 
                g_debug ("dconf-schema.vala:435: Loading schema: %s", path);
2586
 
                schema_list_parse_file (self, path);
 
3338
                _tmp17_ = dir;
 
3339
                _tmp18_ = name;
 
3340
                _tmp19_ = g_build_filename (_tmp17_, _tmp18_, NULL, NULL);
 
3341
                path = _tmp19_;
 
3342
                _tmp20_ = path;
 
3343
                schema_list_parse_file (self, _tmp20_);
2587
3344
                _g_free0 (path);
2588
3345
                _g_free0 (name);
2589
3346
        }
2722
3479
 
2723
3480
 
2724
3481
static void schema_list_instance_init (SchemaList * self) {
2725
 
        GHashTable* _tmp0_ = NULL;
2726
 
        GHashTable* _tmp1_ = NULL;
2727
 
        GHashTable* _tmp2_ = NULL;
 
3482
        GHashFunc _tmp0_;
 
3483
        GEqualFunc _tmp1_;
 
3484
        GHashTable* _tmp2_;
 
3485
        GHashFunc _tmp3_;
 
3486
        GEqualFunc _tmp4_;
 
3487
        GHashTable* _tmp5_;
 
3488
        GHashFunc _tmp6_;
 
3489
        GEqualFunc _tmp7_;
 
3490
        GHashTable* _tmp8_;
2728
3491
        self->schemas = NULL;
2729
 
        _tmp0_ = g_hash_table_new_full (g_str_hash, g_str_equal, _g_free0_, _schema_key_unref0_);
2730
 
        self->keys = _tmp0_;
2731
 
        _tmp1_ = g_hash_table_new_full (g_str_hash, g_str_equal, _g_free0_, _schema_enum_unref0_);
2732
 
        self->enums = _tmp1_;
2733
 
        _tmp2_ = g_hash_table_new_full (g_str_hash, g_str_equal, _g_free0_, _schema_flags_unref0_);
2734
 
        self->flags = _tmp2_;
 
3492
        _tmp0_ = g_str_hash;
 
3493
        _tmp1_ = g_str_equal;
 
3494
        _tmp2_ = g_hash_table_new_full (_tmp0_, _tmp1_, _g_free0_, _schema_key_unref0_);
 
3495
        self->keys = _tmp2_;
 
3496
        _tmp3_ = g_str_hash;
 
3497
        _tmp4_ = g_str_equal;
 
3498
        _tmp5_ = g_hash_table_new_full (_tmp3_, _tmp4_, _g_free0_, _schema_enum_unref0_);
 
3499
        self->enums = _tmp5_;
 
3500
        _tmp6_ = g_str_hash;
 
3501
        _tmp7_ = g_str_equal;
 
3502
        _tmp8_ = g_hash_table_new_full (_tmp6_, _tmp7_, _g_free0_, _schema_flags_unref0_);
 
3503
        self->flags = _tmp8_;
2735
3504
        self->ref_count = 1;
2736
3505
}
2737
3506