~ubuntu-branches/ubuntu/quantal/vala-0.16/quantal

static const GEnumValue values[] = {{VALA_GIR_PARSER_ARGUMENT_TYPE_SKIP, "VALA_GIR_PARSER_ARGUMENT_TYPE_SKIP", "skip"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_HIDDEN, "VALA_GIR_PARSER_ARGUMENT_TYPE_HIDDEN", "hidden"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_TYPE, "VALA_GIR_PARSER_ARGUMENT_TYPE_TYPE", "type"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_TYPE_ARGUMENTS, "VALA_GIR_PARSER_ARGUMENT_TYPE_TYPE_ARGUMENTS", "type-arguments"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_CHEADER_FILENAME, "VALA_GIR_PARSER_ARGUMENT_TYPE_CHEADER_FILENAME", "cheader-filename"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_NAME, "VALA_GIR_PARSER_ARGUMENT_TYPE_NAME", "name"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_OWNED, "VALA_GIR_PARSER_ARGUMENT_TYPE_OWNED", "owned"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_UNOWNED, "VALA_GIR_PARSER_ARGUMENT_TYPE_UNOWNED", "unowned"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_PARENT, "VALA_GIR_PARSER_ARGUMENT_TYPE_PARENT", "parent"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_NULLABLE, "VALA_GIR_PARSER_ARGUMENT_TYPE_NULLABLE", "nullable"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_DEPRECATED, "VALA_GIR_PARSER_ARGUMENT_TYPE_DEPRECATED", "deprecated"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_REPLACEMENT, "VALA_GIR_PARSER_ARGUMENT_TYPE_REPLACEMENT", "replacement"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_DEPRECATED_SINCE, "VALA_GIR_PARSER_ARGUMENT_TYPE_DEPRECATED_SINCE", "deprecated-since"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_ARRAY, "VALA_GIR_PARSER_ARGUMENT_TYPE_ARRAY", "array"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_ARRAY_LENGTH_IDX, "VALA_GIR_PARSER_ARGUMENT_TYPE_ARRAY_LENGTH_IDX", "array-length-idx"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_DEFAULT, "VALA_GIR_PARSER_ARGUMENT_TYPE_DEFAULT", "default"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_OUT, "VALA_GIR_PARSER_ARGUMENT_TYPE_OUT", "out"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_REF, "VALA_GIR_PARSER_ARGUMENT_TYPE_REF", "ref"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_VFUNC_NAME, "VALA_GIR_PARSER_ARGUMENT_TYPE_VFUNC_NAME", "vfunc-name"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_VIRTUAL, "VALA_GIR_PARSER_ARGUMENT_TYPE_VIRTUAL", "virtual"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_ABSTRACT, "VALA_GIR_PARSER_ARGUMENT_TYPE_ABSTRACT", "abstract"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_SCOPE, "VALA_GIR_PARSER_ARGUMENT_TYPE_SCOPE", "scope"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_STRUCT, "VALA_GIR_PARSER_ARGUMENT_TYPE_STRUCT", "struct"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_THROWS, "VALA_GIR_PARSER_ARGUMENT_TYPE_THROWS", "throws"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_PRINTF_FORMAT, "VALA_GIR_PARSER_ARGUMENT_TYPE_PRINTF_FORMAT", "printf-format"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_ARRAY_LENGTH_FIELD, "VALA_GIR_PARSER_ARGUMENT_TYPE_ARRAY_LENGTH_FIELD", "array-length-field"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_SENTINEL, "VALA_GIR_PARSER_ARGUMENT_TYPE_SENTINEL", "sentinel"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_CLOSURE, "VALA_GIR_PARSER_ARGUMENT_TYPE_CLOSURE", "closure"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_CPREFIX, "VALA_GIR_PARSER_ARGUMENT_TYPE_CPREFIX", "cprefix"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_LOWER_CASE_CPREFIX, "VALA_GIR_PARSER_ARGUMENT_TYPE_LOWER_CASE_CPREFIX", "lower-case-cprefix"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_ERRORDOMAIN, "VALA_GIR_PARSER_ARGUMENT_TYPE_ERRORDOMAIN", "errordomain"}, {0, NULL, NULL}};

2482

2483

GType vala_gir_parser_argument_type_type_id;

2483

2484

vala_gir_parser_argument_type_type_id = g_enum_register_static ("ValaGirParserArgumentType", values);

2484

2485

g_once_init_leave (&vala_gir_parser_argument_type_type_id__volatile, vala_gir_parser_argument_type_type_id);

4572

4573

e = _inner_error_;

4573

4574

_inner_error_ = NULL;

4574

4575

_tmp3_ = e->message;

4575

g_error ("valagirparser.vala:1455: Unable to compile regex: %s", _tmp3_);

4576

g_error ("valagirparser.vala:1459: Unable to compile regex: %s", _tmp3_);

4576

4577

_g_error_free0 (e);

4577

4578

}

4578

4579

__finally4:

9700

9701

gboolean _tmp103_ = FALSE;

9701

9702

const gchar* _tmp104_;

9702

9703

gboolean _tmp107_;

9704

ValaGirParserNode* _tmp112_;

9705

ValaMap* _tmp113_;

9706

gpointer _tmp114_ = NULL;

9707

gchar* _tmp115_;

9708

const gchar* _tmp116_;

9709

gboolean _tmp117_;

9703

9710

_tmp98_ = self->priv->current;

9704

9711

_tmp99_ = _tmp98_->parent;

9705

9712

_tmp100_ = _tmp99_->symbol;

9733

9740

_tmp110_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp109_);

9734

9741

_tmp111_ = _tmp110_;

9735

9742

vala_code_node_set_attribute ((ValaCodeNode*) _tmp108_, "NoWrapper", TRUE, _tmp111_);

9736

} else {

9737

ValaGirParserNode* _tmp112_;

9738

ValaMap* _tmp113_;

9739

gpointer _tmp114_ = NULL;

9740

gchar* _tmp115_;

9741

const gchar* _tmp116_;

9742

gboolean _tmp117_;

9743

_tmp112_ = self->priv->current;

9744

_tmp113_ = _tmp112_->girdata;

9745

_tmp114_ = vala_map_get (_tmp113_, "name");

9746

_tmp115_ = (gchar*) _tmp114_;

9747

_tmp116_ = name;

9748

_tmp117_ = g_strcmp0 (_tmp115_, _tmp116_) != 0;

9749

_g_free0 (_tmp115_);

9750

if (_tmp117_) {

9751

ValaMethod* _tmp118_;

9752

ValaGirParserNode* _tmp119_;

9753

ValaMap* _tmp120_;

9754

gpointer _tmp121_ = NULL;

9755

gchar* _tmp122_;

9756

_tmp118_ = m;

9757

_tmp119_ = self->priv->current;

9758

_tmp120_ = _tmp119_->girdata;

9759

_tmp121_ = vala_map_get (_tmp120_, "name");

9760

_tmp122_ = (gchar*) _tmp121_;

9761

vala_code_node_set_attribute_string ((ValaCodeNode*) _tmp118_, "CCode", "vfunc_name", _tmp122_, NULL);

9762

_g_free0 (_tmp122_);

9763

}

9743

}

9744

_tmp112_ = self->priv->current;

9745

_tmp113_ = _tmp112_->girdata;

9746

_tmp114_ = vala_map_get (_tmp113_, "name");

9747

_tmp115_ = (gchar*) _tmp114_;

9748

_tmp116_ = name;

9749

_tmp117_ = g_strcmp0 (_tmp115_, _tmp116_) != 0;

9750

_g_free0 (_tmp115_);

9751

if (_tmp117_) {

9752

ValaMethod* _tmp118_;

9753

ValaGirParserNode* _tmp119_;

9754

ValaMap* _tmp120_;

9755

gpointer _tmp121_ = NULL;

9756

gchar* _tmp122_;

9757

_tmp118_ = m;

9758

_tmp119_ = self->priv->current;

9759

_tmp120_ = _tmp119_->girdata;

9760

_tmp121_ = vala_map_get (_tmp120_, "name");

9761

_tmp122_ = (gchar*) _tmp121_;

9762

vala_code_node_set_attribute_string ((ValaCodeNode*) _tmp118_, "CCode", "vfunc_name", _tmp122_, NULL);

9763

_g_free0 (_tmp122_);

9764

}

