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

« back to all changes in this revision

Viewing changes to editor/dconf-schema.c

  • Committer: Package Import Robot
  • Author(s): Andreas Henriksson, Jackson Doak
  • Date: 2014-03-24 21:08:24 UTC
  • mfrom: (1.1.34) (6.2.7 experimental)
  • Revision ID: package-import@ubuntu.com-20140324210824-7ptw8y51yr0z7qpf
Tags: 0.20.0-1
[ Jackson Doak ]
* New upstream release
* Bump valac build-depend to 0.18.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
/* dconf-schema.c generated by valac 0.23.3, the Vala compiler
 
1
/* dconf-schema.c generated by valac 0.18.1, the Vala compiler
2
2
 * generated from dconf-schema.vala, do not modify */
3
3
 
4
4
 
421
421
 
422
422
SchemaKey* schema_key_construct_from_xml (GType object_type, xmlNode* node, Schema* schema, const gchar* gettext_domain) {
423
423
        SchemaKey* self = NULL;
424
 
        Schema* _tmp0_ = NULL;
425
 
        Schema* _tmp1_ = NULL;
426
 
        const gchar* _tmp2_ = NULL;
427
 
        gchar* _tmp3_ = NULL;
 
424
        Schema* _tmp0_;
 
425
        Schema* _tmp1_;
 
426
        const gchar* _tmp2_;
 
427
        gchar* _tmp3_;
428
428
        GError * _inner_error_ = NULL;
429
429
        g_return_val_if_fail (schema != NULL, NULL);
430
430
        self = (SchemaKey*) g_type_create_instance (object_type);
437
437
        _g_free0 (self->gettext_domain);
438
438
        self->gettext_domain = _tmp3_;
439
439
        {
440
 
                xmlAttr* prop = NULL;
441
 
                xmlNode* _tmp4_ = NULL;
442
 
                xmlAttr* _tmp5_ = NULL;
 
440
                xmlNode* _tmp4_;
 
441
                xmlAttr* _tmp5_;
 
442
                xmlAttr* prop;
443
443
                _tmp4_ = node;
444
444
                _tmp5_ = _tmp4_->properties;
445
445
                prop = _tmp5_;
446
446
                {
447
 
                        gboolean _tmp6_ = FALSE;
 
447
                        gboolean _tmp6_;
448
448
                        _tmp6_ = TRUE;
449
449
                        while (TRUE) {
450
 
                                xmlAttr* _tmp9_ = NULL;
451
 
                                xmlAttr* _tmp10_ = NULL;
452
 
                                const gchar* _tmp11_ = NULL;
453
 
                                if (!_tmp6_) {
454
 
                                        xmlAttr* _tmp7_ = NULL;
455
 
                                        xmlAttr* _tmp8_ = NULL;
456
 
                                        _tmp7_ = prop;
457
 
                                        _tmp8_ = _tmp7_->next;
458
 
                                        prop = _tmp8_;
 
450
                                gboolean _tmp7_;
 
451
                                xmlAttr* _tmp10_;
 
452
                                xmlAttr* _tmp11_;
 
453
                                const gchar* _tmp12_;
 
454
                                _tmp7_ = _tmp6_;
 
455
                                if (!_tmp7_) {
 
456
                                        xmlAttr* _tmp8_;
 
457
                                        xmlAttr* _tmp9_;
 
458
                                        _tmp8_ = prop;
 
459
                                        _tmp9_ = _tmp8_->next;
 
460
                                        prop = _tmp9_;
459
461
                                }
460
462
                                _tmp6_ = FALSE;
461
 
                                _tmp9_ = prop;
462
 
                                if (!(_tmp9_ != NULL)) {
463
 
                                        break;
464
 
                                }
465
463
                                _tmp10_ = prop;
466
 
                                _tmp11_ = _tmp10_->name;
467
 
                                if (g_strcmp0 (_tmp11_, "name") == 0) {
468
 
                                        xmlAttr* _tmp12_ = NULL;
469
 
                                        xmlNode* _tmp13_ = NULL;
470
 
                                        const gchar* _tmp14_ = NULL;
471
 
                                        gchar* _tmp15_ = NULL;
472
 
                                        _tmp12_ = prop;
473
 
                                        _tmp13_ = _tmp12_->children;
474
 
                                        _tmp14_ = _tmp13_->content;
475
 
                                        _tmp15_ = g_strdup (_tmp14_);
 
464
                                if (!(_tmp10_ != NULL)) {
 
465
                                        break;
 
466
                                }
 
467
                                _tmp11_ = prop;
 
468
                                _tmp12_ = _tmp11_->name;
 
469
                                if (g_strcmp0 (_tmp12_, "name") == 0) {
 
470
                                        xmlAttr* _tmp13_;
 
471
                                        xmlNode* _tmp14_;
 
472
                                        const gchar* _tmp15_;
 
473
                                        gchar* _tmp16_;
 
474
                                        _tmp13_ = prop;
 
475
                                        _tmp14_ = _tmp13_->children;
 
476
                                        _tmp15_ = _tmp14_->content;
 
477
                                        _tmp16_ = g_strdup (_tmp15_);
476
478
                                        _g_free0 (self->name);
477
 
                                        self->name = _tmp15_;
 
479
                                        self->name = _tmp16_;
478
480
                                } else {
479
 
                                        xmlAttr* _tmp16_ = NULL;
480
 
                                        const gchar* _tmp17_ = NULL;
481
 
                                        _tmp16_ = prop;
482
 
                                        _tmp17_ = _tmp16_->name;
483
 
                                        if (g_strcmp0 (_tmp17_, "type") == 0) {
484
 
                                                xmlAttr* _tmp18_ = NULL;
485
 
                                                xmlNode* _tmp19_ = NULL;
486
 
                                                const gchar* _tmp20_ = NULL;
487
 
                                                gchar* _tmp21_ = NULL;
488
 
                                                _tmp18_ = prop;
489
 
                                                _tmp19_ = _tmp18_->children;
490
 
                                                _tmp20_ = _tmp19_->content;
491
 
                                                _tmp21_ = g_strdup (_tmp20_);
 
481
                                        xmlAttr* _tmp17_;
 
482
                                        const gchar* _tmp18_;
 
483
                                        _tmp17_ = prop;
 
484
                                        _tmp18_ = _tmp17_->name;
 
485
                                        if (g_strcmp0 (_tmp18_, "type") == 0) {
 
486
                                                xmlAttr* _tmp19_;
 
487
                                                xmlNode* _tmp20_;
 
488
                                                const gchar* _tmp21_;
 
489
                                                gchar* _tmp22_;
 
490
                                                _tmp19_ = prop;
 
491
                                                _tmp20_ = _tmp19_->children;
 
492
                                                _tmp21_ = _tmp20_->content;
 
493
                                                _tmp22_ = g_strdup (_tmp21_);
492
494
                                                _g_free0 (self->type);
493
 
                                                self->type = _tmp21_;
 
495
                                                self->type = _tmp22_;
494
496
                                        } else {
495
 
                                                xmlAttr* _tmp22_ = NULL;
496
 
                                                const gchar* _tmp23_ = NULL;
497
 
                                                _tmp22_ = prop;
498
 
                                                _tmp23_ = _tmp22_->name;
499
 
                                                if (g_strcmp0 (_tmp23_, "enum") == 0) {
500
 
                                                        gchar* _tmp24_ = NULL;
501
 
                                                        xmlAttr* _tmp25_ = NULL;
502
 
                                                        xmlNode* _tmp26_ = NULL;
503
 
                                                        const gchar* _tmp27_ = NULL;
504
 
                                                        gchar* _tmp28_ = NULL;
505
 
                                                        _tmp24_ = g_strdup ("s");
 
497
                                                xmlAttr* _tmp23_;
 
498
                                                const gchar* _tmp24_;
 
499
                                                _tmp23_ = prop;
 
500
                                                _tmp24_ = _tmp23_->name;
 
501
                                                if (g_strcmp0 (_tmp24_, "enum") == 0) {
 
502
                                                        gchar* _tmp25_;
 
503
                                                        xmlAttr* _tmp26_;
 
504
                                                        xmlNode* _tmp27_;
 
505
                                                        const gchar* _tmp28_;
 
506
                                                        gchar* _tmp29_;
 
507
                                                        _tmp25_ = g_strdup ("s");
506
508
                                                        _g_free0 (self->type);
507
 
                                                        self->type = _tmp24_;
508
 
                                                        _tmp25_ = prop;
509
 
                                                        _tmp26_ = _tmp25_->children;
510
 
                                                        _tmp27_ = _tmp26_->content;
511
 
                                                        _tmp28_ = g_strdup (_tmp27_);
 
509
                                                        self->type = _tmp25_;
 
510
                                                        _tmp26_ = prop;
 
511
                                                        _tmp27_ = _tmp26_->children;
 
512
                                                        _tmp28_ = _tmp27_->content;
 
513
                                                        _tmp29_ = g_strdup (_tmp28_);
512
514
                                                        _g_free0 (self->enum_name);
513
 
                                                        self->enum_name = _tmp28_;
 
515
                                                        self->enum_name = _tmp29_;
514
516
                                                } else {
515
 
                                                        xmlAttr* _tmp29_ = NULL;
516
 
                                                        const gchar* _tmp30_ = NULL;
517
 
                                                        _tmp29_ = prop;
518
 
                                                        _tmp30_ = _tmp29_->name;
519
 
                                                        if (g_strcmp0 (_tmp30_, "flags") == 0) {
520
 
                                                                gchar* _tmp31_ = NULL;
521
 
                                                                _tmp31_ = g_strdup ("as");
 
517
                                                        xmlAttr* _tmp30_;
 
518
                                                        const gchar* _tmp31_;
 
519
                                                        _tmp30_ = prop;
 
520
                                                        _tmp31_ = _tmp30_->name;
 
521
                                                        if (g_strcmp0 (_tmp31_, "flags") == 0) {
 
522
                                                                gchar* _tmp32_;
 
523
                                                                _tmp32_ = g_strdup ("as");
522
524
                                                                _g_free0 (self->type);
523
 
                                                                self->type = _tmp31_;
 
525
                                                                self->type = _tmp32_;
524
526
                                                        } else {
525
 
                                                                xmlAttr* _tmp32_ = NULL;
526
 
                                                                const gchar* _tmp33_ = NULL;
527
 
                                                                _tmp32_ = prop;
528
 
                                                                _tmp33_ = _tmp32_->name;
529
 
                                                                g_warning ("dconf-schema.vala:35: Unknown property on <key>, %s", _tmp33_);
 
527
                                                                xmlAttr* _tmp33_;
 
528
                                                                const gchar* _tmp34_;
 
529
                                                                _tmp33_ = prop;
 
530
                                                                _tmp34_ = _tmp33_->name;
 
531
                                                                g_warning ("dconf-schema.vala:35: Unknown property on <key>, %s", _tmp34_);
530
532
                                                        }
531
533
                                                }
532
534
                                        }
535
537
                }
536
538
        }
537
539
        {
538
 
                xmlNode* child = NULL;
539
 
                xmlNode* _tmp34_ = NULL;
540
 
                xmlNode* _tmp35_ = NULL;
541
 
                _tmp34_ = node;
542
 
                _tmp35_ = _tmp34_->children;
543
 
                child = _tmp35_;
 
540
                xmlNode* _tmp35_;
 
541
                xmlNode* _tmp36_;
 
542
                xmlNode* child;
 
543
                _tmp35_ = node;
 
544
                _tmp36_ = _tmp35_->children;
 
545
                child = _tmp36_;
544
546
                {
545
 
                        gboolean _tmp36_ = FALSE;
546
 
                        _tmp36_ = TRUE;
 
547
                        gboolean _tmp37_;
 
548
                        _tmp37_ = TRUE;
547
549
                        while (TRUE) {
548
 
                                xmlNode* _tmp39_ = NULL;
549
 
                                xmlNode* _tmp40_ = NULL;
550
 
                                const gchar* _tmp41_ = NULL;
551
 
                                if (!_tmp36_) {
552
 
                                        xmlNode* _tmp37_ = NULL;
553
 
                                        xmlNode* _tmp38_ = NULL;
554
 
                                        _tmp37_ = child;
555
 
                                        _tmp38_ = _tmp37_->next;
556
 
                                        child = _tmp38_;
 
550
                                gboolean _tmp38_;
 
551
                                xmlNode* _tmp41_;
 
552
                                xmlNode* _tmp42_;
 
553
                                const gchar* _tmp43_;
 
554
                                _tmp38_ = _tmp37_;
 
555
                                if (!_tmp38_) {
 
556
                                        xmlNode* _tmp39_;
 
557
                                        xmlNode* _tmp40_;
 
558
                                        _tmp39_ = child;
 
559
                                        _tmp40_ = _tmp39_->next;
 
560
                                        child = _tmp40_;
557
561
                                }
558
 
                                _tmp36_ = FALSE;
559
 
                                _tmp39_ = child;
560
 
                                if (!(_tmp39_ != NULL)) {
 
562
                                _tmp37_ = FALSE;
 
563
                                _tmp41_ = child;
 
564
                                if (!(_tmp41_ != NULL)) {
561
565
                                        break;
562
566
                                }
563
 
                                _tmp40_ = child;
564
 
                                _tmp41_ = _tmp40_->name;
565
 
                                if (g_strcmp0 (_tmp41_, "default") == 0) {
 
567
                                _tmp42_ = child;
 
568
                                _tmp43_ = _tmp42_->name;
 
569
                                if (g_strcmp0 (_tmp43_, "default") == 0) {
566
570
                                        {
567
 
                                                GVariant* _tmp42_ = NULL;
568
 
                                                const gchar* _tmp43_ = NULL;
569
 
                                                GVariantType* _tmp44_ = NULL;
570
 
                                                GVariantType* _tmp45_ = NULL;
571
 
                                                xmlNode* _tmp46_ = NULL;
572
 
                                                gchar* _tmp47_ = NULL;
 
571
                                                const gchar* _tmp44_;
 
572
                                                GVariantType* _tmp45_;
 
573
                                                GVariantType* _tmp46_;
 
574
                                                xmlNode* _tmp47_;
573
575
                                                gchar* _tmp48_ = NULL;
574
 
                                                GVariant* _tmp49_ = NULL;
 
576
                                                gchar* _tmp49_;
575
577
                                                GVariant* _tmp50_ = NULL;
576
 
                                                GVariant* _tmp51_ = NULL;
577
 
                                                _tmp43_ = self->type;
578
 
                                                _tmp44_ = g_variant_type_new (_tmp43_);
579
 
                                                _tmp45_ = _tmp44_;
580
 
                                                _tmp46_ = child;
581
 
                                                _tmp47_ = (gchar*) xmlNodeGetContent (_tmp46_);
582
 
                                                _tmp48_ = _tmp47_;
583
 
                                                _tmp49_ = g_variant_parse (_tmp45_, _tmp48_, NULL, NULL, &_inner_error_);
584
 
                                                _tmp50_ = _tmp49_;
585
 
                                                _g_free0 (_tmp48_);
586
 
                                                _g_variant_type_free0 (_tmp45_);
587
 
                                                _tmp42_ = _tmp50_;
 
578
                                                GVariant* _tmp51_;
 
579
                                                GVariant* _tmp52_;
 
580
                                                _tmp44_ = self->type;
 
581
                                                _tmp45_ = g_variant_type_new (_tmp44_);
 
582
                                                _tmp46_ = _tmp45_;
 
583
                                                _tmp47_ = child;
 
584
                                                _tmp48_ = xmlNodeGetContent (_tmp47_);
 
585
                                                _tmp49_ = _tmp48_;
 
586
                                                _tmp50_ = g_variant_parse (_tmp46_, _tmp49_, NULL, NULL, &_inner_error_);
 
587
                                                _tmp51_ = _tmp50_;
 
588
                                                _g_free0 (_tmp49_);
 
589
                                                _g_variant_type_free0 (_tmp46_);
 
590
                                                _tmp52_ = _tmp51_;
588
591
                                                if (_inner_error_ != NULL) {
589
592
                                                        if (_inner_error_->domain == G_VARIANT_PARSE_ERROR) {
590
593
                                                                goto __catch5_g_variant_parse_error;
593
596
                                                        g_clear_error (&_inner_error_);
594
597
                                                        return NULL;
595
598
                                                }
596
 
                                                _tmp51_ = _tmp42_;
597
 
                                                _tmp42_ = NULL;
598
599
                                                _g_variant_unref0 (self->default_value);
599
 
                                                self->default_value = _tmp51_;
600
 
                                                _g_variant_unref0 (_tmp42_);
 
600
                                                self->default_value = _tmp52_;
601
601
                                        }
602
602
                                        goto __finally5;
603
603
                                        __catch5_g_variant_parse_error:
614
614
                                                return NULL;
615
615
                                        }
616
616
                                } else {
617
 
                                        xmlNode* _tmp52_ = NULL;
618
 
                                        const gchar* _tmp53_ = NULL;
619
 
                                        _tmp52_ = child;
620
 
                                        _tmp53_ = _tmp52_->name;
621
 
                                        if (g_strcmp0 (_tmp53_, "summary") == 0) {
622
 
                                                xmlNode* _tmp54_ = NULL;
623
 
                                                gchar* _tmp55_ = NULL;
624
 
                                                _tmp54_ = child;
625
 
                                                _tmp55_ = (gchar*) xmlNodeGetContent (_tmp54_);
 
617
                                        xmlNode* _tmp53_;
 
618
                                        const gchar* _tmp54_;
 
619
                                        _tmp53_ = child;
 
620
                                        _tmp54_ = _tmp53_->name;
 
621
                                        if (g_strcmp0 (_tmp54_, "summary") == 0) {
 
622
                                                xmlNode* _tmp55_;
 
623
                                                gchar* _tmp56_ = NULL;
 
624
                                                _tmp55_ = child;
 
625
                                                _tmp56_ = xmlNodeGetContent (_tmp55_);
626
626
                                                _g_free0 (self->summary);
627
 
                                                self->summary = _tmp55_;
 
627
                                                self->summary = _tmp56_;
628
628
                                        } else {
629
 
                                                xmlNode* _tmp56_ = NULL;
630
 
                                                const gchar* _tmp57_ = NULL;
631
 
                                                _tmp56_ = child;
632
 
                                                _tmp57_ = _tmp56_->name;
633
 
                                                if (g_strcmp0 (_tmp57_, "description") == 0) {
634
 
                                                        xmlNode* _tmp58_ = NULL;
635
 
                                                        gchar* _tmp59_ = NULL;
636
 
                                                        _tmp58_ = child;
637
 
                                                        _tmp59_ = (gchar*) xmlNodeGetContent (_tmp58_);
 
629
                                                xmlNode* _tmp57_;
 
630
                                                const gchar* _tmp58_;
 
631
                                                _tmp57_ = child;
 
632
                                                _tmp58_ = _tmp57_->name;
 
633
                                                if (g_strcmp0 (_tmp58_, "description") == 0) {
 
634
                                                        xmlNode* _tmp59_;
 
635
                                                        gchar* _tmp60_ = NULL;
 
636
                                                        _tmp59_ = child;
 
637
                                                        _tmp60_ = xmlNodeGetContent (_tmp59_);
638
638
                                                        _g_free0 (self->description);
639
 
                                                        self->description = _tmp59_;
 
639
                                                        self->description = _tmp60_;
640
640
                                                } else {
641
 
                                                        xmlNode* _tmp60_ = NULL;
642
 
                                                        const gchar* _tmp61_ = NULL;
643
 
                                                        _tmp60_ = child;
644
 
                                                        _tmp61_ = _tmp60_->name;
645
 
                                                        if (g_strcmp0 (_tmp61_, "range") == 0) {
646
 
                                                                const gchar* _tmp62_ = NULL;
647
 
                                                                xmlNode* _tmp63_ = NULL;
648
 
                                                                SchemaValueRange* _tmp64_ = NULL;
649
 
                                                                _tmp62_ = self->type;
650
 
                                                                _tmp63_ = child;
651
 
                                                                _tmp64_ = schema_value_range_new_from_xml (_tmp62_, _tmp63_);
 
641
                                                        xmlNode* _tmp61_;
 
642
                                                        const gchar* _tmp62_;
 
643
                                                        _tmp61_ = child;
 
644
                                                        _tmp62_ = _tmp61_->name;
 
645
                                                        if (g_strcmp0 (_tmp62_, "range") == 0) {
 
646
                                                                const gchar* _tmp63_;
 
647
                                                                xmlNode* _tmp64_;
 
648
                                                                SchemaValueRange* _tmp65_;
 
649
                                                                _tmp63_ = self->type;
 
650
                                                                _tmp64_ = child;
 
651
                                                                _tmp65_ = schema_value_range_new_from_xml (_tmp63_, _tmp64_);
652
652
                                                                _schema_value_range_unref0 (self->range);
653
 
                                                                self->range = _tmp64_;
 
653
                                                                self->range = _tmp65_;
654
654
                                                        } else {
655
 
                                                                xmlNode* _tmp65_ = NULL;
656
 
                                                                const gchar* _tmp66_ = NULL;
657
 
                                                                _tmp65_ = child;
658
 
                                                                _tmp66_ = _tmp65_->name;
659
 
                                                                if (g_strcmp0 (_tmp66_, "choices") == 0) {
 
655
                                                                xmlNode* _tmp66_;
 
656
                                                                const gchar* _tmp67_;
 
657
                                                                _tmp66_ = child;
 
658
                                                                _tmp67_ = _tmp66_->name;
 
659
                                                                if (g_strcmp0 (_tmp67_, "choices") == 0) {
660
660
                                                                        {
661
 
                                                                                xmlNode* n = NULL;
662
 
                                                                                xmlNode* _tmp67_ = NULL;
663
 
                                                                                xmlNode* _tmp68_ = NULL;
664
 
                                                                                _tmp67_ = child;
665
 
                                                                                _tmp68_ = _tmp67_->children;
666
 
                                                                                n = _tmp68_;
 
661
                                                                                xmlNode* _tmp68_;
 
662
                                                                                xmlNode* _tmp69_;
 
663
                                                                                xmlNode* n;
 
664
                                                                                _tmp68_ = child;
 
665
                                                                                _tmp69_ = _tmp68_->children;
 
666
                                                                                n = _tmp69_;
667
667
                                                                                {
668
 
                                                                                        gboolean _tmp69_ = FALSE;
669
 
                                                                                        _tmp69_ = TRUE;
 
668
                                                                                        gboolean _tmp70_;
 
669
                                                                                        _tmp70_ = TRUE;
670
670
                                                                                        while (TRUE) {
671
 
                                                                                                xmlNode* _tmp72_ = NULL;
672
 
                                                                                                xmlNode* _tmp73_ = NULL;
673
 
                                                                                                xmlElementType _tmp74_ = 0;
674
 
                                                                                                xmlNode* _tmp75_ = NULL;
675
 
                                                                                                const gchar* _tmp76_ = NULL;
676
 
                                                                                                gchar* value = NULL;
677
 
                                                                                                const gchar* _tmp93_ = NULL;
678
 
                                                                                                GVariant* v = NULL;
679
 
                                                                                                const gchar* _tmp94_ = NULL;
680
 
                                                                                                GVariant* _tmp95_ = NULL;
681
 
                                                                                                const gchar* _tmp96_ = NULL;
682
 
                                                                                                GVariant* _tmp97_ = NULL;
683
 
                                                                                                SchemaChoice* _tmp98_ = NULL;
684
 
                                                                                                if (!_tmp69_) {
685
 
                                                                                                        xmlNode* _tmp70_ = NULL;
686
 
                                                                                                        xmlNode* _tmp71_ = NULL;
687
 
                                                                                                        _tmp70_ = n;
688
 
                                                                                                        _tmp71_ = _tmp70_->next;
689
 
                                                                                                        n = _tmp71_;
 
671
                                                                                                gboolean _tmp71_;
 
672
                                                                                                xmlNode* _tmp74_;
 
673
                                                                                                xmlNode* _tmp75_;
 
674
                                                                                                xmlElementType _tmp76_;
 
675
                                                                                                xmlNode* _tmp77_;
 
676
                                                                                                const gchar* _tmp78_;
 
677
                                                                                                gchar* value;
 
678
                                                                                                const gchar* _tmp96_;
 
679
                                                                                                const gchar* _tmp97_;
 
680
                                                                                                GVariant* _tmp98_;
 
681
                                                                                                GVariant* v;
 
682
                                                                                                const gchar* _tmp99_;
 
683
                                                                                                GVariant* _tmp100_;
 
684
                                                                                                SchemaChoice* _tmp101_;
 
685
                                                                                                _tmp71_ = _tmp70_;
 
686
                                                                                                if (!_tmp71_) {
 
687
                                                                                                        xmlNode* _tmp72_;
 
688
                                                                                                        xmlNode* _tmp73_;
 
689
                                                                                                        _tmp72_ = n;
 
690
                                                                                                        _tmp73_ = _tmp72_->next;
 
691
                                                                                                        n = _tmp73_;
690
692
                                                                                                }
691
 
                                                                                                _tmp69_ = FALSE;
692
 
                                                                                                _tmp72_ = n;
693
 
                                                                                                if (!(_tmp72_ != NULL)) {
 
693
                                                                                                _tmp70_ = FALSE;
 
694
                                                                                                _tmp74_ = n;
 
695
                                                                                                if (!(_tmp74_ != NULL)) {
694
696
                                                                                                        break;
695
697
                                                                                                }
696
 
                                                                                                _tmp73_ = n;
697
 
                                                                                                _tmp74_ = _tmp73_->type;
698
 
                                                                                                if (_tmp74_ != XML_ELEMENT_NODE) {
699
 
                                                                                                        continue;
700
 
                                                                                                }
701
698
                                                                                                _tmp75_ = n;
702
 
                                                                                                _tmp76_ = _tmp75_->name;
703
 
                                                                                                if (g_strcmp0 (_tmp76_, "choice") != 0) {
704
 
                                                                                                        xmlNode* _tmp77_ = NULL;
705
 
                                                                                                        const gchar* _tmp78_ = NULL;
706
 
                                                                                                        _tmp77_ = n;
707
 
                                                                                                        _tmp78_ = _tmp77_->name;
708
 
                                                                                                        g_warning ("dconf-schema.vala:68: Unknown child tag in <choices>, <%s>", _tmp78_);
 
699
                                                                                                _tmp76_ = _tmp75_->type;
 
700
                                                                                                if (_tmp76_ != XML_ELEMENT_NODE) {
 
701
                                                                                                        continue;
 
702
                                                                                                }
 
703
                                                                                                _tmp77_ = n;
 
704
                                                                                                _tmp78_ = _tmp77_->name;
 
705
                                                                                                if (g_strcmp0 (_tmp78_, "choice") != 0) {
 
706
                                                                                                        xmlNode* _tmp79_;
 
707
                                                                                                        const gchar* _tmp80_;
 
708
                                                                                                        _tmp79_ = n;
 
709
                                                                                                        _tmp80_ = _tmp79_->name;
 
710
                                                                                                        g_warning ("dconf-schema.vala:68: Unknown child tag in <choices>, <%s>", _tmp80_);
709
711
                                                                                                        continue;
710
712
                                                                                                }
711
713
                                                                                                value = NULL;
712
714
                                                                                                {
713
 
                                                                                                        xmlAttr* prop = NULL;
714
 
                                                                                                        xmlNode* _tmp79_ = NULL;
715
 
                                                                                                        xmlAttr* _tmp80_ = NULL;
716
 
                                                                                                        _tmp79_ = n;
717
 
                                                                                                        _tmp80_ = _tmp79_->properties;
718
 
                                                                                                        prop = _tmp80_;
 
715
                                                                                                        xmlNode* _tmp81_;
 
716
                                                                                                        xmlAttr* _tmp82_;
 
717
                                                                                                        xmlAttr* prop;
 
718
                                                                                                        _tmp81_ = n;
 
719
                                                                                                        _tmp82_ = _tmp81_->properties;
 
720
                                                                                                        prop = _tmp82_;
719
721
                                                                                                        {
720
 
                                                                                                                gboolean _tmp81_ = FALSE;
721
 
                                                                                                                _tmp81_ = TRUE;
 
722
                                                                                                                gboolean _tmp83_;
 
723
                                                                                                                _tmp83_ = TRUE;
722
724
                                                                                                                while (TRUE) {
723
 
                                                                                                                        xmlAttr* _tmp84_ = NULL;
724
 
                                                                                                                        xmlAttr* _tmp85_ = NULL;
725
 
                                                                                                                        const gchar* _tmp86_ = NULL;
726
 
                                                                                                                        if (!_tmp81_) {
727
 
                                                                                                                                xmlAttr* _tmp82_ = NULL;
728
 
                                                                                                                                xmlAttr* _tmp83_ = NULL;
729
 
                                                                                                                                _tmp82_ = prop;
730
 
                                                                                                                                _tmp83_ = _tmp82_->next;
731
 
                                                                                                                                prop = _tmp83_;
 
725
                                                                                                                        gboolean _tmp84_;
 
726
                                                                                                                        xmlAttr* _tmp87_;
 
727
                                                                                                                        xmlAttr* _tmp88_;
 
728
                                                                                                                        const gchar* _tmp89_;
 
729
                                                                                                                        _tmp84_ = _tmp83_;
 
730
                                                                                                                        if (!_tmp84_) {
 
731
                                                                                                                                xmlAttr* _tmp85_;
 
732
                                                                                                                                xmlAttr* _tmp86_;
 
733
                                                                                                                                _tmp85_ = prop;
 
734
                                                                                                                                _tmp86_ = _tmp85_->next;
 
735
                                                                                                                                prop = _tmp86_;
732
736
                                                                                                                        }
733
 
                                                                                                                        _tmp81_ = FALSE;
734
 
                                                                                                                        _tmp84_ = prop;
735
 
                                                                                                                        if (!(_tmp84_ != NULL)) {
 
737
                                                                                                                        _tmp83_ = FALSE;
 
738
                                                                                                                        _tmp87_ = prop;
 
739
                                                                                                                        if (!(_tmp87_ != NULL)) {
736
740
                                                                                                                                break;
737
741
                                                                                                                        }
738
 
                                                                                                                        _tmp85_ = prop;
739
 
                                                                                                                        _tmp86_ = _tmp85_->name;
740
 
                                                                                                                        if (g_strcmp0 (_tmp86_, "value") == 0) {
741
 
                                                                                                                                xmlAttr* _tmp87_ = NULL;
742
 
                                                                                                                                xmlNode* _tmp88_ = NULL;
743
 
                                                                                                                                const gchar* _tmp89_ = NULL;
744
 
                                                                                                                                gchar* _tmp90_ = NULL;
745
 
                                                                                                                                _tmp87_ = prop;
746
 
                                                                                                                                _tmp88_ = _tmp87_->children;
747
 
                                                                                                                                _tmp89_ = _tmp88_->content;
748
 
                                                                                                                                _tmp90_ = g_strdup (_tmp89_);
 
742
                                                                                                                        _tmp88_ = prop;
 
743
                                                                                                                        _tmp89_ = _tmp88_->name;
 
744
                                                                                                                        if (g_strcmp0 (_tmp89_, "value") == 0) {
 
745
                                                                                                                                xmlAttr* _tmp90_;
 
746
                                                                                                                                xmlNode* _tmp91_;
 
747
                                                                                                                                const gchar* _tmp92_;
 
748
                                                                                                                                gchar* _tmp93_;
 
749
                                                                                                                                _tmp90_ = prop;
 
750
                                                                                                                                _tmp91_ = _tmp90_->children;
 
751
                                                                                                                                _tmp92_ = _tmp91_->content;
 
752
                                                                                                                                _tmp93_ = g_strdup (_tmp92_);
749
753
                                                                                                                                _g_free0 (value);
750
 
                                                                                                                                value = _tmp90_;
 
754
                                                                                                                                value = _tmp93_;
751
755
                                                                                                                        } else {
752
 
                                                                                                                                xmlAttr* _tmp91_ = NULL;
753
 
                                                                                                                                const gchar* _tmp92_ = NULL;
754
 
                                                                                                                                _tmp91_ = prop;
755
 
                                                                                                                                _tmp92_ = _tmp91_->name;
756
 
                                                                                                                                g_warning ("dconf-schema.vala:78: Unknown property on <choice>, %s", _tmp92_);
 
756
                                                                                                                                xmlAttr* _tmp94_;
 
757
                                                                                                                                const gchar* _tmp95_;
 
758
                                                                                                                                _tmp94_ = prop;
 
759
                                                                                                                                _tmp95_ = _tmp94_->name;
 
760
                                                                                                                                g_warning ("dconf-schema.vala:78: Unknown property on <choice>, %s", _tmp95_);
757
761
                                                                                                                        }
758
762
                                                                                                                }
759
763
                                                                                                        }
760
764
                                                                                                }
761
 
                                                                                                _tmp93_ = value;
762
 
                                                                                                if (_tmp93_ == NULL) {
 
765
                                                                                                _tmp96_ = value;
 
766
                                                                                                if (_tmp96_ == NULL) {
763
767
                                                                                                        g_warning ("dconf-schema.vala:83: Ignoring <choice> with no value");
764
768
                                                                                                        _g_free0 (value);
765
769
                                                                                                        continue;
766
770
                                                                                                }
767
 
                                                                                                _tmp94_ = value;
768
 
                                                                                                _tmp95_ = g_variant_new_string (_tmp94_);
769
 
                                                                                                g_variant_ref_sink (_tmp95_);
770
 
                                                                                                v = _tmp95_;
771
 
                                                                                                _tmp96_ = value;
772
 
                                                                                                _tmp97_ = v;
773
 
                                                                                                _tmp98_ = schema_choice_new (_tmp96_, _tmp97_);
774
 
                                                                                                self->choices = g_list_append (self->choices, _tmp98_);
 
771
                                                                                                _tmp97_ = value;
 
772
                                                                                                _tmp98_ = g_variant_new_string (_tmp97_);
 
773
                                                                                                g_variant_ref_sink (_tmp98_);
 
774
                                                                                                v = _tmp98_;
 
775
                                                                                                _tmp99_ = value;
 
776
                                                                                                _tmp100_ = v;
 
777
                                                                                                _tmp101_ = schema_choice_new (_tmp99_, _tmp100_);
 
778
                                                                                                self->choices = g_list_append (self->choices, _tmp101_);
775
779
                                                                                                _g_variant_unref0 (v);
776
780
                                                                                                _g_free0 (value);
777
781
                                                                                        }
778
782
                                                                                }
779
783
                                                                        }
780
784
                                                                } else {
781
 
                                                                        xmlNode* _tmp99_ = NULL;
782
 
                                                                        const gchar* _tmp100_ = NULL;
783
 
                                                                        _tmp99_ = child;
784
 
                                                                        _tmp100_ = _tmp99_->name;
785
 
                                                                        if (g_strcmp0 (_tmp100_, "aliases") == 0) {
 
785
                                                                        xmlNode* _tmp102_;
 
786
                                                                        const gchar* _tmp103_;
 
787
                                                                        _tmp102_ = child;
 
788
                                                                        _tmp103_ = _tmp102_->name;
 
789
                                                                        if (g_strcmp0 (_tmp103_, "aliases") == 0) {
786
790
                                                                                {
787
 
                                                                                        xmlNode* n = NULL;
788
 
                                                                                        xmlNode* _tmp101_ = NULL;
789
 
                                                                                        xmlNode* _tmp102_ = NULL;
790
 
                                                                                        _tmp101_ = child;
791
 
                                                                                        _tmp102_ = _tmp101_->children;
792
 
                                                                                        n = _tmp102_;
 
791
                                                                                        xmlNode* _tmp104_;
 
792
                                                                                        xmlNode* _tmp105_;
 
793
                                                                                        xmlNode* n;
 
794
                                                                                        _tmp104_ = child;
 
795
                                                                                        _tmp105_ = _tmp104_->children;
 
796
                                                                                        n = _tmp105_;
793
797
                                                                                        {
794
 
                                                                                                gboolean _tmp103_ = FALSE;
795
 
                                                                                                _tmp103_ = TRUE;
 
798
                                                                                                gboolean _tmp106_;
 
799
                                                                                                _tmp106_ = TRUE;
796
800
                                                                                                while (TRUE) {
797
 
                                                                                                        xmlNode* _tmp106_ = NULL;
798
 
                                                                                                        xmlNode* _tmp107_ = NULL;
799
 
                                                                                                        xmlElementType _tmp108_ = 0;
800
 
                                                                                                        xmlNode* _tmp109_ = NULL;
801
 
                                                                                                        const gchar* _tmp110_ = NULL;
802
 
                                                                                                        gchar* value = NULL;
803
 
                                                                                                        gchar* target = NULL;
804
 
                                                                                                        const gchar* _tmp133_ = NULL;
805
 
                                                                                                        const gchar* _tmp134_ = NULL;
806
 
                                                                                                        GVariant* v = NULL;
807
 
                                                                                                        const gchar* _tmp135_ = NULL;
808
 
                                                                                                        GVariant* _tmp136_ = NULL;
809
 
                                                                                                        const gchar* _tmp137_ = NULL;
810
 
                                                                                                        GVariant* _tmp138_ = NULL;
811
 
                                                                                                        SchemaChoice* _tmp139_ = NULL;
812
 
                                                                                                        if (!_tmp103_) {
813
 
                                                                                                                xmlNode* _tmp104_ = NULL;
814
 
                                                                                                                xmlNode* _tmp105_ = NULL;
815
 
                                                                                                                _tmp104_ = n;
816
 
                                                                                                                _tmp105_ = _tmp104_->next;
817
 
                                                                                                                n = _tmp105_;
 
801
                                                                                                        gboolean _tmp107_;
 
802
                                                                                                        xmlNode* _tmp110_;
 
803
                                                                                                        xmlNode* _tmp111_;
 
804
                                                                                                        xmlElementType _tmp112_;
 
805
                                                                                                        xmlNode* _tmp113_;
 
806
                                                                                                        const gchar* _tmp114_;
 
807
                                                                                                        gchar* value;
 
808
                                                                                                        gchar* target;
 
809
                                                                                                        const gchar* _tmp138_;
 
810
                                                                                                        const gchar* _tmp139_;
 
811
                                                                                                        const gchar* _tmp140_;
 
812
                                                                                                        GVariant* _tmp141_;
 
813
                                                                                                        GVariant* v;
 
814
                                                                                                        const gchar* _tmp142_;
 
815
                                                                                                        GVariant* _tmp143_;
 
816
                                                                                                        SchemaChoice* _tmp144_;
 
817
                                                                                                        _tmp107_ = _tmp106_;
 
818
                                                                                                        if (!_tmp107_) {
 
819
                                                                                                                xmlNode* _tmp108_;
 
820
                                                                                                                xmlNode* _tmp109_;
 
821
                                                                                                                _tmp108_ = n;
 
822
                                                                                                                _tmp109_ = _tmp108_->next;
 
823
                                                                                                                n = _tmp109_;
818
824
                                                                                                        }
819
 
                                                                                                        _tmp103_ = FALSE;
820
 
                                                                                                        _tmp106_ = n;
821
 
                                                                                                        if (!(_tmp106_ != NULL)) {
 
825
                                                                                                        _tmp106_ = FALSE;
 
826
                                                                                                        _tmp110_ = n;
 
827
                                                                                                        if (!(_tmp110_ != NULL)) {
822
828
                                                                                                                break;
823
829
                                                                                                        }
824
 
                                                                                                        _tmp107_ = n;
825
 
                                                                                                        _tmp108_ = _tmp107_->type;
826
 
                                                                                                        if (_tmp108_ != XML_ELEMENT_NODE) {
 
830
                                                                                                        _tmp111_ = n;
 
831
                                                                                                        _tmp112_ = _tmp111_->type;
 
832
                                                                                                        if (_tmp112_ != XML_ELEMENT_NODE) {
827
833
                                                                                                                continue;
828
834
                                                                                                        }
829
 
                                                                                                        _tmp109_ = n;
830
 
                                                                                                        _tmp110_ = _tmp109_->name;
831
 
                                                                                                        if (g_strcmp0 (_tmp110_, "alias") != 0) {
832
 
                                                                                                                xmlNode* _tmp111_ = NULL;
833
 
                                                                                                                const gchar* _tmp112_ = NULL;
834
 
                                                                                                                _tmp111_ = n;
835
 
                                                                                                                _tmp112_ = _tmp111_->name;
836
 
                                                                                                                g_warning ("dconf-schema.vala:99: Unknown child tag in <aliases>, <%s>", _tmp112_);
 
835
                                                                                                        _tmp113_ = n;
 
836
                                                                                                        _tmp114_ = _tmp113_->name;
 
837
                                                                                                        if (g_strcmp0 (_tmp114_, "alias") != 0) {
 
838
                                                                                                                xmlNode* _tmp115_;
 
839
                                                                                                                const gchar* _tmp116_;
 
840
                                                                                                                _tmp115_ = n;
 
841
                                                                                                                _tmp116_ = _tmp115_->name;
 
842
                                                                                                                g_warning ("dconf-schema.vala:99: Unknown child tag in <aliases>, <%s>", _tmp116_);
837
843
                                                                                                                continue;
838
844
                                                                                                        }
839
845
                                                                                                        value = NULL;
840
846
                                                                                                        target = NULL;
841
847
                                                                                                        {
842
 
                                                                                                                xmlAttr* prop = NULL;
843
 
                                                                                                                xmlNode* _tmp113_ = NULL;
844
 
                                                                                                                xmlAttr* _tmp114_ = NULL;
845
 
                                                                                                                _tmp113_ = n;
846
 
                                                                                                                _tmp114_ = _tmp113_->properties;
847
 
                                                                                                                prop = _tmp114_;
 
848
                                                                                                                xmlNode* _tmp117_;
 
849
                                                                                                                xmlAttr* _tmp118_;
 
850
                                                                                                                xmlAttr* prop;
 
851
                                                                                                                _tmp117_ = n;
 
852
                                                                                                                _tmp118_ = _tmp117_->properties;
 
853
                                                                                                                prop = _tmp118_;
848
854
                                                                                                                {
849
 
                                                                                                                        gboolean _tmp115_ = FALSE;
850
 
                                                                                                                        _tmp115_ = TRUE;
 
855
                                                                                                                        gboolean _tmp119_;
 
856
                                                                                                                        _tmp119_ = TRUE;
851
857
                                                                                                                        while (TRUE) {
852
 
                                                                                                                                xmlAttr* _tmp118_ = NULL;
853
 
                                                                                                                                xmlAttr* _tmp119_ = NULL;
854
 
                                                                                                                                const gchar* _tmp120_ = NULL;
855
 
                                                                                                                                if (!_tmp115_) {
856
 
                                                                                                                                        xmlAttr* _tmp116_ = NULL;
857
 
                                                                                                                                        xmlAttr* _tmp117_ = NULL;
858
 
                                                                                                                                        _tmp116_ = prop;
859
 
                                                                                                                                        _tmp117_ = _tmp116_->next;
860
 
                                                                                                                                        prop = _tmp117_;
 
858
                                                                                                                                gboolean _tmp120_;
 
859
                                                                                                                                xmlAttr* _tmp123_;
 
860
                                                                                                                                xmlAttr* _tmp124_;
 
861
                                                                                                                                const gchar* _tmp125_;
 
862
                                                                                                                                _tmp120_ = _tmp119_;
 
863
                                                                                                                                if (!_tmp120_) {
 
864
                                                                                                                                        xmlAttr* _tmp121_;
 
865
                                                                                                                                        xmlAttr* _tmp122_;
 
866
                                                                                                                                        _tmp121_ = prop;
 
867
                                                                                                                                        _tmp122_ = _tmp121_->next;
 
868
                                                                                                                                        prop = _tmp122_;
861
869
                                                                                                                                }
862
 
                                                                                                                                _tmp115_ = FALSE;
863
 
                                                                                                                                _tmp118_ = prop;
864
 
                                                                                                                                if (!(_tmp118_ != NULL)) {
 
870
                                                                                                                                _tmp119_ = FALSE;
 
871
                                                                                                                                _tmp123_ = prop;
 
872
                                                                                                                                if (!(_tmp123_ != NULL)) {
865
873
                                                                                                                                        break;
866
874
                                                                                                                                }
867
 
                                                                                                                                _tmp119_ = prop;
868
 
                                                                                                                                _tmp120_ = _tmp119_->name;
869
 
                                                                                                                                if (g_strcmp0 (_tmp120_, "value") == 0) {
870
 
                                                                                                                                        xmlAttr* _tmp121_ = NULL;
871
 
                                                                                                                                        xmlNode* _tmp122_ = NULL;
872
 
                                                                                                                                        const gchar* _tmp123_ = NULL;
873
 
                                                                                                                                        gchar* _tmp124_ = NULL;
874
 
                                                                                                                                        _tmp121_ = prop;
875
 
                                                                                                                                        _tmp122_ = _tmp121_->children;
876
 
                                                                                                                                        _tmp123_ = _tmp122_->content;
877
 
                                                                                                                                        _tmp124_ = g_strdup (_tmp123_);
 
875
                                                                                                                                _tmp124_ = prop;
 
876
                                                                                                                                _tmp125_ = _tmp124_->name;
 
877
                                                                                                                                if (g_strcmp0 (_tmp125_, "value") == 0) {
 
878
                                                                                                                                        xmlAttr* _tmp126_;
 
879
                                                                                                                                        xmlNode* _tmp127_;
 
880
                                                                                                                                        const gchar* _tmp128_;
 
881
                                                                                                                                        gchar* _tmp129_;
 
882
                                                                                                                                        _tmp126_ = prop;
 
883
                                                                                                                                        _tmp127_ = _tmp126_->children;
 
884
                                                                                                                                        _tmp128_ = _tmp127_->content;
 
885
                                                                                                                                        _tmp129_ = g_strdup (_tmp128_);
878
886
                                                                                                                                        _g_free0 (value);
879
 
                                                                                                                                        value = _tmp124_;
 
887
                                                                                                                                        value = _tmp129_;
880
888
                                                                                                                                } else {
881
 
                                                                                                                                        xmlAttr* _tmp125_ = NULL;
882
 
                                                                                                                                        const gchar* _tmp126_ = NULL;
883
 
                                                                                                                                        _tmp125_ = prop;
884
 
                                                                                                                                        _tmp126_ = _tmp125_->name;
885
 
                                                                                                                                        if (g_strcmp0 (_tmp126_, "target") == 0) {
886
 
                                                                                                                                                xmlAttr* _tmp127_ = NULL;
887
 
                                                                                                                                                xmlNode* _tmp128_ = NULL;
888
 
                                                                                                                                                const gchar* _tmp129_ = NULL;
889
 
                                                                                                                                                gchar* _tmp130_ = NULL;
890
 
                                                                                                                                                _tmp127_ = prop;
891
 
                                                                                                                                                _tmp128_ = _tmp127_->children;
892
 
                                                                                                                                                _tmp129_ = _tmp128_->content;
893
 
                                                                                                                                                _tmp130_ = g_strdup (_tmp129_);
 
889
                                                                                                                                        xmlAttr* _tmp130_;
 
890
                                                                                                                                        const gchar* _tmp131_;
 
891
                                                                                                                                        _tmp130_ = prop;
 
892
                                                                                                                                        _tmp131_ = _tmp130_->name;
 
893
                                                                                                                                        if (g_strcmp0 (_tmp131_, "target") == 0) {
 
894
                                                                                                                                                xmlAttr* _tmp132_;
 
895
                                                                                                                                                xmlNode* _tmp133_;
 
896
                                                                                                                                                const gchar* _tmp134_;
 
897
                                                                                                                                                gchar* _tmp135_;
 
898
                                                                                                                                                _tmp132_ = prop;
 
899
                                                                                                                                                _tmp133_ = _tmp132_->children;
 
900
                                                                                                                                                _tmp134_ = _tmp133_->content;
 
901
                                                                                                                                                _tmp135_ = g_strdup (_tmp134_);
894
902
                                                                                                                                                _g_free0 (target);
895
 
                                                                                                                                                target = _tmp130_;
 
903
                                                                                                                                                target = _tmp135_;
896
904
                                                                                                                                        } else {
897
 
                                                                                                                                                xmlAttr* _tmp131_ = NULL;
898
 
                                                                                                                                                const gchar* _tmp132_ = NULL;
899
 
                                                                                                                                                _tmp131_ = prop;
900
 
                                                                                                                                                _tmp132_ = _tmp131_->name;
901
 
                                                                                                                                                g_warning ("dconf-schema.vala:111: Unknown property on <alias>, %s", _tmp132_);
 
905
                                                                                                                                                xmlAttr* _tmp136_;
 
906
                                                                                                                                                const gchar* _tmp137_;
 
907
                                                                                                                                                _tmp136_ = prop;
 
908
                                                                                                                                                _tmp137_ = _tmp136_->name;
 
909
                                                                                                                                                g_warning ("dconf-schema.vala:111: Unknown property on <alias>, %s", _tmp137_);
902
910
                                                                                                                                        }
903
911
                                                                                                                                }
904
912
                                                                                                                        }
905
913
                                                                                                                }
906
914
                                                                                                        }
907
 
                                                                                                        _tmp133_ = value;
908
 
                                                                                                        if (_tmp133_ == NULL) {
 
915
                                                                                                        _tmp138_ = value;
 
916
                                                                                                        if (_tmp138_ == NULL) {
909
917
                                                                                                                g_warning ("dconf-schema.vala:116: Ignoring <alias> with no value");
910
918
                                                                                                                _g_free0 (target);
911
919
                                                                                                                _g_free0 (value);
912
920
                                                                                                                continue;
913
921
                                                                                                        }
914
 
                                                                                                        _tmp134_ = target;
915
 
                                                                                                        if (_tmp134_ == NULL) {
 
922
                                                                                                        _tmp139_ = target;
 
923
                                                                                                        if (_tmp139_ == NULL) {
916
924
                                                                                                                g_warning ("dconf-schema.vala:121: Ignoring <alias> with no target");
917
925
                                                                                                                _g_free0 (target);
918
926
                                                                                                                _g_free0 (value);
919
927
                                                                                                                continue;
920
928
                                                                                                        }
921
 
                                                                                                        _tmp135_ = target;
922
 
                                                                                                        _tmp136_ = g_variant_new_string (_tmp135_);
923
 
                                                                                                        g_variant_ref_sink (_tmp136_);
924
 
                                                                                                        v = _tmp136_;
925
 
                                                                                                        _tmp137_ = value;
926
 
                                                                                                        _tmp138_ = v;
927
 
                                                                                                        _tmp139_ = schema_choice_new (_tmp137_, _tmp138_);
928
 
                                                                                                        self->choices = g_list_append (self->choices, _tmp139_);
 
929
                                                                                                        _tmp140_ = target;
 
930
                                                                                                        _tmp141_ = g_variant_new_string (_tmp140_);
 
931
                                                                                                        g_variant_ref_sink (_tmp141_);
 
932
                                                                                                        v = _tmp141_;
 
933
                                                                                                        _tmp142_ = value;
 
934
                                                                                                        _tmp143_ = v;
 
935
                                                                                                        _tmp144_ = schema_choice_new (_tmp142_, _tmp143_);
 
936
                                                                                                        self->choices = g_list_append (self->choices, _tmp144_);
929
937
                                                                                                        _g_variant_unref0 (v);
930
938
                                                                                                        _g_free0 (target);
931
939
                                                                                                        _g_free0 (value);
933
941
                                                                                        }
934
942
                                                                                }
935
943
                                                                        } else {
936
 
                                                                                gboolean _tmp140_ = FALSE;
937
 
                                                                                xmlNode* _tmp141_ = NULL;
938
 
                                                                                xmlElementType _tmp142_ = 0;
939
 
                                                                                _tmp141_ = child;
940
 
                                                                                _tmp142_ = _tmp141_->type;
941
 
                                                                                if (_tmp142_ != XML_TEXT_NODE) {
942
 
                                                                                        xmlNode* _tmp143_ = NULL;
943
 
                                                                                        xmlElementType _tmp144_ = 0;
944
 
                                                                                        _tmp143_ = child;
945
 
                                                                                        _tmp144_ = _tmp143_->type;
946
 
                                                                                        _tmp140_ = _tmp144_ != XML_COMMENT_NODE;
 
944
                                                                                gboolean _tmp145_ = FALSE;
 
945
                                                                                xmlNode* _tmp146_;
 
946
                                                                                xmlElementType _tmp147_;
 
947
                                                                                gboolean _tmp150_;
 
948
                                                                                _tmp146_ = child;
 
949
                                                                                _tmp147_ = _tmp146_->type;
 
950
                                                                                if (_tmp147_ != XML_TEXT_NODE) {
 
951
                                                                                        xmlNode* _tmp148_;
 
952
                                                                                        xmlElementType _tmp149_;
 
953
                                                                                        _tmp148_ = child;
 
954
                                                                                        _tmp149_ = _tmp148_->type;
 
955
                                                                                        _tmp145_ = _tmp149_ != XML_COMMENT_NODE;
947
956
                                                                                } else {
948
 
                                                                                        _tmp140_ = FALSE;
 
957
                                                                                        _tmp145_ = FALSE;
949
958
                                                                                }
950
 
                                                                                if (_tmp140_) {
951
 
                                                                                        xmlNode* _tmp145_ = NULL;
952
 
                                                                                        const gchar* _tmp146_ = NULL;
953
 
                                                                                        _tmp145_ = child;
954
 
                                                                                        _tmp146_ = _tmp145_->name;
955
 
                                                                                        g_warning ("dconf-schema.vala:130: Unknown child tag in <key>, <%s>", _tmp146_);
 
959
                                                                                _tmp150_ = _tmp145_;
 
960
                                                                                if (_tmp150_) {
 
961
                                                                                        xmlNode* _tmp151_;
 
962
                                                                                        const gchar* _tmp152_;
 
963
                                                                                        _tmp151_ = child;
 
964
                                                                                        _tmp152_ = _tmp151_->name;
 
965
                                                                                        g_warning ("dconf-schema.vala:130: Unknown child tag in <key>, <%s>", _tmp152_);
956
966
                                                                                }
957
967
                                                                        }
958
968
                                                                }
1156
1166
 
1157
1167
SchemaValue* schema_value_construct (GType object_type, guint index, const gchar* nick, gint value) {
1158
1168
        SchemaValue * self = NULL;
1159
 
        guint _tmp0_ = 0U;
1160
 
        const gchar* _tmp1_ = NULL;
1161
 
        gchar* _tmp2_ = NULL;
1162
 
        gint _tmp3_ = 0;
 
1169
        guint _tmp0_;
 
1170
        const gchar* _tmp1_;
 
1171
        gchar* _tmp2_;
 
1172
        gint _tmp3_;
1163
1173
        g_return_val_if_fail (nick != NULL, NULL);
1164
1174
        self = (SchemaValue*) g_object_new (object_type, NULL);
1165
1175
        _tmp0_ = index;
1216
1226
 
1217
1227
SchemaChoice* schema_choice_construct (GType object_type, const gchar* name, GVariant* value) {
1218
1228
        SchemaChoice* self = NULL;
1219
 
        const gchar* _tmp0_ = NULL;
1220
 
        gchar* _tmp1_ = NULL;
1221
 
        GVariant* _tmp2_ = NULL;
1222
 
        GVariant* _tmp3_ = NULL;
 
1229
        const gchar* _tmp0_;
 
1230
        gchar* _tmp1_;
 
1231
        GVariant* _tmp2_;
 
1232
        GVariant* _tmp3_;
1223
1233
        g_return_val_if_fail (name != NULL, NULL);
1224
1234
        g_return_val_if_fail (value != NULL, NULL);
1225
1235
        self = (SchemaChoice*) g_type_create_instance (object_type);
1407
1417
        g_return_val_if_fail (type != NULL, NULL);
1408
1418
        self = (SchemaValueRange*) g_type_create_instance (object_type);
1409
1419
        {
1410
 
                xmlAttr* prop = NULL;
1411
 
                xmlNode* _tmp0_ = NULL;
1412
 
                xmlAttr* _tmp1_ = NULL;
 
1420
                xmlNode* _tmp0_;
 
1421
                xmlAttr* _tmp1_;
 
1422
                xmlAttr* prop;
1413
1423
                _tmp0_ = node;
1414
1424
                _tmp1_ = _tmp0_->properties;
1415
1425
                prop = _tmp1_;
1416
1426
                {
1417
 
                        gboolean _tmp2_ = FALSE;
 
1427
                        gboolean _tmp2_;
1418
1428
                        _tmp2_ = TRUE;
1419
1429
                        while (TRUE) {
1420
 
                                xmlAttr* _tmp5_ = NULL;
1421
 
                                xmlAttr* _tmp6_ = NULL;
1422
 
                                const gchar* _tmp7_ = NULL;
1423
 
                                if (!_tmp2_) {
1424
 
                                        xmlAttr* _tmp3_ = NULL;
1425
 
                                        xmlAttr* _tmp4_ = NULL;
1426
 
                                        _tmp3_ = prop;
1427
 
                                        _tmp4_ = _tmp3_->next;
1428
 
                                        prop = _tmp4_;
 
1430
                                gboolean _tmp3_;
 
1431
                                xmlAttr* _tmp6_;
 
1432
                                xmlAttr* _tmp7_;
 
1433
                                const gchar* _tmp8_;
 
1434
                                _tmp3_ = _tmp2_;
 
1435
                                if (!_tmp3_) {
 
1436
                                        xmlAttr* _tmp4_;
 
1437
                                        xmlAttr* _tmp5_;
 
1438
                                        _tmp4_ = prop;
 
1439
                                        _tmp5_ = _tmp4_->next;
 
1440
                                        prop = _tmp5_;
1429
1441
                                }
1430
1442
                                _tmp2_ = FALSE;
1431
 
                                _tmp5_ = prop;
1432
 
                                if (!(_tmp5_ != NULL)) {
1433
 
                                        break;
1434
 
                                }
1435
1443
                                _tmp6_ = prop;
1436
 
                                _tmp7_ = _tmp6_->name;
1437
 
                                if (g_strcmp0 (_tmp7_, "min") == 0) {
 
1444
                                if (!(_tmp6_ != NULL)) {
 
1445
                                        break;
 
1446
                                }
 
1447
                                _tmp7_ = prop;
 
1448
                                _tmp8_ = _tmp7_->name;
 
1449
                                if (g_strcmp0 (_tmp8_, "min") == 0) {
1438
1450
                                        {
1439
 
                                                GVariant* _tmp8_ = NULL;
1440
 
                                                const gchar* _tmp9_ = NULL;
1441
 
                                                GVariantType* _tmp10_ = NULL;
1442
 
                                                GVariantType* _tmp11_ = NULL;
1443
 
                                                xmlAttr* _tmp12_ = NULL;
1444
 
                                                xmlNode* _tmp13_ = NULL;
1445
 
                                                const gchar* _tmp14_ = NULL;
 
1451
                                                const gchar* _tmp9_;
 
1452
                                                GVariantType* _tmp10_;
 
1453
                                                GVariantType* _tmp11_;
 
1454
                                                xmlAttr* _tmp12_;
 
1455
                                                xmlNode* _tmp13_;
 
1456
                                                const gchar* _tmp14_;
1446
1457
                                                GVariant* _tmp15_ = NULL;
1447
 
                                                GVariant* _tmp16_ = NULL;
1448
 
                                                GVariant* _tmp17_ = NULL;
 
1458
                                                GVariant* _tmp16_;
 
1459
                                                GVariant* _tmp17_;
1449
1460
                                                _tmp9_ = type;
1450
1461
                                                _tmp10_ = g_variant_type_new (_tmp9_);
1451
1462
                                                _tmp11_ = _tmp10_;
1455
1466
                                                _tmp15_ = g_variant_parse (_tmp11_, _tmp14_, NULL, NULL, &_inner_error_);
1456
1467
                                                _tmp16_ = _tmp15_;
1457
1468
                                                _g_variant_type_free0 (_tmp11_);
1458
 
                                                _tmp8_ = _tmp16_;
 
1469
                                                _tmp17_ = _tmp16_;
1459
1470
                                                if (_inner_error_ != NULL) {
1460
1471
                                                        if (_inner_error_->domain == G_VARIANT_PARSE_ERROR) {
1461
1472
                                                                goto __catch6_g_variant_parse_error;
1464
1475
                                                        g_clear_error (&_inner_error_);
1465
1476
                                                        return NULL;
1466
1477
                                                }
1467
 
                                                _tmp17_ = _tmp8_;
1468
 
                                                _tmp8_ = NULL;
1469
1478
                                                _g_variant_unref0 (self->min);
1470
1479
                                                self->min = _tmp17_;
1471
 
                                                _g_variant_unref0 (_tmp8_);
1472
1480
                                        }
1473
1481
                                        goto __finally6;
1474
1482
                                        __catch6_g_variant_parse_error:
1485
1493
                                                return NULL;
1486
1494
                                        }
1487
1495
                                } else {
1488
 
                                        xmlAttr* _tmp18_ = NULL;
1489
 
                                        const gchar* _tmp19_ = NULL;
 
1496
                                        xmlAttr* _tmp18_;
 
1497
                                        const gchar* _tmp19_;
1490
1498
                                        _tmp18_ = prop;
1491
1499
                                        _tmp19_ = _tmp18_->name;
1492
1500
                                        if (g_strcmp0 (_tmp19_, "max") == 0) {
1493
1501
                                                {
1494
 
                                                        GVariant* _tmp20_ = NULL;
1495
 
                                                        const gchar* _tmp21_ = NULL;
1496
 
                                                        GVariantType* _tmp22_ = NULL;
1497
 
                                                        GVariantType* _tmp23_ = NULL;
1498
 
                                                        xmlAttr* _tmp24_ = NULL;
1499
 
                                                        xmlNode* _tmp25_ = NULL;
1500
 
                                                        const gchar* _tmp26_ = NULL;
1501
 
                                                        GVariant* _tmp27_ = NULL;
1502
 
                                                        GVariant* _tmp28_ = NULL;
1503
 
                                                        GVariant* _tmp29_ = NULL;
1504
 
                                                        _tmp21_ = type;
1505
 
                                                        _tmp22_ = g_variant_type_new (_tmp21_);
1506
 
                                                        _tmp23_ = _tmp22_;
1507
 
                                                        _tmp24_ = prop;
1508
 
                                                        _tmp25_ = _tmp24_->children;
1509
 
                                                        _tmp26_ = _tmp25_->content;
1510
 
                                                        _tmp27_ = g_variant_parse (_tmp23_, _tmp26_, NULL, NULL, &_inner_error_);
 
1502
                                                        const gchar* _tmp20_;
 
1503
                                                        GVariantType* _tmp21_;
 
1504
                                                        GVariantType* _tmp22_;
 
1505
                                                        xmlAttr* _tmp23_;
 
1506
                                                        xmlNode* _tmp24_;
 
1507
                                                        const gchar* _tmp25_;
 
1508
                                                        GVariant* _tmp26_ = NULL;
 
1509
                                                        GVariant* _tmp27_;
 
1510
                                                        GVariant* _tmp28_;
 
1511
                                                        _tmp20_ = type;
 
1512
                                                        _tmp21_ = g_variant_type_new (_tmp20_);
 
1513
                                                        _tmp22_ = _tmp21_;
 
1514
                                                        _tmp23_ = prop;
 
1515
                                                        _tmp24_ = _tmp23_->children;
 
1516
                                                        _tmp25_ = _tmp24_->content;
 
1517
                                                        _tmp26_ = g_variant_parse (_tmp22_, _tmp25_, NULL, NULL, &_inner_error_);
 
1518
                                                        _tmp27_ = _tmp26_;
 
1519
                                                        _g_variant_type_free0 (_tmp22_);
1511
1520
                                                        _tmp28_ = _tmp27_;
1512
 
                                                        _g_variant_type_free0 (_tmp23_);
1513
 
                                                        _tmp20_ = _tmp28_;
1514
1521
                                                        if (_inner_error_ != NULL) {
1515
1522
                                                                if (_inner_error_->domain == G_VARIANT_PARSE_ERROR) {
1516
1523
                                                                        goto __catch7_g_variant_parse_error;
1519
1526
                                                                g_clear_error (&_inner_error_);
1520
1527
                                                                return NULL;
1521
1528
                                                        }
1522
 
                                                        _tmp29_ = _tmp20_;
1523
 
                                                        _tmp20_ = NULL;
1524
1529
                                                        _g_variant_unref0 (self->max);
1525
 
                                                        self->max = _tmp29_;
1526
 
                                                        _g_variant_unref0 (_tmp20_);
 
1530
                                                        self->max = _tmp28_;
1527
1531
                                                }
1528
1532
                                                goto __finally7;
1529
1533
                                                __catch7_g_variant_parse_error:
1540
1544
                                                        return NULL;
1541
1545
                                                }
1542
1546
                                        } else {
1543
 
                                                xmlAttr* _tmp30_ = NULL;
1544
 
                                                const gchar* _tmp31_ = NULL;
1545
 
                                                _tmp30_ = prop;
1546
 
                                                _tmp31_ = _tmp30_->name;
1547
 
                                                g_warning ("dconf-schema.vala:196: Unknown property in <range>, %s", _tmp31_);
 
1547
                                                xmlAttr* _tmp29_;
 
1548
                                                const gchar* _tmp30_;
 
1549
                                                _tmp29_ = prop;
 
1550
                                                _tmp30_ = _tmp29_->name;
 
1551
                                                g_warning ("dconf-schema.vala:196: Unknown property in <range>, %s", _tmp30_);
1548
1552
                                        }
1549
1553
                                }
1550
1554
                        }
1755
1759
 
1756
1760
SchemaEnum* schema_enum_construct_from_xml (GType object_type, SchemaList* list, xmlNode* node) {
1757
1761
        SchemaEnum* self = NULL;
1758
 
        SchemaList* _tmp0_ = NULL;
1759
 
        SchemaList* _tmp1_ = NULL;
 
1762
        SchemaList* _tmp0_;
 
1763
        SchemaList* _tmp1_;
1760
1764
        g_return_val_if_fail (list != NULL, NULL);
1761
1765
        self = (SchemaEnum*) g_type_create_instance (object_type);
1762
1766
        _tmp0_ = list;
1764
1768
        _schema_list_unref0 (self->list);
1765
1769
        self->list = _tmp1_;
1766
1770
        {
1767
 
                xmlAttr* prop = NULL;
1768
 
                xmlNode* _tmp2_ = NULL;
1769
 
                xmlAttr* _tmp3_ = NULL;
 
1771
                xmlNode* _tmp2_;
 
1772
                xmlAttr* _tmp3_;
 
1773
                xmlAttr* prop;
1770
1774
                _tmp2_ = node;
1771
1775
                _tmp3_ = _tmp2_->properties;
1772
1776
                prop = _tmp3_;
1773
1777
                {
1774
 
                        gboolean _tmp4_ = FALSE;
 
1778
                        gboolean _tmp4_;
1775
1779
                        _tmp4_ = TRUE;
1776
1780
                        while (TRUE) {
1777
 
                                xmlAttr* _tmp7_ = NULL;
1778
 
                                xmlAttr* _tmp8_ = NULL;
1779
 
                                const gchar* _tmp9_ = NULL;
1780
 
                                if (!_tmp4_) {
1781
 
                                        xmlAttr* _tmp5_ = NULL;
1782
 
                                        xmlAttr* _tmp6_ = NULL;
1783
 
                                        _tmp5_ = prop;
1784
 
                                        _tmp6_ = _tmp5_->next;
1785
 
                                        prop = _tmp6_;
 
1781
                                gboolean _tmp5_;
 
1782
                                xmlAttr* _tmp8_;
 
1783
                                xmlAttr* _tmp9_;
 
1784
                                const gchar* _tmp10_;
 
1785
                                _tmp5_ = _tmp4_;
 
1786
                                if (!_tmp5_) {
 
1787
                                        xmlAttr* _tmp6_;
 
1788
                                        xmlAttr* _tmp7_;
 
1789
                                        _tmp6_ = prop;
 
1790
                                        _tmp7_ = _tmp6_->next;
 
1791
                                        prop = _tmp7_;
1786
1792
                                }
1787
1793
                                _tmp4_ = FALSE;
1788
 
                                _tmp7_ = prop;
1789
 
                                if (!(_tmp7_ != NULL)) {
1790
 
                                        break;
1791
 
                                }
1792
1794
                                _tmp8_ = prop;
1793
 
                                _tmp9_ = _tmp8_->name;
1794
 
                                if (g_strcmp0 (_tmp9_, "id") == 0) {
1795
 
                                        xmlAttr* _tmp10_ = NULL;
1796
 
                                        xmlNode* _tmp11_ = NULL;
1797
 
                                        const gchar* _tmp12_ = NULL;
1798
 
                                        gchar* _tmp13_ = NULL;
1799
 
                                        _tmp10_ = prop;
1800
 
                                        _tmp11_ = _tmp10_->children;
1801
 
                                        _tmp12_ = _tmp11_->content;
1802
 
                                        _tmp13_ = g_strdup (_tmp12_);
 
1795
                                if (!(_tmp8_ != NULL)) {
 
1796
                                        break;
 
1797
                                }
 
1798
                                _tmp9_ = prop;
 
1799
                                _tmp10_ = _tmp9_->name;
 
1800
                                if (g_strcmp0 (_tmp10_, "id") == 0) {
 
1801
                                        xmlAttr* _tmp11_;
 
1802
                                        xmlNode* _tmp12_;
 
1803
                                        const gchar* _tmp13_;
 
1804
                                        gchar* _tmp14_;
 
1805
                                        _tmp11_ = prop;
 
1806
                                        _tmp12_ = _tmp11_->children;
 
1807
                                        _tmp13_ = _tmp12_->content;
 
1808
                                        _tmp14_ = g_strdup (_tmp13_);
1803
1809
                                        _g_free0 (self->id);
1804
 
                                        self->id = _tmp13_;
 
1810
                                        self->id = _tmp14_;
1805
1811
                                } else {
1806
 
                                        xmlAttr* _tmp14_ = NULL;
1807
 
                                        const gchar* _tmp15_ = NULL;
1808
 
                                        _tmp14_ = prop;
1809
 
                                        _tmp15_ = _tmp14_->name;
1810
 
                                        g_warning ("dconf-schema.vala:219: Unknown property in <enum>, %s", _tmp15_);
 
1812
                                        xmlAttr* _tmp15_;
 
1813
                                        const gchar* _tmp16_;
 
1814
                                        _tmp15_ = prop;
 
1815
                                        _tmp16_ = _tmp15_->name;
 
1816
                                        g_warning ("dconf-schema.vala:219: Unknown property in <enum>, %s", _tmp16_);
1811
1817
                                }
1812
1818
                        }
1813
1819
                }
1814
1820
        }
1815
1821
        {
1816
 
                xmlNode* child = NULL;
1817
 
                xmlNode* _tmp16_ = NULL;
1818
 
                xmlNode* _tmp17_ = NULL;
1819
 
                _tmp16_ = node;
1820
 
                _tmp17_ = _tmp16_->children;
1821
 
                child = _tmp17_;
 
1822
                xmlNode* _tmp17_;
 
1823
                xmlNode* _tmp18_;
 
1824
                xmlNode* child;
 
1825
                _tmp17_ = node;
 
1826
                _tmp18_ = _tmp17_->children;
 
1827
                child = _tmp18_;
1822
1828
                {
1823
 
                        gboolean _tmp18_ = FALSE;
1824
 
                        _tmp18_ = TRUE;
 
1829
                        gboolean _tmp19_;
 
1830
                        _tmp19_ = TRUE;
1825
1831
                        while (TRUE) {
1826
 
                                xmlNode* _tmp21_ = NULL;
1827
 
                                xmlNode* _tmp22_ = NULL;
1828
 
                                const gchar* _tmp23_ = NULL;
1829
 
                                if (!_tmp18_) {
1830
 
                                        xmlNode* _tmp19_ = NULL;
1831
 
                                        xmlNode* _tmp20_ = NULL;
1832
 
                                        _tmp19_ = child;
1833
 
                                        _tmp20_ = _tmp19_->next;
1834
 
                                        child = _tmp20_;
 
1832
                                gboolean _tmp20_;
 
1833
                                xmlNode* _tmp23_;
 
1834
                                xmlNode* _tmp24_;
 
1835
                                const gchar* _tmp25_;
 
1836
                                _tmp20_ = _tmp19_;
 
1837
                                if (!_tmp20_) {
 
1838
                                        xmlNode* _tmp21_;
 
1839
                                        xmlNode* _tmp22_;
 
1840
                                        _tmp21_ = child;
 
1841
                                        _tmp22_ = _tmp21_->next;
 
1842
                                        child = _tmp22_;
1835
1843
                                }
1836
 
                                _tmp18_ = FALSE;
1837
 
                                _tmp21_ = child;
1838
 
                                if (!(_tmp21_ != NULL)) {
 
1844
                                _tmp19_ = FALSE;
 
1845
                                _tmp23_ = child;
 
1846
                                if (!(_tmp23_ != NULL)) {
1839
1847
                                        break;
1840
1848
                                }
1841
 
                                _tmp22_ = child;
1842
 
                                _tmp23_ = _tmp22_->name;
1843
 
                                if (g_strcmp0 (_tmp23_, "value") == 0) {
1844
 
                                        gchar* nick = NULL;
1845
 
                                        gint value = 0;
1846
 
                                        SchemaValue* schema_value = NULL;
1847
 
                                        GList* _tmp44_ = NULL;
1848
 
                                        guint _tmp45_ = 0U;
1849
 
                                        const gchar* _tmp46_ = NULL;
1850
 
                                        gint _tmp47_ = 0;
1851
 
                                        SchemaValue* _tmp48_ = NULL;
1852
 
                                        SchemaValue* _tmp49_ = NULL;
1853
 
                                        SchemaValue* _tmp50_ = NULL;
 
1849
                                _tmp24_ = child;
 
1850
                                _tmp25_ = _tmp24_->name;
 
1851
                                if (g_strcmp0 (_tmp25_, "value") == 0) {
 
1852
                                        gchar* nick;
 
1853
                                        gint value;
 
1854
                                        GList* _tmp47_;
 
1855
                                        guint _tmp48_ = 0U;
 
1856
                                        const gchar* _tmp49_;
 
1857
                                        gint _tmp50_;
 
1858
                                        SchemaValue* _tmp51_;
 
1859
                                        SchemaValue* schema_value;
 
1860
                                        SchemaValue* _tmp52_;
 
1861
                                        SchemaValue* _tmp53_;
1854
1862
                                        nick = NULL;
1855
1863
                                        value = -1;
1856
1864
                                        {
1857
 
                                                xmlAttr* prop = NULL;
1858
 
                                                xmlNode* _tmp24_ = NULL;
1859
 
                                                xmlAttr* _tmp25_ = NULL;
1860
 
                                                _tmp24_ = child;
1861
 
                                                _tmp25_ = _tmp24_->properties;
1862
 
                                                prop = _tmp25_;
 
1865
                                                xmlNode* _tmp26_;
 
1866
                                                xmlAttr* _tmp27_;
 
1867
                                                xmlAttr* prop;
 
1868
                                                _tmp26_ = child;
 
1869
                                                _tmp27_ = _tmp26_->properties;
 
1870
                                                prop = _tmp27_;
1863
1871
                                                {
1864
 
                                                        gboolean _tmp26_ = FALSE;
1865
 
                                                        _tmp26_ = TRUE;
 
1872
                                                        gboolean _tmp28_;
 
1873
                                                        _tmp28_ = TRUE;
1866
1874
                                                        while (TRUE) {
1867
 
                                                                xmlAttr* _tmp29_ = NULL;
1868
 
                                                                xmlAttr* _tmp30_ = NULL;
1869
 
                                                                const gchar* _tmp31_ = NULL;
1870
 
                                                                if (!_tmp26_) {
1871
 
                                                                        xmlAttr* _tmp27_ = NULL;
1872
 
                                                                        xmlAttr* _tmp28_ = NULL;
1873
 
                                                                        _tmp27_ = prop;
1874
 
                                                                        _tmp28_ = _tmp27_->next;
1875
 
                                                                        prop = _tmp28_;
 
1875
                                                                gboolean _tmp29_;
 
1876
                                                                xmlAttr* _tmp32_;
 
1877
                                                                xmlAttr* _tmp33_;
 
1878
                                                                const gchar* _tmp34_;
 
1879
                                                                _tmp29_ = _tmp28_;
 
1880
                                                                if (!_tmp29_) {
 
1881
                                                                        xmlAttr* _tmp30_;
 
1882
                                                                        xmlAttr* _tmp31_;
 
1883
                                                                        _tmp30_ = prop;
 
1884
                                                                        _tmp31_ = _tmp30_->next;
 
1885
                                                                        prop = _tmp31_;
1876
1886
                                                                }
1877
 
                                                                _tmp26_ = FALSE;
1878
 
                                                                _tmp29_ = prop;
1879
 
                                                                if (!(_tmp29_ != NULL)) {
 
1887
                                                                _tmp28_ = FALSE;
 
1888
                                                                _tmp32_ = prop;
 
1889
                                                                if (!(_tmp32_ != NULL)) {
1880
1890
                                                                        break;
1881
1891
                                                                }
1882
 
                                                                _tmp30_ = prop;
1883
 
                                                                _tmp31_ = _tmp30_->name;
1884
 
                                                                if (g_strcmp0 (_tmp31_, "value") == 0) {
1885
 
                                                                        xmlAttr* _tmp32_ = NULL;
1886
 
                                                                        xmlNode* _tmp33_ = NULL;
1887
 
                                                                        const gchar* _tmp34_ = NULL;
1888
 
                                                                        gint _tmp35_ = 0;
1889
 
                                                                        _tmp32_ = prop;
1890
 
                                                                        _tmp33_ = _tmp32_->children;
1891
 
                                                                        _tmp34_ = _tmp33_->content;
1892
 
                                                                        _tmp35_ = atoi (_tmp34_);
1893
 
                                                                        value = _tmp35_;
 
1892
                                                                _tmp33_ = prop;
 
1893
                                                                _tmp34_ = _tmp33_->name;
 
1894
                                                                if (g_strcmp0 (_tmp34_, "value") == 0) {
 
1895
                                                                        xmlAttr* _tmp35_;
 
1896
                                                                        xmlNode* _tmp36_;
 
1897
                                                                        const gchar* _tmp37_;
 
1898
                                                                        gint _tmp38_ = 0;
 
1899
                                                                        _tmp35_ = prop;
 
1900
                                                                        _tmp36_ = _tmp35_->children;
 
1901
                                                                        _tmp37_ = _tmp36_->content;
 
1902
                                                                        _tmp38_ = atoi (_tmp37_);
 
1903
                                                                        value = _tmp38_;
1894
1904
                                                                } else {
1895
 
                                                                        xmlAttr* _tmp36_ = NULL;
1896
 
                                                                        const gchar* _tmp37_ = NULL;
1897
 
                                                                        _tmp36_ = prop;
1898
 
                                                                        _tmp37_ = _tmp36_->name;
1899
 
                                                                        if (g_strcmp0 (_tmp37_, "nick") == 0) {
1900
 
                                                                                xmlAttr* _tmp38_ = NULL;
1901
 
                                                                                xmlNode* _tmp39_ = NULL;
1902
 
                                                                                const gchar* _tmp40_ = NULL;
1903
 
                                                                                gchar* _tmp41_ = NULL;
1904
 
                                                                                _tmp38_ = prop;
1905
 
                                                                                _tmp39_ = _tmp38_->children;
1906
 
                                                                                _tmp40_ = _tmp39_->content;
1907
 
                                                                                _tmp41_ = g_strdup (_tmp40_);
 
1905
                                                                        xmlAttr* _tmp39_;
 
1906
                                                                        const gchar* _tmp40_;
 
1907
                                                                        _tmp39_ = prop;
 
1908
                                                                        _tmp40_ = _tmp39_->name;
 
1909
                                                                        if (g_strcmp0 (_tmp40_, "nick") == 0) {
 
1910
                                                                                xmlAttr* _tmp41_;
 
1911
                                                                                xmlNode* _tmp42_;
 
1912
                                                                                const gchar* _tmp43_;
 
1913
                                                                                gchar* _tmp44_;
 
1914
                                                                                _tmp41_ = prop;
 
1915
                                                                                _tmp42_ = _tmp41_->children;
 
1916
                                                                                _tmp43_ = _tmp42_->content;
 
1917
                                                                                _tmp44_ = g_strdup (_tmp43_);
1908
1918
                                                                                _g_free0 (nick);
1909
 
                                                                                nick = _tmp41_;
 
1919
                                                                                nick = _tmp44_;
1910
1920
                                                                        } else {
1911
 
                                                                                xmlAttr* _tmp42_ = NULL;
1912
 
                                                                                const gchar* _tmp43_ = NULL;
1913
 
                                                                                _tmp42_ = prop;
1914
 
                                                                                _tmp43_ = _tmp42_->name;
1915
 
                                                                                g_warning ("dconf-schema.vala:239: Unknown property in enum <value>, %s", _tmp43_);
 
1921
                                                                                xmlAttr* _tmp45_;
 
1922
                                                                                const gchar* _tmp46_;
 
1923
                                                                                _tmp45_ = prop;
 
1924
                                                                                _tmp46_ = _tmp45_->name;
 
1925
                                                                                g_warning ("dconf-schema.vala:239: Unknown property in enum <value>, %s", _tmp46_);
1916
1926
                                                                        }
1917
1927
                                                                }
1918
1928
                                                        }
1919
1929
                                                }
1920
1930
                                        }
1921
 
                                        _tmp44_ = self->values;
1922
 
                                        _tmp45_ = g_list_length (_tmp44_);
1923
 
                                        _tmp46_ = nick;
1924
 
                                        _tmp47_ = value;
1925
 
                                        _tmp48_ = schema_value_new (_tmp45_, _tmp46_, _tmp47_);
1926
 
                                        schema_value = _tmp48_;
1927
 
                                        _tmp49_ = schema_value;
1928
 
                                        _tmp50_ = _g_object_ref0 (_tmp49_);
1929
 
                                        self->values = g_list_append (self->values, _tmp50_);
 
1931
                                        _tmp47_ = self->values;
 
1932
                                        _tmp48_ = g_list_length (_tmp47_);
 
1933
                                        _tmp49_ = nick;
 
1934
                                        _tmp50_ = value;
 
1935
                                        _tmp51_ = schema_value_new (_tmp48_, _tmp49_, _tmp50_);
 
1936
                                        schema_value = _tmp51_;
 
1937
                                        _tmp52_ = schema_value;
 
1938
                                        _tmp53_ = _g_object_ref0 (_tmp52_);
 
1939
                                        self->values = g_list_append (self->values, _tmp53_);
1930
1940
                                        _g_object_unref0 (schema_value);
1931
1941
                                        _g_free0 (nick);
1932
1942
                                } else {
1933
 
                                        gboolean _tmp51_ = FALSE;
1934
 
                                        xmlNode* _tmp52_ = NULL;
1935
 
                                        xmlElementType _tmp53_ = 0;
1936
 
                                        _tmp52_ = child;
1937
 
                                        _tmp53_ = _tmp52_->type;
1938
 
                                        if (_tmp53_ != XML_TEXT_NODE) {
1939
 
                                                xmlNode* _tmp54_ = NULL;
1940
 
                                                xmlElementType _tmp55_ = 0;
1941
 
                                                _tmp54_ = child;
1942
 
                                                _tmp55_ = _tmp54_->type;
1943
 
                                                _tmp51_ = _tmp55_ != XML_COMMENT_NODE;
 
1943
                                        gboolean _tmp54_ = FALSE;
 
1944
                                        xmlNode* _tmp55_;
 
1945
                                        xmlElementType _tmp56_;
 
1946
                                        gboolean _tmp59_;
 
1947
                                        _tmp55_ = child;
 
1948
                                        _tmp56_ = _tmp55_->type;
 
1949
                                        if (_tmp56_ != XML_TEXT_NODE) {
 
1950
                                                xmlNode* _tmp57_;
 
1951
                                                xmlElementType _tmp58_;
 
1952
                                                _tmp57_ = child;
 
1953
                                                _tmp58_ = _tmp57_->type;
 
1954
                                                _tmp54_ = _tmp58_ != XML_COMMENT_NODE;
1944
1955
                                        } else {
1945
 
                                                _tmp51_ = FALSE;
 
1956
                                                _tmp54_ = FALSE;
1946
1957
                                        }
1947
 
                                        if (_tmp51_) {
1948
 
                                                xmlNode* _tmp56_ = NULL;
1949
 
                                                const gchar* _tmp57_ = NULL;
1950
 
                                                _tmp56_ = child;
1951
 
                                                _tmp57_ = _tmp56_->name;
1952
 
                                                g_warning ("dconf-schema.vala:249: Unknown tag in <enum>, <%s>", _tmp57_);
 
1958
                                        _tmp59_ = _tmp54_;
 
1959
                                        if (_tmp59_) {
 
1960
                                                xmlNode* _tmp60_;
 
1961
                                                const gchar* _tmp61_;
 
1962
                                                _tmp60_ = child;
 
1963
                                                _tmp61_ = _tmp60_->name;
 
1964
                                                g_warning ("dconf-schema.vala:249: Unknown tag in <enum>, <%s>", _tmp61_);
1953
1965
                                        }
1954
1966
                                }
1955
1967
                        }
2141
2153
 
2142
2154
SchemaFlags* schema_flags_construct_from_xml (GType object_type, SchemaList* list, xmlNode* node) {
2143
2155
        SchemaFlags* self = NULL;
2144
 
        SchemaList* _tmp0_ = NULL;
2145
 
        SchemaList* _tmp1_ = NULL;
 
2156
        SchemaList* _tmp0_;
 
2157
        SchemaList* _tmp1_;
2146
2158
        g_return_val_if_fail (list != NULL, NULL);
2147
2159
        self = (SchemaFlags*) g_type_create_instance (object_type);
2148
2160
        _tmp0_ = list;
2150
2162
        _schema_list_unref0 (self->list);
2151
2163
        self->list = _tmp1_;
2152
2164
        {
2153
 
                xmlAttr* prop = NULL;
2154
 
                xmlNode* _tmp2_ = NULL;
2155
 
                xmlAttr* _tmp3_ = NULL;
 
2165
                xmlNode* _tmp2_;
 
2166
                xmlAttr* _tmp3_;
 
2167
                xmlAttr* prop;
2156
2168
                _tmp2_ = node;
2157
2169
                _tmp3_ = _tmp2_->properties;
2158
2170
                prop = _tmp3_;
2159
2171
                {
2160
 
                        gboolean _tmp4_ = FALSE;
 
2172
                        gboolean _tmp4_;
2161
2173
                        _tmp4_ = TRUE;
2162
2174
                        while (TRUE) {
2163
 
                                xmlAttr* _tmp7_ = NULL;
2164
 
                                xmlAttr* _tmp8_ = NULL;
2165
 
                                const gchar* _tmp9_ = NULL;
2166
 
                                if (!_tmp4_) {
2167
 
                                        xmlAttr* _tmp5_ = NULL;
2168
 
                                        xmlAttr* _tmp6_ = NULL;
2169
 
                                        _tmp5_ = prop;
2170
 
                                        _tmp6_ = _tmp5_->next;
2171
 
                                        prop = _tmp6_;
 
2175
                                gboolean _tmp5_;
 
2176
                                xmlAttr* _tmp8_;
 
2177
                                xmlAttr* _tmp9_;
 
2178
                                const gchar* _tmp10_;
 
2179
                                _tmp5_ = _tmp4_;
 
2180
                                if (!_tmp5_) {
 
2181
                                        xmlAttr* _tmp6_;
 
2182
                                        xmlAttr* _tmp7_;
 
2183
                                        _tmp6_ = prop;
 
2184
                                        _tmp7_ = _tmp6_->next;
 
2185
                                        prop = _tmp7_;
2172
2186
                                }
2173
2187
                                _tmp4_ = FALSE;
2174
 
                                _tmp7_ = prop;
2175
 
                                if (!(_tmp7_ != NULL)) {
2176
 
                                        break;
2177
 
                                }
2178
2188
                                _tmp8_ = prop;
2179
 
                                _tmp9_ = _tmp8_->name;
2180
 
                                if (g_strcmp0 (_tmp9_, "id") == 0) {
2181
 
                                        xmlAttr* _tmp10_ = NULL;
2182
 
                                        xmlNode* _tmp11_ = NULL;
2183
 
                                        const gchar* _tmp12_ = NULL;
2184
 
                                        gchar* _tmp13_ = NULL;
2185
 
                                        _tmp10_ = prop;
2186
 
                                        _tmp11_ = _tmp10_->children;
2187
 
                                        _tmp12_ = _tmp11_->content;
2188
 
                                        _tmp13_ = g_strdup (_tmp12_);
 
2189
                                if (!(_tmp8_ != NULL)) {
 
2190
                                        break;
 
2191
                                }
 
2192
                                _tmp9_ = prop;
 
2193
                                _tmp10_ = _tmp9_->name;
 
2194
                                if (g_strcmp0 (_tmp10_, "id") == 0) {
 
2195
                                        xmlAttr* _tmp11_;
 
2196
                                        xmlNode* _tmp12_;
 
2197
                                        const gchar* _tmp13_;
 
2198
                                        gchar* _tmp14_;
 
2199
                                        _tmp11_ = prop;
 
2200
                                        _tmp12_ = _tmp11_->children;
 
2201
                                        _tmp13_ = _tmp12_->content;
 
2202
                                        _tmp14_ = g_strdup (_tmp13_);
2189
2203
                                        _g_free0 (self->id);
2190
 
                                        self->id = _tmp13_;
 
2204
                                        self->id = _tmp14_;
2191
2205
                                } else {
2192
 
                                        xmlAttr* _tmp14_ = NULL;
2193
 
                                        const gchar* _tmp15_ = NULL;
2194
 
                                        _tmp14_ = prop;
2195
 
                                        _tmp15_ = _tmp14_->name;
2196
 
                                        g_warning ("dconf-schema.vala:272: Unknown property in <flags>, %s", _tmp15_);
 
2206
                                        xmlAttr* _tmp15_;
 
2207
                                        const gchar* _tmp16_;
 
2208
                                        _tmp15_ = prop;
 
2209
                                        _tmp16_ = _tmp15_->name;
 
2210
                                        g_warning ("dconf-schema.vala:272: Unknown property in <flags>, %s", _tmp16_);
2197
2211
                                }
2198
2212
                        }
2199
2213
                }
2200
2214
        }
2201
2215
        {
2202
 
                xmlNode* child = NULL;
2203
 
                xmlNode* _tmp16_ = NULL;
2204
 
                xmlNode* _tmp17_ = NULL;
2205
 
                _tmp16_ = node;
2206
 
                _tmp17_ = _tmp16_->children;
2207
 
                child = _tmp17_;
 
2216
                xmlNode* _tmp17_;
 
2217
                xmlNode* _tmp18_;
 
2218
                xmlNode* child;
 
2219
                _tmp17_ = node;
 
2220
                _tmp18_ = _tmp17_->children;
 
2221
                child = _tmp18_;
2208
2222
                {
2209
 
                        gboolean _tmp18_ = FALSE;
2210
 
                        _tmp18_ = TRUE;
 
2223
                        gboolean _tmp19_;
 
2224
                        _tmp19_ = TRUE;
2211
2225
                        while (TRUE) {
2212
 
                                xmlNode* _tmp21_ = NULL;
2213
 
                                xmlNode* _tmp22_ = NULL;
2214
 
                                const gchar* _tmp23_ = NULL;
2215
 
                                if (!_tmp18_) {
2216
 
                                        xmlNode* _tmp19_ = NULL;
2217
 
                                        xmlNode* _tmp20_ = NULL;
2218
 
                                        _tmp19_ = child;
2219
 
                                        _tmp20_ = _tmp19_->next;
2220
 
                                        child = _tmp20_;
 
2226
                                gboolean _tmp20_;
 
2227
                                xmlNode* _tmp23_;
 
2228
                                xmlNode* _tmp24_;
 
2229
                                const gchar* _tmp25_;
 
2230
                                _tmp20_ = _tmp19_;
 
2231
                                if (!_tmp20_) {
 
2232
                                        xmlNode* _tmp21_;
 
2233
                                        xmlNode* _tmp22_;
 
2234
                                        _tmp21_ = child;
 
2235
                                        _tmp22_ = _tmp21_->next;
 
2236
                                        child = _tmp22_;
2221
2237
                                }
2222
 
                                _tmp18_ = FALSE;
2223
 
                                _tmp21_ = child;
2224
 
                                if (!(_tmp21_ != NULL)) {
 
2238
                                _tmp19_ = FALSE;
 
2239
                                _tmp23_ = child;
 
2240
                                if (!(_tmp23_ != NULL)) {
2225
2241
                                        break;
2226
2242
                                }
2227
 
                                _tmp22_ = child;
2228
 
                                _tmp23_ = _tmp22_->name;
2229
 
                                if (g_strcmp0 (_tmp23_, "value") == 0) {
2230
 
                                        gchar* nick = NULL;
2231
 
                                        gint value = 0;
2232
 
                                        SchemaValue* schema_value = NULL;
2233
 
                                        GList* _tmp44_ = NULL;
2234
 
                                        guint _tmp45_ = 0U;
2235
 
                                        const gchar* _tmp46_ = NULL;
2236
 
                                        gint _tmp47_ = 0;
2237
 
                                        SchemaValue* _tmp48_ = NULL;
2238
 
                                        SchemaValue* _tmp49_ = NULL;
2239
 
                                        SchemaValue* _tmp50_ = NULL;
 
2243
                                _tmp24_ = child;
 
2244
                                _tmp25_ = _tmp24_->name;
 
2245
                                if (g_strcmp0 (_tmp25_, "value") == 0) {
 
2246
                                        gchar* nick;
 
2247
                                        gint value;
 
2248
                                        GList* _tmp47_;
 
2249
                                        guint _tmp48_ = 0U;
 
2250
                                        const gchar* _tmp49_;
 
2251
                                        gint _tmp50_;
 
2252
                                        SchemaValue* _tmp51_;
 
2253
                                        SchemaValue* schema_value;
 
2254
                                        SchemaValue* _tmp52_;
 
2255
                                        SchemaValue* _tmp53_;
2240
2256
                                        nick = NULL;
2241
2257
                                        value = -1;
2242
2258
                                        {
2243
 
                                                xmlAttr* prop = NULL;
2244
 
                                                xmlNode* _tmp24_ = NULL;
2245
 
                                                xmlAttr* _tmp25_ = NULL;
2246
 
                                                _tmp24_ = child;
2247
 
                                                _tmp25_ = _tmp24_->properties;
2248
 
                                                prop = _tmp25_;
 
2259
                                                xmlNode* _tmp26_;
 
2260
                                                xmlAttr* _tmp27_;
 
2261
                                                xmlAttr* prop;
 
2262
                                                _tmp26_ = child;
 
2263
                                                _tmp27_ = _tmp26_->properties;
 
2264
                                                prop = _tmp27_;
2249
2265
                                                {
2250
 
                                                        gboolean _tmp26_ = FALSE;
2251
 
                                                        _tmp26_ = TRUE;
 
2266
                                                        gboolean _tmp28_;
 
2267
                                                        _tmp28_ = TRUE;
2252
2268
                                                        while (TRUE) {
2253
 
                                                                xmlAttr* _tmp29_ = NULL;
2254
 
                                                                xmlAttr* _tmp30_ = NULL;
2255
 
                                                                const gchar* _tmp31_ = NULL;
2256
 
                                                                if (!_tmp26_) {
2257
 
                                                                        xmlAttr* _tmp27_ = NULL;
2258
 
                                                                        xmlAttr* _tmp28_ = NULL;
2259
 
                                                                        _tmp27_ = prop;
2260
 
                                                                        _tmp28_ = _tmp27_->next;
2261
 
                                                                        prop = _tmp28_;
 
2269
                                                                gboolean _tmp29_;
 
2270
                                                                xmlAttr* _tmp32_;
 
2271
                                                                xmlAttr* _tmp33_;
 
2272
                                                                const gchar* _tmp34_;
 
2273
                                                                _tmp29_ = _tmp28_;
 
2274
                                                                if (!_tmp29_) {
 
2275
                                                                        xmlAttr* _tmp30_;
 
2276
                                                                        xmlAttr* _tmp31_;
 
2277
                                                                        _tmp30_ = prop;
 
2278
                                                                        _tmp31_ = _tmp30_->next;
 
2279
                                                                        prop = _tmp31_;
2262
2280
                                                                }
2263
 
                                                                _tmp26_ = FALSE;
2264
 
                                                                _tmp29_ = prop;
2265
 
                                                                if (!(_tmp29_ != NULL)) {
 
2281
                                                                _tmp28_ = FALSE;
 
2282
                                                                _tmp32_ = prop;
 
2283
                                                                if (!(_tmp32_ != NULL)) {
2266
2284
                                                                        break;
2267
2285
                                                                }
2268
 
                                                                _tmp30_ = prop;
2269
 
                                                                _tmp31_ = _tmp30_->name;
2270
 
                                                                if (g_strcmp0 (_tmp31_, "value") == 0) {
2271
 
                                                                        xmlAttr* _tmp32_ = NULL;
2272
 
                                                                        xmlNode* _tmp33_ = NULL;
2273
 
                                                                        const gchar* _tmp34_ = NULL;
2274
 
                                                                        gint _tmp35_ = 0;
2275
 
                                                                        _tmp32_ = prop;
2276
 
                                                                        _tmp33_ = _tmp32_->children;
2277
 
                                                                        _tmp34_ = _tmp33_->content;
2278
 
                                                                        _tmp35_ = atoi (_tmp34_);
2279
 
                                                                        value = _tmp35_;
 
2286
                                                                _tmp33_ = prop;
 
2287
                                                                _tmp34_ = _tmp33_->name;
 
2288
                                                                if (g_strcmp0 (_tmp34_, "value") == 0) {
 
2289
                                                                        xmlAttr* _tmp35_;
 
2290
                                                                        xmlNode* _tmp36_;
 
2291
                                                                        const gchar* _tmp37_;
 
2292
                                                                        gint _tmp38_ = 0;
 
2293
                                                                        _tmp35_ = prop;
 
2294
                                                                        _tmp36_ = _tmp35_->children;
 
2295
                                                                        _tmp37_ = _tmp36_->content;
 
2296
                                                                        _tmp38_ = atoi (_tmp37_);
 
2297
                                                                        value = _tmp38_;
2280
2298
                                                                } else {
2281
 
                                                                        xmlAttr* _tmp36_ = NULL;
2282
 
                                                                        const gchar* _tmp37_ = NULL;
2283
 
                                                                        _tmp36_ = prop;
2284
 
                                                                        _tmp37_ = _tmp36_->name;
2285
 
                                                                        if (g_strcmp0 (_tmp37_, "nick") == 0) {
2286
 
                                                                                xmlAttr* _tmp38_ = NULL;
2287