9765

} else {

9766

const gchar* _tmp123_;

17006

ValaSymbol* _tmp2_;

17007

gboolean _tmp6_;

17008

ValaMap* _tmp65_;

17009

gboolean _tmp730_ = FALSE;

17010

gboolean _tmp731_ = FALSE;

17011

gboolean _tmp732_;

17012

gboolean _tmp734_;

17009

gboolean _tmp733_ = FALSE;

17010

gboolean _tmp734_ = FALSE;

17011

gboolean _tmp735_;

17013

17012

gboolean _tmp737_;

17013

gboolean _tmp740_;

17014

g_return_if_fail (self != NULL);

17015

g_return_if_fail (parser != NULL);

17016

_tmp0_ = self->processed;

17224

_tmp65_ = self->girdata;

17225

if (_tmp65_ != NULL) {

17226

ValaSymbol* _tmp66_;

17227

ValaGirParserMetadata* _tmp655_;

17228

gboolean _tmp656_ = FALSE;

17229

ValaGirParserMetadata* _tmp661_;

17230

gboolean _tmp662_ = FALSE;

17231

ValaGirParserMetadata* _tmp675_;

17232

gboolean _tmp676_ = FALSE;

17233

ValaGirParserNode* _tmp678_;

17234

ValaSymbol* _tmp679_;

17235

gchar* _tmp689_ = NULL;

17236

gchar* _tmp690_;

17237

gchar* _tmp691_ = NULL;

17238

gchar* _tmp692_;

17239

gboolean _tmp693_;

17240

gchar* _tmp697_ = NULL;

17241

gchar* _tmp698_;

17242

gchar* _tmp699_ = NULL;

17243

gchar* _tmp700_;

17244

gboolean _tmp701_;

17245

gchar* _tmp709_ = NULL;

17246

gchar* _tmp710_;

17247

gchar* _tmp711_ = NULL;

17248

gchar* _tmp712_;

17249

gboolean _tmp713_;

17250

gboolean _tmp717_ = FALSE;

17251

gboolean _tmp718_ = FALSE;

17252

ValaSymbol* _tmp719_;

17227

ValaGirParserMetadata* _tmp658_;

17228

gboolean _tmp659_ = FALSE;

17229

ValaGirParserMetadata* _tmp664_;

17230

gboolean _tmp665_ = FALSE;

17231

ValaGirParserMetadata* _tmp678_;

17232

gboolean _tmp679_ = FALSE;

17233

ValaGirParserNode* _tmp681_;

17234

ValaSymbol* _tmp682_;

17235

gchar* _tmp692_ = NULL;

17236

gchar* _tmp693_;

17237

gchar* _tmp694_ = NULL;

17238

gchar* _tmp695_;

17239

gboolean _tmp696_;

17240

gchar* _tmp700_ = NULL;

17241

gchar* _tmp701_;

17242

gchar* _tmp702_ = NULL;

17243

gchar* _tmp703_;

17244

gboolean _tmp704_;

17245

gchar* _tmp712_ = NULL;

17246

gchar* _tmp713_;

17247

gchar* _tmp714_ = NULL;

17248

gchar* _tmp715_;

17249

gboolean _tmp716_;

17253

17250

gboolean _tmp720_ = FALSE;

17254

gboolean _tmp722_;

17255

gboolean _tmp726_;

17251

gboolean _tmp721_ = FALSE;

17252

ValaSymbol* _tmp722_;

17253

gboolean _tmp723_ = FALSE;

17254

gboolean _tmp725_;

17255

gboolean _tmp729_;

17256

_tmp66_ = self->symbol;

17257

if (VALA_IS_METHOD (_tmp66_)) {

17258

ValaSymbol* _tmp67_;

17264

ValaArrayList* _tmp72_ = NULL;

17265

ValaArrayList* colliding;

17266

ValaMethod* _tmp178_;

17267

ValaMethod* _tmp193_;

17268

gboolean _tmp194_;

17269

gboolean _tmp195_;

17267

ValaMethod* _tmp196_;

17268

gboolean _tmp197_;

17269

gboolean _tmp198_;

17270

_tmp67_ = self->symbol;

17271

_tmp68_ = _vala_code_node_ref0 (VALA_METHOD (_tmp67_));

17272

m = _tmp68_;

17590

if (!VALA_IS_CREATION_METHOD (_tmp178_)) {

17591

ValaGirParserMetadata* _tmp179_;

17592

gboolean _tmp180_ = FALSE;

17593

ValaGirParserMetadata* _tmp182_;

17594

gboolean _tmp183_ = FALSE;

17593

17595

_tmp179_ = self->metadata;

17594

_tmp180_ = vala_gir_parser_metadata_has_argument (_tmp179_, VALA_GIR_PARSER_ARGUMENT_TYPE_VFUNC_NAME);

17596

_tmp180_ = vala_gir_parser_metadata_has_argument (_tmp179_, VALA_GIR_PARSER_ARGUMENT_TYPE_DESTROYS_INSTANCE);

17595

17597

if (_tmp180_) {

17596

ValaGirParserNode* _tmp181_;

17597

ValaGirParserMetadata* _tmp182_;

17598

gchar* _tmp183_ = NULL;

17599

gchar* _tmp184_;

17600

ValaGirParserNode* _tmp185_ = NULL;

17601

ValaGirParserNode* _tmp186_;

17598

ValaMethod* _tmp181_;

17599

_tmp181_ = m;

17600

vala_code_node_set_attribute ((ValaCodeNode*) _tmp181_, "DestroysInstance", TRUE, NULL);

17601

}

17602

_tmp182_ = self->metadata;

17603

_tmp183_ = vala_gir_parser_metadata_has_argument (_tmp182_, VALA_GIR_PARSER_ARGUMENT_TYPE_VFUNC_NAME);

17604

if (_tmp183_) {

17605

ValaGirParserNode* _tmp184_;

17606

ValaGirParserMetadata* _tmp185_;

17607

gchar* _tmp186_ = NULL;

17608

gchar* _tmp187_;

17609

ValaGirParserNode* _tmp188_ = NULL;

17610

ValaGirParserNode* _tmp189_;

17602

17611

ValaGirParserNode* vfunc;

17603

gboolean _tmp187_ = FALSE;

17604

ValaGirParserNode* _tmp188_;

17605

gboolean _tmp190_;

17606

_tmp181_ = self->parent;

17607

_tmp182_ = self->metadata;

17608

_tmp183_ = vala_gir_parser_metadata_get_string (_tmp182_, VALA_GIR_PARSER_ARGUMENT_TYPE_VFUNC_NAME);

17609

_tmp184_ = _tmp183_;

17610

_tmp185_ = vala_gir_parser_node_lookup (_tmp181_, _tmp184_, FALSE, NULL);

17611

_tmp186_ = _tmp185_;

17612

_g_free0 (_tmp184_);

17613

vfunc = _tmp186_;

17614

_tmp188_ = vfunc;

17615

if (_tmp188_ != NULL) {

17616

ValaGirParserNode* _tmp189_;

17617

_tmp189_ = vfunc;

17618

_tmp187_ = _tmp189_ != self;

17619

} else {

17620

_tmp187_ = FALSE;

17621

}

17622

_tmp190_ = _tmp187_;

17623

if (_tmp190_) {

17624

ValaGirParserNode* _tmp191_;

17612

gboolean _tmp190_ = FALSE;

17613

ValaGirParserNode* _tmp191_;

17614

gboolean _tmp193_;

17615

_tmp184_ = self->parent;

17616

_tmp185_ = self->metadata;

17617

_tmp186_ = vala_gir_parser_metadata_get_string (_tmp185_, VALA_GIR_PARSER_ARGUMENT_TYPE_VFUNC_NAME);

17618

_tmp187_ = _tmp186_;

17619

_tmp188_ = vala_gir_parser_node_lookup (_tmp184_, _tmp187_, FALSE, NULL);

17620

_tmp189_ = _tmp188_;

17621

_g_free0 (_tmp187_);

17622

vfunc = _tmp189_;

17623

_tmp191_ = vfunc;

17624

if (_tmp191_ != NULL) {

17625

ValaGirParserNode* _tmp192_;

17626

_tmp191_ = vfunc;

17627

_tmp191_->processed = TRUE;

17628

17626

_tmp192_ = vfunc;

17629

_tmp192_->merged = TRUE;

17627

_tmp190_ = _tmp192_ != self;

17628

} else {

17629

_tmp190_ = FALSE;

17630

}

17631

_tmp193_ = _tmp190_;

17632

if (_tmp193_) {

17633

ValaGirParserNode* _tmp194_;

17634

ValaGirParserNode* _tmp195_;

17635

_tmp194_ = vfunc;

17636

_tmp194_->processed = TRUE;

17637

_tmp195_ = vfunc;

17638

_tmp195_->merged = TRUE;

17630

17639

}

17631

17640

_vala_gir_parser_node_unref0 (vfunc);

17632

17641

}

17633

17642

}

17634

_tmp193_ = m;

17635

_tmp194_ = vala_method_get_coroutine (_tmp193_);

17636

_tmp195_ = _tmp194_;

17637

if (_tmp195_) {

17638

ValaGirParser* _tmp196_;

17639

_tmp196_ = parser;

17640

vala_gir_parser_process_async_method (_tmp196_, self);

17643

_tmp196_ = m;

17644

_tmp197_ = vala_method_get_coroutine (_tmp196_);

17645

_tmp198_ = _tmp197_;

17646

if (_tmp198_) {

17647

ValaGirParser* _tmp199_;

17648

_tmp199_ = parser;

17649

vala_gir_parser_process_async_method (_tmp199_, self);

17641

17650

}

17642

17651

_vala_iterable_unref0 (colliding);

17643

17652

_vala_code_node_unref0 (m);

17644

17653

} else {

17645

ValaSymbol* _tmp197_;

17646

_tmp197_ = self->symbol;

17647

if (VALA_IS_PROPERTY (_tmp197_)) {

17648

ValaGirParserNode* _tmp198_;

17649

const gchar* _tmp199_;

17650

ValaArrayList* _tmp200_ = NULL;

17654

ValaSymbol* _tmp200_;

17655

_tmp200_ = self->symbol;

17656

if (VALA_IS_PROPERTY (_tmp200_)) {

17657

ValaGirParserNode* _tmp201_;

17658

const gchar* _tmp202_;

17659

ValaArrayList* _tmp203_ = NULL;

17651

17660

ValaArrayList* colliding;

17652

ValaSymbol* _tmp219_;

17653

ValaProperty* _tmp220_;

17661

ValaSymbol* _tmp222_;

17662

ValaProperty* _tmp223_;

17654

17663

ValaProperty* prop;

17655

ValaMap* _tmp221_;

17656

gpointer _tmp222_ = NULL;

17664

ValaMap* _tmp224_;

17665

gpointer _tmp225_ = NULL;

17657

17666

gchar* readable;

17658

ValaMap* _tmp223_;

17659

gpointer _tmp224_ = NULL;

17667

ValaMap* _tmp226_;

17668

gpointer _tmp227_ = NULL;

17660

17669

gchar* writable;

17661

ValaMap* _tmp225_;

17662

gpointer _tmp226_ = NULL;

17670

ValaMap* _tmp228_;

17671

gpointer _tmp229_ = NULL;

17663

17672

gchar* construct_;

17664

ValaMap* _tmp227_;

17665

gpointer _tmp228_ = NULL;

17673

ValaMap* _tmp230_;

17674

gpointer _tmp231_ = NULL;

17666

17675

gchar* construct_only;

17667

const gchar* _tmp229_;

17668

gboolean _tmp238_ = FALSE;

17669

const gchar* _tmp239_;

17670

gboolean _tmp241_;

17676

const gchar* _tmp232_;

17677

gboolean _tmp241_ = FALSE;

17678

const gchar* _tmp242_;

17679

gboolean _tmp244_;

17671

17680

ValaGirParserNode* getter;

17672

ValaGirParserNode* _tmp258_;

17673

const gchar* _tmp259_;

17674

gchar* _tmp260_ = NULL;

17675

gchar* _tmp261_;

17676

ValaArrayList* _tmp262_ = NULL;

17677

ValaArrayList* _tmp263_;

17681

ValaGirParserNode* _tmp261_;

17682

const gchar* _tmp262_;

17683

gchar* _tmp263_ = NULL;

17684

gchar* _tmp264_;

17685

ValaArrayList* _tmp265_ = NULL;

17686

ValaArrayList* _tmp266_;

17678

17687

ValaArrayList* getters;

17679

ValaArrayList* _tmp264_;

17688

ValaArrayList* _tmp267_;

17680

17689

ValaGirParserNode* setter;

17681

ValaGirParserNode* _tmp296_;

17682

const gchar* _tmp297_;

17683

gchar* _tmp298_ = NULL;

17684

gchar* _tmp299_;

17685

ValaArrayList* _tmp300_ = NULL;

17686

ValaArrayList* _tmp301_;

17690

ValaGirParserNode* _tmp299_;

17691

const gchar* _tmp300_;

17692

gchar* _tmp301_ = NULL;

17693

gchar* _tmp302_;

17694

ValaArrayList* _tmp303_ = NULL;

17695

ValaArrayList* _tmp304_;

17687

17696

ValaArrayList* setters;

17688

ValaArrayList* _tmp302_;

17689

ValaProperty* _tmp334_;

17690

ValaProperty* _tmp335_;

17691

ValaPropertyAccessor* _tmp336_;

17692

ValaPropertyAccessor* _tmp337_;

17693

gboolean _tmp401_ = FALSE;

17694

gboolean _tmp402_ = FALSE;

17695

ValaProperty* _tmp403_;

17696

ValaAttribute* _tmp404_ = NULL;

17697

ValaAttribute* _tmp405_;

17698

gboolean _tmp406_;

17699

gboolean _tmp410_;

17700

gboolean _tmp416_;

17701

ValaProperty* _tmp467_;

17702

ValaAttribute* _tmp468_ = NULL;

17703

ValaAttribute* _tmp469_;

17704

gboolean _tmp470_;

17705

_tmp198_ = self->parent;

17706

_tmp199_ = self->name;

17707

_tmp200_ = vala_gir_parser_node_lookup_all (_tmp198_, _tmp199_);

17708

colliding = _tmp200_;

17697

ValaArrayList* _tmp305_;

17698

ValaProperty* _tmp337_;

17699

ValaProperty* _tmp338_;

17700

ValaPropertyAccessor* _tmp339_;

17701

ValaPropertyAccessor* _tmp340_;

17702

gboolean _tmp404_ = FALSE;

17703

gboolean _tmp405_ = FALSE;

17704

ValaProperty* _tmp406_;

17705

ValaAttribute* _tmp407_ = NULL;

17706

ValaAttribute* _tmp408_;

17707

gboolean _tmp409_;

17708

gboolean _tmp413_;

17709

gboolean _tmp419_;

17710

ValaProperty* _tmp470_;

17711

ValaAttribute* _tmp471_ = NULL;

17712

ValaAttribute* _tmp472_;

17713

gboolean _tmp473_;

17714

_tmp201_ = self->parent;

17715

_tmp202_ = self->name;

17716

_tmp203_ = vala_gir_parser_node_lookup_all (_tmp201_, _tmp202_);

17717

colliding = _tmp203_;

17709

17718

{

17710

ValaArrayList* _tmp201_;

17711

ValaArrayList* _tmp202_;

17719

ValaArrayList* _tmp204_;

17720

ValaArrayList* _tmp205_;

17712

17721

ValaArrayList* _node_list;

17713

ValaArrayList* _tmp203_;

17714

gint _tmp204_;

17715

gint _tmp205_;

17722

ValaArrayList* _tmp206_;

17723

gint _tmp207_;

17724

gint _tmp208_;

17716

17725

gint _node_size;

17717

17726

gint _node_index;

17718

_tmp201_ = colliding;

17719

_tmp202_ = _vala_iterable_ref0 (_tmp201_);

17720

_node_list = _tmp202_;

17721

_tmp203_ = _node_list;

17722

_tmp204_ = vala_collection_get_size ((ValaCollection*) _tmp203_);

17723

_tmp205_ = _tmp204_;

17724

_node_size = _tmp205_;

17727

_tmp204_ = colliding;

17728

_tmp205_ = _vala_iterable_ref0 (_tmp204_);

17729

_node_list = _tmp205_;

17730

_tmp206_ = _node_list;

17731

_tmp207_ = vala_collection_get_size ((ValaCollection*) _tmp206_);

17732

_tmp208_ = _tmp207_;

17733

_node_size = _tmp208_;

17725

17734

_node_index = -1;

17726

17735

while (TRUE) {

17727

gint _tmp206_;

17728

gint _tmp207_;

17729

gint _tmp208_;

17730

ValaArrayList* _tmp209_;

17736

gint _tmp209_;

17731

17737

gint _tmp210_;

17732

gpointer _tmp211_ = NULL;

17738

gint _tmp211_;

17739

ValaArrayList* _tmp212_;

17740

gint _tmp213_;

17741

gpointer _tmp214_ = NULL;

17733

17742

ValaGirParserNode* node;

17734

ValaGirParserNode* _tmp212_;

17735

ValaSymbol* _tmp213_;

17736

_tmp206_ = _node_index;

17737

_node_index = _tmp206_ + 1;

17738

_tmp207_ = _node_index;

17739

_tmp208_ = _node_size;

17740

if (!(_tmp207_ < _tmp208_)) {

17741

break;

17742

}

17743

_tmp209_ = _node_list;

17743

ValaGirParserNode* _tmp215_;

17744

ValaSymbol* _tmp216_;

17745

_tmp209_ = _node_index;

17746

_node_index = _tmp209_ + 1;

17744

17747

_tmp210_ = _node_index;

17745

_tmp211_ = vala_list_get ((ValaList*) _tmp209_, _tmp210_);

17746

node = (ValaGirParserNode*) _tmp211_;

17747

_tmp212_ = node;

17748

_tmp213_ = _tmp212_->symbol;

17749

if (VALA_IS_SIGNAL (_tmp213_)) {

17750

ValaGirParserNode* _tmp214_;

17751

ValaGirParserNode* _tmp215_;

17752

_tmp214_ = node;

17753

_tmp214_->processed = TRUE;

17754

_tmp215_ = node;

17755

_tmp215_->merged = TRUE;

17748

_tmp211_ = _node_size;

17749

if (!(_tmp210_ < _tmp211_)) {

17750

break;

17751

}

17752

_tmp212_ = _node_list;

17753

_tmp213_ = _node_index;

17754

_tmp214_ = vala_list_get ((ValaList*) _tmp212_, _tmp213_);

17755

node = (ValaGirParserNode*) _tmp214_;

17756

_tmp215_ = node;

17757

_tmp216_ = _tmp215_->symbol;

17758

if (VALA_IS_SIGNAL (_tmp216_)) {

17759

ValaGirParserNode* _tmp217_;

17760

ValaGirParserNode* _tmp218_;

17761

_tmp217_ = node;

17762

_tmp217_->processed = TRUE;

17763

_tmp218_ = node;

17764

_tmp218_->merged = TRUE;

17756

17765

} else {

17757

ValaGirParserNode* _tmp216_;

17758

ValaSymbol* _tmp217_;

17759

_tmp216_ = node;

17760

_tmp217_ = _tmp216_->symbol;

17761

if (VALA_IS_METHOD (_tmp217_)) {

17762

ValaGirParserNode* _tmp218_;

17763

_tmp218_ = node;

17764

_tmp218_->merged = TRUE;

17766

ValaGirParserNode* _tmp219_;

17767

ValaSymbol* _tmp220_;

17768

_tmp219_ = node;

17769

_tmp220_ = _tmp219_->symbol;

17770

if (VALA_IS_METHOD (_tmp220_)) {

17771

ValaGirParserNode* _tmp221_;

17772

_tmp221_ = node;

17773

_tmp221_->merged = TRUE;

17765

17774

}

17766

17775

}

17767

17776

_vala_gir_parser_node_unref0 (node);

17768

17777

}

17769

17778

_vala_iterable_unref0 (_node_list);

17770

17779

}

17771

_tmp219_ = self->symbol;

17772

_tmp220_ = _vala_code_node_ref0 (VALA_PROPERTY (_tmp219_));

17773

prop = _tmp220_;

17774

_tmp221_ = self->girdata;

17775

_tmp222_ = vala_map_get (_tmp221_, "readable");

17776

readable = (gchar*) _tmp222_;

17777

_tmp223_ = self->girdata;

17778

_tmp224_ = vala_map_get (_tmp223_, "writable");

17779

writable = (gchar*) _tmp224_;

17780

_tmp225_ = self->girdata;

17781

_tmp226_ = vala_map_get (_tmp225_, "construct");

17782

construct_ = (gchar*) _tmp226_;

17783

_tmp227_ = self->girdata;

17784

_tmp228_ = vala_map_get (_tmp227_, "construct-only");

17785

construct_only = (gchar*) _tmp228_;

17786

_tmp229_ = readable;

17787

if (g_strcmp0 (_tmp229_, "0") != 0) {

17788

ValaProperty* _tmp230_;

17789

ValaProperty* _tmp231_;

17790

ValaDataType* _tmp232_;

17791

ValaDataType* _tmp233_;

17792

ValaDataType* _tmp234_ = NULL;

17780

_tmp222_ = self->symbol;

17781

_tmp223_ = _vala_code_node_ref0 (VALA_PROPERTY (_tmp222_));

17782

prop = _tmp223_;

17783

_tmp224_ = self->girdata;

17784

_tmp225_ = vala_map_get (_tmp224_, "readable");

17785

readable = (gchar*) _tmp225_;

17786

_tmp226_ = self->girdata;

17787

_tmp227_ = vala_map_get (_tmp226_, "writable");

17788

writable = (gchar*) _tmp227_;

17789

_tmp228_ = self->girdata;

17790

_tmp229_ = vala_map_get (_tmp228_, "construct");

17791

construct_ = (gchar*) _tmp229_;

17792

_tmp230_ = self->girdata;

17793

_tmp231_ = vala_map_get (_tmp230_, "construct-only");

17794

construct_only = (gchar*) _tmp231_;

17795

_tmp232_ = readable;

17796

if (g_strcmp0 (_tmp232_, "0") != 0) {

17797

ValaProperty* _tmp233_;

17798

ValaProperty* _tmp234_;

17793

17799

ValaDataType* _tmp235_;

17794

ValaPropertyAccessor* _tmp236_;

17795

ValaPropertyAccessor* _tmp237_;

17796

_tmp230_ = prop;

17797

_tmp231_ = prop;

17798

_tmp232_ = vala_property_get_property_type (_tmp231_);

17799

_tmp233_ = _tmp232_;

17800

_tmp234_ = vala_data_type_copy (_tmp233_);

17801

_tmp235_ = _tmp234_;

17802

_tmp236_ = vala_property_accessor_new (TRUE, FALSE, FALSE, _tmp235_, NULL, NULL, NULL);

17803

_tmp237_ = _tmp236_;

17804

vala_property_set_get_accessor (_tmp230_, _tmp237_);

17805

_vala_code_node_unref0 (_tmp237_);

17806

_vala_code_node_unref0 (_tmp235_);

17800

ValaDataType* _tmp236_;

17801

ValaDataType* _tmp237_ = NULL;

17802

ValaDataType* _tmp238_;

17803

ValaPropertyAccessor* _tmp239_;

17804

ValaPropertyAccessor* _tmp240_;

17805

_tmp233_ = prop;

17806

_tmp234_ = prop;

17807

_tmp235_ = vala_property_get_property_type (_tmp234_);

17808

_tmp236_ = _tmp235_;

17809

_tmp237_ = vala_data_type_copy (_tmp236_);

17810

_tmp238_ = _tmp237_;

17811

_tmp239_ = vala_property_accessor_new (TRUE, FALSE, FALSE, _tmp238_, NULL, NULL, NULL);

17812

_tmp240_ = _tmp239_;

17813

vala_property_set_get_accessor (_tmp233_, _tmp240_);

17814

_vala_code_node_unref0 (_tmp240_);

17815

_vala_code_node_unref0 (_tmp238_);

17807

17816

}

17808

_tmp239_ = writable;

17809

if (g_strcmp0 (_tmp239_, "1") == 0) {

17810

_tmp238_ = TRUE;

17817

_tmp242_ = writable;

17818

if (g_strcmp0 (_tmp242_, "1") == 0) {

17819

_tmp241_ = TRUE;

17811

17820

} else {

17812

const gchar* _tmp240_;

17813

_tmp240_ = construct_only;

17814

_tmp238_ = g_strcmp0 (_tmp240_, "1") == 0;

17815

}

17816

_tmp241_ = _tmp238_;

17817

if (_tmp241_) {

17818

gboolean _tmp242_ = FALSE;

17819

17821

const gchar* _tmp243_;

17822

_tmp243_ = construct_only;

17823

_tmp241_ = g_strcmp0 (_tmp243_, "1") == 0;

17824

}

17825

_tmp244_ = _tmp241_;

17826

if (_tmp244_) {

17820

17827

gboolean _tmp245_ = FALSE;

17821

17828

const gchar* _tmp246_;

17822

ValaProperty* _tmp248_;

17823

gboolean _tmp249_;

17824

gboolean _tmp250_;

17829

gboolean _tmp248_ = FALSE;

17830

const gchar* _tmp249_;

17825

17831

ValaProperty* _tmp251_;

17826

ValaDataType* _tmp252_;

17827

ValaDataType* _tmp253_;

17828

ValaDataType* _tmp254_ = NULL;

17832

gboolean _tmp252_;

17833

gboolean _tmp253_;

17834

ValaProperty* _tmp254_;

17829

17835

ValaDataType* _tmp255_;

17830

ValaPropertyAccessor* _tmp256_;

17831

ValaPropertyAccessor* _tmp257_;

17832

_tmp243_ = construct_only;

17833

if (g_strcmp0 (_tmp243_, "1") != 0) {

17834

const gchar* _tmp244_;

17835

_tmp244_ = writable;

17836

_tmp242_ = g_strcmp0 (_tmp244_, "1") == 0;

17837

} else {

17838

_tmp242_ = FALSE;

17839

}

17836

ValaDataType* _tmp256_;

17837

ValaDataType* _tmp257_ = NULL;

17838

ValaDataType* _tmp258_;

17839

ValaPropertyAccessor* _tmp259_;

17840

ValaPropertyAccessor* _tmp260_;

17840

17841

_tmp246_ = construct_only;

17841

if (g_strcmp0 (_tmp246_, "1") == 0) {

17842

_tmp245_ = TRUE;

17843

} else {

17842

if (g_strcmp0 (_tmp246_, "1") != 0) {

17844

17843

const gchar* _tmp247_;

17845

_tmp247_ = construct_;

17844

_tmp247_ = writable;

17846

17845

_tmp245_ = g_strcmp0 (_tmp247_, "1") == 0;

17847

}

17848

_tmp248_ = prop;

17849

_tmp249_ = _tmp242_;

17850

_tmp250_ = _tmp245_;

17846

} else {

17847

_tmp245_ = FALSE;

17848

}

17849

_tmp249_ = construct_only;

17850

if (g_strcmp0 (_tmp249_, "1") == 0) {

17851

_tmp248_ = TRUE;

17852

} else {

17853

const gchar* _tmp250_;

17854

_tmp250_ = construct_;

17855

_tmp248_ = g_strcmp0 (_tmp250_, "1") == 0;

17856

}

17851

17857

_tmp251_ = prop;

17852

_tmp252_ = vala_property_get_property_type (_tmp251_);

17853

_tmp253_ = _tmp252_;

17854

_tmp254_ = vala_data_type_copy (_tmp253_);

17855

_tmp255_ = _tmp254_;

17856

_tmp256_ = vala_property_accessor_new (FALSE, _tmp249_, _tmp250_, _tmp255_, NULL, NULL, NULL);

17857

_tmp257_ = _tmp256_;

17858

vala_property_set_set_accessor (_tmp248_, _tmp257_);

17859

_vala_code_node_unref0 (_tmp257_);

17860

_vala_code_node_unref0 (_tmp255_);

17858

_tmp252_ = _tmp245_;

17859

_tmp253_ = _tmp248_;

17860

_tmp254_ = prop;

17861

_tmp255_ = vala_property_get_property_type (_tmp254_);

17862

_tmp256_ = _tmp255_;

17863

_tmp257_ = vala_data_type_copy (_tmp256_);

17864

_tmp258_ = _tmp257_;

17865

_tmp259_ = vala_property_accessor_new (FALSE, _tmp252_, _tmp253_, _tmp258_, NULL, NULL, NULL);

17866

_tmp260_ = _tmp259_;

17867

vala_property_set_set_accessor (_tmp251_, _tmp260_);

17868

_vala_code_node_unref0 (_tmp260_);

17869

_vala_code_node_unref0 (_tmp258_);

17861

17870

}

17862

17871

getter = NULL;

17863

_tmp258_ = self->parent;

17864

_tmp259_ = self->name;

17865

_tmp260_ = g_strdup_printf ("get_%s", _tmp259_);

17866

_tmp261_ = _tmp260_;

17867

_tmp262_ = vala_gir_parser_node_lookup_all (_tmp258_, _tmp261_);

17868

_tmp263_ = _tmp262_;

17869

_g_free0 (_tmp261_);

17870

getters = _tmp263_;

17871

_tmp264_ = getters;

17872

if (_tmp264_ != NULL) {

17872

_tmp261_ = self->parent;

17873

_tmp262_ = self->name;

17874

_tmp263_ = g_strdup_printf ("get_%s", _tmp262_);

17875

_tmp264_ = _tmp263_;

17876

_tmp265_ = vala_gir_parser_node_lookup_all (_tmp261_, _tmp264_);

17877

_tmp266_ = _tmp265_;

17878

_g_free0 (_tmp264_);

17879

getters = _tmp266_;

17880

_tmp267_ = getters;

17881

if (_tmp267_ != NULL) {

17873

17882

{

17874

ValaArrayList* _tmp265_;

17875

ValaArrayList* _tmp266_;

17883

ValaArrayList* _tmp268_;

17884

ValaArrayList* _tmp269_;

17876

17885

ValaArrayList* _g_list;

17877

ValaArrayList* _tmp267_;

17878

gint _tmp268_;

17879

gint _tmp269_;

17886

ValaArrayList* _tmp270_;

17887

gint _tmp271_;

17888

gint _tmp272_;

17880

17889

gint _g_size;

17881

17890

gint _g_index;

17882

_tmp265_ = getters;

17883

_tmp266_ = _vala_iterable_ref0 (_tmp265_);

17884

_g_list = _tmp266_;

17885

_tmp267_ = _g_list;

17886

_tmp268_ = vala_collection_get_size ((ValaCollection*) _tmp267_);

17887

_tmp269_ = _tmp268_;

17888

_g_size = _tmp269_;

17891

_tmp268_ = getters;

17892

_tmp269_ = _vala_iterable_ref0 (_tmp268_);

17893

_g_list = _tmp269_;

17894

_tmp270_ = _g_list;

17895

_tmp271_ = vala_collection_get_size ((ValaCollection*) _tmp270_);

17896

_tmp272_ = _tmp271_;

17897

_g_size = _tmp272_;

17889

17898

_g_index = -1;

17890

17899

while (TRUE) {

17891

gint _tmp270_;

17892

gint _tmp271_;

17893

gint _tmp272_;

17894

ValaArrayList* _tmp273_;

17900

gint _tmp273_;

17895

17901

gint _tmp274_;

17896

gpointer _tmp275_ = NULL;

17902

gint _tmp275_;

17903

ValaArrayList* _tmp276_;

17904

gint _tmp277_;

17905

gpointer _tmp278_ = NULL;

17897

17906

ValaGirParserNode* g;

17898

gboolean _tmp276_ = FALSE;

17899

gboolean _tmp277_ = FALSE;

17900

ValaGirParserNode* _tmp278_;

17901

gboolean _tmp281_;

17902

gboolean _tmp293_;

17903

_tmp270_ = _g_index;

17904

_g_index = _tmp270_ + 1;

17905

_tmp271_ = _g_index;

17906

_tmp272_ = _g_size;

17907

if (!(_tmp271_ < _tmp272_)) {

17908

break;

17909

}

17910

_tmp273_ = _g_list;

17907

gboolean _tmp279_ = FALSE;

17908

gboolean _tmp280_ = FALSE;

17909

ValaGirParserNode* _tmp281_;

17910

gboolean _tmp284_;

17911

gboolean _tmp296_;

17912

_tmp273_ = _g_index;

17913

_g_index = _tmp273_ + 1;

17911

17914

_tmp274_ = _g_index;

17912

_tmp275_ = vala_list_get ((ValaList*) _tmp273_, _tmp274_);

17913

g = (ValaGirParserNode*) _tmp275_;

17914

_tmp278_ = getter;

17915

if (_tmp278_ == NULL) {

17916

_tmp277_ = TRUE;

17915

_tmp275_ = _g_size;

17916

if (!(_tmp274_ < _tmp275_)) {

17917

break;

17918

}

17919

_tmp276_ = _g_list;

17920

_tmp277_ = _g_index;

17921

_tmp278_ = vala_list_get ((ValaList*) _tmp276_, _tmp277_);

17922

g = (ValaGirParserNode*) _tmp278_;

17923

_tmp281_ = getter;

17924

if (_tmp281_ == NULL) {

17925

_tmp280_ = TRUE;

17917

17926

} else {

17918

ValaGirParserNode* _tmp279_;

17919

gboolean _tmp280_;

17920

_tmp279_ = g;

17921

_tmp280_ = _tmp279_->merged;

17922

_tmp277_ = !_tmp280_;

17923

}

17924

_tmp281_ = _tmp277_;

17925

if (_tmp281_) {

17926

17927

ValaGirParserNode* _tmp282_;

17927

gchar* _tmp283_ = NULL;

17928

gchar* _tmp284_;

17928

gboolean _tmp283_;

17929

_tmp282_ = g;

17930

_tmp283_ = _tmp282_->merged;

17931

_tmp280_ = !_tmp283_;

17932

}

17933

_tmp284_ = _tmp280_;

17934

if (_tmp284_) {

17929

17935

ValaGirParserNode* _tmp285_;

17930

17936

gchar* _tmp286_ = NULL;

17931

17937

gchar* _tmp287_;

17932

gchar* _tmp288_;

17933

gchar* _tmp289_;

17934

const gchar* _tmp290_;

17938

ValaGirParserNode* _tmp288_;

17939

gchar* _tmp289_ = NULL;

17940

gchar* _tmp290_;

17935

17941

gchar* _tmp291_;

17936

17942

gchar* _tmp292_;

17937

_tmp282_ = g;

17938

_tmp283_ = vala_gir_parser_node_get_cname (_tmp282_);

17939

_tmp284_ = _tmp283_;

17940

_tmp285_ = self->parent;

17941

_tmp286_ = vala_gir_parser_node_get_lower_case_cprefix (_tmp285_);

17943

const gchar* _tmp293_;

17944

gchar* _tmp294_;

17945

gchar* _tmp295_;

17946

_tmp285_ = g;

17947

_tmp286_ = vala_gir_parser_node_get_cname (_tmp285_);

17942

17948

_tmp287_ = _tmp286_;

17943

_tmp288_ = g_strconcat (_tmp287_, "get_", NULL);

17944

_tmp289_ = _tmp288_;

17945

_tmp290_ = self->name;

17946

_tmp291_ = g_strconcat (_tmp289_, _tmp290_, NULL);

17949

_tmp288_ = self->parent;

17950

_tmp289_ = vala_gir_parser_node_get_lower_case_cprefix (_tmp288_);

17951

_tmp290_ = _tmp289_;

17952

_tmp291_ = g_strconcat (_tmp290_, "get_", NULL);

17947

17953

_tmp292_ = _tmp291_;

17948

_tmp276_ = g_strcmp0 (_tmp284_, _tmp292_) == 0;

17954

_tmp293_ = self->name;

17955

_tmp294_ = g_strconcat (_tmp292_, _tmp293_, NULL);

17956

_tmp295_ = _tmp294_;

17957

_tmp279_ = g_strcmp0 (_tmp287_, _tmp295_) == 0;

17958

_g_free0 (_tmp295_);

17949

17959

_g_free0 (_tmp292_);

17950

_g_free0 (_tmp289_);

17960

_g_free0 (_tmp290_);

17951

17961

_g_free0 (_tmp287_);

17952

_g_free0 (_tmp284_);

17953

17962

} else {

17954

_tmp276_ = FALSE;

17963

_tmp279_ = FALSE;

17955

17964

}

17956

_tmp293_ = _tmp276_;

17957

if (_tmp293_) {

17958

ValaGirParserNode* _tmp294_;

17959

ValaGirParserNode* _tmp295_;

17960

_tmp294_ = g;

17961

_tmp295_ = _vala_gir_parser_node_ref0 (_tmp294_);

17965

_tmp296_ = _tmp279_;

17966

if (_tmp296_) {

17967

ValaGirParserNode* _tmp297_;

17968

ValaGirParserNode* _tmp298_;

17969

_tmp297_ = g;

17970

_tmp298_ = _vala_gir_parser_node_ref0 (_tmp297_);

17962

17971

_vala_gir_parser_node_unref0 (getter);

17963

getter = _tmp295_;

17972

getter = _tmp298_;

17964

17973

}

17965

17974

_vala_gir_parser_node_unref0 (g);

17966

17975

}

17968

17977

}

17969

17978

}

17970

17979

setter = NULL;

17971

_tmp296_ = self->parent;

17972

_tmp297_ = self->name;

17973

_tmp298_ = g_strdup_printf ("set_%s", _tmp297_);

17974

_tmp299_ = _tmp298_;

17975

_tmp300_ = vala_gir_parser_node_lookup_all (_tmp296_, _tmp299_);

17976

_tmp301_ = _tmp300_;

17977

_g_free0 (_tmp299_);

17978

setters = _tmp301_;

17979

_tmp302_ = setters;

17980

if (_tmp302_ != NULL) {

17980

_tmp299_ = self->parent;

17981

_tmp300_ = self->name;

17982

_tmp301_ = g_strdup_printf ("set_%s", _tmp300_);

17983

_tmp302_ = _tmp301_;

17984

_tmp303_ = vala_gir_parser_node_lookup_all (_tmp299_, _tmp302_);

17985

_tmp304_ = _tmp303_;

17986

_g_free0 (_tmp302_);

17987

setters = _tmp304_;

17988

_tmp305_ = setters;

17989

if (_tmp305_ != NULL) {

17981

17990

{

17982

ValaArrayList* _tmp303_;

17983

ValaArrayList* _tmp304_;

17991

ValaArrayList* _tmp306_;

17992

ValaArrayList* _tmp307_;

17984

17993

ValaArrayList* _s_list;

17985

ValaArrayList* _tmp305_;

17986

gint _tmp306_;

17987

gint _tmp307_;

17994

ValaArrayList* _tmp308_;

17995

gint _tmp309_;

17996

gint _tmp310_;

17988

17997

gint _s_size;

17989

17998

gint _s_index;

17990

_tmp303_ = setters;

17991

_tmp304_ = _vala_iterable_ref0 (_tmp303_);

17992

_s_list = _tmp304_;

17993

_tmp305_ = _s_list;

17994

_tmp306_ = vala_collection_get_size ((ValaCollection*) _tmp305_);

17995

_tmp307_ = _tmp306_;

17996

_s_size = _tmp307_;

17999

_tmp306_ = setters;

18000

_tmp307_ = _vala_iterable_ref0 (_tmp306_);

18001

_s_list = _tmp307_;

18002

_tmp308_ = _s_list;

18003

_tmp309_ = vala_collection_get_size ((ValaCollection*) _tmp308_);

18004

_tmp310_ = _tmp309_;

18005

_s_size = _tmp310_;

17997

18006

_s_index = -1;

17998

18007

while (TRUE) {

17999

gint _tmp308_;

18000

gint _tmp309_;

18001

gint _tmp310_;

18002

ValaArrayList* _tmp311_;

18008

gint _tmp311_;

18003

18009

gint _tmp312_;

18004

gpointer _tmp313_ = NULL;

18010

gint _tmp313_;

18011

ValaArrayList* _tmp314_;

18012

gint _tmp315_;

18013

gpointer _tmp316_ = NULL;

18005

18014

ValaGirParserNode* s;

18006

gboolean _tmp314_ = FALSE;

18007

gboolean _tmp315_ = FALSE;

18008

ValaGirParserNode* _tmp316_;

18009

gboolean _tmp319_;

18010

gboolean _tmp331_;

18011

_tmp308_ = _s_index;

18012

_s_index = _tmp308_ + 1;

18013

_tmp309_ = _s_index;

18014

_tmp310_ = _s_size;

18015

if (!(_tmp309_ < _tmp310_)) {

18016

break;

18017

}

18018

_tmp311_ = _s_list;

18015

gboolean _tmp317_ = FALSE;

18016

gboolean _tmp318_ = FALSE;

18017

ValaGirParserNode* _tmp319_;

18018

gboolean _tmp322_;

18019

gboolean _tmp334_;

18020

_tmp311_ = _s_index;

18021

_s_index = _tmp311_ + 1;

18019

18022

_tmp312_ = _s_index;

18020

_tmp313_ = vala_list_get ((ValaList*) _tmp311_, _tmp312_);

18021

s = (ValaGirParserNode*) _tmp313_;

18022

_tmp316_ = setter;

18023

if (_tmp316_ == NULL) {

18024

_tmp315_ = TRUE;

18023

_tmp313_ = _s_size;

18024

if (!(_tmp312_ < _tmp313_)) {

18025

break;

18026

}

18027

_tmp314_ = _s_list;

18028

_tmp315_ = _s_index;

18029

_tmp316_ = vala_list_get ((ValaList*) _tmp314_, _tmp315_);

18030

s = (ValaGirParserNode*) _tmp316_;

18031

_tmp319_ = setter;

18032

if (_tmp319_ == NULL) {

18033

_tmp318_ = TRUE;

18025

18034

} else {

18026

ValaGirParserNode* _tmp317_;

18027

gboolean _tmp318_;

18028

_tmp317_ = s;

18029

_tmp318_ = _tmp317_->merged;

18030

_tmp315_ = !_tmp318_;

18031

}

18032

_tmp319_ = _tmp315_;

18033

if (_tmp319_) {

18034

18035

ValaGirParserNode* _tmp320_;

18035

gchar* _tmp321_ = NULL;

18036

gchar* _tmp322_;

18036

gboolean _tmp321_;

18037

_tmp320_ = s;

18038

_tmp321_ = _tmp320_->merged;

18039

_tmp318_ = !_tmp321_;

18040

}

18041

_tmp322_ = _tmp318_;

18042

if (_tmp322_) {

18037

18043

ValaGirParserNode* _tmp323_;

18038

18044

gchar* _tmp324_ = NULL;

18039

18045

gchar* _tmp325_;

18040

gchar* _tmp326_;

18041

gchar* _tmp327_;

18042

const gchar* _tmp328_;

18046

ValaGirParserNode* _tmp326_;

18047

gchar* _tmp327_ = NULL;

18048

gchar* _tmp328_;

18043

18049

gchar* _tmp329_;

18044

18050

gchar* _tmp330_;

18045

_tmp320_ = s;

18046

_tmp321_ = vala_gir_parser_node_get_cname (_tmp320_);

18047

_tmp322_ = _tmp321_;

18048

_tmp323_ = self->parent;

18049

_tmp324_ = vala_gir_parser_node_get_lower_case_cprefix (_tmp323_);

18051

const gchar* _tmp331_;

18052

gchar* _tmp332_;

18053

gchar* _tmp333_;

18054

_tmp323_ = s;

18055

_tmp324_ = vala_gir_parser_node_get_cname (_tmp323_);

18050

18056

_tmp325_ = _tmp324_;

18051

_tmp326_ = g_strconcat (_tmp325_, "set_", NULL);

18052

_tmp327_ = _tmp326_;

18053

_tmp328_ = self->name;

18054

_tmp329_ = g_strconcat (_tmp327_, _tmp328_, NULL);

18057

_tmp326_ = self->parent;

18058

_tmp327_ = vala_gir_parser_node_get_lower_case_cprefix (_tmp326_);

18059

_tmp328_ = _tmp327_;

18060

_tmp329_ = g_strconcat (_tmp328_, "set_", NULL);

18055

18061

_tmp330_ = _tmp329_;

18056

_tmp314_ = g_strcmp0 (_tmp322_, _tmp330_) == 0;

18062

_tmp331_ = self->name;

18063

_tmp332_ = g_strconcat (_tmp330_, _tmp331_, NULL);

18064

_tmp333_ = _tmp332_;

18065

_tmp317_ = g_strcmp0 (_tmp325_, _tmp333_) == 0;

18066

_g_free0 (_tmp333_);

18057

18067

_g_free0 (_tmp330_);

18058

_g_free0 (_tmp327_);

18068

_g_free0 (_tmp328_);

18059

18069

_g_free0 (_tmp325_);

18060

_g_free0 (_tmp322_);

18061

18070

} else {

18062

_tmp314_ = FALSE;

18071

_tmp317_ = FALSE;

18063

18072

}

18064

_tmp331_ = _tmp314_;

18065

if (_tmp331_) {

18066

ValaGirParserNode* _tmp332_;

18067

ValaGirParserNode* _tmp333_;

18068

_tmp332_ = s;

18069

_tmp333_ = _vala_gir_parser_node_ref0 (_tmp332_);

18073

_tmp334_ = _tmp317_;

18074

if (_tmp334_) {

18075

ValaGirParserNode* _tmp335_;

18076

ValaGirParserNode* _tmp336_;

18077

_tmp335_ = s;

18078

_tmp336_ = _vala_gir_parser_node_ref0 (_tmp335_);

18070

18079

_vala_gir_parser_node_unref0 (setter);

18071

setter = _tmp333_;

18080

setter = _tmp336_;

18072

18081

}

18073

18082

_vala_gir_parser_node_unref0 (s);

18074

18083

}

18075

18084

_vala_iterable_unref0 (_s_list);

18076

18085

}

18077

18086

}

18078

_tmp334_ = prop;

18079

vala_code_node_set_attribute ((ValaCodeNode*) _tmp334_, "NoAccessorMethod", FALSE, NULL);

18080

_tmp335_ = prop;

18081

_tmp336_ = vala_property_get_get_accessor (_tmp335_);

18082

_tmp337_ = _tmp336_;

18083

if (_tmp337_ != NULL) {

18084

ValaMethod* _tmp338_ = NULL;

18085

ValaGirParserNode* _tmp339_;

18086

ValaMethod* _tmp342_;

18087

ValaMethod* _tmp343_;

18088

ValaMethod* m;

18089

gboolean _tmp344_ = FALSE;

18087

_tmp337_ = prop;

18088

vala_code_node_set_attribute ((ValaCodeNode*) _tmp337_, "NoAccessorMethod", FALSE, NULL);

18089

_tmp338_ = prop;

18090

_tmp339_ = vala_property_get_get_accessor (_tmp338_);

18091

_tmp340_ = _tmp339_;

18092

if (_tmp340_ != NULL) {

18093

ValaMethod* _tmp341_ = NULL;

18094

ValaGirParserNode* _tmp342_;

18090

18095

ValaMethod* _tmp345_;

18091

gboolean _tmp359_;

18092

_tmp339_ = getter;

18093

if (_tmp339_ != NULL) {

18094

ValaGirParserNode* _tmp340_;

18095

ValaSymbol* _tmp341_;

18096

_tmp340_ = getter;

18097

_tmp341_ = _tmp340_->symbol;

18098

_tmp338_ = VALA_IS_METHOD (_tmp341_) ? ((ValaMethod*) _tmp341_) : NULL;

18096

ValaMethod* _tmp346_;

18097

ValaMethod* m;

18098

gboolean _tmp347_ = FALSE;

18099

ValaMethod* _tmp348_;

18100

gboolean _tmp362_;

18101

_tmp342_ = getter;

18102

if (_tmp342_ != NULL) {

18103

ValaGirParserNode* _tmp343_;

18104

ValaSymbol* _tmp344_;

18105

_tmp343_ = getter;

18106

_tmp344_ = _tmp343_->symbol;

18107

_tmp341_ = VALA_IS_METHOD (_tmp344_) ? ((ValaMethod*) _tmp344_) : NULL;

18099

18108

} else {

18100

_tmp338_ = NULL;

18109

_tmp341_ = NULL;

18101

18110

}

18102

_tmp342_ = _tmp338_;

18103

_tmp343_ = _vala_code_node_ref0 (_tmp342_);

18104

m = _tmp343_;

18105

_tmp345_ = m;

18106

if (_tmp345_ != NULL) {

18107

gboolean _tmp346_ = FALSE;

18108

gboolean _tmp347_ = FALSE;

18109

ValaMethod* _tmp348_;

18110

gboolean _tmp349_;

18111

gboolean _tmp350_;

18112

gboolean _tmp354_;

18113

gboolean _tmp358_;

18114

_tmp348_ = m;

18115

_tmp349_ = vala_method_get_is_abstract (_tmp348_);

18116

_tmp350_ = _tmp349_;

18117

if (_tmp350_) {

18118

_tmp347_ = TRUE;

18119

} else {

18120

ValaMethod* _tmp351_;

18121

gboolean _tmp352_;

18122

gboolean _tmp353_;

18123

_tmp351_ = m;

18124

_tmp352_ = vala_method_get_is_virtual (_tmp351_);

18125

_tmp353_ = _tmp352_;

18126

_tmp347_ = _tmp353_;

18127

}

18128

_tmp354_ = _tmp347_;

18129

if (_tmp354_) {

18130

_tmp346_ = TRUE;

18131

} else {

18132

ValaProperty* _tmp355_;

18111

_tmp345_ = _tmp341_;

18112

_tmp346_ = _vala_code_node_ref0 (_tmp345_);

18113

m = _tmp346_;

18114

_tmp348_ = m;

18115

if (_tmp348_ != NULL) {

18116

gboolean _tmp349_ = FALSE;

18117

gboolean _tmp350_ = FALSE;

18118

ValaMethod* _tmp351_;

18119

gboolean _tmp352_;

18120

gboolean _tmp353_;

18121

gboolean _tmp357_;

18122

gboolean _tmp361_;

18123

_tmp351_ = m;

18124

_tmp352_ = vala_method_get_is_abstract (_tmp351_);

18125

_tmp353_ = _tmp352_;

18126

if (_tmp353_) {

18127

_tmp350_ = TRUE;

18128

} else {

18129

ValaMethod* _tmp354_;

18130

gboolean _tmp355_;

18133

18131

gboolean _tmp356_;

18134

gboolean _tmp357_;

18135

_tmp355_ = prop;

18136

_tmp356_ = vala_property_get_is_abstract (_tmp355_);

18137

_tmp357_ = _tmp356_;

18138

_tmp346_ = !_tmp357_;

18139

}

18140

_tmp358_ = _tmp346_;

18141

_tmp344_ = _tmp358_;

18132

_tmp354_ = m;

18133

_tmp355_ = vala_method_get_is_virtual (_tmp354_);

18134

_tmp356_ = _tmp355_;

18135

_tmp350_ = _tmp356_;

18136

}

18137

_tmp357_ = _tmp350_;

18138

if (_tmp357_) {

18139

_tmp349_ = TRUE;

18140

} else {

18141

ValaProperty* _tmp358_;

18142

gboolean _tmp359_;

18143

gboolean _tmp360_;

18144

_tmp358_ = prop;

18145

_tmp359_ = vala_property_get_is_abstract (_tmp358_);

18146

_tmp360_ = _tmp359_;

18147

_tmp349_ = !_tmp360_;

18148

}

18149

_tmp361_ = _tmp349_;

18150

_tmp347_ = _tmp361_;

18142

18151

} else {

18143

_tmp344_ = FALSE;

18152

_tmp347_ = FALSE;

18144

18153

}

18145

_tmp359_ = _tmp344_;

18146

if (_tmp359_) {

18147

ValaGirParserNode* _tmp360_;

18148

ValaGirParser* _tmp361_;

18149

gboolean _tmp362_ = FALSE;

18150

ValaMethod* _tmp363_;

18151

ValaDataType* _tmp364_;

18152

ValaDataType* _tmp365_;

18153

gboolean _tmp371_;

18154

_tmp360_ = getter;

18155

_tmp361_ = parser;

18156

vala_gir_parser_node_process (_tmp360_, _tmp361_);

18157

_tmp363_ = m;

18158

_tmp364_ = vala_method_get_return_type (_tmp363_);

18159

_tmp365_ = _tmp364_;

18160

if (VALA_IS_VOID_TYPE (_tmp365_)) {

18161

_tmp362_ = TRUE;

18154

_tmp362_ = _tmp347_;

18155

if (_tmp362_) {

18156

ValaGirParserNode* _tmp363_;

18157

ValaGirParser* _tmp364_;

18158

gboolean _tmp365_ = FALSE;

18159

ValaMethod* _tmp366_;

18160

ValaDataType* _tmp367_;

18161

ValaDataType* _tmp368_;

18162

gboolean _tmp374_;

18163

_tmp363_ = getter;

18164

_tmp364_ = parser;

18165

vala_gir_parser_node_process (_tmp363_, _tmp364_);

18166

_tmp366_ = m;

18167

_tmp367_ = vala_method_get_return_type (_tmp366_);

18168

_tmp368_ = _tmp367_;

18169

if (VALA_IS_VOID_TYPE (_tmp368_)) {

18170

_tmp365_ = TRUE;

18162

18171

} else {

18163

ValaMethod* _tmp366_;

18164

ValaList* _tmp367_ = NULL;

18165

ValaList* _tmp368_;

18166

gint _tmp369_;

18167

gint _tmp370_;

18168

_tmp366_ = m;

18169

_tmp367_ = vala_method_get_parameters (_tmp366_);

18170

_tmp368_ = _tmp367_;

18171

_tmp369_ = vala_collection_get_size ((ValaCollection*) _tmp368_);

18172

_tmp370_ = _tmp369_;

18173

_tmp362_ = _tmp370_ != 0;

18174

_vala_iterable_unref0 (_tmp368_);

18172

ValaMethod* _tmp369_;

18173

ValaList* _tmp370_ = NULL;

18174

ValaList* _tmp371_;

18175

gint _tmp372_;

18176

gint _tmp373_;

18177

_tmp369_ = m;

18178

_tmp370_ = vala_method_get_parameters (_tmp369_);

18179

_tmp371_ = _tmp370_;

18180

_tmp372_ = vala_collection_get_size ((ValaCollection*) _tmp371_);

18181

_tmp373_ = _tmp372_;

18182

_tmp365_ = _tmp373_ != 0;

18183

_vala_iterable_unref0 (_tmp371_);

18175

18184

}

18176

_tmp371_ = _tmp362_;

18177

if (_tmp371_) {

18178

ValaProperty* _tmp372_;

18179

_tmp372_ = prop;

18180

vala_code_node_set_attribute ((ValaCodeNode*) _tmp372_, "NoAccessorMethod", TRUE, NULL);

18185

_tmp374_ = _tmp365_;

18186

if (_tmp374_) {

18187

ValaProperty* _tmp375_;

18188

_tmp375_ = prop;

18189

vala_code_node_set_attribute ((ValaCodeNode*) _tmp375_, "NoAccessorMethod", TRUE, NULL);

18181

18190

} else {

18182

ValaGirParserNode* _tmp373_;

18183

const gchar* _tmp374_;

18184

const gchar* _tmp375_;

18185

ValaProperty* _tmp390_;

18186

ValaPropertyAccessor* _tmp391_;

18187

ValaPropertyAccessor* _tmp392_;

18188

ValaDataType* _tmp393_;

18189

ValaDataType* _tmp394_;

18190

ValaMethod* _tmp395_;

18191

ValaGirParserNode* _tmp376_;

18192

const gchar* _tmp377_;

18193

const gchar* _tmp378_;

18194

ValaProperty* _tmp393_;

18195

ValaPropertyAccessor* _tmp394_;

18196

ValaPropertyAccessor* _tmp395_;

18191

18197

ValaDataType* _tmp396_;

18192

18198

ValaDataType* _tmp397_;

18193

gboolean _tmp398_;

18194

gboolean _tmp399_;

18195

_tmp373_ = getter;

18196

_tmp374_ = _tmp373_->name;

18197

_tmp375_ = self->name;

18198

if (g_strcmp0 (_tmp374_, _tmp375_) == 0) {

18199

ValaMethod* _tmp398_;

18200

ValaDataType* _tmp399_;

18201

ValaDataType* _tmp400_;

18202

gboolean _tmp401_;

18203

gboolean _tmp402_;

18204

_tmp376_ = getter;

18205

_tmp377_ = _tmp376_->name;

18206

_tmp378_ = self->name;

18207

if (g_strcmp0 (_tmp377_, _tmp378_) == 0) {

18199

18208

{

18200

ValaArrayList* _tmp376_;

18201

ValaArrayList* _tmp377_;

18209

ValaArrayList* _tmp379_;

18210

ValaArrayList* _tmp380_;

18202

18211

ValaArrayList* _node_list;

18203

ValaArrayList* _tmp378_;

18204

gint _tmp379_;

18205

gint _tmp380_;

18212

ValaArrayList* _tmp381_;

18213

gint _tmp382_;

18214

gint _tmp383_;

18206

18215

gint _node_size;

18207

18216

gint _node_index;

18208

_tmp376_ = colliding;

18209

_tmp377_ = _vala_iterable_ref0 (_tmp376_);

18210

_node_list = _tmp377_;

18211

_tmp378_ = _node_list;

18212

_tmp379_ = vala_collection_get_size ((ValaCollection*) _tmp378_);

18213

_tmp380_ = _tmp379_;

18214

_node_size = _tmp380_;

18217

_tmp379_ = colliding;

18218

_tmp380_ = _vala_iterable_ref0 (_tmp379_);

18219

_node_list = _tmp380_;

18220

_tmp381_ = _node_list;

18221

_tmp382_ = vala_collection_get_size ((ValaCollection*) _tmp381_);

18222

_tmp383_ = _tmp382_;

18223

_node_size = _tmp383_;

18215

18224

_node_index = -1;

18216

18225

while (TRUE) {

18217

gint _tmp381_;

18218

gint _tmp382_;

18219

gint _tmp383_;

18220

ValaArrayList* _tmp384_;

18226

gint _tmp384_;

18221

18227

gint _tmp385_;

18222

gpointer _tmp386_ = NULL;

18228

gint _tmp386_;

18229

ValaArrayList* _tmp387_;

18230

gint _tmp388_;

18231

gpointer _tmp389_ = NULL;

18223

18232

ValaGirParserNode* node;

18224

ValaGirParserNode* _tmp387_;

18225

ValaSymbol* _tmp388_;

18226

_tmp381_ = _node_index;

18227

_node_index = _tmp381_ + 1;

18228

_tmp382_ = _node_index;

18229

_tmp383_ = _node_size;

18230

if (!(_tmp382_ < _tmp383_)) {

18233

ValaGirParserNode* _tmp390_;

18234

ValaSymbol* _tmp391_;

18235

_tmp384_ = _node_index;

18236

_node_index = _tmp384_ + 1;

18237

_tmp385_ = _node_index;

18238

_tmp386_ = _node_size;

18239

if (!(_tmp385_ < _tmp386_)) {

18231

18240

break;

18232

18241

}

18233

_tmp384_ = _node_list;

18234

_tmp385_ = _node_index;

18235

_tmp386_ = vala_list_get ((ValaList*) _tmp384_, _tmp385_);

18236

node = (ValaGirParserNode*) _tmp386_;

18237

_tmp387_ = node;

18238

_tmp388_ = _tmp387_->symbol;

18239

if (VALA_IS_METHOD (_tmp388_)) {

18240

ValaGirParserNode* _tmp389_;

18241

_tmp389_ = node;

18242

_tmp389_->merged = TRUE;

18242

_tmp387_ = _node_list;

18243

_tmp388_ = _node_index;

18244

_tmp389_ = vala_list_get ((ValaList*) _tmp387_, _tmp388_);

18245

node = (ValaGirParserNode*) _tmp389_;

18246

_tmp390_ = node;

18247

_tmp391_ = _tmp390_->symbol;

18248

if (VALA_IS_METHOD (_tmp391_)) {

18249

ValaGirParserNode* _tmp392_;

18250

_tmp392_ = node;

18251

_tmp392_->merged = TRUE;

18243

18252

}

18244

18253

_vala_gir_parser_node_unref0 (node);

18245

18254

}

18246

18255

_vala_iterable_unref0 (_node_list);

18247

18256

}

18248

18257

}

18249

_tmp390_ = prop;

18250

_tmp391_ = vala_property_get_get_accessor (_tmp390_);

18251

_tmp392_ = _tmp391_;

18252

_tmp393_ = vala_property_accessor_get_value_type (_tmp392_);

18253

_tmp394_ = _tmp393_;

18254

_tmp395_ = m;

18255

_tmp396_ = vala_method_get_return_type (_tmp395_);

18258

_tmp393_ = prop;

18259

_tmp394_ = vala_property_get_get_accessor (_tmp393_);

18260

_tmp395_ = _tmp394_;

18261

_tmp396_ = vala_property_accessor_get_value_type (_tmp395_);

18256

18262

_tmp397_ = _tmp396_;

18257

_tmp398_ = vala_data_type_get_value_owned (_tmp397_);

18258

_tmp399_ = _tmp398_;

18259

vala_data_type_set_value_owned (_tmp394_, _tmp399_);

18263

_tmp398_ = m;

18264

_tmp399_ = vala_method_get_return_type (_tmp398_);

18265

_tmp400_ = _tmp399_;

18266

_tmp401_ = vala_data_type_get_value_owned (_tmp400_);

18267

_tmp402_ = _tmp401_;

18268

vala_data_type_set_value_owned (_tmp397_, _tmp402_);

18260

18269

}

18261

18270

} else {

18262

ValaProperty* _tmp400_;

18263

_tmp400_ = prop;

18264

vala_code_node_set_attribute ((ValaCodeNode*) _tmp400_, "NoAccessorMethod", TRUE, NULL);

18271

ValaProperty* _tmp403_;

18272

_tmp403_ = prop;

18273

vala_code_node_set_attribute ((ValaCodeNode*) _tmp403_, "NoAccessorMethod", TRUE, NULL);

18265

18274

}

18266

18275

_vala_code_node_unref0 (m);

18267

18276

}

18268

_tmp403_ = prop;

18269

_tmp404_ = vala_code_node_get_attribute ((ValaCodeNode*) _tmp403_, "NoAccessorMethod");

18270

_tmp405_ = _tmp404_;

18271

_tmp406_ = _tmp405_ == NULL;

18272

_vala_code_node_unref0 (_tmp405_);

18273

if (_tmp406_) {

18274

ValaProperty* _tmp407_;

18275

ValaPropertyAccessor* _tmp408_;

18276

ValaPropertyAccessor* _tmp409_;

18277

_tmp407_ = prop;

18278

_tmp408_ = vala_property_get_set_accessor (_tmp407_);

18279

_tmp409_ = _tmp408_;

18280

_tmp402_ = _tmp409_ != NULL;

18281

} else {

18282

_tmp402_ = FALSE;

18283

}

18284

_tmp410_ = _tmp402_;

18285

if (_tmp410_) {

18286

ValaProperty* _tmp411_;

18277

_tmp406_ = prop;

18278

_tmp407_ = vala_code_node_get_attribute ((ValaCodeNode*) _tmp406_, "NoAccessorMethod");

18279

_tmp408_ = _tmp407_;

18280

_tmp409_ = _tmp408_ == NULL;

18281

_vala_code_node_unref0 (_tmp408_);

18282

if (_tmp409_) {

18283

ValaProperty* _tmp410_;

18284

ValaPropertyAccessor* _tmp411_;

18287

18285

ValaPropertyAccessor* _tmp412_;

18288

ValaPropertyAccessor* _tmp413_;

18289

gboolean _tmp414_;

18290

gboolean _tmp415_;

18291

_tmp411_ = prop;

18292

_tmp412_ = vala_property_get_set_accessor (_tmp411_);

18293

_tmp413_ = _tmp412_;

18294

_tmp414_ = vala_property_accessor_get_writable (_tmp413_);

18295

_tmp415_ = _tmp414_;

18296

_tmp401_ = _tmp415_;

18297

} else {

18298

_tmp401_ = FALSE;

18299

}

18300

_tmp416_ = _tmp401_;

18301

if (_tmp416_) {

18302

ValaMethod* _tmp417_ = NULL;

18303

ValaGirParserNode* _tmp418_;

18304

ValaMethod* _tmp421_;

18305

ValaMethod* _tmp422_;

18306

ValaMethod* m;

18307

gboolean _tmp423_ = FALSE;

18286

_tmp410_ = prop;

18287

_tmp411_ = vala_property_get_set_accessor (_tmp410_);

18288

_tmp412_ = _tmp411_;

18289

_tmp405_ = _tmp412_ != NULL;

18290

} else {

18291

_tmp405_ = FALSE;

18292

}

18293

_tmp413_ = _tmp405_;

18294

if (_tmp413_) {

18295

ValaProperty* _tmp414_;

18296

ValaPropertyAccessor* _tmp415_;

18297

ValaPropertyAccessor* _tmp416_;

18298

gboolean _tmp417_;

18299

gboolean _tmp418_;

18300

_tmp414_ = prop;

18301

_tmp415_ = vala_property_get_set_accessor (_tmp414_);

18302

_tmp416_ = _tmp415_;

18303

_tmp417_ = vala_property_accessor_get_writable (_tmp416_);

18304

_tmp418_ = _tmp417_;

18305

_tmp404_ = _tmp418_;

18306

} else {

18307

_tmp404_ = FALSE;

18308

}

18309

_tmp419_ = _tmp404_;

18310

if (_tmp419_) {

18311

ValaMethod* _tmp420_ = NULL;

18312

ValaGirParserNode* _tmp421_;

18308

18313

ValaMethod* _tmp424_;

18309

gboolean _tmp438_;

18310

_tmp418_ = setter;

18311

if (_tmp418_ != NULL) {

18312

ValaGirParserNode* _tmp419_;

18313

ValaSymbol* _tmp420_;

18314

_tmp419_ = setter;

18315

_tmp420_ = _tmp419_->symbol;

18316

_tmp417_ = VALA_IS_METHOD (_tmp420_) ? ((ValaMethod*) _tmp420_) : NULL;

18314

ValaMethod* _tmp425_;

18315

ValaMethod* m;

18316

gboolean _tmp426_ = FALSE;

18317

ValaMethod* _tmp427_;

18318

gboolean _tmp441_;

18319

_tmp421_ = setter;

18320

if (_tmp421_ != NULL) {

18321

ValaGirParserNode* _tmp422_;

18322

ValaSymbol* _tmp423_;

18323

_tmp422_ = setter;

18324

_tmp423_ = _tmp422_->symbol;

18325

_tmp420_ = VALA_IS_METHOD (_tmp423_) ? ((ValaMethod*) _tmp423_) : NULL;

18317

18326

} else {

18318

_tmp417_ = NULL;

18327

_tmp420_ = NULL;

18319

18328

}

18320

_tmp421_ = _tmp417_;

18321

_tmp422_ = _vala_code_node_ref0 (_tmp421_);

18322

m = _tmp422_;

18323

_tmp424_ = m;

18324

if (_tmp424_ != NULL) {

18325

gboolean _tmp425_ = FALSE;

18326

gboolean _tmp426_ = FALSE;

18327

ValaMethod* _tmp427_;

18328

gboolean _tmp428_;

18329

gboolean _tmp429_;

18330

gboolean _tmp433_;

18331

gboolean _tmp437_;

18332

_tmp427_ = m;

18333

_tmp428_ = vala_method_get_is_abstract (_tmp427_);

18334

_tmp429_ = _tmp428_;

18335

if (_tmp429_) {

18336

_tmp426_ = TRUE;

18337

} else {

18338

ValaMethod* _tmp430_;

18339

gboolean _tmp431_;

18340

gboolean _tmp432_;

18341

_tmp430_ = m;

18342

_tmp431_ = vala_method_get_is_virtual (_tmp430_);

18343

_tmp432_ = _tmp431_;

18344

_tmp426_ = _tmp432_;

18345

}

18346

_tmp433_ = _tmp426_;

18347

if (_tmp433_) {

18348

_tmp425_ = TRUE;

18349

} else {

18350

ValaProperty* _tmp434_;

18329

_tmp424_ = _tmp420_;

18330

_tmp425_ = _vala_code_node_ref0 (_tmp424_);

18331

m = _tmp425_;

18332

_tmp427_ = m;

18333

if (_tmp427_ != NULL) {

18334

gboolean _tmp428_ = FALSE;

18335

gboolean _tmp429_ = FALSE;

18336

ValaMethod* _tmp430_;

18337

gboolean _tmp431_;

18338

gboolean _tmp432_;

18339

gboolean _tmp436_;

18340

gboolean _tmp440_;

18341

_tmp430_ = m;

18342

_tmp431_ = vala_method_get_is_abstract (_tmp430_);

18343

_tmp432_ = _tmp431_;

18344

if (_tmp432_) {

18345

_tmp429_ = TRUE;

18346

} else {

18347

ValaMethod* _tmp433_;

18348

gboolean _tmp434_;

18351

18349

gboolean _tmp435_;

18352

gboolean _tmp436_;

18353

_tmp434_ = prop;

18354

_tmp435_ = vala_property_get_is_abstract (_tmp434_);

18355

_tmp436_ = _tmp435_;

18356

_tmp425_ = !_tmp436_;

18357

}

18358

_tmp437_ = _tmp425_;

18359

_tmp423_ = _tmp437_;

18350

_tmp433_ = m;

18351

_tmp434_ = vala_method_get_is_virtual (_tmp433_);

18352

_tmp435_ = _tmp434_;

18353

_tmp429_ = _tmp435_;

18354

}

18355

_tmp436_ = _tmp429_;

18356

if (_tmp436_) {

18357

_tmp428_ = TRUE;

18358

} else {

18359

ValaProperty* _tmp437_;

18360

gboolean _tmp438_;

18361

gboolean _tmp439_;

18362

_tmp437_ = prop;

18363

_tmp438_ = vala_property_get_is_abstract (_tmp437_);

18364

_tmp439_ = _tmp438_;

18365

_tmp428_ = !_tmp439_;

18366

}

18367

_tmp440_ = _tmp428_;

18368

_tmp426_ = _tmp440_;

18360

18369

} else {

18361

_tmp423_ = FALSE;

18370

_tmp426_ = FALSE;

18362

18371

}

18363

_tmp438_ = _tmp423_;

18364

if (_tmp438_) {

18365

ValaGirParserNode* _tmp439_;

18366

ValaGirParser* _tmp440_;

18367

gboolean _tmp441_ = FALSE;

18368

ValaMethod* _tmp442_;

18369

ValaDataType* _tmp443_;

18370

ValaDataType* _tmp444_;

18371

gboolean _tmp450_;

18372

_tmp439_ = setter;

18373

_tmp440_ = parser;

18374

vala_gir_parser_node_process (_tmp439_, _tmp440_);

18375

_tmp442_ = m;

18376

_tmp443_ = vala_method_get_return_type (_tmp442_);

18377

_tmp444_ = _tmp443_;

18378

if (!VALA_IS_VOID_TYPE (_tmp444_)) {

18379

_tmp441_ = TRUE;

18372

_tmp441_ = _tmp426_;

18373

if (_tmp441_) {

18374

ValaGirParserNode* _tmp442_;

18375

ValaGirParser* _tmp443_;

18376

gboolean _tmp444_ = FALSE;

18377

ValaMethod* _tmp445_;

18378

ValaDataType* _tmp446_;

18379

ValaDataType* _tmp447_;

18380

gboolean _tmp453_;

18381

_tmp442_ = setter;

18382

_tmp443_ = parser;

18383

vala_gir_parser_node_process (_tmp442_, _tmp443_);

18384

_tmp445_ = m;

18385

_tmp446_ = vala_method_get_return_type (_tmp445_);

18386

_tmp447_ = _tmp446_;

18387

if (!VALA_IS_VOID_TYPE (_tmp447_)) {

18388

_tmp444_ = TRUE;

18380

18389

} else {

18381

ValaMethod* _tmp445_;

18382

ValaList* _tmp446_ = NULL;

18383

ValaList* _tmp447_;

18384

gint _tmp448_;

18385

gint _tmp449_;

18386

_tmp445_ = m;

18387

_tmp446_ = vala_method_get_parameters (_tmp445_);

18388

_tmp447_ = _tmp446_;

18389

_tmp448_ = vala_collection_get_size ((ValaCollection*) _tmp447_);

18390

_tmp449_ = _tmp448_;

18391

_tmp441_ = _tmp449_ != 1;

18392

_vala_iterable_unref0 (_tmp447_);

18390

ValaMethod* _tmp448_;

18391

ValaList* _tmp449_ = NULL;

18392

ValaList* _tmp450_;

18393

gint _tmp451_;

18394

gint _tmp452_;

18395

_tmp448_ = m;

18396

_tmp449_ = vala_method_get_parameters (_tmp448_);

18397

_tmp450_ = _tmp449_;

18398

_tmp451_ = vala_collection_get_size ((ValaCollection*) _tmp450_);

18399

_tmp452_ = _tmp451_;

18400

_tmp444_ = _tmp452_ != 1;

18401

_vala_iterable_unref0 (_tmp450_);

18393

18402

}

18394

_tmp450_ = _tmp441_;

18395

if (_tmp450_) {

18396

ValaProperty* _tmp451_;

18397

_tmp451_ = prop;

18398

vala_code_node_set_attribute ((ValaCodeNode*) _tmp451_, "NoAccessorMethod", TRUE, NULL);

18403

_tmp453_ = _tmp444_;

18404

if (_tmp453_) {

18405

ValaProperty* _tmp454_;

18406

_tmp454_ = prop;

18407

vala_code_node_set_attribute ((ValaCodeNode*) _tmp454_, "NoAccessorMethod", TRUE, NULL);

18399

18408

} else {

18400

ValaProperty* _tmp452_;

18401

ValaPropertyAccessor* _tmp453_;

18402

ValaPropertyAccessor* _tmp454_;

18403

ValaDataType* _tmp455_;

18404

ValaDataType* _tmp456_;

18405

ValaMethod* _tmp457_;

18406

ValaList* _tmp458_ = NULL;

18407

ValaList* _tmp459_;

18408

gpointer _tmp460_ = NULL;

18409

ValaParameter* _tmp461_;

18410

ValaDataType* _tmp462_;

18411

ValaDataType* _tmp463_;

18412

gboolean _tmp464_;

18413

gboolean _tmp465_;

18414

_tmp452_ = prop;

18415

_tmp453_ = vala_property_get_set_accessor (_tmp452_);

18416

_tmp454_ = _tmp453_;

18417

_tmp455_ = vala_property_accessor_get_value_type (_tmp454_);

18418

_tmp456_ = _tmp455_;

18419

_tmp457_ = m;

18420

_tmp458_ = vala_method_get_parameters (_tmp457_);

18409

ValaProperty* _tmp455_;

18410

ValaPropertyAccessor* _tmp456_;

18411

ValaPropertyAccessor* _tmp457_;

18412

ValaDataType* _tmp458_;

18413

ValaDataType* _tmp459_;

18414

ValaMethod* _tmp460_;

18415

ValaList* _tmp461_ = NULL;

18416

ValaList* _tmp462_;

18417

gpointer _tmp463_ = NULL;

18418

ValaParameter* _tmp464_;

18419

ValaDataType* _tmp465_;

18420

ValaDataType* _tmp466_;

18421

gboolean _tmp467_;

18422

gboolean _tmp468_;

18423

_tmp455_ = prop;

18424

_tmp456_ = vala_property_get_set_accessor (_tmp455_);

18425

_tmp457_ = _tmp456_;

18426

_tmp458_ = vala_property_accessor_get_value_type (_tmp457_);

18421

18427

_tmp459_ = _tmp458_;

18422

_tmp460_ = vala_list_get (_tmp459_, 0);

18423

_tmp461_ = (ValaParameter*) _tmp460_;

18424

_tmp462_ = vala_variable_get_variable_type ((ValaVariable*) _tmp461_);

18425

_tmp463_ = _tmp462_;

18426

_tmp464_ = vala_data_type_get_value_owned (_tmp463_);

18427

_tmp465_ = _tmp464_;

18428

vala_data_type_set_value_owned (_tmp456_, _tmp465_);

18429

_vala_code_node_unref0 (_tmp461_);

18430

_vala_iterable_unref0 (_tmp459_);

18428

_tmp460_ = m;

18429

_tmp461_ = vala_method_get_parameters (_tmp460_);

18430

_tmp462_ = _tmp461_;

18431

_tmp463_ = vala_list_get (_tmp462_, 0);

18432

_tmp464_ = (ValaParameter*) _tmp463_;

18433

_tmp465_ = vala_variable_get_variable_type ((ValaVariable*) _tmp464_);

18434

_tmp466_ = _tmp465_;

18435

_tmp467_ = vala_data_type_get_value_owned (_tmp466_);

18436

_tmp468_ = _tmp467_;

18437

vala_data_type_set_value_owned (_tmp459_, _tmp468_);

18438

_vala_code_node_unref0 (_tmp464_);

18439

_vala_iterable_unref0 (_tmp462_);

18431

18440

}

18432

18441

} else {

18433

ValaProperty* _tmp466_;

18434

_tmp466_ = prop;

18435

vala_code_node_set_attribute ((ValaCodeNode*) _tmp466_, "NoAccessorMethod", TRUE, NULL);

18442

ValaProperty* _tmp469_;

18443

_tmp469_ = prop;

18444

vala_code_node_set_attribute ((ValaCodeNode*) _tmp469_, "NoAccessorMethod", TRUE, NULL);

18436

18445

}

18437

18446

_vala_code_node_unref0 (m);

18438

18447

}

18439

_tmp467_ = prop;

18440

_tmp468_ = vala_code_node_get_attribute ((ValaCodeNode*) _tmp467_, "NoAccessorMethod");

18441

_tmp469_ = _tmp468_;

18442

_tmp470_ = _tmp469_ != NULL;

18443

_vala_code_node_unref0 (_tmp469_);

18444

if (_tmp470_) {

18445

ValaProperty* _tmp471_;

18446

ValaPropertyAccessor* _tmp472_;

18447

ValaPropertyAccessor* _tmp473_;

18448

ValaProperty* _tmp479_;

18449

ValaPropertyAccessor* _tmp480_;

18450

ValaPropertyAccessor* _tmp481_;

18451

_tmp471_ = prop;

18452

_tmp472_ = vala_property_get_get_accessor (_tmp471_);

18453

_tmp473_ = _tmp472_;

18454

if (_tmp473_ != NULL) {

18455

ValaProperty* _tmp474_;

18456

ValaPropertyAccessor* _tmp475_;

18457

ValaPropertyAccessor* _tmp476_;

18458

ValaDataType* _tmp477_;

18459

ValaDataType* _tmp478_;

18460

_tmp474_ = prop;

18461

_tmp475_ = vala_property_get_get_accessor (_tmp474_);

18462

_tmp476_ = _tmp475_;

18463

_tmp477_ = vala_property_accessor_get_value_type (_tmp476_);

18464

_tmp478_ = _tmp477_;

18465

vala_data_type_set_value_owned (_tmp478_, TRUE);

18448

_tmp470_ = prop;

18449

_tmp471_ = vala_code_node_get_attribute ((ValaCodeNode*) _tmp470_, "NoAccessorMethod");

18450

_tmp472_ = _tmp471_;

18451

_tmp473_ = _tmp472_ != NULL;

18452

_vala_code_node_unref0 (_tmp472_);

18453

if (_tmp473_) {

18454

ValaProperty* _tmp474_;

18455

ValaPropertyAccessor* _tmp475_;

18456

ValaPropertyAccessor* _tmp476_;

18457

ValaProperty* _tmp482_;

18458

ValaPropertyAccessor* _tmp483_;

18459

ValaPropertyAccessor* _tmp484_;

18460

_tmp474_ = prop;

18461

_tmp475_ = vala_property_get_get_accessor (_tmp474_);

18462

_tmp476_ = _tmp475_;

18463

if (_tmp476_ != NULL) {

18464

ValaProperty* _tmp477_;

18465

ValaPropertyAccessor* _tmp478_;

18466

ValaPropertyAccessor* _tmp479_;

18467

ValaDataType* _tmp480_;

18468

ValaDataType* _tmp481_;

18469

_tmp477_ = prop;

18470

_tmp478_ = vala_property_get_get_accessor (_tmp477_);

18471

_tmp479_ = _tmp478_;

18472

_tmp480_ = vala_property_accessor_get_value_type (_tmp479_);

18473

_tmp481_ = _tmp480_;

18474

vala_data_type_set_value_owned (_tmp481_, TRUE);

18466

18475

}

18467

_tmp479_ = prop;

18468

_tmp480_ = vala_property_get_set_accessor (_tmp479_);

18469

_tmp481_ = _tmp480_;

18470

if (_tmp481_ != NULL) {

18471

ValaProperty* _tmp482_;

18472

ValaPropertyAccessor* _tmp483_;

18473

ValaPropertyAccessor* _tmp484_;

18474

ValaDataType* _tmp485_;

18475

ValaDataType* _tmp486_;

18476

_tmp482_ = prop;

18477

_tmp483_ = vala_property_get_set_accessor (_tmp482_);

18478

_tmp484_ = _tmp483_;

18479

_tmp485_ = vala_property_accessor_get_value_type (_tmp484_);

18480

_tmp486_ = _tmp485_;

18481

vala_data_type_set_value_owned (_tmp486_, FALSE);

18476

_tmp482_ = prop;

18477

_tmp483_ = vala_property_get_set_accessor (_tmp482_);

18478

_tmp484_ = _tmp483_;

18479

if (_tmp484_ != NULL) {

18480

ValaProperty* _tmp485_;

18481

ValaPropertyAccessor* _tmp486_;

18482

ValaPropertyAccessor* _tmp487_;

18483

ValaDataType* _tmp488_;

18484

ValaDataType* _tmp489_;

18485

_tmp485_ = prop;

18486

_tmp486_ = vala_property_get_set_accessor (_tmp485_);

18487

_tmp487_ = _tmp486_;

18488

_tmp488_ = vala_property_accessor_get_value_type (_tmp487_);

18489

_tmp489_ = _tmp488_;

18490

vala_data_type_set_value_owned (_tmp489_, FALSE);

18482

18491

}

18483

18492

}

18484

18493

_vala_iterable_unref0 (setters);

18492

18501

_vala_code_node_unref0 (prop);

18493

18502

_vala_iterable_unref0 (colliding);

18494

18503

} else {

18495

ValaSymbol* _tmp487_;

18496

_tmp487_ = self->symbol;

18497

if (VALA_IS_FIELD (_tmp487_)) {

18498

ValaSymbol* _tmp488_;

18499

ValaField* _tmp489_;

18504

ValaSymbol* _tmp490_;

18505

_tmp490_ = self->symbol;

18506

if (VALA_IS_FIELD (_tmp490_)) {

18507

ValaSymbol* _tmp491_;

18508

ValaField* _tmp492_;

18500

18509

ValaField* field;

18501

ValaGirParserNode* _tmp490_;

18502

const gchar* _tmp491_;

18503

ValaArrayList* _tmp492_ = NULL;

18510

ValaGirParserNode* _tmp493_;

18511

const gchar* _tmp494_;

18512

ValaArrayList* _tmp495_ = NULL;

18504

18513

ValaArrayList* colliding;

18505

ValaArrayList* _tmp493_;

18506

gint _tmp494_;

18507

gint _tmp495_;

18508

gboolean _tmp496_ = FALSE;

18509

ValaField* _tmp497_;

18510

ValaDataType* _tmp498_;

18511

ValaDataType* _tmp499_;

18512

gboolean _tmp502_;

18513

_tmp488_ = self->symbol;

18514

_tmp489_ = _vala_code_node_ref0 (VALA_FIELD (_tmp488_));

18515

field = _tmp489_;

18516

_tmp490_ = self->parent;

18517

_tmp491_ = self->name;

18518

_tmp492_ = vala_gir_parser_node_lookup_all (_tmp490_, _tmp491_);

18519

colliding = _tmp492_;

18520

_tmp493_ = colliding;

18521

_tmp494_ = vala_collection_get_size ((ValaCollection*) _tmp493_);

18522

_tmp495_ = _tmp494_;

18523

if (_tmp495_ > 1) {

18514

ValaArrayList* _tmp496_;

18515

gint _tmp497_;

18516

gint _tmp498_;

18517

gboolean _tmp499_ = FALSE;

18518

ValaField* _tmp500_;

18519

ValaDataType* _tmp501_;

18520

ValaDataType* _tmp502_;

18521

gboolean _tmp505_;

18522

_tmp491_ = self->symbol;

18523

_tmp492_ = _vala_code_node_ref0 (VALA_FIELD (_tmp491_));

18524

field = _tmp492_;

18525

_tmp493_ = self->parent;

18526

_tmp494_ = self->name;

18527

_tmp495_ = vala_gir_parser_node_lookup_all (_tmp493_, _tmp494_);

18528

colliding = _tmp495_;

18529

_tmp496_ = colliding;

18530

_tmp497_ = vala_collection_get_size ((ValaCollection*) _tmp496_);

18531

_tmp498_ = _tmp497_;

18532

if (_tmp498_ > 1) {

18524

18533

self->merged = TRUE;

18525

18534

}

18526

_tmp497_ = field;

18527

_tmp498_ = vala_variable_get_variable_type ((ValaVariable*) _tmp497_);

18528

_tmp499_ = _tmp498_;

18529

if (VALA_IS_DELEGATE_TYPE (_tmp499_)) {

18530

ValaGirParserNode* _tmp500_;

18531

ValaUnresolvedSymbol* _tmp501_;

18532

_tmp500_ = self->parent;

18533

_tmp501_ = _tmp500_->gtype_struct_for;

18534

_tmp496_ = _tmp501_ != NULL;

18535

_tmp500_ = field;

18536

_tmp501_ = vala_variable_get_variable_type ((ValaVariable*) _tmp500_);

18537

_tmp502_ = _tmp501_;

18538

if (VALA_IS_DELEGATE_TYPE (_tmp502_)) {

18539

ValaGirParserNode* _tmp503_;

18540

ValaUnresolvedSymbol* _tmp504_;

18541

_tmp503_ = self->parent;

18542

_tmp504_ = _tmp503_->gtype_struct_for;

18543

_tmp499_ = _tmp504_ != NULL;

18535

18544

} else {

18536

_tmp496_ = FALSE;

18545

_tmp499_ = FALSE;

18537

18546

}

18538

_tmp502_ = _tmp496_;

18539

if (_tmp502_) {

18540

ValaField* _tmp503_;

18541

ValaDataType* _tmp504_;

18542

ValaDataType* _tmp505_;

18543

ValaDelegate* _tmp506_;

18544

ValaDelegate* _tmp507_;

18545

ValaDelegate* _tmp508_;

18547

_tmp505_ = _tmp499_;

18548

if (_tmp505_) {

18549

ValaField* _tmp506_;

18550

ValaDataType* _tmp507_;

18551

ValaDataType* _tmp508_;

18552

ValaDelegate* _tmp509_;

18553

ValaDelegate* _tmp510_;

18554

ValaDelegate* _tmp511_;

18546

18555

ValaDelegate* d;

18547

ValaGirParser* _tmp509_;

18548

ValaDelegate* _tmp510_;

18549

ValaGirParserNode* _tmp511_;

18550

ValaUnresolvedSymbol* _tmp512_;

18551

_tmp503_ = field;

18552

_tmp504_ = vala_variable_get_variable_type ((ValaVariable*) _tmp503_);

18553

_tmp505_ = _tmp504_;

18554

_tmp506_ = vala_delegate_type_get_delegate_symbol (VALA_DELEGATE_TYPE (_tmp505_));

18555

_tmp507_ = _tmp506_;

18556

_tmp508_ = _vala_code_node_ref0 (_tmp507_);

18557

d = _tmp508_;

18558

_tmp509_ = parser;

18559

_tmp510_ = d;

18560

_tmp511_ = self->parent;

18561

_tmp512_ = _tmp511_->gtype_struct_for;

18562

vala_gir_parser_process_virtual_method_field (_tmp509_, self, _tmp510_, _tmp512_);

18556

ValaGirParser* _tmp512_;

18557

ValaDelegate* _tmp513_;

18558

ValaGirParserNode* _tmp514_;

18559

ValaUnresolvedSymbol* _tmp515_;

18560

_tmp506_ = field;

18561

_tmp507_ = vala_variable_get_variable_type ((ValaVariable*) _tmp506_);

18562

_tmp508_ = _tmp507_;

18563

_tmp509_ = vala_delegate_type_get_delegate_symbol (VALA_DELEGATE_TYPE (_tmp508_));

18564

_tmp510_ = _tmp509_;

18565

_tmp511_ = _vala_code_node_ref0 (_tmp510_);

18566

d = _tmp511_;

18567

_tmp512_ = parser;

18568

_tmp513_ = d;

18569

_tmp514_ = self->parent;

18570

_tmp515_ = _tmp514_->gtype_struct_for;

18571

vala_gir_parser_process_virtual_method_field (_tmp512_, self, _tmp513_, _tmp515_);

18563

18572

self->merged = TRUE;

18564

18573

_vala_code_node_unref0 (d);

18565

18574

} else {

18566

ValaField* _tmp513_;

18567

ValaDataType* _tmp514_;

18568

ValaDataType* _tmp515_;

18569

_tmp513_ = field;

18570

_tmp514_ = vala_variable_get_variable_type ((ValaVariable*) _tmp513_);

18571

_tmp515_ = _tmp514_;

18572

if (VALA_IS_ARRAY_TYPE (_tmp515_)) {

18575

ValaField* _tmp516_;

18576

ValaDataType* _tmp517_;

18577

ValaDataType* _tmp518_;

18578

_tmp516_ = field;

18579

_tmp517_ = vala_variable_get_variable_type ((ValaVariable*) _tmp516_);

18580

_tmp518_ = _tmp517_;

18581

if (VALA_IS_ARRAY_TYPE (_tmp518_)) {

18573

18582

ValaGirParserNode* array_length = NULL;

18574

ValaGirParserMetadata* _tmp516_;

18575

gboolean _tmp517_ = FALSE;

18576

gboolean _tmp538_ = FALSE;

18577

ValaGirParserNode* _tmp539_;

18578

gboolean _tmp542_;

18579

_tmp516_ = self->metadata;

18580

_tmp517_ = vala_gir_parser_metadata_has_argument (_tmp516_, VALA_GIR_PARSER_ARGUMENT_TYPE_ARRAY_LENGTH_FIELD);

18581

if (_tmp517_) {

18582

ValaGirParserNode* _tmp518_;

18583

ValaGirParserMetadata* _tmp519_;

18584

gchar* _tmp520_ = NULL;

18585

gchar* _tmp521_;

18586

ValaGirParserNode* _tmp522_ = NULL;

18587

_tmp518_ = self->parent;

18588

_tmp519_ = self->metadata;

18589

_tmp520_ = vala_gir_parser_metadata_get_string (_tmp519_, VALA_GIR_PARSER_ARGUMENT_TYPE_ARRAY_LENGTH_FIELD);

18590

_tmp521_ = _tmp520_;

18591

_tmp522_ = vala_gir_parser_node_lookup (_tmp518_, _tmp521_, FALSE, NULL);

18583

ValaGirParserMetadata* _tmp519_;

18584

gboolean _tmp520_ = FALSE;

18585

gboolean _tmp541_ = FALSE;

18586

ValaGirParserNode* _tmp542_;

18587

gboolean _tmp545_;

18588

_tmp519_ = self->metadata;

18589

_tmp520_ = vala_gir_parser_metadata_has_argument (_tmp519_, VALA_GIR_PARSER_ARGUMENT_TYPE_ARRAY_LENGTH_FIELD);

18590

if (_tmp520_) {

18591

ValaGirParserNode* _tmp521_;

18592

ValaGirParserMetadata* _tmp522_;

18593

gchar* _tmp523_ = NULL;

18594

gchar* _tmp524_;

18595

ValaGirParserNode* _tmp525_ = NULL;

18596

_tmp521_ = self->parent;

18597

_tmp522_ = self->metadata;

18598

_tmp523_ = vala_gir_parser_metadata_get_string (_tmp522_, VALA_GIR_PARSER_ARGUMENT_TYPE_ARRAY_LENGTH_FIELD);

18599

_tmp524_ = _tmp523_;

18600

_tmp525_ = vala_gir_parser_node_lookup (_tmp521_, _tmp524_, FALSE, NULL);

18592

18601

_vala_gir_parser_node_unref0 (array_length);

18593

array_length = _tmp522_;

18594

_g_free0 (_tmp521_);

18602

array_length = _tmp525_;

18603

_g_free0 (_tmp524_);

18595

18604

} else {

18596

ValaGirParserNode* _tmp523_;

18597

ValaField* _tmp524_;

18598

const gchar* _tmp525_;

18599

const gchar* _tmp526_;

18600

gchar* _tmp527_ = NULL;

18601

gchar* _tmp528_;

18602

ValaGirParserNode* _tmp529_ = NULL;

18603

ValaGirParserNode* _tmp530_;

18604

_tmp523_ = self->parent;

18605

_tmp524_ = field;

18606

_tmp525_ = vala_symbol_get_name ((ValaSymbol*) _tmp524_);

18607

_tmp526_ = _tmp525_;

18608

_tmp527_ = g_strdup_printf ("n_%s", _tmp526_);

18609

_tmp528_ = _tmp527_;

18610

_tmp529_ = vala_gir_parser_node_lookup (_tmp523_, _tmp528_, FALSE, NULL);

18605

ValaGirParserNode* _tmp526_;

18606

ValaField* _tmp527_;

18607

const gchar* _tmp528_;

18608

const gchar* _tmp529_;

18609

gchar* _tmp530_ = NULL;

18610

gchar* _tmp531_;

18611

ValaGirParserNode* _tmp532_ = NULL;

18612

ValaGirParserNode* _tmp533_;

18613

_tmp526_ = self->parent;

18614

_tmp527_ = field;

18615

_tmp528_ = vala_symbol_get_name ((ValaSymbol*) _tmp527_);

18616

_tmp529_ = _tmp528_;

18617

_tmp530_ = g_strdup_printf ("n_%s", _tmp529_);

18618

_tmp531_ = _tmp530_;

18619

_tmp532_ = vala_gir_parser_node_lookup (_tmp526_, _tmp531_, FALSE, NULL);

18611

18620

_vala_gir_parser_node_unref0 (array_length);

18612

array_length = _tmp529_;

18613

_g_free0 (_tmp528_);

18614

_tmp530_ = array_length;

18615

if (_tmp530_ == NULL) {

18616

ValaGirParserNode* _tmp531_;

18617

ValaField* _tmp532_;

18618

const gchar* _tmp533_;

18619

const gchar* _tmp534_;

18620

gchar* _tmp535_ = NULL;

18621

gchar* _tmp536_;

18622

ValaGirParserNode* _tmp537_ = NULL;

18623

_tmp531_ = self->parent;

18624

_tmp532_ = field;

18625

_tmp533_ = vala_symbol_get_name ((ValaSymbol*) _tmp532_);

18626

_tmp534_ = _tmp533_;

18627

_tmp535_ = g_strdup_printf ("%s_length", _tmp534_);

18628

_tmp536_ = _tmp535_;

18629

_tmp537_ = vala_gir_parser_node_lookup (_tmp531_, _tmp536_, FALSE, NULL);

18621

array_length = _tmp532_;

18622

_g_free0 (_tmp531_);

18623

_tmp533_ = array_length;

18624

if (_tmp533_ == NULL) {

18625

ValaGirParserNode* _tmp534_;

18626

ValaField* _tmp535_;

18627

const gchar* _tmp536_;

18628

const gchar* _tmp537_;

18629

gchar* _tmp538_ = NULL;

18630

gchar* _tmp539_;

18631

ValaGirParserNode* _tmp540_ = NULL;

18632

_tmp534_ = self->parent;

18633

_tmp535_ = field;

18634

_tmp536_ = vala_symbol_get_name ((ValaSymbol*) _tmp535_);

18635

_tmp537_ = _tmp536_;

18636

_tmp538_ = g_strdup_printf ("%s_length", _tmp537_);

18637

_tmp539_ = _tmp538_;

18638

_tmp540_ = vala_gir_parser_node_lookup (_tmp534_, _tmp539_, FALSE, NULL);

18630

18639

_vala_gir_parser_node_unref0 (array_length);

18631

array_length = _tmp537_;

18632

_g_free0 (_tmp536_);

18640

array_length = _tmp540_;

18641

_g_free0 (_tmp539_);

18633

18642

}

18634

18643

}

18635

_tmp539_ = array_length;

18636

if (_tmp539_ != NULL) {

18637

ValaGirParserNode* _tmp540_;

18638

ValaSymbol* _tmp541_;

18639

_tmp540_ = array_length;

18640

_tmp541_ = _tmp540_->symbol;

18641

_tmp538_ = VALA_IS_FIELD (_tmp541_);

18642

} else {

18643

_tmp538_ = FALSE;

18644

}

18645

_tmp542_ = _tmp538_;

18646

if (_tmp542_) {

18644

_tmp542_ = array_length;

18645

if (_tmp542_ != NULL) {

18647

18646

ValaGirParserNode* _tmp543_;

18648

18647

ValaSymbol* _tmp544_;

18649

ValaField* _tmp545_;

18648

_tmp543_ = array_length;

18649

_tmp544_ = _tmp543_->symbol;

18650

_tmp541_ = VALA_IS_FIELD (_tmp544_);

18651

} else {

18652

_tmp541_ = FALSE;

18653

}

18654

_tmp545_ = _tmp541_;

18655

if (_tmp545_) {

18656

ValaGirParserNode* _tmp546_;

18657

ValaSymbol* _tmp547_;

18658

ValaField* _tmp548_;

18650

18659

ValaField* length_field;

18651

ValaField* _tmp546_;

18652

ValaField* _tmp547_;

18653

const gchar* _tmp548_;

18654

const gchar* _tmp549_;

18660

ValaField* _tmp549_;

18655

18661

ValaField* _tmp550_;

18656

ValaDataType* _tmp551_;

18657

ValaDataType* _tmp552_;

18658

gchar* _tmp553_ = NULL;

18662

const gchar* _tmp551_;

18663

const gchar* _tmp552_;

18664

ValaField* _tmp553_;

18665

ValaDataType* _tmp554_;

18666

ValaDataType* _tmp555_;

18667

gchar* _tmp556_ = NULL;

18659

18668

gchar* length_type;

18660

const gchar* _tmp554_;

18661

ValaField* _tmp564_;

18662

ValaField* _tmp565_;

18663

_tmp543_ = array_length;

18664

_tmp544_ = _tmp543_->symbol;

18665

_tmp545_ = _vala_code_node_ref0 (VALA_FIELD (_tmp544_));

18666

length_field = _tmp545_;

18667

_tmp546_ = field;

18668

_tmp547_ = length_field;

18669

_tmp548_ = vala_symbol_get_name ((ValaSymbol*) _tmp547_);

18670

_tmp549_ = _tmp548_;

18671

vala_code_node_set_attribute_string ((ValaCodeNode*) _tmp546_, "CCode", "array_length_cname", _tmp549_, NULL);

18669

const gchar* _tmp557_;

18670

ValaField* _tmp567_;

18671

ValaField* _tmp568_;

18672

_tmp546_ = array_length;

18673

_tmp547_ = _tmp546_->symbol;

18674

_tmp548_ = _vala_code_node_ref0 (VALA_FIELD (_tmp547_));

18675

length_field = _tmp548_;

18676

_tmp549_ = field;

18672

18677

_tmp550_ = length_field;

18673

_tmp551_ = vala_variable_get_variable_type ((ValaVariable*) _tmp550_);

18678

_tmp551_ = vala_symbol_get_name ((ValaSymbol*) _tmp550_);

18674

18679

_tmp552_ = _tmp551_;

18675

_tmp553_ = vala_data_type_to_qualified_string (_tmp552_, NULL);

18676

length_type = _tmp553_;

18677

_tmp554_ = length_type;

18678

if (g_strcmp0 (_tmp554_, "int") != 0) {

18679

ValaGirParser* _tmp555_;

18680

ValaGirParserNode* _tmp556_;

18681

const gchar* _tmp557_;

18682

ValaGirParserNode* _tmp558_ = NULL;

18680

vala_code_node_set_attribute_string ((ValaCodeNode*) _tmp549_, "CCode", "array_length_cname", _tmp552_, NULL);

18681

_tmp553_ = length_field;

18682

_tmp554_ = vala_variable_get_variable_type ((ValaVariable*) _tmp553_);

18683

_tmp555_ = _tmp554_;

18684

_tmp556_ = vala_data_type_to_qualified_string (_tmp555_, NULL);

18685

length_type = _tmp556_;

18686

_tmp557_ = length_type;

18687

if (g_strcmp0 (_tmp557_, "int") != 0) {

18688

ValaGirParser* _tmp558_;

18689

ValaGirParserNode* _tmp559_;

18690

const gchar* _tmp560_;

18691

ValaGirParserNode* _tmp561_ = NULL;

18683

18692

ValaGirParserNode* st;

18684

ValaGirParserNode* _tmp559_;

18685

_tmp555_ = parser;

18686

_tmp556_ = _tmp555_->priv->root;

18687

_tmp557_ = length_type;

18688

_tmp558_ = vala_gir_parser_node_lookup (_tmp556_, _tmp557_, FALSE, NULL);

18689

st = _tmp558_;

18690

_tmp559_ = st;

18691

if (_tmp559_ != NULL) {

18692

ValaField* _tmp560_;

18693

ValaGirParserNode* _tmp561_;

18694

gchar* _tmp562_ = NULL;

18695

gchar* _tmp563_;

18696

_tmp560_ = field;

18697

_tmp561_ = st;

18698

_tmp562_ = vala_gir_parser_node_get_cname (_tmp561_);

18699

_tmp563_ = _tmp562_;

18700

vala_code_node_set_attribute_string ((ValaCodeNode*) _tmp560_, "CCode", "array_length_type", _tmp563_, NULL);

18701

_g_free0 (_tmp563_);

18693

ValaGirParserNode* _tmp562_;

18694

_tmp558_ = parser;

18695

_tmp559_ = _tmp558_->priv->root;

18696

_tmp560_ = length_type;

18697

_tmp561_ = vala_gir_parser_node_lookup (_tmp559_, _tmp560_, FALSE, NULL);

18698

st = _tmp561_;

18699

_tmp562_ = st;

18700

if (_tmp562_ != NULL) {

18701

ValaField* _tmp563_;

18702

ValaGirParserNode* _tmp564_;

18703

gchar* _tmp565_ = NULL;

18704

gchar* _tmp566_;

18705

_tmp563_ = field;

18706

_tmp564_ = st;

18707

_tmp565_ = vala_gir_parser_node_get_cname (_tmp564_);

18708

_tmp566_ = _tmp565_;

18709

vala_code_node_set_attribute_string ((ValaCodeNode*) _tmp563_, "CCode", "array_length_type", _tmp566_, NULL);

18710

_g_free0 (_tmp566_);

18702

18711

}

18703

18712

_vala_gir_parser_node_unref0 (st);

18704

18713

}

18705

_tmp564_ = field;

18706

vala_code_node_remove_attribute_argument ((ValaCodeNode*) _tmp564_, "CCode", "array_length");

18707

_tmp565_ = field;

18708

vala_code_node_remove_attribute_argument ((ValaCodeNode*) _tmp565_, "CCode", "array_null_terminated");

18714

_tmp567_ = field;

18715

vala_code_node_remove_attribute_argument ((ValaCodeNode*) _tmp567_, "CCode", "array_length");

18716

_tmp568_ = field;

18717

vala_code_node_remove_attribute_argument ((ValaCodeNode*) _tmp568_, "CCode", "array_null_terminated");

18709

18718

_g_free0 (length_type);

18710

18719

_vala_code_node_unref0 (length_field);

18711

18720

}

18715

18724

_vala_iterable_unref0 (colliding);

18716

18725

_vala_code_node_unref0 (field);

18717

18726

} else {

18718

gboolean _tmp566_ = FALSE;

18719

ValaSymbol* _tmp567_;

18720

gboolean _tmp569_;

18721

_tmp567_ = self->symbol;

18722

if (VALA_IS_SIGNAL (_tmp567_)) {

18723

_tmp566_ = TRUE;

18724

} else {

18725

ValaSymbol* _tmp568_;

18726

_tmp568_ = self->symbol;

18727

_tmp566_ = VALA_IS_DELEGATE (_tmp568_);

18728

}

18729

_tmp569_ = _tmp566_;

18730

if (_tmp569_) {

18731

ValaGirParser* _tmp570_;

18732

_tmp570_ = parser;

18733

vala_gir_parser_process_callable (_tmp570_, self);

18727

gboolean _tmp569_ = FALSE;

18728

ValaSymbol* _tmp570_;

18729

gboolean _tmp572_;

18730

_tmp570_ = self->symbol;

18731

if (VALA_IS_SIGNAL (_tmp570_)) {

18732

_tmp569_ = TRUE;

18734

18733

} else {

18735

18734

ValaSymbol* _tmp571_;

18736

18735

_tmp571_ = self->symbol;

18737

if (VALA_IS_INTERFACE (_tmp571_)) {

18738

ValaGirParser* _tmp572_;

18739

_tmp572_ = parser;

18740

vala_gir_parser_process_interface (_tmp572_, self);

18736

_tmp569_ = VALA_IS_DELEGATE (_tmp571_);

18737

}

18738

_tmp572_ = _tmp569_;

18739

if (_tmp572_) {

18740

ValaGirParser* _tmp573_;

18741

_tmp573_ = parser;

18742

vala_gir_parser_process_callable (_tmp573_, self);

18743

} else {

18744

ValaSymbol* _tmp574_;

18745

_tmp574_ = self->symbol;

18746

if (VALA_IS_INTERFACE (_tmp574_)) {

18747

ValaGirParser* _tmp575_;

18748

_tmp575_ = parser;

18749

vala_gir_parser_process_interface (_tmp575_, self);

18741

18750

} else {

18742

ValaSymbol* _tmp573_;

18743

_tmp573_ = self->symbol;

18744

if (VALA_IS_STRUCT (_tmp573_)) {

18745

gboolean _tmp574_ = FALSE;

18746

ValaGirParserNode* _tmp575_;

18747

ValaSymbol* _tmp576_;

18748

gboolean _tmp579_;

18749

_tmp575_ = self->parent;

18750

_tmp576_ = _tmp575_->symbol;

18751

if (VALA_IS_OBJECT_TYPE_SYMBOL (_tmp576_)) {

18752

_tmp574_ = TRUE;

18751

ValaSymbol* _tmp576_;

18752

_tmp576_ = self->symbol;

18753

if (VALA_IS_STRUCT (_tmp576_)) {

18754

gboolean _tmp577_ = FALSE;

18755

ValaGirParserNode* _tmp578_;

18756

ValaSymbol* _tmp579_;

18757

gboolean _tmp582_;

18758

_tmp578_ = self->parent;

18759

_tmp579_ = _tmp578_->symbol;

18760

if (VALA_IS_OBJECT_TYPE_SYMBOL (_tmp579_)) {

18761

_tmp577_ = TRUE;

18753

18762

} else {

18754

ValaGirParserNode* _tmp577_;

18755

ValaSymbol* _tmp578_;

18756

_tmp577_ = self->parent;

18757

_tmp578_ = _tmp577_->symbol;

18758

_tmp574_ = VALA_IS_STRUCT (_tmp578_);

18763

ValaGirParserNode* _tmp580_;

18764

ValaSymbol* _tmp581_;

18765

_tmp580_ = self->parent;

18766

_tmp581_ = _tmp580_->symbol;

18767

_tmp577_ = VALA_IS_STRUCT (_tmp581_);

18759

18768

}

18760

_tmp579_ = _tmp574_;

18761

if (_tmp579_) {

18769

_tmp582_ = _tmp577_;

18770

if (_tmp582_) {

18762

18771

{

18763

ValaArrayList* _tmp580_;

18764

ValaArrayList* _tmp581_;

18772

ValaArrayList* _tmp583_;

18773

ValaArrayList* _tmp584_;

18765

18774

ValaArrayList* _fn_list;

18766

ValaArrayList* _tmp582_;

18767

gint _tmp583_;

18768

gint _tmp584_;

18775

ValaArrayList* _tmp585_;

18776

gint _tmp586_;

18777

gint _tmp587_;

18769

18778

gint _fn_size;

18770

18779

gint _fn_index;

18771

_tmp580_ = self->members;

18772

_tmp581_ = _vala_iterable_ref0 (_tmp580_);

18773

_fn_list = _tmp581_;

18774

_tmp582_ = _fn_list;

18775

_tmp583_ = vala_collection_get_size ((ValaCollection*) _tmp582_);

18776

_tmp584_ = _tmp583_;

18777

_fn_size = _tmp584_;

18780

_tmp583_ = self->members;

18781

_tmp584_ = _vala_iterable_ref0 (_tmp583_);

18782

_fn_list = _tmp584_;

18783

_tmp585_ = _fn_list;

18784

_tmp586_ = vala_collection_get_size ((ValaCollection*) _tmp585_);

18785

_tmp587_ = _tmp586_;

18786

_fn_size = _tmp587_;

18778

18787

_fn_index = -1;

18779

18788

while (TRUE) {

18780

gint _tmp585_;

18781

gint _tmp586_;

18782

gint _tmp587_;

18783

ValaArrayList* _tmp588_;

18789

gint _tmp588_;

18784

18790

gint _tmp589_;

18785

gpointer _tmp590_ = NULL;

18791

gint _tmp590_;

18792

ValaArrayList* _tmp591_;

18793

gint _tmp592_;

18794

gpointer _tmp593_ = NULL;

18786

18795

ValaGirParserNode* fn;

18787

ValaGirParserNode* _tmp591_;

18788

ValaSymbol* _tmp592_;

18789

ValaField* _tmp593_;

18796

ValaGirParserNode* _tmp594_;

18797

ValaSymbol* _tmp595_;

18798

ValaField* _tmp596_;

18790

18799

ValaField* f;

18791

ValaField* _tmp594_;

18792

_tmp585_ = _fn_index;

18793

_fn_index = _tmp585_ + 1;

18794

_tmp586_ = _fn_index;

18795

_tmp587_ = _fn_size;

18796

if (!(_tmp586_ < _tmp587_)) {

18800

ValaField* _tmp597_;

18801

_tmp588_ = _fn_index;

18802

_fn_index = _tmp588_ + 1;

18803

_tmp589_ = _fn_index;

18804

_tmp590_ = _fn_size;

18805

if (!(_tmp589_ < _tmp590_)) {

18797

18806

break;

18798

18807

}

18799

_tmp588_ = _fn_list;

18800

_tmp589_ = _fn_index;

18801

_tmp590_ = vala_list_get ((ValaList*) _tmp588_, _tmp589_);

18802

fn = (ValaGirParserNode*) _tmp590_;

18803

_tmp591_ = fn;

18804

_tmp592_ = _tmp591_->symbol;

18805

_tmp593_ = _vala_code_node_ref0 (VALA_IS_FIELD (_tmp592_) ? ((ValaField*) _tmp592_) : NULL);

18806

f = _tmp593_;

18807

_tmp594_ = f;

18808

if (_tmp594_ != NULL) {

18809

ValaField* _tmp595_;

18810

ValaMemberBinding _tmp596_;

18811

ValaMemberBinding _tmp597_;

18812

ValaField* _tmp607_;

18813

ValaSymbol* _tmp608_;

18814

const gchar* _tmp609_;

18815

const gchar* _tmp610_;

18816

gchar* _tmp611_;

18817

gchar* _tmp612_;

18818

ValaField* _tmp613_;

18819

const gchar* _tmp614_;

18820

const gchar* _tmp615_;

18821

gchar* _tmp616_;

18822

gchar* _tmp617_;

18823

ValaGirParserNode* _tmp618_;

18824

ValaField* _tmp619_;

18825

const gchar* _tmp620_;

18826

const gchar* _tmp621_;

18827

gchar* _tmp622_;

18828

ValaGirParserNode* _tmp623_;

18829

ValaGirParserNode* _tmp624_;

18830

_tmp595_ = f;

18831

_tmp596_ = vala_field_get_binding (_tmp595_);

18832

_tmp597_ = _tmp596_;

18833

if (_tmp597_ == VALA_MEMBER_BINDING_INSTANCE) {

18834

ValaField* _tmp598_;

18835

const gchar* _tmp599_;

18836

gchar* _tmp600_;

18837

gchar* _tmp601_;

18838

ValaGirParserNode* _tmp602_;

18839

gchar* _tmp603_ = NULL;

18808

_tmp591_ = _fn_list;

18809

_tmp592_ = _fn_index;

18810

_tmp593_ = vala_list_get ((ValaList*) _tmp591_, _tmp592_);

18811

fn = (ValaGirParserNode*) _tmp593_;

18812

_tmp594_ = fn;

18813

_tmp595_ = _tmp594_->symbol;

18814

_tmp596_ = _vala_code_node_ref0 (VALA_IS_FIELD (_tmp595_) ? ((ValaField*) _tmp595_) : NULL);

18815

f = _tmp596_;

18816

_tmp597_ = f;

18817

if (_tmp597_ != NULL) {

18818

ValaField* _tmp598_;

18819

ValaMemberBinding _tmp599_;

18820

ValaMemberBinding _tmp600_;

18821

ValaField* _tmp610_;

18822

ValaSymbol* _tmp611_;

18823

const gchar* _tmp612_;

18824

const gchar* _tmp613_;

18825

gchar* _tmp614_;

18826

gchar* _tmp615_;

18827

ValaField* _tmp616_;

18828

const gchar* _tmp617_;

18829

const gchar* _tmp618_;

18830

gchar* _tmp619_;

18831

gchar* _tmp620_;

18832

ValaGirParserNode* _tmp621_;

18833

ValaField* _tmp622_;

18834

const gchar* _tmp623_;

18835

const gchar* _tmp624_;

18836

gchar* _tmp625_;

18837

ValaGirParserNode* _tmp626_;

18838

ValaGirParserNode* _tmp627_;

18839

_tmp598_ = f;

18840

_tmp599_ = vala_field_get_binding (_tmp598_);

18841

_tmp600_ = _tmp599_;

18842

if (_tmp600_ == VALA_MEMBER_BINDING_INSTANCE) {

18843

ValaField* _tmp601_;

18844

const gchar* _tmp602_;

18845

gchar* _tmp603_;

18840

18846

gchar* _tmp604_;

18841

gchar* _tmp605_;

18842

gchar* _tmp606_;

18843

_tmp598_ = f;

18844

_tmp599_ = self->name;

18845

_tmp600_ = g_strconcat (_tmp599_, ".", NULL);

18846

_tmp601_ = _tmp600_;

18847

_tmp602_ = fn;

18848

_tmp603_ = vala_gir_parser_node_get_cname (_tmp602_);

18847

ValaGirParserNode* _tmp605_;

18848

gchar* _tmp606_ = NULL;

18849

gchar* _tmp607_;

18850

gchar* _tmp608_;

18851

gchar* _tmp609_;

18852

_tmp601_ = f;

18853

_tmp602_ = self->name;

18854

_tmp603_ = g_strconcat (_tmp602_, ".", NULL);

18849

18855

_tmp604_ = _tmp603_;

18850

_tmp605_ = g_strconcat (_tmp601_, _tmp604_, NULL);

18851

_tmp606_ = _tmp605_;

18852

vala_code_node_set_attribute_string ((ValaCodeNode*) _tmp598_, "CCode", "cname", _tmp606_, NULL);

18853

_g_free0 (_tmp606_);

18856

_tmp605_ = fn;

18857

_tmp606_ = vala_gir_parser_node_get_cname (_tmp605_);

18858

_tmp607_ = _tmp606_;

18859

_tmp608_ = g_strconcat (_tmp604_, _tmp607_, NULL);

18860

_tmp609_ = _tmp608_;

18861

vala_code_node_set_attribute_string ((ValaCodeNode*) _tmp601_, "CCode", "cname", _tmp609_, NULL);

18862

_g_free0 (_tmp609_);

18863

_g_free0 (_tmp607_);

18854

18864

_g_free0 (_tmp604_);

18855

_g_free0 (_tmp601_);

18856

18865

}

18857

_tmp607_ = f;

18858

_tmp608_ = self->symbol;

18859

_tmp609_ = vala_symbol_get_name (_tmp608_);

18860

_tmp610_ = _tmp609_;

18861

_tmp611_ = g_strconcat (_tmp610_, "_", NULL);

18862

_tmp612_ = _tmp611_;

18863

_tmp613_ = f;

18864

_tmp614_ = vala_symbol_get_name ((ValaSymbol*) _tmp613_);

18866

_tmp610_ = f;

18867

_tmp611_ = self->symbol;

18868

_tmp612_ = vala_symbol_get_name (_tmp611_);

18869

_tmp613_ = _tmp612_;

18870

_tmp614_ = g_strconcat (_tmp613_, "_", NULL);

18865

18871

_tmp615_ = _tmp614_;

18866

_tmp616_ = g_strconcat (_tmp612_, _tmp615_, NULL);

18867

_tmp617_ = _tmp616_;

18868

vala_symbol_set_name ((ValaSymbol*) _tmp607_, _tmp617_);

18869

_g_free0 (_tmp617_);

18870

_g_free0 (_tmp612_);

18871

_tmp618_ = fn;

18872

_tmp619_ = f;

18873

_tmp620_ = vala_symbol_get_name ((ValaSymbol*) _tmp619_);

18874

_tmp621_ = _tmp620_;

18875

_tmp622_ = g_strdup (_tmp621_);

18876

_g_free0 (_tmp618_->name);

18877

_tmp618_->name = _tmp622_;

18878

_tmp623_ = self->parent;

18879

_tmp624_ = fn;

18880

vala_gir_parser_node_add_member (_tmp623_, _tmp624_);

18872

_tmp616_ = f;

18873

_tmp617_ = vala_symbol_get_name ((ValaSymbol*) _tmp616_);

18874

_tmp618_ = _tmp617_;

18875

_tmp619_ = g_strconcat (_tmp615_, _tmp618_, NULL);

18876

_tmp620_ = _tmp619_;

18877

vala_symbol_set_name ((ValaSymbol*) _tmp610_, _tmp620_);

18878

_g_free0 (_tmp620_);

18879

_g_free0 (_tmp615_);

18880

_tmp621_ = fn;

18881

_tmp622_ = f;

18882

_tmp623_ = vala_symbol_get_name ((ValaSymbol*) _tmp622_);

18883

_tmp624_ = _tmp623_;

18884

_tmp625_ = g_strdup (_tmp624_);

18885

_g_free0 (_tmp621_->name);

18886

_tmp621_->name = _tmp625_;

18887

_tmp626_ = self->parent;

18888

_tmp627_ = fn;

18889

vala_gir_parser_node_add_member (_tmp626_, _tmp627_);

18881

18890

}

18882

18891

_vala_code_node_unref0 (f);

18883

18892

_vala_gir_parser_node_unref0 (fn);

18886

18895

}

18887

18896

self->merged = TRUE;

18888

18897

} else {

18889

ValaMap* _tmp625_;

18890

gpointer _tmp626_ = NULL;

18898

ValaMap* _tmp628_;

18899

gpointer _tmp629_ = NULL;

18891

18900

gchar* gtype_struct_for;

18892

const gchar* _tmp627_;

18893

_tmp625_ = self->girdata;

18894

_tmp626_ = vala_map_get (_tmp625_, "glib:is-gtype-struct-for");

18895

gtype_struct_for = (gchar*) _tmp626_;

18896

_tmp627_ = gtype_struct_for;

18897

if (_tmp627_ != NULL) {

18898

ValaGirParser* _tmp628_;

18899

ValaGirParserNode* _tmp629_;

18900

ValaGirParser* _tmp630_;

18901

const gchar* _tmp631_;

18902

ValaSourceReference* _tmp632_;

18903

ValaUnresolvedSymbol* _tmp633_ = NULL;

18904

ValaUnresolvedSymbol* _tmp634_;

18905

ValaGirParserNode* _tmp635_ = NULL;

18906

ValaGirParserNode* _tmp636_;

18901

const gchar* _tmp630_;

18902

_tmp628_ = self->girdata;

18903

_tmp629_ = vala_map_get (_tmp628_, "glib:is-gtype-struct-for");

18904

gtype_struct_for = (gchar*) _tmp629_;

18905

_tmp630_ = gtype_struct_for;

18906

if (_tmp630_ != NULL) {

18907

ValaGirParser* _tmp631_;

18908

ValaGirParserNode* _tmp632_;

18909

ValaGirParser* _tmp633_;

18910

const gchar* _tmp634_;

18911

ValaSourceReference* _tmp635_;

18912

ValaUnresolvedSymbol* _tmp636_ = NULL;

18913

ValaUnresolvedSymbol* _tmp637_;

18914

ValaGirParserNode* _tmp638_ = NULL;

18915

ValaGirParserNode* _tmp639_;

18907

18916

ValaGirParserNode* iface;

18908

gboolean _tmp637_ = FALSE;

18909

gboolean _tmp638_ = FALSE;

18910

ValaGirParserNode* _tmp639_;

18911

gboolean _tmp642_;

18912

gboolean _tmp650_;

18913

_tmp628_ = parser;

18914

_tmp629_ = self->parent;

18915

_tmp630_ = parser;

18916

_tmp631_ = gtype_struct_for;

18917

_tmp632_ = self->source_reference;

18918

_tmp633_ = vala_gir_parser_parse_symbol_from_string (_tmp630_, _tmp631_, _tmp632_);

18919

_tmp634_ = _tmp633_;

18920

_tmp635_ = vala_gir_parser_resolve_node (_tmp628_, _tmp629_, _tmp634_, FALSE);

18921

_tmp636_ = _tmp635_;

18922

_vala_code_node_unref0 (_tmp634_);

18923

iface = _tmp636_;

18924

_tmp639_ = iface;

18925

if (_tmp639_ != NULL) {

18926

ValaGirParserNode* _tmp640_;

18927

ValaSymbol* _tmp641_;

18928

_tmp640_ = iface;

18929

_tmp641_ = _tmp640_->symbol;

18930

_tmp638_ = VALA_IS_INTERFACE (_tmp641_);

18931

} else {

18932

_tmp638_ = FALSE;

18933

}

18934

_tmp642_ = _tmp638_;

18935

if (_tmp642_) {

18917

gboolean _tmp640_ = FALSE;

18918

gboolean _tmp641_ = FALSE;

18919

ValaGirParserNode* _tmp642_;

18920

gboolean _tmp645_;

18921

gboolean _tmp653_;

18922

_tmp631_ = parser;

18923

_tmp632_ = self->parent;

18924

_tmp633_ = parser;

18925

_tmp634_ = gtype_struct_for;

18926

_tmp635_ = self->source_reference;

18927

_tmp636_ = vala_gir_parser_parse_symbol_from_string (_tmp633_, _tmp634_, _tmp635_);

18928

_tmp637_ = _tmp636_;

18929

_tmp638_ = vala_gir_parser_resolve_node (_tmp631_, _tmp632_, _tmp637_, FALSE);

18930

_tmp639_ = _tmp638_;

18931

_vala_code_node_unref0 (_tmp637_);

18932

iface = _tmp639_;

18933

_tmp642_ = iface;

18934

if (_tmp642_ != NULL) {

18936

18935

ValaGirParserNode* _tmp643_;

18937

gchar* _tmp644_ = NULL;

18938

gchar* _tmp645_;

18939

gchar* _tmp646_ = NULL;

18940

gchar* _tmp647_;

18941

gchar* _tmp648_ = NULL;

18942

gchar* _tmp649_;

18936

ValaSymbol* _tmp644_;

18943

18937

_tmp643_ = iface;

18944

_tmp644_ = vala_gir_parser_node_get_cname (_tmp643_);

18945

_tmp645_ = _tmp644_;

18946

_tmp646_ = g_strdup_printf ("%sIface", _tmp645_);

18947

_tmp647_ = _tmp646_;

18948

_tmp648_ = vala_gir_parser_node_get_cname (self);

18949

_tmp649_ = _tmp648_;

18950

_tmp637_ = g_strcmp0 (_tmp647_, _tmp649_) != 0;

18951

_g_free0 (_tmp649_);

18952

_g_free0 (_tmp647_);

18953

_g_free0 (_tmp645_);

18954

} else {

18955

_tmp637_ = FALSE;

18956

}

18957

_tmp650_ = _tmp637_;

18958

if (_tmp650_) {

18959

ValaGirParserNode* _tmp651_;

18960

ValaSymbol* _tmp652_;

18961

gchar* _tmp653_ = NULL;

18962

gchar* _tmp654_;

18963

_tmp651_ = iface;

18964

_tmp652_ = _tmp651_->symbol;

18965

_tmp653_ = vala_gir_parser_node_get_cname (self);

18966

_tmp654_ = _tmp653_;

18967

vala_code_node_set_attribute_string ((ValaCodeNode*) _tmp652_, "CCode", "type_cname", _tmp654_, NULL);

18968

_g_free0 (_tmp654_);

18938

_tmp644_ = _tmp643_->symbol;

18939

_tmp641_ = VALA_IS_INTERFACE (_tmp644_);

18940

} else {

18941

_tmp641_ = FALSE;

18942

}

18943

_tmp645_ = _tmp641_;

18944

if (_tmp645_) {

18945

ValaGirParserNode* _tmp646_;

18946

gchar* _tmp647_ = NULL;

18947

gchar* _tmp648_;

18948

gchar* _tmp649_ = NULL;

18949

gchar* _tmp650_;

18950

gchar* _tmp651_ = NULL;

18951

gchar* _tmp652_;

18952

_tmp646_ = iface;

18953

_tmp647_ = vala_gir_parser_node_get_cname (_tmp646_);

18954

_tmp648_ = _tmp647_;

18955

_tmp649_ = g_strdup_printf ("%sIface", _tmp648_);

18956

_tmp650_ = _tmp649_;

18957

_tmp651_ = vala_gir_parser_node_get_cname (self);

18958

_tmp652_ = _tmp651_;

18959

_tmp640_ = g_strcmp0 (_tmp650_, _tmp652_) != 0;

18960

_g_free0 (_tmp652_);

18961

_g_free0 (_tmp650_);

18962

_g_free0 (_tmp648_);

18963

} else {

18964

_tmp640_ = FALSE;

18965

}

18966

_tmp653_ = _tmp640_;

18967

if (_tmp653_) {

18968

ValaGirParserNode* _tmp654_;

18969

ValaSymbol* _tmp655_;

18970

gchar* _tmp656_ = NULL;

18971

gchar* _tmp657_;

18972

_tmp654_ = iface;

18973

_tmp655_ = _tmp654_->symbol;

18974

_tmp656_ = vala_gir_parser_node_get_cname (self);

18975

_tmp657_ = _tmp656_;

18976

vala_code_node_set_attribute_string ((ValaCodeNode*) _tmp655_, "CCode", "type_cname", _tmp657_, NULL);

18977

_g_free0 (_tmp657_);

18969

18978

}

18970

18979

self->merged = TRUE;

18971

18980

_vala_gir_parser_node_unref0 (iface);

18978

18987

}

18979

18988

}

18980

18989

}

18981

_tmp655_ = self->metadata;

18982

_tmp656_ = vala_gir_parser_metadata_has_argument (_tmp655_, VALA_GIR_PARSER_ARGUMENT_TYPE_REPLACEMENT);

18983

if (_tmp656_) {

18984

ValaSymbol* _tmp657_;

18985

ValaGirParserMetadata* _tmp658_;

18986

gchar* _tmp659_ = NULL;

18987

gchar* _tmp660_;

18988

_tmp657_ = self->symbol;

18989

_tmp658_ = self->metadata;

18990

_tmp659_ = vala_gir_parser_metadata_get_string (_tmp658_, VALA_GIR_PARSER_ARGUMENT_TYPE_REPLACEMENT);

18991

_tmp660_ = _tmp659_;

18992

vala_code_node_set_attribute_string ((ValaCodeNode*) _tmp657_, "Deprecated", "replacement", _tmp660_, NULL);

18993

_g_free0 (_tmp660_);

18990

_tmp658_ = self->metadata;

18991

_tmp659_ = vala_gir_parser_metadata_has_argument (_tmp658_, VALA_GIR_PARSER_ARGUMENT_TYPE_REPLACEMENT);

18992

if (_tmp659_) {

18993

ValaSymbol* _tmp660_;

18994

ValaGirParserMetadata* _tmp661_;

18995

gchar* _tmp662_ = NULL;

18996

gchar* _tmp663_;

18997

_tmp660_ = self->symbol;

18998

_tmp661_ = self->metadata;

18999

_tmp662_ = vala_gir_parser_metadata_get_string (_tmp661_, VALA_GIR_PARSER_ARGUMENT_TYPE_REPLACEMENT);

19000

_tmp663_ = _tmp662_;

19001

vala_code_node_set_attribute_string ((ValaCodeNode*) _tmp660_, "Deprecated", "replacement", _tmp663_, NULL);

19002

_g_free0 (_tmp663_);

18994

19003

}

18995

_tmp661_ = self->metadata;

18996

_tmp662_ = vala_gir_parser_metadata_has_argument (_tmp661_, VALA_GIR_PARSER_ARGUMENT_TYPE_DEPRECATED_SINCE);

18997

if (_tmp662_) {

18998

ValaSymbol* _tmp663_;

18999

ValaGirParserMetadata* _tmp664_;

19000

gchar* _tmp665_ = NULL;

19001

gchar* _tmp666_;

19002

_tmp663_ = self->symbol;

19003

_tmp664_ = self->metadata;

19004

_tmp665_ = vala_gir_parser_metadata_get_string (_tmp664_, VALA_GIR_PARSER_ARGUMENT_TYPE_DEPRECATED_SINCE);

19005

_tmp666_ = _tmp665_;

19006

vala_code_node_set_attribute_string ((ValaCodeNode*) _tmp663_, "Deprecated", "since", _tmp666_, NULL);

19007

_g_free0 (_tmp666_);

19008

} else {

19009

ValaMap* _tmp667_;

19010

gpointer _tmp668_ = NULL;

19004

_tmp664_ = self->metadata;

19005

_tmp665_ = vala_gir_parser_metadata_has_argument (_tmp664_, VALA_GIR_PARSER_ARGUMENT_TYPE_DEPRECATED_SINCE);

19006

if (_tmp665_) {

19007

ValaSymbol* _tmp666_;

19008

ValaGirParserMetadata* _tmp667_;

19009

gchar* _tmp668_ = NULL;

19011

19010

gchar* _tmp669_;

19012

gboolean _tmp670_;

19013

_tmp667_ = self->girdata;

19014

_tmp668_ = vala_map_get (_tmp667_, "deprecated-version");

19015

_tmp669_ = (gchar*) _tmp668_;

19016

_tmp670_ = _tmp669_ != NULL;

19011

_tmp666_ = self->symbol;

19012

_tmp667_ = self->metadata;

19013

_tmp668_ = vala_gir_parser_metadata_get_string (_tmp667_, VALA_GIR_PARSER_ARGUMENT_TYPE_DEPRECATED_SINCE);

19014

_tmp669_ = _tmp668_;

19015

vala_code_node_set_attribute_string ((ValaCodeNode*) _tmp666_, "Deprecated", "since", _tmp669_, NULL);

19017

19016

_g_free0 (_tmp669_);

19018

if (_tmp670_) {

19019

ValaSymbol* _tmp671_;

19020

ValaMap* _tmp672_;

19021

gpointer _tmp673_ = NULL;

19022

gchar* _tmp674_;

19023

_tmp671_ = self->symbol;

19024

_tmp672_ = self->girdata;

19025

_tmp673_ = vala_map_get (_tmp672_, "deprecated-version");

19026

_tmp674_ = (gchar*) _tmp673_;

19027

vala_code_node_set_attribute_string ((ValaCodeNode*) _tmp671_, "Deprecated", "since", _tmp674_, NULL);

19028

_g_free0 (_tmp674_);

19017

} else {

19018

ValaMap* _tmp670_;

19019

gpointer _tmp671_ = NULL;

19020

gchar* _tmp672_;

19021

gboolean _tmp673_;

19022

_tmp670_ = self->girdata;

19023

_tmp671_ = vala_map_get (_tmp670_, "deprecated-version");

19024

_tmp672_ = (gchar*) _tmp671_;

19025

_tmp673_ = _tmp672_ != NULL;

19026

_g_free0 (_tmp672_);

19027

if (_tmp673_) {

19028

ValaSymbol* _tmp674_;

19029

ValaMap* _tmp675_;

19030

gpointer _tmp676_ = NULL;

19031

gchar* _tmp677_;

19032

_tmp674_ = self->symbol;

19033

_tmp675_ = self->girdata;

19034

_tmp676_ = vala_map_get (_tmp675_, "deprecated-version");

19035

_tmp677_ = (gchar*) _tmp676_;

19036

vala_code_node_set_attribute_string ((ValaCodeNode*) _tmp674_, "Deprecated", "since", _tmp677_, NULL);

19037

_g_free0 (_tmp677_);

19029

19038

}

19030

19039

}

19031

_tmp675_ = self->metadata;

19032

_tmp676_ = vala_gir_parser_metadata_get_bool (_tmp675_, VALA_GIR_PARSER_ARGUMENT_TYPE_DEPRECATED, FALSE);

19033

if (_tmp676_) {

19034

ValaSymbol* _tmp677_;

19035

_tmp677_ = self->symbol;

19036

vala_code_node_set_attribute ((ValaCodeNode*) _tmp677_, "Deprecated", TRUE, NULL);

19037

}

19038

_tmp678_ = self->parent;

19039

_tmp679_ = _tmp678_->symbol;

19040

if (VALA_IS_NAMESPACE (_tmp679_)) {

19040

_tmp678_ = self->metadata;

19041

_tmp679_ = vala_gir_parser_metadata_get_bool (_tmp678_, VALA_GIR_PARSER_ARGUMENT_TYPE_DEPRECATED, FALSE);

19042

if (_tmp679_) {

19041

19043

ValaSymbol* _tmp680_;

19042

gchar* _tmp681_ = NULL;

19043

gchar* _tmp682_;

19044

_tmp680_ = self->symbol;

19045

_tmp681_ = vala_gir_parser_node_get_cheader_filename (self);

19046

_tmp682_ = _tmp681_;

19047

vala_code_node_set_attribute_string ((ValaCodeNode*) _tmp680_, "CCode", "cheader_filename", _tmp682_, NULL);

19048

_g_free0 (_tmp682_);

19045

vala_code_node_set_attribute ((ValaCodeNode*) _tmp680_, "Deprecated", TRUE, NULL);

19046

}

19047

_tmp681_ = self->parent;

19048

_tmp682_ = _tmp681_->symbol;

19049

if (VALA_IS_NAMESPACE (_tmp682_)) {

19050

ValaSymbol* _tmp683_;

19051

gchar* _tmp684_ = NULL;

19052

gchar* _tmp685_;

19053

_tmp683_ = self->symbol;

19054

_tmp684_ = vala_gir_parser_node_get_cheader_filename (self);

19055

_tmp685_ = _tmp684_;

19056

vala_code_node_set_attribute_string ((ValaCodeNode*) _tmp683_, "CCode", "cheader_filename", _tmp685_, NULL);

19057

_g_free0 (_tmp685_);

19049

19058

} else {

19050

ValaGirParserMetadata* _tmp683_;

19051

gboolean _tmp684_ = FALSE;

19052

_tmp683_ = self->metadata;

19053

_tmp684_ = vala_gir_parser_metadata_has_argument (_tmp683_, VALA_GIR_PARSER_ARGUMENT_TYPE_CHEADER_FILENAME);

19054

if (_tmp684_) {

19055

ValaSymbol* _tmp685_;

19056

ValaGirParserMetadata* _tmp686_;

19057

gchar* _tmp687_ = NULL;

19058

gchar* _tmp688_;

19059

_tmp685_ = self->symbol;

19060

_tmp686_ = self->metadata;

19061

_tmp687_ = vala_gir_parser_metadata_get_string (_tmp686_, VALA_GIR_PARSER_ARGUMENT_TYPE_CHEADER_FILENAME);

19062

_tmp688_ = _tmp687_;

19063

vala_code_node_set_attribute_string ((ValaCodeNode*) _tmp685_, "CCode", "cheader_filename", _tmp688_, NULL);

19064

_g_free0 (_tmp688_);

19059

ValaGirParserMetadata* _tmp686_;

19060

gboolean _tmp687_ = FALSE;

19061

_tmp686_ = self->metadata;

19062

_tmp687_ = vala_gir_parser_metadata_has_argument (_tmp686_, VALA_GIR_PARSER_ARGUMENT_TYPE_CHEADER_FILENAME);

19063

if (_tmp687_) {

19064

ValaSymbol* _tmp688_;

19065

ValaGirParserMetadata* _tmp689_;

19066

gchar* _tmp690_ = NULL;

19067

gchar* _tmp691_;

19068

_tmp688_ = self->symbol;

19069

_tmp689_ = self->metadata;

19070

_tmp690_ = vala_gir_parser_metadata_get_string (_tmp689_, VALA_GIR_PARSER_ARGUMENT_TYPE_CHEADER_FILENAME);

19071

_tmp691_ = _tmp690_;

19072

vala_code_node_set_attribute_string ((ValaCodeNode*) _tmp688_, "CCode", "cheader_filename", _tmp691_, NULL);

19073

_g_free0 (_tmp691_);

19065

19074

}

19066

19075

}

19067

_tmp689_ = vala_gir_parser_node_get_cname (self);

19068

_tmp690_ = _tmp689_;

19069

_tmp691_ = vala_gir_parser_node_get_default_cname (self);

19070

_tmp692_ = _tmp691_;

19071

_tmp693_ = g_strcmp0 (_tmp690_, _tmp692_) != 0;

19072

_g_free0 (_tmp692_);

19073

_g_free0 (_tmp690_);

19074

if (_tmp693_) {

19075

ValaSymbol* _tmp694_;

19076

gchar* _tmp695_ = NULL;

19077

gchar* _tmp696_;

19078

_tmp694_ = self->symbol;

19079

_tmp695_ = vala_gir_parser_node_get_cname (self);

19080

_tmp696_ = _tmp695_;

19081

vala_code_node_set_attribute_string ((ValaCodeNode*) _tmp694_, "CCode", "cname", _tmp696_, NULL);

19082

_g_free0 (_tmp696_);

19076

_tmp692_ = vala_gir_parser_node_get_cname (self);

19077

_tmp693_ = _tmp692_;

19078

_tmp694_ = vala_gir_parser_node_get_default_cname (self);

19079

_tmp695_ = _tmp694_;

19080

_tmp696_ = g_strcmp0 (_tmp693_, _tmp695_) != 0;

19081

_g_free0 (_tmp695_);

19082

_g_free0 (_tmp693_);

19083

if (_tmp696_) {

19084

ValaSymbol* _tmp697_;

19085

gchar* _tmp698_ = NULL;

19086

gchar* _tmp699_;

19087

_tmp697_ = self->symbol;

19088

_tmp698_ = vala_gir_parser_node_get_cname (self);

19089

_tmp699_ = _tmp698_;

19090

vala_code_node_set_attribute_string ((ValaCodeNode*) _tmp697_, "CCode", "cname", _tmp699_, NULL);

19091

_g_free0 (_tmp699_);

19083

19092

}

19084

_tmp697_ = vala_gir_parser_node_get_lower_case_cprefix (self);

19085

_tmp698_ = _tmp697_;

19086

_tmp699_ = vala_gir_parser_node_get_default_lower_case_cprefix (self);

19087

_tmp700_ = _tmp699_;

19088

_tmp701_ = g_strcmp0 (_tmp698_, _tmp700_) != 0;

19089

_g_free0 (_tmp700_);

19090

_g_free0 (_tmp698_);

19091

if (_tmp701_) {

19092

ValaSymbol* _tmp702_;

19093

_tmp702_ = self->symbol;

19094

if (VALA_IS_CLASS (_tmp702_)) {

19095

ValaSymbol* _tmp703_;

19096

gchar* _tmp704_ = NULL;

19097

gchar* _tmp705_;

19098

_tmp703_ = self->symbol;

19099

_tmp704_ = vala_gir_parser_node_get_lower_case_cprefix (self);

19100

_tmp705_ = _tmp704_;

19101

vala_code_node_set_attribute_string ((ValaCodeNode*) _tmp703_, "CCode", "cprefix", _tmp705_, NULL);

19102

_g_free0 (_tmp705_);

19103

} else {

19093

_tmp700_ = vala_gir_parser_node_get_lower_case_cprefix (self);

19094

_tmp701_ = _tmp700_;

19095

_tmp702_ = vala_gir_parser_node_get_default_lower_case_cprefix (self);

19096

_tmp703_ = _tmp702_;

19097

_tmp704_ = g_strcmp0 (_tmp701_, _tmp703_) != 0;

19098

_g_free0 (_tmp703_);

19099

_g_free0 (_tmp701_);

19100

if (_tmp704_) {

19101

ValaSymbol* _tmp705_;

19102

_tmp705_ = self->symbol;

19103

if (VALA_IS_CLASS (_tmp705_)) {

19104

ValaSymbol* _tmp706_;

19105

gchar* _tmp707_ = NULL;

19106

gchar* _tmp708_;

19107

_tmp706_ = self->symbol;

19108

_tmp707_ = vala_gir_parser_node_get_lower_case_cprefix (self);

19109

_tmp708_ = _tmp707_;

19110

vala_code_node_set_attribute_string ((ValaCodeNode*) _tmp706_, "CCode", "lower_case_cprefix", _tmp708_, NULL);

19110

vala_code_node_set_attribute_string ((ValaCodeNode*) _tmp706_, "CCode", "cprefix", _tmp708_, NULL);

19111

_g_free0 (_tmp708_);

19112

} else {

19113

ValaSymbol* _tmp709_;

19114

gchar* _tmp710_ = NULL;

19115

gchar* _tmp711_;

19116

_tmp709_ = self->symbol;

19117

_tmp710_ = vala_gir_parser_node_get_lower_case_cprefix (self);

19118

_tmp711_ = _tmp710_;

19119

vala_code_node_set_attribute_string ((ValaCodeNode*) _tmp709_, "CCode", "lower_case_cprefix", _tmp711_, NULL);

19120

_g_free0 (_tmp711_);

19112

19121

}

19113

19122

}

19114

_tmp709_ = vala_gir_parser_node_get_lower_case_csuffix (self);

19115

_tmp710_ = _tmp709_;

19116

_tmp711_ = vala_gir_parser_node_get_default_lower_case_csuffix (self);

19117

_tmp712_ = _tmp711_;

19118

_tmp713_ = g_strcmp0 (_tmp710_, _tmp712_) != 0;

19119

_g_free0 (_tmp712_);

19120

_g_free0 (_tmp710_);

19121

if (_tmp713_) {

19122

ValaSymbol* _tmp714_;

19123

gchar* _tmp715_ = NULL;

19124

gchar* _tmp716_;

19125

_tmp714_ = self->symbol;

19126

_tmp715_ = vala_gir_parser_node_get_lower_case_csuffix (self);

19127

_tmp716_ = _tmp715_;

19128

vala_code_node_set_attribute_string ((ValaCodeNode*) _tmp714_, "CCode", "lower_case_csuffix", _tmp716_, NULL);

19129

_g_free0 (_tmp716_);

19130

}

19131

_tmp719_ = self->symbol;

19132

_tmp720_ = vala_gir_parser_is_container (_tmp719_);

19133

if (_tmp720_) {

19134

ValaSymbol* _tmp721_;

19135

_tmp721_ = self->symbol;

19136

_tmp718_ = !VALA_IS_NAMESPACE (_tmp721_);

19137

} else {

19138

_tmp718_ = FALSE;

19139

}

19140

_tmp722_ = _tmp718_;

19141

if (_tmp722_) {

19142

const gchar* _tmp723_;

19143

gchar* _tmp724_ = NULL;

19144

gchar* _tmp725_;

19145

_tmp723_ = self->name;

19146

_tmp724_ = vala_gir_parser_node_get_gir_name (self);

19147

_tmp725_ = _tmp724_;

19148

_tmp717_ = g_strcmp0 (_tmp723_, _tmp725_) != 0;

19149

_g_free0 (_tmp725_);

19150

} else {

19151

_tmp717_ = FALSE;

19152

}

19153

_tmp726_ = _tmp717_;

19154

if (_tmp726_) {

19155

ValaSymbol* _tmp727_;

19156

gchar* _tmp728_ = NULL;

19157

gchar* _tmp729_;

19158

_tmp727_ = self->symbol;

19159

_tmp728_ = vala_gir_parser_node_get_gir_name (self);

19160

_tmp729_ = _tmp728_;

19161

vala_code_node_set_attribute_string ((ValaCodeNode*) _tmp727_, "GIR", "name", _tmp729_, NULL);

19162

_g_free0 (_tmp729_);

19163

}

19164

}

19165

_tmp732_ = self->new_symbol;

19166

if (_tmp732_) {

19167

gboolean _tmp733_;

19168

_tmp733_ = self->merged;

19169

_tmp731_ = _tmp733_;

19170

} else {

19171

_tmp731_ = FALSE;

19172

}

19173

_tmp734_ = _tmp731_;

19174

if (!_tmp734_) {

19175

ValaSymbol* _tmp735_;

19176

gboolean _tmp736_ = FALSE;

19177

_tmp735_ = self->symbol;

19178

_tmp736_ = vala_gir_parser_is_container (_tmp735_);

19179

_tmp730_ = _tmp736_;

19180

} else {

19181

_tmp730_ = FALSE;

19182

}

19183

_tmp737_ = _tmp730_;

19184

if (_tmp737_) {

19185

ValaSymbol* _tmp762_;

19186

ValaClass* _tmp763_;

19187

ValaClass* cl;

19188

gboolean _tmp764_ = FALSE;

19189

gboolean _tmp765_ = FALSE;

19123

_tmp712_ = vala_gir_parser_node_get_lower_case_csuffix (self);

19124

_tmp713_ = _tmp712_;

19125

_tmp714_ = vala_gir_parser_node_get_default_lower_case_csuffix (self);

19126

_tmp715_ = _tmp714_;

19127

_tmp716_ = g_strcmp0 (_tmp713_, _tmp715_) != 0;

19128

_g_free0 (_tmp715_);

19129

_g_free0 (_tmp713_);

19130

if (_tmp716_) {

19131

ValaSymbol* _tmp717_;

19132

gchar* _tmp718_ = NULL;

19133

gchar* _tmp719_;

19134

_tmp717_ = self->symbol;

19135

_tmp718_ = vala_gir_parser_node_get_lower_case_csuffix (self);

19136

_tmp719_ = _tmp718_;

19137

vala_code_node_set_attribute_string ((ValaCodeNode*) _tmp717_, "CCode", "lower_case_csuffix", _tmp719_, NULL);

19138

_g_free0 (_tmp719_);

19139

}

19140

_tmp722_ = self->symbol;

19141

_tmp723_ = vala_gir_parser_is_container (_tmp722_);

19142

if (_tmp723_) {

19143

ValaSymbol* _tmp724_;

19144

_tmp724_ = self->symbol;

19145

_tmp721_ = !VALA_IS_NAMESPACE (_tmp724_);

19146

} else {

19147

_tmp721_ = FALSE;

19148

}

19149

_tmp725_ = _tmp721_;

19150

if (_tmp725_) {

19151

const gchar* _tmp726_;

19152

gchar* _tmp727_ = NULL;

19153

gchar* _tmp728_;

19154

_tmp726_ = self->name;

19155

_tmp727_ = vala_gir_parser_node_get_gir_name (self);

19156

_tmp728_ = _tmp727_;

19157

_tmp720_ = g_strcmp0 (_tmp726_, _tmp728_) != 0;

19158

_g_free0 (_tmp728_);

19159

} else {

19160

_tmp720_ = FALSE;

19161

}

19162

_tmp729_ = _tmp720_;

19163

if (_tmp729_) {

19164

ValaSymbol* _tmp730_;

19165

gchar* _tmp731_ = NULL;

19166

gchar* _tmp732_;

19167

_tmp730_ = self->symbol;

19168

_tmp731_ = vala_gir_parser_node_get_gir_name (self);

19169

_tmp732_ = _tmp731_;

19170

vala_code_node_set_attribute_string ((ValaCodeNode*) _tmp730_, "GIR", "name", _tmp732_, NULL);

19171

_g_free0 (_tmp732_);

19172

}

19173

}

19174

_tmp735_ = self->new_symbol;

19175

if (_tmp735_) {

19176

gboolean _tmp736_;

19177

_tmp736_ = self->merged;

19178

_tmp734_ = _tmp736_;

19179

} else {

19180

_tmp734_ = FALSE;

19181

}

19182

_tmp737_ = _tmp734_;

19183

if (!_tmp737_) {

19184

ValaSymbol* _tmp738_;

19185

gboolean _tmp739_ = FALSE;

19186

_tmp738_ = self->symbol;

19187

_tmp739_ = vala_gir_parser_is_container (_tmp738_);

19188

_tmp733_ = _tmp739_;

19189

} else {

19190

_tmp733_ = FALSE;

19191

}

19192

_tmp740_ = _tmp733_;

19193

if (_tmp740_) {

19194

ValaSymbol* _tmp765_;

19190

19195

ValaClass* _tmp766_;

19191

gboolean _tmp770_;

19192

gboolean _tmp774_;

19196

ValaClass* cl;

19197

gboolean _tmp767_ = FALSE;

19198

gboolean _tmp768_ = FALSE;

19199

ValaClass* _tmp769_;

19200

gboolean _tmp773_;

19201

gboolean _tmp777_;

19193

19202

{

19194

ValaArrayList* _tmp738_;

19195

ValaArrayList* _tmp739_;

19203

ValaArrayList* _tmp741_;

19204

ValaArrayList* _tmp742_;

19196

19205

ValaArrayList* _node_list;

19197

ValaArrayList* _tmp740_;

19198

gint _tmp741_;

19199

gint _tmp742_;

19206

ValaArrayList* _tmp743_;

19207

gint _tmp744_;

19208

gint _tmp745_;

19200

19209

gint _node_size;

19201

19210

gint _node_index;

19202

_tmp738_ = self->members;

19203

_tmp739_ = _vala_iterable_ref0 (_tmp738_);

19204

_node_list = _tmp739_;

19205

_tmp740_ = _node_list;

19206

_tmp741_ = vala_collection_get_size ((ValaCollection*) _tmp740_);

19207

_tmp742_ = _tmp741_;

19208

_node_size = _tmp742_;

19211

_tmp741_ = self->members;

19212

_tmp742_ = _vala_iterable_ref0 (_tmp741_);

19213

_node_list = _tmp742_;

19214

_tmp743_ = _node_list;

19215

_tmp744_ = vala_collection_get_size ((ValaCollection*) _tmp743_);

19216

_tmp745_ = _tmp744_;

19217

_node_size = _tmp745_;

19209

19218

_node_index = -1;

19210

19219

while (TRUE) {

19211

gint _tmp743_;

19212

gint _tmp744_;

19213

gint _tmp745_;

19214

ValaArrayList* _tmp746_;

19220

gint _tmp746_;

19215

19221

gint _tmp747_;

19216

gpointer _tmp748_ = NULL;

19222

gint _tmp748_;

19223

ValaArrayList* _tmp749_;

19224

gint _tmp750_;

19225

gpointer _tmp751_ = NULL;

19217

19226

ValaGirParserNode* node;

19218

gboolean _tmp749_ = FALSE;

19219

gboolean _tmp750_ = FALSE;

19220

ValaGirParserNode* _tmp751_;

19221

gboolean _tmp752_;

19227

gboolean _tmp752_ = FALSE;

19228

gboolean _tmp753_ = FALSE;

19229

ValaGirParserNode* _tmp754_;

19222

19230

gboolean _tmp755_;

19223

19231

gboolean _tmp758_;

19224

_tmp743_ = _node_index;

19225

_node_index = _tmp743_ + 1;

19226

_tmp744_ = _node_index;

19227

_tmp745_ = _node_size;

19228

if (!(_tmp744_ < _tmp745_)) {

19229

break;

19230

}

19231

_tmp746_ = _node_list;

19232

gboolean _tmp761_;

19233

_tmp746_ = _node_index;

19234

_node_index = _tmp746_ + 1;

19232

19235

_tmp747_ = _node_index;

19233

_tmp748_ = vala_list_get ((ValaList*) _tmp746_, _tmp747_);

19234

node = (ValaGirParserNode*) _tmp748_;

19235

_tmp751_ = node;

19236

_tmp752_ = _tmp751_->new_symbol;

19237

if (_tmp752_) {

19238

ValaGirParserNode* _tmp753_;

19239

gboolean _tmp754_;

19240

_tmp753_ = node;

19241

_tmp754_ = _tmp753_->merged;

19242

_tmp750_ = !_tmp754_;

19243

} else {

19244

_tmp750_ = FALSE;

19236

_tmp748_ = _node_size;

19237

if (!(_tmp747_ < _tmp748_)) {

19238

break;

19245

19239

}

19246

_tmp755_ = _tmp750_;

19240

_tmp749_ = _node_list;

19241

_tmp750_ = _node_index;

19242

_tmp751_ = vala_list_get ((ValaList*) _tmp749_, _tmp750_);

19243

node = (ValaGirParserNode*) _tmp751_;

19244

_tmp754_ = node;

19245

_tmp755_ = _tmp754_->new_symbol;

19247

19246

if (_tmp755_) {

19248

ValaGirParserMetadata* _tmp756_;

19249

gboolean _tmp757_ = FALSE;

19250

_tmp756_ = self->metadata;

19251

_tmp757_ = vala_gir_parser_metadata_get_bool (_tmp756_, VALA_GIR_PARSER_ARGUMENT_TYPE_HIDDEN, FALSE);

19252

_tmp749_ = !_tmp757_;

19247

ValaGirParserNode* _tmp756_;

19248

gboolean _tmp757_;

19249

_tmp756_ = node;

19250

_tmp757_ = _tmp756_->merged;

19251

_tmp753_ = !_tmp757_;

19253

19252

} else {

19254

_tmp749_ = FALSE;

19253

_tmp753_ = FALSE;

19255

19254

}

19256

_tmp758_ = _tmp749_;

19255

_tmp758_ = _tmp753_;

19257

19256

if (_tmp758_) {

19258

ValaSymbol* _tmp759_;

19259

ValaGirParserNode* _tmp760_;

19260

ValaSymbol* _tmp761_;

19261

_tmp759_ = self->symbol;

19262

_tmp760_ = node;

19263

_tmp761_ = _tmp760_->symbol;

19264

vala_gir_parser_add_symbol_to_container (_tmp759_, _tmp761_);

19257

ValaGirParserMetadata* _tmp759_;

19258

gboolean _tmp760_ = FALSE;

19259

_tmp759_ = self->metadata;

19260

_tmp760_ = vala_gir_parser_metadata_get_bool (_tmp759_, VALA_GIR_PARSER_ARGUMENT_TYPE_HIDDEN, FALSE);

19261

_tmp752_ = !_tmp760_;

19262

} else {

19263

_tmp752_ = FALSE;

19264

}

19265

_tmp761_ = _tmp752_;

19266

if (_tmp761_) {

19267

ValaSymbol* _tmp762_;

19268

ValaGirParserNode* _tmp763_;

19269

ValaSymbol* _tmp764_;

19270

_tmp762_ = self->symbol;

19271

_tmp763_ = node;

19272

_tmp764_ = _tmp763_->symbol;

19273

vala_gir_parser_add_symbol_to_container (_tmp762_, _tmp764_);

19265

19274

}

19266

19275

_vala_gir_parser_node_unref0 (node);

19267

19276

}

19268

19277

_vala_iterable_unref0 (_node_list);

19269

19278

}

19270

_tmp762_ = self->symbol;

19271

_tmp763_ = _vala_code_node_ref0 (VALA_IS_CLASS (_tmp762_) ? ((ValaClass*) _tmp762_) : NULL);

19272

cl = _tmp763_;

19273

_tmp766_ = cl;

19274

if (_tmp766_ != NULL) {

19275

ValaClass* _tmp767_;

19276

gboolean _tmp768_;

19277

gboolean _tmp769_;

19278

_tmp767_ = cl;

19279

_tmp768_ = vala_class_get_is_compact (_tmp767_);

19280

_tmp769_ = _tmp768_;

19281

_tmp765_ = !_tmp769_;

19282

} else {

19283

_tmp765_ = FALSE;

19284

}

19285

_tmp770_ = _tmp765_;

19286

if (_tmp770_) {

19287

ValaClass* _tmp771_;

19288

ValaMethod* _tmp772_;

19289

ValaMethod* _tmp773_;

19290

_tmp771_ = cl;

19291

_tmp772_ = vala_class_get_default_construction_method (_tmp771_);

19292

_tmp773_ = _tmp772_;

19293

_tmp764_ = _tmp773_ == NULL;

19294

} else {

19295

_tmp764_ = FALSE;

19296

}

19297

_tmp774_ = _tmp764_;

19298

if (_tmp774_) {

19299

ValaClass* _tmp775_;

19300

ValaSourceReference* _tmp776_;

19301

ValaSourceReference* _tmp777_;

19302

ValaCreationMethod* _tmp778_;

19279

_tmp765_ = self->symbol;

19280

_tmp766_ = _vala_code_node_ref0 (VALA_IS_CLASS (_tmp765_) ? ((ValaClass*) _tmp765_) : NULL);

19281

cl = _tmp766_;

19282

_tmp769_ = cl;

19283

if (_tmp769_ != NULL) {

19284

ValaClass* _tmp770_;

19285

gboolean _tmp771_;

19286

gboolean _tmp772_;

19287

_tmp770_ = cl;

19288

_tmp771_ = vala_class_get_is_compact (_tmp770_);

19289

_tmp772_ = _tmp771_;

19290

_tmp768_ = !_tmp772_;

19291

} else {

19292

_tmp768_ = FALSE;

19293

}

19294

_tmp773_ = _tmp768_;

19295

if (_tmp773_) {

19296

ValaClass* _tmp774_;

19297

ValaMethod* _tmp775_;

19298

ValaMethod* _tmp776_;

19299

_tmp774_ = cl;

19300

_tmp775_ = vala_class_get_default_construction_method (_tmp774_);

19301

_tmp776_ = _tmp775_;

19302

_tmp767_ = _tmp776_ == NULL;

19303

} else {

19304

_tmp767_ = FALSE;

19305

}

19306

_tmp777_ = _tmp767_;

19307

if (_tmp777_) {

19308

ValaClass* _tmp778_;

19309

ValaSourceReference* _tmp779_;

19310

ValaSourceReference* _tmp780_;

19311

ValaCreationMethod* _tmp781_;

19303

19312

ValaCreationMethod* cm;

19304

ValaCreationMethod* _tmp779_;

19305

ValaCreationMethod* _tmp780_;

19306

ValaClass* _tmp781_;

19307

19313

ValaCreationMethod* _tmp782_;

19308

_tmp775_ = cl;

19309

_tmp776_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp775_);

19310

_tmp777_ = _tmp776_;

19311

_tmp778_ = vala_creation_method_new (NULL, NULL, _tmp777_, NULL);

19312

cm = _tmp778_;

19313

_tmp779_ = cm;

19314

vala_method_set_has_construct_function ((ValaMethod*) _tmp779_, FALSE);

19315

_tmp780_ = cm;

19316

vala_symbol_set_access ((ValaSymbol*) _tmp780_, VALA_SYMBOL_ACCESSIBILITY_PROTECTED);

19317

_tmp781_ = cl;

19314

ValaCreationMethod* _tmp783_;

19315

ValaClass* _tmp784_;

19316

ValaCreationMethod* _tmp785_;

19317

_tmp778_ = cl;

19318

_tmp779_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp778_);

19319

_tmp780_ = _tmp779_;

19320

_tmp781_ = vala_creation_method_new (NULL, NULL, _tmp780_, NULL);

19321

cm = _tmp781_;

19318

19322

_tmp782_ = cm;

19319

vala_symbol_add_method ((ValaSymbol*) _tmp781_, (ValaMethod*) _tmp782_);

19323

vala_method_set_has_construct_function ((ValaMethod*) _tmp782_, FALSE);

19324

_tmp783_ = cm;

19325

vala_symbol_set_access ((ValaSymbol*) _tmp783_, VALA_SYMBOL_ACCESSIBILITY_PROTECTED);

19326

_tmp784_ = cl;

19327

_tmp785_ = cm;

19328

vala_symbol_add_method ((ValaSymbol*) _tmp784_, (ValaMethod*) _tmp785_);

19320

19329

_vala_code_node_unref0 (cm);

19321

19330

}

19322

19331

_vala_code_node_unref0 (cl);

Older »