diff -Nru vala-0.34.6/ChangeLog vala-0.34.7/ChangeLog --- vala-0.34.6/ChangeLog 2017-03-07 09:40:30.000000000 +0000 +++ vala-0.34.7/ChangeLog 2017-03-20 21:32:41.000000000 +0000 @@ -1,3 +1,91 @@ +2017-03-20 Rico Tzschichholz + + Release 0.34.7 + +2017-03-16 Marvin W + + codegen: Properly null-out source on ownership-transfer of delegates + +2017-03-16 Rico Tzschichholz + + gio-2.0: Add/"Unlock" missing GTask symbols + +2017-03-16 Alistair Thomas + + valac: State default output directory is current working directory + https://bugzilla.gnome.org/show_bug.cgi?id=740303 + +2017-03-16 Rico Tzschichholz + + signalmodule: Handle nullable ValueTypes properly and treat them as pointer + Nullable value-types are actually pointers to heap-allocated structures. + Therefore a pointer-based marshaller is required for those types. + + https://bugzilla.gnome.org/show_bug.cgi?id=758816 + + codegen: Add some missing to predefined marshallers from glib + g_cclosure_marshal_VOID__BOXED + g_cclosure_marshal_VOID__VARIANT + g_cclosure_marshal_BOOLEAN__BOXED_BOXED + +2017-03-16 Ole André Vadla Ravnås + + vala: Fix MemberAccess.is_non_null() for EnumValue constants + This is because an EnumValue object does not have a type reference. + + https://bugzilla.gnome.org/show_bug.cgi?id=780050 + +2017-03-16 Rico Tzschichholz + + vala: Non-null initializers are not allowed for owned namespace fields + https://bugzilla.gnome.org/show_bug.cgi?id=777697 + + gio-2.0 Update SettingsBackend related bindings + + poppler-glib: Update to 0.52.0 + +2017-03-16 Alistair Thomas + + manual: Add language="vala" attribute to Devhelp version + + manual: Update from wiki.gnome.org + +2017-03-16 Rico Tzschichholz + + codegen: Fix base-access from within overriding struct-property-accessor + Based on patch by gandalfn + + https://bugzilla.gnome.org/show_bug.cgi?id=764481 + +2017-03-16 Alistair Thomas + + enchant: Minor fixes + Remove superfluous cname_prefix namespace-attribute. + Add get_version() and fix array-length-type of Dict.suggest(). + + https://bugzilla.gnome.org/show_bug.cgi?id=767522 + +2017-03-16 Rico Tzschichholz + + gstreamer-1.0: Mark *.make_writable with "ReturnsModifiedPointer" + https://bugzilla.gnome.org/show_bug.cgi?id=759255 + + girparser: Add metadata-support for "returns_modified_pointer" + https://bugzilla.gnome.org/show_bug.cgi?id=759255 + + gstreamer-1.0: Fix Gst.Base.Adapter.map/take bindings + There is no explicit array-length returned while it is implicitly related + to the in-parameter those methods are taking. + + https://bugzilla.gnome.org/show_bug.cgi?id=705987 + + gtk+-3.0: Widget.override_* are deprecated since 3.16 + https://bugzilla.gnome.org/show_bug.cgi?id=777782 + + manual: Update timestamps of directory-targets + + signalmodule: Fix deprecation of signals + 2017-03-07 Rico Tzschichholz Release 0.34.6 diff -Nru vala-0.34.6/codegen/valaccodebasemodule.c vala-0.34.7/codegen/valaccodebasemodule.c --- vala-0.34.6/codegen/valaccodebasemodule.c 2017-03-07 09:40:04.000000000 +0000 +++ vala-0.34.7/codegen/valaccodebasemodule.c 2017-03-20 21:31:16.000000000 +0000 @@ -960,12 +960,12 @@ ValaSet* _tmp18_ = NULL; ValaSet* _tmp19_ = NULL; ValaSet* _tmp20_ = NULL; - GHashFunc _tmp21_ = NULL; - GEqualFunc _tmp22_ = NULL; - ValaHashSet* _tmp23_ = NULL; - ValaSet* _tmp24_ = NULL; - ValaSet* _tmp25_ = NULL; - ValaSet* _tmp26_ = NULL; + ValaSet* _tmp21_ = NULL; + ValaSet* _tmp22_ = NULL; + ValaSet* _tmp23_ = NULL; + GHashFunc _tmp24_ = NULL; + GEqualFunc _tmp25_ = NULL; + ValaHashSet* _tmp26_ = NULL; ValaSet* _tmp27_ = NULL; ValaSet* _tmp28_ = NULL; ValaSet* _tmp29_ = NULL; @@ -1012,6 +1012,9 @@ ValaSet* _tmp70_ = NULL; ValaSet* _tmp71_ = NULL; ValaSet* _tmp72_ = NULL; + ValaSet* _tmp73_ = NULL; + ValaSet* _tmp74_ = NULL; + ValaSet* _tmp75_ = NULL; self = (ValaCCodeBaseModule*) vala_code_generator_construct (object_type); _tmp0_ = g_str_hash; _tmp1_ = g_str_equal; @@ -1054,109 +1057,115 @@ vala_collection_add ((ValaCollection*) _tmp19_, "VOID:UINT,POINTER"); _tmp20_ = self->predefined_marshal_set; vala_collection_add ((ValaCollection*) _tmp20_, "BOOLEAN:FLAGS"); - _tmp21_ = g_str_hash; - _tmp22_ = g_str_equal; - _tmp23_ = vala_hash_set_new (G_TYPE_STRING, (GBoxedCopyFunc) g_strdup, (GDestroyNotify) g_free, _tmp21_, _tmp22_); + _tmp21_ = self->predefined_marshal_set; + vala_collection_add ((ValaCollection*) _tmp21_, "VOID:BOXED"); + _tmp22_ = self->predefined_marshal_set; + vala_collection_add ((ValaCollection*) _tmp22_, "VOID:VARIANT"); + _tmp23_ = self->predefined_marshal_set; + vala_collection_add ((ValaCollection*) _tmp23_, "BOOLEAN:BOXED,BOXED"); + _tmp24_ = g_str_hash; + _tmp25_ = g_str_equal; + _tmp26_ = vala_hash_set_new (G_TYPE_STRING, (GBoxedCopyFunc) g_strdup, (GDestroyNotify) g_free, _tmp24_, _tmp25_); _vala_iterable_unref0 (self->priv->reserved_identifiers); - self->priv->reserved_identifiers = (ValaSet*) _tmp23_; - _tmp24_ = self->priv->reserved_identifiers; - vala_collection_add ((ValaCollection*) _tmp24_, "_Bool"); - _tmp25_ = self->priv->reserved_identifiers; - vala_collection_add ((ValaCollection*) _tmp25_, "_Complex"); - _tmp26_ = self->priv->reserved_identifiers; - vala_collection_add ((ValaCollection*) _tmp26_, "_Imaginary"); + self->priv->reserved_identifiers = (ValaSet*) _tmp26_; _tmp27_ = self->priv->reserved_identifiers; - vala_collection_add ((ValaCollection*) _tmp27_, "asm"); + vala_collection_add ((ValaCollection*) _tmp27_, "_Bool"); _tmp28_ = self->priv->reserved_identifiers; - vala_collection_add ((ValaCollection*) _tmp28_, "auto"); + vala_collection_add ((ValaCollection*) _tmp28_, "_Complex"); _tmp29_ = self->priv->reserved_identifiers; - vala_collection_add ((ValaCollection*) _tmp29_, "break"); + vala_collection_add ((ValaCollection*) _tmp29_, "_Imaginary"); _tmp30_ = self->priv->reserved_identifiers; - vala_collection_add ((ValaCollection*) _tmp30_, "case"); + vala_collection_add ((ValaCollection*) _tmp30_, "asm"); _tmp31_ = self->priv->reserved_identifiers; - vala_collection_add ((ValaCollection*) _tmp31_, "char"); + vala_collection_add ((ValaCollection*) _tmp31_, "auto"); _tmp32_ = self->priv->reserved_identifiers; - vala_collection_add ((ValaCollection*) _tmp32_, "const"); + vala_collection_add ((ValaCollection*) _tmp32_, "break"); _tmp33_ = self->priv->reserved_identifiers; - vala_collection_add ((ValaCollection*) _tmp33_, "continue"); + vala_collection_add ((ValaCollection*) _tmp33_, "case"); _tmp34_ = self->priv->reserved_identifiers; - vala_collection_add ((ValaCollection*) _tmp34_, "default"); + vala_collection_add ((ValaCollection*) _tmp34_, "char"); _tmp35_ = self->priv->reserved_identifiers; - vala_collection_add ((ValaCollection*) _tmp35_, "do"); + vala_collection_add ((ValaCollection*) _tmp35_, "const"); _tmp36_ = self->priv->reserved_identifiers; - vala_collection_add ((ValaCollection*) _tmp36_, "double"); + vala_collection_add ((ValaCollection*) _tmp36_, "continue"); _tmp37_ = self->priv->reserved_identifiers; - vala_collection_add ((ValaCollection*) _tmp37_, "else"); + vala_collection_add ((ValaCollection*) _tmp37_, "default"); _tmp38_ = self->priv->reserved_identifiers; - vala_collection_add ((ValaCollection*) _tmp38_, "enum"); + vala_collection_add ((ValaCollection*) _tmp38_, "do"); _tmp39_ = self->priv->reserved_identifiers; - vala_collection_add ((ValaCollection*) _tmp39_, "extern"); + vala_collection_add ((ValaCollection*) _tmp39_, "double"); _tmp40_ = self->priv->reserved_identifiers; - vala_collection_add ((ValaCollection*) _tmp40_, "float"); + vala_collection_add ((ValaCollection*) _tmp40_, "else"); _tmp41_ = self->priv->reserved_identifiers; - vala_collection_add ((ValaCollection*) _tmp41_, "for"); + vala_collection_add ((ValaCollection*) _tmp41_, "enum"); _tmp42_ = self->priv->reserved_identifiers; - vala_collection_add ((ValaCollection*) _tmp42_, "goto"); + vala_collection_add ((ValaCollection*) _tmp42_, "extern"); _tmp43_ = self->priv->reserved_identifiers; - vala_collection_add ((ValaCollection*) _tmp43_, "if"); + vala_collection_add ((ValaCollection*) _tmp43_, "float"); _tmp44_ = self->priv->reserved_identifiers; - vala_collection_add ((ValaCollection*) _tmp44_, "inline"); + vala_collection_add ((ValaCollection*) _tmp44_, "for"); _tmp45_ = self->priv->reserved_identifiers; - vala_collection_add ((ValaCollection*) _tmp45_, "int"); + vala_collection_add ((ValaCollection*) _tmp45_, "goto"); _tmp46_ = self->priv->reserved_identifiers; - vala_collection_add ((ValaCollection*) _tmp46_, "long"); + vala_collection_add ((ValaCollection*) _tmp46_, "if"); _tmp47_ = self->priv->reserved_identifiers; - vala_collection_add ((ValaCollection*) _tmp47_, "register"); + vala_collection_add ((ValaCollection*) _tmp47_, "inline"); _tmp48_ = self->priv->reserved_identifiers; - vala_collection_add ((ValaCollection*) _tmp48_, "restrict"); + vala_collection_add ((ValaCollection*) _tmp48_, "int"); _tmp49_ = self->priv->reserved_identifiers; - vala_collection_add ((ValaCollection*) _tmp49_, "return"); + vala_collection_add ((ValaCollection*) _tmp49_, "long"); _tmp50_ = self->priv->reserved_identifiers; - vala_collection_add ((ValaCollection*) _tmp50_, "short"); + vala_collection_add ((ValaCollection*) _tmp50_, "register"); _tmp51_ = self->priv->reserved_identifiers; - vala_collection_add ((ValaCollection*) _tmp51_, "signed"); + vala_collection_add ((ValaCollection*) _tmp51_, "restrict"); _tmp52_ = self->priv->reserved_identifiers; - vala_collection_add ((ValaCollection*) _tmp52_, "sizeof"); + vala_collection_add ((ValaCollection*) _tmp52_, "return"); _tmp53_ = self->priv->reserved_identifiers; - vala_collection_add ((ValaCollection*) _tmp53_, "static"); + vala_collection_add ((ValaCollection*) _tmp53_, "short"); _tmp54_ = self->priv->reserved_identifiers; - vala_collection_add ((ValaCollection*) _tmp54_, "struct"); + vala_collection_add ((ValaCollection*) _tmp54_, "signed"); _tmp55_ = self->priv->reserved_identifiers; - vala_collection_add ((ValaCollection*) _tmp55_, "switch"); + vala_collection_add ((ValaCollection*) _tmp55_, "sizeof"); _tmp56_ = self->priv->reserved_identifiers; - vala_collection_add ((ValaCollection*) _tmp56_, "typedef"); + vala_collection_add ((ValaCollection*) _tmp56_, "static"); _tmp57_ = self->priv->reserved_identifiers; - vala_collection_add ((ValaCollection*) _tmp57_, "union"); + vala_collection_add ((ValaCollection*) _tmp57_, "struct"); _tmp58_ = self->priv->reserved_identifiers; - vala_collection_add ((ValaCollection*) _tmp58_, "unsigned"); + vala_collection_add ((ValaCollection*) _tmp58_, "switch"); _tmp59_ = self->priv->reserved_identifiers; - vala_collection_add ((ValaCollection*) _tmp59_, "void"); + vala_collection_add ((ValaCollection*) _tmp59_, "typedef"); _tmp60_ = self->priv->reserved_identifiers; - vala_collection_add ((ValaCollection*) _tmp60_, "volatile"); + vala_collection_add ((ValaCollection*) _tmp60_, "union"); _tmp61_ = self->priv->reserved_identifiers; - vala_collection_add ((ValaCollection*) _tmp61_, "while"); + vala_collection_add ((ValaCollection*) _tmp61_, "unsigned"); _tmp62_ = self->priv->reserved_identifiers; - vala_collection_add ((ValaCollection*) _tmp62_, "_Alignas"); + vala_collection_add ((ValaCollection*) _tmp62_, "void"); _tmp63_ = self->priv->reserved_identifiers; - vala_collection_add ((ValaCollection*) _tmp63_, "_Alignof"); + vala_collection_add ((ValaCollection*) _tmp63_, "volatile"); _tmp64_ = self->priv->reserved_identifiers; - vala_collection_add ((ValaCollection*) _tmp64_, "_Atomic"); + vala_collection_add ((ValaCollection*) _tmp64_, "while"); _tmp65_ = self->priv->reserved_identifiers; - vala_collection_add ((ValaCollection*) _tmp65_, "_Generic"); + vala_collection_add ((ValaCollection*) _tmp65_, "_Alignas"); _tmp66_ = self->priv->reserved_identifiers; - vala_collection_add ((ValaCollection*) _tmp66_, "_Noreturn"); + vala_collection_add ((ValaCollection*) _tmp66_, "_Alignof"); _tmp67_ = self->priv->reserved_identifiers; - vala_collection_add ((ValaCollection*) _tmp67_, "_Static_assert"); + vala_collection_add ((ValaCollection*) _tmp67_, "_Atomic"); _tmp68_ = self->priv->reserved_identifiers; - vala_collection_add ((ValaCollection*) _tmp68_, "_Thread_local"); + vala_collection_add ((ValaCollection*) _tmp68_, "_Generic"); _tmp69_ = self->priv->reserved_identifiers; - vala_collection_add ((ValaCollection*) _tmp69_, "cdecl"); + vala_collection_add ((ValaCollection*) _tmp69_, "_Noreturn"); _tmp70_ = self->priv->reserved_identifiers; - vala_collection_add ((ValaCollection*) _tmp70_, "error"); + vala_collection_add ((ValaCollection*) _tmp70_, "_Static_assert"); _tmp71_ = self->priv->reserved_identifiers; - vala_collection_add ((ValaCollection*) _tmp71_, "result"); + vala_collection_add ((ValaCollection*) _tmp71_, "_Thread_local"); _tmp72_ = self->priv->reserved_identifiers; - vala_collection_add ((ValaCollection*) _tmp72_, "self"); + vala_collection_add ((ValaCollection*) _tmp72_, "cdecl"); + _tmp73_ = self->priv->reserved_identifiers; + vala_collection_add ((ValaCollection*) _tmp73_, "error"); + _tmp74_ = self->priv->reserved_identifiers; + vala_collection_add ((ValaCollection*) _tmp74_, "result"); + _tmp75_ = self->priv->reserved_identifiers; + vala_collection_add ((ValaCollection*) _tmp75_, "self"); return self; } @@ -31563,146 +31572,198 @@ _tmp54_ = vala_expression_get_value_type ((ValaExpression*) _tmp53_); _tmp55_ = _tmp54_; if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp55_, VALA_TYPE_DELEGATE_TYPE)) { - ValaCCodeExpression* target_destroy_notify = NULL; - ValaReferenceTransferExpression* _tmp56_ = NULL; - ValaExpression* _tmp57_ = NULL; - ValaExpression* _tmp58_ = NULL; - ValaTargetValue* _tmp59_ = NULL; - ValaTargetValue* _tmp60_ = NULL; + ValaCCodeFunction* _tmp56_ = NULL; + ValaCCodeFunction* _tmp57_ = NULL; + ValaReferenceTransferExpression* _tmp58_ = NULL; + ValaExpression* _tmp59_ = NULL; + ValaExpression* _tmp60_ = NULL; ValaCCodeExpression* _tmp61_ = NULL; ValaCCodeExpression* _tmp62_ = NULL; - _tmp56_ = expr; - _tmp57_ = vala_reference_transfer_expression_get_inner (_tmp56_); - _tmp58_ = _tmp57_; - _tmp59_ = vala_expression_get_target_value (_tmp58_); + ValaCCodeConstant* _tmp63_ = NULL; + ValaCCodeConstant* _tmp64_ = NULL; + ValaCCodeExpression* target = NULL; + ValaReferenceTransferExpression* _tmp65_ = NULL; + ValaExpression* _tmp66_ = NULL; + ValaExpression* _tmp67_ = NULL; + ValaTargetValue* _tmp68_ = NULL; + ValaTargetValue* _tmp69_ = NULL; + ValaCCodeExpression* _tmp70_ = NULL; + ValaCCodeExpression* _tmp71_ = NULL; + ValaCCodeExpression* target_destroy_notify = NULL; + ValaReferenceTransferExpression* _tmp77_ = NULL; + ValaExpression* _tmp78_ = NULL; + ValaExpression* _tmp79_ = NULL; + ValaTargetValue* _tmp80_ = NULL; + ValaTargetValue* _tmp81_ = NULL; + ValaCCodeExpression* _tmp82_ = NULL; + ValaCCodeExpression* _tmp83_ = NULL; + _tmp56_ = vala_ccode_base_module_get_ccode (self); + _tmp57_ = _tmp56_; + _tmp58_ = expr; + _tmp59_ = vala_reference_transfer_expression_get_inner (_tmp58_); _tmp60_ = _tmp59_; - _tmp61_ = vala_ccode_base_module_get_delegate_target_destroy_notify_cvalue (self, _tmp60_); - target_destroy_notify = _tmp61_; - _tmp62_ = target_destroy_notify; - if (_tmp62_ != NULL) { - ValaCCodeFunction* _tmp63_ = NULL; - ValaCCodeFunction* _tmp64_ = NULL; - ValaCCodeExpression* _tmp65_ = NULL; - ValaCCodeConstant* _tmp66_ = NULL; - ValaCCodeConstant* _tmp67_ = NULL; - _tmp63_ = vala_ccode_base_module_get_ccode (self); - _tmp64_ = _tmp63_; - _tmp65_ = target_destroy_notify; - _tmp66_ = vala_ccode_constant_new ("NULL"); - _tmp67_ = _tmp66_; - vala_ccode_function_add_assignment (_tmp64_, _tmp65_, (ValaCCodeExpression*) _tmp67_); - _vala_ccode_node_unref0 (_tmp67_); + _tmp61_ = vala_ccode_base_module_get_cvalue (self, _tmp60_); + _tmp62_ = _tmp61_; + _tmp63_ = vala_ccode_constant_new ("NULL"); + _tmp64_ = _tmp63_; + vala_ccode_function_add_assignment (_tmp57_, _tmp62_, (ValaCCodeExpression*) _tmp64_); + _vala_ccode_node_unref0 (_tmp64_); + _vala_ccode_node_unref0 (_tmp62_); + _tmp65_ = expr; + _tmp66_ = vala_reference_transfer_expression_get_inner (_tmp65_); + _tmp67_ = _tmp66_; + _tmp68_ = vala_expression_get_target_value (_tmp67_); + _tmp69_ = _tmp68_; + _tmp70_ = vala_ccode_base_module_get_delegate_target_cvalue (self, _tmp69_); + target = _tmp70_; + _tmp71_ = target; + if (_tmp71_ != NULL) { + ValaCCodeFunction* _tmp72_ = NULL; + ValaCCodeFunction* _tmp73_ = NULL; + ValaCCodeExpression* _tmp74_ = NULL; + ValaCCodeConstant* _tmp75_ = NULL; + ValaCCodeConstant* _tmp76_ = NULL; + _tmp72_ = vala_ccode_base_module_get_ccode (self); + _tmp73_ = _tmp72_; + _tmp74_ = target; + _tmp75_ = vala_ccode_constant_new ("NULL"); + _tmp76_ = _tmp75_; + vala_ccode_function_add_assignment (_tmp73_, _tmp74_, (ValaCCodeExpression*) _tmp76_); + _vala_ccode_node_unref0 (_tmp76_); + } + _tmp77_ = expr; + _tmp78_ = vala_reference_transfer_expression_get_inner (_tmp77_); + _tmp79_ = _tmp78_; + _tmp80_ = vala_expression_get_target_value (_tmp79_); + _tmp81_ = _tmp80_; + _tmp82_ = vala_ccode_base_module_get_delegate_target_destroy_notify_cvalue (self, _tmp81_); + target_destroy_notify = _tmp82_; + _tmp83_ = target_destroy_notify; + if (_tmp83_ != NULL) { + ValaCCodeFunction* _tmp84_ = NULL; + ValaCCodeFunction* _tmp85_ = NULL; + ValaCCodeExpression* _tmp86_ = NULL; + ValaCCodeConstant* _tmp87_ = NULL; + ValaCCodeConstant* _tmp88_ = NULL; + _tmp84_ = vala_ccode_base_module_get_ccode (self); + _tmp85_ = _tmp84_; + _tmp86_ = target_destroy_notify; + _tmp87_ = vala_ccode_constant_new ("NULL"); + _tmp88_ = _tmp87_; + vala_ccode_function_add_assignment (_tmp85_, _tmp86_, (ValaCCodeExpression*) _tmp88_); + _vala_ccode_node_unref0 (_tmp88_); } _vala_ccode_node_unref0 (target_destroy_notify); + _vala_ccode_node_unref0 (target); } else { - ValaReferenceTransferExpression* _tmp68_ = NULL; - ValaExpression* _tmp69_ = NULL; - ValaExpression* _tmp70_ = NULL; - ValaDataType* _tmp71_ = NULL; - ValaDataType* _tmp72_ = NULL; - _tmp68_ = expr; - _tmp69_ = vala_reference_transfer_expression_get_inner (_tmp68_); - _tmp70_ = _tmp69_; - _tmp71_ = vala_expression_get_value_type (_tmp70_); - _tmp72_ = _tmp71_; - if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp72_, VALA_TYPE_ARRAY_TYPE)) { + ValaReferenceTransferExpression* _tmp89_ = NULL; + ValaExpression* _tmp90_ = NULL; + ValaExpression* _tmp91_ = NULL; + ValaDataType* _tmp92_ = NULL; + ValaDataType* _tmp93_ = NULL; + _tmp89_ = expr; + _tmp90_ = vala_reference_transfer_expression_get_inner (_tmp89_); + _tmp91_ = _tmp90_; + _tmp92_ = vala_expression_get_value_type (_tmp91_); + _tmp93_ = _tmp92_; + if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp93_, VALA_TYPE_ARRAY_TYPE)) { ValaArrayType* array_type = NULL; - ValaReferenceTransferExpression* _tmp73_ = NULL; - ValaExpression* _tmp74_ = NULL; - ValaExpression* _tmp75_ = NULL; - ValaDataType* _tmp76_ = NULL; - ValaDataType* _tmp77_ = NULL; - ValaArrayType* _tmp78_ = NULL; + ValaReferenceTransferExpression* _tmp94_ = NULL; + ValaExpression* _tmp95_ = NULL; + ValaExpression* _tmp96_ = NULL; + ValaDataType* _tmp97_ = NULL; + ValaDataType* _tmp98_ = NULL; + ValaArrayType* _tmp99_ = NULL; ValaGLibValue* glib_value = NULL; - ValaReferenceTransferExpression* _tmp79_ = NULL; - ValaExpression* _tmp80_ = NULL; - ValaExpression* _tmp81_ = NULL; - ValaTargetValue* _tmp82_ = NULL; - ValaTargetValue* _tmp83_ = NULL; - ValaGLibValue* _tmp84_ = NULL; - ValaCCodeFunction* _tmp85_ = NULL; - ValaCCodeFunction* _tmp86_ = NULL; - ValaReferenceTransferExpression* _tmp87_ = NULL; - ValaExpression* _tmp88_ = NULL; - ValaExpression* _tmp89_ = NULL; - ValaCCodeExpression* _tmp90_ = NULL; - ValaCCodeExpression* _tmp91_ = NULL; - ValaCCodeConstant* _tmp92_ = NULL; - ValaCCodeConstant* _tmp93_ = NULL; - ValaGLibValue* _tmp94_ = NULL; - ValaList* _tmp95_ = NULL; - _tmp73_ = expr; - _tmp74_ = vala_reference_transfer_expression_get_inner (_tmp73_); - _tmp75_ = _tmp74_; - _tmp76_ = vala_expression_get_value_type (_tmp75_); - _tmp77_ = _tmp76_; - _tmp78_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp77_, VALA_TYPE_ARRAY_TYPE, ValaArrayType)); - array_type = _tmp78_; - _tmp79_ = expr; - _tmp80_ = vala_reference_transfer_expression_get_inner (_tmp79_); - _tmp81_ = _tmp80_; - _tmp82_ = vala_expression_get_target_value (_tmp81_); - _tmp83_ = _tmp82_; - _tmp84_ = _vala_target_value_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp83_, VALA_TYPE_GLIB_VALUE, ValaGLibValue)); - glib_value = _tmp84_; - _tmp85_ = vala_ccode_base_module_get_ccode (self); - _tmp86_ = _tmp85_; - _tmp87_ = expr; - _tmp88_ = vala_reference_transfer_expression_get_inner (_tmp87_); - _tmp89_ = _tmp88_; - _tmp90_ = vala_ccode_base_module_get_cvalue (self, _tmp89_); - _tmp91_ = _tmp90_; - _tmp92_ = vala_ccode_constant_new ("NULL"); - _tmp93_ = _tmp92_; - vala_ccode_function_add_assignment (_tmp86_, _tmp91_, (ValaCCodeExpression*) _tmp93_); - _vala_ccode_node_unref0 (_tmp93_); - _vala_ccode_node_unref0 (_tmp91_); - _tmp94_ = glib_value; - _tmp95_ = _tmp94_->array_length_cvalues; - if (_tmp95_ != NULL) { + ValaReferenceTransferExpression* _tmp100_ = NULL; + ValaExpression* _tmp101_ = NULL; + ValaExpression* _tmp102_ = NULL; + ValaTargetValue* _tmp103_ = NULL; + ValaTargetValue* _tmp104_ = NULL; + ValaGLibValue* _tmp105_ = NULL; + ValaCCodeFunction* _tmp106_ = NULL; + ValaCCodeFunction* _tmp107_ = NULL; + ValaReferenceTransferExpression* _tmp108_ = NULL; + ValaExpression* _tmp109_ = NULL; + ValaExpression* _tmp110_ = NULL; + ValaCCodeExpression* _tmp111_ = NULL; + ValaCCodeExpression* _tmp112_ = NULL; + ValaCCodeConstant* _tmp113_ = NULL; + ValaCCodeConstant* _tmp114_ = NULL; + ValaGLibValue* _tmp115_ = NULL; + ValaList* _tmp116_ = NULL; + _tmp94_ = expr; + _tmp95_ = vala_reference_transfer_expression_get_inner (_tmp94_); + _tmp96_ = _tmp95_; + _tmp97_ = vala_expression_get_value_type (_tmp96_); + _tmp98_ = _tmp97_; + _tmp99_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp98_, VALA_TYPE_ARRAY_TYPE, ValaArrayType)); + array_type = _tmp99_; + _tmp100_ = expr; + _tmp101_ = vala_reference_transfer_expression_get_inner (_tmp100_); + _tmp102_ = _tmp101_; + _tmp103_ = vala_expression_get_target_value (_tmp102_); + _tmp104_ = _tmp103_; + _tmp105_ = _vala_target_value_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp104_, VALA_TYPE_GLIB_VALUE, ValaGLibValue)); + glib_value = _tmp105_; + _tmp106_ = vala_ccode_base_module_get_ccode (self); + _tmp107_ = _tmp106_; + _tmp108_ = expr; + _tmp109_ = vala_reference_transfer_expression_get_inner (_tmp108_); + _tmp110_ = _tmp109_; + _tmp111_ = vala_ccode_base_module_get_cvalue (self, _tmp110_); + _tmp112_ = _tmp111_; + _tmp113_ = vala_ccode_constant_new ("NULL"); + _tmp114_ = _tmp113_; + vala_ccode_function_add_assignment (_tmp107_, _tmp112_, (ValaCCodeExpression*) _tmp114_); + _vala_ccode_node_unref0 (_tmp114_); + _vala_ccode_node_unref0 (_tmp112_); + _tmp115_ = glib_value; + _tmp116_ = _tmp115_->array_length_cvalues; + if (_tmp116_ != NULL) { { gint dim = 0; dim = 1; { - gboolean _tmp96_ = FALSE; - _tmp96_ = TRUE; + gboolean _tmp117_ = FALSE; + _tmp117_ = TRUE; while (TRUE) { - gint _tmp98_ = 0; - ValaArrayType* _tmp99_ = NULL; - gint _tmp100_ = 0; - gint _tmp101_ = 0; - ValaCCodeFunction* _tmp102_ = NULL; - ValaCCodeFunction* _tmp103_ = NULL; - ValaGLibValue* _tmp104_ = NULL; - gint _tmp105_ = 0; - ValaCCodeExpression* _tmp106_ = NULL; - ValaCCodeExpression* _tmp107_ = NULL; - ValaCCodeConstant* _tmp108_ = NULL; - ValaCCodeConstant* _tmp109_ = NULL; - if (!_tmp96_) { - gint _tmp97_ = 0; - _tmp97_ = dim; - dim = _tmp97_ + 1; + gint _tmp119_ = 0; + ValaArrayType* _tmp120_ = NULL; + gint _tmp121_ = 0; + gint _tmp122_ = 0; + ValaCCodeFunction* _tmp123_ = NULL; + ValaCCodeFunction* _tmp124_ = NULL; + ValaGLibValue* _tmp125_ = NULL; + gint _tmp126_ = 0; + ValaCCodeExpression* _tmp127_ = NULL; + ValaCCodeExpression* _tmp128_ = NULL; + ValaCCodeConstant* _tmp129_ = NULL; + ValaCCodeConstant* _tmp130_ = NULL; + if (!_tmp117_) { + gint _tmp118_ = 0; + _tmp118_ = dim; + dim = _tmp118_ + 1; } - _tmp96_ = FALSE; - _tmp98_ = dim; - _tmp99_ = array_type; - _tmp100_ = vala_array_type_get_rank (_tmp99_); - _tmp101_ = _tmp100_; - if (!(_tmp98_ <= _tmp101_)) { + _tmp117_ = FALSE; + _tmp119_ = dim; + _tmp120_ = array_type; + _tmp121_ = vala_array_type_get_rank (_tmp120_); + _tmp122_ = _tmp121_; + if (!(_tmp119_ <= _tmp122_)) { break; } - _tmp102_ = vala_ccode_base_module_get_ccode (self); - _tmp103_ = _tmp102_; - _tmp104_ = glib_value; - _tmp105_ = dim; - _tmp106_ = vala_ccode_base_module_get_array_length_cvalue (self, (ValaTargetValue*) _tmp104_, _tmp105_); - _tmp107_ = _tmp106_; - _tmp108_ = vala_ccode_constant_new ("0"); - _tmp109_ = _tmp108_; - vala_ccode_function_add_assignment (_tmp103_, _tmp107_, (ValaCCodeExpression*) _tmp109_); - _vala_ccode_node_unref0 (_tmp109_); - _vala_ccode_node_unref0 (_tmp107_); + _tmp123_ = vala_ccode_base_module_get_ccode (self); + _tmp124_ = _tmp123_; + _tmp125_ = glib_value; + _tmp126_ = dim; + _tmp127_ = vala_ccode_base_module_get_array_length_cvalue (self, (ValaTargetValue*) _tmp125_, _tmp126_); + _tmp128_ = _tmp127_; + _tmp129_ = vala_ccode_constant_new ("0"); + _tmp130_ = _tmp129_; + vala_ccode_function_add_assignment (_tmp124_, _tmp128_, (ValaCCodeExpression*) _tmp130_); + _vala_ccode_node_unref0 (_tmp130_); + _vala_ccode_node_unref0 (_tmp128_); } } } @@ -31710,27 +31771,27 @@ _vala_target_value_unref0 (glib_value); _vala_code_node_unref0 (array_type); } else { - ValaCCodeFunction* _tmp110_ = NULL; - ValaCCodeFunction* _tmp111_ = NULL; - ValaReferenceTransferExpression* _tmp112_ = NULL; - ValaExpression* _tmp113_ = NULL; - ValaExpression* _tmp114_ = NULL; - ValaCCodeExpression* _tmp115_ = NULL; - ValaCCodeExpression* _tmp116_ = NULL; - ValaCCodeConstant* _tmp117_ = NULL; - ValaCCodeConstant* _tmp118_ = NULL; - _tmp110_ = vala_ccode_base_module_get_ccode (self); - _tmp111_ = _tmp110_; - _tmp112_ = expr; - _tmp113_ = vala_reference_transfer_expression_get_inner (_tmp112_); - _tmp114_ = _tmp113_; - _tmp115_ = vala_ccode_base_module_get_cvalue (self, _tmp114_); - _tmp116_ = _tmp115_; - _tmp117_ = vala_ccode_constant_new ("NULL"); - _tmp118_ = _tmp117_; - vala_ccode_function_add_assignment (_tmp111_, _tmp116_, (ValaCCodeExpression*) _tmp118_); - _vala_ccode_node_unref0 (_tmp118_); - _vala_ccode_node_unref0 (_tmp116_); + ValaCCodeFunction* _tmp131_ = NULL; + ValaCCodeFunction* _tmp132_ = NULL; + ValaReferenceTransferExpression* _tmp133_ = NULL; + ValaExpression* _tmp134_ = NULL; + ValaExpression* _tmp135_ = NULL; + ValaCCodeExpression* _tmp136_ = NULL; + ValaCCodeExpression* _tmp137_ = NULL; + ValaCCodeConstant* _tmp138_ = NULL; + ValaCCodeConstant* _tmp139_ = NULL; + _tmp131_ = vala_ccode_base_module_get_ccode (self); + _tmp132_ = _tmp131_; + _tmp133_ = expr; + _tmp134_ = vala_reference_transfer_expression_get_inner (_tmp133_); + _tmp135_ = _tmp134_; + _tmp136_ = vala_ccode_base_module_get_cvalue (self, _tmp135_); + _tmp137_ = _tmp136_; + _tmp138_ = vala_ccode_constant_new ("NULL"); + _tmp139_ = _tmp138_; + vala_ccode_function_add_assignment (_tmp132_, _tmp137_, (ValaCCodeExpression*) _tmp139_); + _vala_ccode_node_unref0 (_tmp139_); + _vala_ccode_node_unref0 (_tmp137_); } } } @@ -35723,44 +35784,44 @@ void vala_ccode_base_module_store_property (ValaCCodeBaseModule* self, ValaProperty* prop, ValaExpression* instance, ValaTargetValue* value) { ValaExpression* _tmp0_ = NULL; gchar* set_func = NULL; - gchar* _tmp90_ = NULL; + gchar* _tmp102_ = NULL; ValaProperty* base_property = NULL; - ValaProperty* _tmp91_ = NULL; - ValaProperty* _tmp92_ = NULL; - ValaProperty* _tmp93_ = NULL; - gboolean _tmp94_ = FALSE; + ValaProperty* _tmp103_ = NULL; + ValaProperty* _tmp104_ = NULL; + ValaProperty* _tmp105_ = NULL; + gboolean _tmp106_ = FALSE; ValaCCodeFunctionCall* ccall = NULL; - const gchar* _tmp130_ = NULL; - ValaCCodeIdentifier* _tmp131_ = NULL; - ValaCCodeIdentifier* _tmp132_ = NULL; - ValaCCodeFunctionCall* _tmp133_ = NULL; - ValaCCodeFunctionCall* _tmp134_ = NULL; - ValaProperty* _tmp135_ = NULL; - ValaMemberBinding _tmp136_ = 0; - ValaMemberBinding _tmp137_ = 0; - ValaProperty* _tmp163_ = NULL; - gboolean _tmp164_ = FALSE; + const gchar* _tmp142_ = NULL; + ValaCCodeIdentifier* _tmp143_ = NULL; + ValaCCodeIdentifier* _tmp144_ = NULL; + ValaCCodeFunctionCall* _tmp145_ = NULL; + ValaCCodeFunctionCall* _tmp146_ = NULL; + ValaProperty* _tmp147_ = NULL; + ValaMemberBinding _tmp148_ = 0; + ValaMemberBinding _tmp149_ = 0; + ValaProperty* _tmp175_ = NULL; + gboolean _tmp176_ = FALSE; ValaCCodeExpression* cexpr = NULL; - ValaTargetValue* _tmp169_ = NULL; - ValaCCodeExpression* _tmp170_ = NULL; - ValaProperty* _tmp171_ = NULL; - ValaDataType* _tmp172_ = NULL; - ValaDataType* _tmp173_ = NULL; - gboolean _tmp174_ = FALSE; - ValaArrayType* array_type = NULL; - ValaProperty* _tmp177_ = NULL; - ValaDataType* _tmp178_ = NULL; - ValaDataType* _tmp179_ = NULL; - ValaArrayType* _tmp180_ = NULL; - ValaCCodeFunctionCall* _tmp181_ = NULL; + ValaTargetValue* _tmp181_ = NULL; ValaCCodeExpression* _tmp182_ = NULL; - gboolean _tmp183_ = FALSE; - ValaArrayType* _tmp184_ = NULL; - ValaProperty* _tmp225_ = NULL; - gboolean _tmp226_ = FALSE; - ValaCCodeFunction* _tmp230_ = NULL; - ValaCCodeFunction* _tmp231_ = NULL; - ValaCCodeFunctionCall* _tmp232_ = NULL; + ValaProperty* _tmp183_ = NULL; + ValaDataType* _tmp184_ = NULL; + ValaDataType* _tmp185_ = NULL; + gboolean _tmp186_ = FALSE; + ValaArrayType* array_type = NULL; + ValaProperty* _tmp189_ = NULL; + ValaDataType* _tmp190_ = NULL; + ValaDataType* _tmp191_ = NULL; + ValaArrayType* _tmp192_ = NULL; + ValaCCodeFunctionCall* _tmp193_ = NULL; + ValaCCodeExpression* _tmp194_ = NULL; + gboolean _tmp195_ = FALSE; + ValaArrayType* _tmp196_ = NULL; + ValaProperty* _tmp237_ = NULL; + gboolean _tmp238_ = FALSE; + ValaCCodeFunction* _tmp242_ = NULL; + ValaCCodeFunction* _tmp243_ = NULL; + ValaCCodeFunctionCall* _tmp244_ = NULL; g_return_if_fail (self != NULL); g_return_if_fail (prop != NULL); g_return_if_fail (value != NULL); @@ -35814,13 +35875,18 @@ ValaExpression* _tmp39_ = NULL; ValaCCodeExpression* _tmp40_ = NULL; ValaCCodeExpression* _tmp41_ = NULL; - ValaCCodeFunctionCall* _tmp42_ = NULL; - ValaTargetValue* _tmp43_ = NULL; - ValaCCodeExpression* _tmp44_ = NULL; - ValaCCodeExpression* _tmp45_ = NULL; - ValaCCodeFunction* _tmp46_ = NULL; - ValaCCodeFunction* _tmp47_ = NULL; - ValaCCodeFunctionCall* _tmp48_ = NULL; + ValaCCodeExpression* cexpr = NULL; + ValaTargetValue* _tmp42_ = NULL; + ValaCCodeExpression* _tmp43_ = NULL; + ValaProperty* _tmp44_ = NULL; + ValaDataType* _tmp45_ = NULL; + ValaDataType* _tmp46_ = NULL; + gboolean _tmp47_ = FALSE; + ValaCCodeFunctionCall* _tmp50_ = NULL; + ValaCCodeExpression* _tmp51_ = NULL; + ValaCCodeFunction* _tmp52_ = NULL; + ValaCCodeFunction* _tmp53_ = NULL; + ValaCCodeFunctionCall* _tmp54_ = NULL; _tmp4_ = prop; _tmp5_ = vala_property_get_base_property (_tmp4_); _tmp6_ = _tmp5_; @@ -35873,119 +35939,150 @@ _tmp41_ = G_TYPE_CHECK_INSTANCE_CAST (_tmp40_, VALA_TYPE_CCODE_EXPRESSION, ValaCCodeExpression); vala_ccode_function_call_add_argument (_tmp38_, _tmp41_); _vala_ccode_node_unref0 (_tmp41_); - _tmp42_ = ccall; - _tmp43_ = value; - _tmp44_ = vala_ccode_base_module_get_cvalue_ (self, _tmp43_); - _tmp45_ = _tmp44_; - vala_ccode_function_call_add_argument (_tmp42_, _tmp45_); - _vala_ccode_node_unref0 (_tmp45_); - _tmp46_ = vala_ccode_base_module_get_ccode (self); - _tmp47_ = _tmp46_; - _tmp48_ = ccall; - vala_ccode_function_add_expression (_tmp47_, (ValaCCodeExpression*) _tmp48_); + _tmp42_ = value; + _tmp43_ = vala_ccode_base_module_get_cvalue_ (self, _tmp42_); + cexpr = _tmp43_; + _tmp44_ = prop; + _tmp45_ = vala_property_get_property_type (_tmp44_); + _tmp46_ = _tmp45_; + _tmp47_ = vala_data_type_is_real_non_null_struct_type (_tmp46_); + if (_tmp47_) { + ValaCCodeExpression* _tmp48_ = NULL; + ValaCCodeUnaryExpression* _tmp49_ = NULL; + _tmp48_ = cexpr; + _tmp49_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, _tmp48_); + _vala_ccode_node_unref0 (cexpr); + cexpr = (ValaCCodeExpression*) _tmp49_; + } + _tmp50_ = ccall; + _tmp51_ = cexpr; + vala_ccode_function_call_add_argument (_tmp50_, _tmp51_); + _tmp52_ = vala_ccode_base_module_get_ccode (self); + _tmp53_ = _tmp52_; + _tmp54_ = ccall; + vala_ccode_function_add_expression (_tmp53_, (ValaCCodeExpression*) _tmp54_); + _vala_ccode_node_unref0 (cexpr); _vala_ccode_node_unref0 (ccall); _vala_ccode_node_unref0 (vcast); _vala_code_node_unref0 (base_class); } else { - ValaProperty* _tmp49_ = NULL; - ValaProperty* _tmp50_ = NULL; - ValaProperty* _tmp51_ = NULL; - _tmp49_ = prop; - _tmp50_ = vala_property_get_base_interface_property (_tmp49_); - _tmp51_ = _tmp50_; - if (_tmp51_ != NULL) { + ValaProperty* _tmp55_ = NULL; + ValaProperty* _tmp56_ = NULL; + ValaProperty* _tmp57_ = NULL; + _tmp55_ = prop; + _tmp56_ = vala_property_get_base_interface_property (_tmp55_); + _tmp57_ = _tmp56_; + if (_tmp57_ != NULL) { ValaInterface* base_iface = NULL; - ValaProperty* _tmp52_ = NULL; - ValaProperty* _tmp53_ = NULL; - ValaProperty* _tmp54_ = NULL; - ValaSymbol* _tmp55_ = NULL; - ValaSymbol* _tmp56_ = NULL; - ValaInterface* _tmp57_ = NULL; + ValaProperty* _tmp58_ = NULL; + ValaProperty* _tmp59_ = NULL; + ValaProperty* _tmp60_ = NULL; + ValaSymbol* _tmp61_ = NULL; + ValaSymbol* _tmp62_ = NULL; + ValaInterface* _tmp63_ = NULL; gchar* parent_iface_var = NULL; - ValaClass* _tmp58_ = NULL; - ValaClass* _tmp59_ = NULL; - gchar* _tmp60_ = NULL; - gchar* _tmp61_ = NULL; - ValaInterface* _tmp62_ = NULL; - gchar* _tmp63_ = NULL; - gchar* _tmp64_ = NULL; - gchar* _tmp65_ = NULL; + ValaClass* _tmp64_ = NULL; + ValaClass* _tmp65_ = NULL; gchar* _tmp66_ = NULL; + gchar* _tmp67_ = NULL; + ValaInterface* _tmp68_ = NULL; + gchar* _tmp69_ = NULL; + gchar* _tmp70_ = NULL; + gchar* _tmp71_ = NULL; + gchar* _tmp72_ = NULL; ValaCCodeFunctionCall* ccall = NULL; - const gchar* _tmp67_ = NULL; - ValaCCodeIdentifier* _tmp68_ = NULL; - ValaCCodeIdentifier* _tmp69_ = NULL; - ValaProperty* _tmp70_ = NULL; - const gchar* _tmp71_ = NULL; - const gchar* _tmp72_ = NULL; - gchar* _tmp73_ = NULL; - gchar* _tmp74_ = NULL; - ValaCCodeMemberAccess* _tmp75_ = NULL; - ValaCCodeMemberAccess* _tmp76_ = NULL; - ValaCCodeFunctionCall* _tmp77_ = NULL; - ValaCCodeFunctionCall* _tmp78_ = NULL; - ValaCCodeFunctionCall* _tmp79_ = NULL; - ValaExpression* _tmp80_ = NULL; - ValaCCodeExpression* _tmp81_ = NULL; - ValaCCodeExpression* _tmp82_ = NULL; + const gchar* _tmp73_ = NULL; + ValaCCodeIdentifier* _tmp74_ = NULL; + ValaCCodeIdentifier* _tmp75_ = NULL; + ValaProperty* _tmp76_ = NULL; + const gchar* _tmp77_ = NULL; + const gchar* _tmp78_ = NULL; + gchar* _tmp79_ = NULL; + gchar* _tmp80_ = NULL; + ValaCCodeMemberAccess* _tmp81_ = NULL; + ValaCCodeMemberAccess* _tmp82_ = NULL; ValaCCodeFunctionCall* _tmp83_ = NULL; - ValaTargetValue* _tmp84_ = NULL; - ValaCCodeExpression* _tmp85_ = NULL; - ValaCCodeExpression* _tmp86_ = NULL; - ValaCCodeFunction* _tmp87_ = NULL; - ValaCCodeFunction* _tmp88_ = NULL; - ValaCCodeFunctionCall* _tmp89_ = NULL; - _tmp52_ = prop; - _tmp53_ = vala_property_get_base_interface_property (_tmp52_); - _tmp54_ = _tmp53_; - _tmp55_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp54_); - _tmp56_ = _tmp55_; - _tmp57_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp56_, VALA_TYPE_INTERFACE, ValaInterface)); - base_iface = _tmp57_; - _tmp58_ = vala_ccode_base_module_get_current_class (self); - _tmp59_ = _tmp58_; - _tmp60_ = vala_ccode_base_module_get_ccode_lower_case_name ((ValaCodeNode*) _tmp59_, NULL); - _tmp61_ = _tmp60_; - _tmp62_ = base_iface; - _tmp63_ = vala_ccode_base_module_get_ccode_lower_case_name ((ValaCodeNode*) _tmp62_, NULL); - _tmp64_ = _tmp63_; - _tmp65_ = g_strdup_printf ("%s_%s_parent_iface", _tmp61_, _tmp64_); - _tmp66_ = _tmp65_; - _g_free0 (_tmp64_); - _g_free0 (_tmp61_); - parent_iface_var = _tmp66_; - _tmp67_ = parent_iface_var; - _tmp68_ = vala_ccode_identifier_new (_tmp67_); - _tmp69_ = _tmp68_; - _tmp70_ = prop; - _tmp71_ = vala_symbol_get_name ((ValaSymbol*) _tmp70_); + ValaCCodeFunctionCall* _tmp84_ = NULL; + ValaCCodeFunctionCall* _tmp85_ = NULL; + ValaExpression* _tmp86_ = NULL; + ValaCCodeExpression* _tmp87_ = NULL; + ValaCCodeExpression* _tmp88_ = NULL; + ValaCCodeExpression* cexpr = NULL; + ValaTargetValue* _tmp89_ = NULL; + ValaCCodeExpression* _tmp90_ = NULL; + ValaProperty* _tmp91_ = NULL; + ValaDataType* _tmp92_ = NULL; + ValaDataType* _tmp93_ = NULL; + gboolean _tmp94_ = FALSE; + ValaCCodeFunctionCall* _tmp97_ = NULL; + ValaCCodeExpression* _tmp98_ = NULL; + ValaCCodeFunction* _tmp99_ = NULL; + ValaCCodeFunction* _tmp100_ = NULL; + ValaCCodeFunctionCall* _tmp101_ = NULL; + _tmp58_ = prop; + _tmp59_ = vala_property_get_base_interface_property (_tmp58_); + _tmp60_ = _tmp59_; + _tmp61_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp60_); + _tmp62_ = _tmp61_; + _tmp63_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp62_, VALA_TYPE_INTERFACE, ValaInterface)); + base_iface = _tmp63_; + _tmp64_ = vala_ccode_base_module_get_current_class (self); + _tmp65_ = _tmp64_; + _tmp66_ = vala_ccode_base_module_get_ccode_lower_case_name ((ValaCodeNode*) _tmp65_, NULL); + _tmp67_ = _tmp66_; + _tmp68_ = base_iface; + _tmp69_ = vala_ccode_base_module_get_ccode_lower_case_name ((ValaCodeNode*) _tmp68_, NULL); + _tmp70_ = _tmp69_; + _tmp71_ = g_strdup_printf ("%s_%s_parent_iface", _tmp67_, _tmp70_); _tmp72_ = _tmp71_; - _tmp73_ = g_strdup_printf ("set_%s", _tmp72_); - _tmp74_ = _tmp73_; - _tmp75_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp69_, _tmp74_); - _tmp76_ = _tmp75_; - _tmp77_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp76_); + _g_free0 (_tmp70_); + _g_free0 (_tmp67_); + parent_iface_var = _tmp72_; + _tmp73_ = parent_iface_var; + _tmp74_ = vala_ccode_identifier_new (_tmp73_); + _tmp75_ = _tmp74_; + _tmp76_ = prop; + _tmp77_ = vala_symbol_get_name ((ValaSymbol*) _tmp76_); _tmp78_ = _tmp77_; - _vala_ccode_node_unref0 (_tmp76_); - _g_free0 (_tmp74_); - _vala_ccode_node_unref0 (_tmp69_); - ccall = _tmp78_; - _tmp79_ = ccall; - _tmp80_ = instance; - _tmp81_ = vala_ccode_base_module_get_ccodenode (self, _tmp80_); - _tmp82_ = G_TYPE_CHECK_INSTANCE_CAST (_tmp81_, VALA_TYPE_CCODE_EXPRESSION, ValaCCodeExpression); - vala_ccode_function_call_add_argument (_tmp79_, _tmp82_); + _tmp79_ = g_strdup_printf ("set_%s", _tmp78_); + _tmp80_ = _tmp79_; + _tmp81_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp75_, _tmp80_); + _tmp82_ = _tmp81_; + _tmp83_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp82_); + _tmp84_ = _tmp83_; _vala_ccode_node_unref0 (_tmp82_); - _tmp83_ = ccall; - _tmp84_ = value; - _tmp85_ = vala_ccode_base_module_get_cvalue_ (self, _tmp84_); - _tmp86_ = _tmp85_; - vala_ccode_function_call_add_argument (_tmp83_, _tmp86_); - _vala_ccode_node_unref0 (_tmp86_); - _tmp87_ = vala_ccode_base_module_get_ccode (self); - _tmp88_ = _tmp87_; - _tmp89_ = ccall; - vala_ccode_function_add_expression (_tmp88_, (ValaCCodeExpression*) _tmp89_); + _g_free0 (_tmp80_); + _vala_ccode_node_unref0 (_tmp75_); + ccall = _tmp84_; + _tmp85_ = ccall; + _tmp86_ = instance; + _tmp87_ = vala_ccode_base_module_get_ccodenode (self, _tmp86_); + _tmp88_ = G_TYPE_CHECK_INSTANCE_CAST (_tmp87_, VALA_TYPE_CCODE_EXPRESSION, ValaCCodeExpression); + vala_ccode_function_call_add_argument (_tmp85_, _tmp88_); + _vala_ccode_node_unref0 (_tmp88_); + _tmp89_ = value; + _tmp90_ = vala_ccode_base_module_get_cvalue_ (self, _tmp89_); + cexpr = _tmp90_; + _tmp91_ = prop; + _tmp92_ = vala_property_get_property_type (_tmp91_); + _tmp93_ = _tmp92_; + _tmp94_ = vala_data_type_is_real_non_null_struct_type (_tmp93_); + if (_tmp94_) { + ValaCCodeExpression* _tmp95_ = NULL; + ValaCCodeUnaryExpression* _tmp96_ = NULL; + _tmp95_ = cexpr; + _tmp96_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, _tmp95_); + _vala_ccode_node_unref0 (cexpr); + cexpr = (ValaCCodeExpression*) _tmp96_; + } + _tmp97_ = ccall; + _tmp98_ = cexpr; + vala_ccode_function_call_add_argument (_tmp97_, _tmp98_); + _tmp99_ = vala_ccode_base_module_get_ccode (self); + _tmp100_ = _tmp99_; + _tmp101_ = ccall; + vala_ccode_function_add_expression (_tmp100_, (ValaCCodeExpression*) _tmp101_); + _vala_ccode_node_unref0 (cexpr); _vala_ccode_node_unref0 (ccall); _g_free0 (parent_iface_var); _vala_code_node_unref0 (base_iface); @@ -35993,365 +36090,365 @@ } return; } - _tmp90_ = g_strdup ("g_object_set"); - set_func = _tmp90_; - _tmp91_ = prop; - _tmp92_ = _vala_code_node_ref0 (_tmp91_); - base_property = _tmp92_; - _tmp93_ = prop; - _tmp94_ = vala_ccode_base_module_get_ccode_no_accessor_method (_tmp93_); - if (!_tmp94_) { - ValaProperty* _tmp95_ = NULL; - ValaProperty* _tmp96_ = NULL; - ValaProperty* _tmp97_ = NULL; + _tmp102_ = g_strdup ("g_object_set"); + set_func = _tmp102_; + _tmp103_ = prop; + _tmp104_ = _vala_code_node_ref0 (_tmp103_); + base_property = _tmp104_; + _tmp105_ = prop; + _tmp106_ = vala_ccode_base_module_get_ccode_no_accessor_method (_tmp105_); + if (!_tmp106_) { + ValaProperty* _tmp107_ = NULL; + ValaProperty* _tmp108_ = NULL; ValaProperty* _tmp109_ = NULL; - _tmp95_ = prop; - _tmp96_ = vala_property_get_base_property (_tmp95_); - _tmp97_ = _tmp96_; - if (_tmp97_ != NULL) { - ValaProperty* _tmp98_ = NULL; - ValaProperty* _tmp99_ = NULL; - ValaProperty* _tmp100_ = NULL; - ValaProperty* _tmp101_ = NULL; - _tmp98_ = prop; - _tmp99_ = vala_property_get_base_property (_tmp98_); - _tmp100_ = _tmp99_; - _tmp101_ = _vala_code_node_ref0 (_tmp100_); + ValaProperty* _tmp121_ = NULL; + _tmp107_ = prop; + _tmp108_ = vala_property_get_base_property (_tmp107_); + _tmp109_ = _tmp108_; + if (_tmp109_ != NULL) { + ValaProperty* _tmp110_ = NULL; + ValaProperty* _tmp111_ = NULL; + ValaProperty* _tmp112_ = NULL; + ValaProperty* _tmp113_ = NULL; + _tmp110_ = prop; + _tmp111_ = vala_property_get_base_property (_tmp110_); + _tmp112_ = _tmp111_; + _tmp113_ = _vala_code_node_ref0 (_tmp112_); _vala_code_node_unref0 (base_property); - base_property = _tmp101_; + base_property = _tmp113_; } else { - ValaProperty* _tmp102_ = NULL; - ValaProperty* _tmp103_ = NULL; - ValaProperty* _tmp104_ = NULL; - _tmp102_ = prop; - _tmp103_ = vala_property_get_base_interface_property (_tmp102_); - _tmp104_ = _tmp103_; - if (_tmp104_ != NULL) { - ValaProperty* _tmp105_ = NULL; - ValaProperty* _tmp106_ = NULL; - ValaProperty* _tmp107_ = NULL; - ValaProperty* _tmp108_ = NULL; - _tmp105_ = prop; - _tmp106_ = vala_property_get_base_interface_property (_tmp105_); - _tmp107_ = _tmp106_; - _tmp108_ = _vala_code_node_ref0 (_tmp107_); + ValaProperty* _tmp114_ = NULL; + ValaProperty* _tmp115_ = NULL; + ValaProperty* _tmp116_ = NULL; + _tmp114_ = prop; + _tmp115_ = vala_property_get_base_interface_property (_tmp114_); + _tmp116_ = _tmp115_; + if (_tmp116_ != NULL) { + ValaProperty* _tmp117_ = NULL; + ValaProperty* _tmp118_ = NULL; + ValaProperty* _tmp119_ = NULL; + ValaProperty* _tmp120_ = NULL; + _tmp117_ = prop; + _tmp118_ = vala_property_get_base_interface_property (_tmp117_); + _tmp119_ = _tmp118_; + _tmp120_ = _vala_code_node_ref0 (_tmp119_); _vala_code_node_unref0 (base_property); - base_property = _tmp108_; + base_property = _tmp120_; } } - _tmp109_ = prop; - if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp109_, VALA_TYPE_DYNAMIC_PROPERTY)) { - ValaProperty* _tmp110_ = NULL; - gchar* _tmp111_ = NULL; - _tmp110_ = prop; - _tmp111_ = vala_ccode_base_module_get_dynamic_property_setter_cname (self, G_TYPE_CHECK_INSTANCE_CAST (_tmp110_, VALA_TYPE_DYNAMIC_PROPERTY, ValaDynamicProperty)); + _tmp121_ = prop; + if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp121_, VALA_TYPE_DYNAMIC_PROPERTY)) { + ValaProperty* _tmp122_ = NULL; + gchar* _tmp123_ = NULL; + _tmp122_ = prop; + _tmp123_ = vala_ccode_base_module_get_dynamic_property_setter_cname (self, G_TYPE_CHECK_INSTANCE_CAST (_tmp122_, VALA_TYPE_DYNAMIC_PROPERTY, ValaDynamicProperty)); _g_free0 (set_func); - set_func = _tmp111_; + set_func = _tmp123_; } else { - ValaProperty* _tmp112_ = NULL; - ValaPropertyAccessor* _tmp113_ = NULL; - ValaPropertyAccessor* _tmp114_ = NULL; - ValaCCodeFile* _tmp115_ = NULL; - ValaProperty* _tmp116_ = NULL; - ValaPropertyAccessor* _tmp117_ = NULL; - ValaPropertyAccessor* _tmp118_ = NULL; - gchar* _tmp119_ = NULL; - gboolean _tmp120_ = FALSE; - ValaProperty* _tmp121_ = NULL; - gboolean _tmp122_ = FALSE; - gboolean _tmp123_ = FALSE; - _tmp112_ = base_property; - _tmp113_ = vala_property_get_set_accessor (_tmp112_); - _tmp114_ = _tmp113_; - _tmp115_ = self->cfile; - vala_ccode_base_module_generate_property_accessor_declaration (self, _tmp114_, _tmp115_); - _tmp116_ = base_property; - _tmp117_ = vala_property_get_set_accessor (_tmp116_); - _tmp118_ = _tmp117_; - _tmp119_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp118_); + ValaProperty* _tmp124_ = NULL; + ValaPropertyAccessor* _tmp125_ = NULL; + ValaPropertyAccessor* _tmp126_ = NULL; + ValaCCodeFile* _tmp127_ = NULL; + ValaProperty* _tmp128_ = NULL; + ValaPropertyAccessor* _tmp129_ = NULL; + ValaPropertyAccessor* _tmp130_ = NULL; + gchar* _tmp131_ = NULL; + gboolean _tmp132_ = FALSE; + ValaProperty* _tmp133_ = NULL; + gboolean _tmp134_ = FALSE; + gboolean _tmp135_ = FALSE; + _tmp124_ = base_property; + _tmp125_ = vala_property_get_set_accessor (_tmp124_); + _tmp126_ = _tmp125_; + _tmp127_ = self->cfile; + vala_ccode_base_module_generate_property_accessor_declaration (self, _tmp126_, _tmp127_); + _tmp128_ = base_property; + _tmp129_ = vala_property_get_set_accessor (_tmp128_); + _tmp130_ = _tmp129_; + _tmp131_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp130_); _g_free0 (set_func); - set_func = _tmp119_; - _tmp121_ = prop; - _tmp122_ = vala_symbol_get_external ((ValaSymbol*) _tmp121_); - _tmp123_ = _tmp122_; - if (!_tmp123_) { - ValaProperty* _tmp124_ = NULL; - gboolean _tmp125_ = FALSE; - gboolean _tmp126_ = FALSE; - _tmp124_ = prop; - _tmp125_ = vala_symbol_get_external_package ((ValaSymbol*) _tmp124_); - _tmp126_ = _tmp125_; - _tmp120_ = _tmp126_; - } else { - _tmp120_ = FALSE; - } - if (_tmp120_) { - ValaProperty* _tmp127_ = NULL; - gboolean _tmp128_ = FALSE; - _tmp127_ = prop; - _tmp128_ = vala_ccode_base_module_add_generated_external_symbol (self, (ValaSymbol*) _tmp127_); - if (_tmp128_) { - ValaProperty* _tmp129_ = NULL; - _tmp129_ = prop; - vala_code_visitor_visit_property ((ValaCodeVisitor*) self, _tmp129_); + set_func = _tmp131_; + _tmp133_ = prop; + _tmp134_ = vala_symbol_get_external ((ValaSymbol*) _tmp133_); + _tmp135_ = _tmp134_; + if (!_tmp135_) { + ValaProperty* _tmp136_ = NULL; + gboolean _tmp137_ = FALSE; + gboolean _tmp138_ = FALSE; + _tmp136_ = prop; + _tmp137_ = vala_symbol_get_external_package ((ValaSymbol*) _tmp136_); + _tmp138_ = _tmp137_; + _tmp132_ = _tmp138_; + } else { + _tmp132_ = FALSE; + } + if (_tmp132_) { + ValaProperty* _tmp139_ = NULL; + gboolean _tmp140_ = FALSE; + _tmp139_ = prop; + _tmp140_ = vala_ccode_base_module_add_generated_external_symbol (self, (ValaSymbol*) _tmp139_); + if (_tmp140_) { + ValaProperty* _tmp141_ = NULL; + _tmp141_ = prop; + vala_code_visitor_visit_property ((ValaCodeVisitor*) self, _tmp141_); } } } } - _tmp130_ = set_func; - _tmp131_ = vala_ccode_identifier_new (_tmp130_); - _tmp132_ = _tmp131_; - _tmp133_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp132_); - _tmp134_ = _tmp133_; - _vala_ccode_node_unref0 (_tmp132_); - ccall = _tmp134_; - _tmp135_ = prop; - _tmp136_ = vala_property_get_binding (_tmp135_); - _tmp137_ = _tmp136_; - if (_tmp137_ == VALA_MEMBER_BINDING_INSTANCE) { + _tmp142_ = set_func; + _tmp143_ = vala_ccode_identifier_new (_tmp142_); + _tmp144_ = _tmp143_; + _tmp145_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp144_); + _tmp146_ = _tmp145_; + _vala_ccode_node_unref0 (_tmp144_); + ccall = _tmp146_; + _tmp147_ = prop; + _tmp148_ = vala_property_get_binding (_tmp147_); + _tmp149_ = _tmp148_; + if (_tmp149_ == VALA_MEMBER_BINDING_INSTANCE) { ValaCCodeExpression* cinstance = NULL; - ValaExpression* _tmp138_ = NULL; - ValaCCodeExpression* _tmp139_ = NULL; - gboolean _tmp140_ = FALSE; - ValaProperty* _tmp141_ = NULL; - ValaSymbol* _tmp142_ = NULL; - ValaSymbol* _tmp143_ = NULL; - ValaCCodeFunctionCall* _tmp161_ = NULL; - ValaCCodeExpression* _tmp162_ = NULL; - _tmp138_ = instance; - _tmp139_ = vala_ccode_base_module_get_ccodenode (self, _tmp138_); - cinstance = G_TYPE_CHECK_INSTANCE_CAST (_tmp139_, VALA_TYPE_CCODE_EXPRESSION, ValaCCodeExpression); - _tmp141_ = prop; - _tmp142_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp141_); - _tmp143_ = _tmp142_; - if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp143_, VALA_TYPE_STRUCT)) { - ValaProperty* _tmp144_ = NULL; - ValaSymbol* _tmp145_ = NULL; - ValaSymbol* _tmp146_ = NULL; - gboolean _tmp147_ = FALSE; - _tmp144_ = prop; - _tmp145_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp144_); - _tmp146_ = _tmp145_; - _tmp147_ = vala_struct_is_simple_type (G_TYPE_CHECK_INSTANCE_CAST (_tmp146_, VALA_TYPE_STRUCT, ValaStruct)); - _tmp140_ = !_tmp147_; + ValaExpression* _tmp150_ = NULL; + ValaCCodeExpression* _tmp151_ = NULL; + gboolean _tmp152_ = FALSE; + ValaProperty* _tmp153_ = NULL; + ValaSymbol* _tmp154_ = NULL; + ValaSymbol* _tmp155_ = NULL; + ValaCCodeFunctionCall* _tmp173_ = NULL; + ValaCCodeExpression* _tmp174_ = NULL; + _tmp150_ = instance; + _tmp151_ = vala_ccode_base_module_get_ccodenode (self, _tmp150_); + cinstance = G_TYPE_CHECK_INSTANCE_CAST (_tmp151_, VALA_TYPE_CCODE_EXPRESSION, ValaCCodeExpression); + _tmp153_ = prop; + _tmp154_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp153_); + _tmp155_ = _tmp154_; + if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp155_, VALA_TYPE_STRUCT)) { + ValaProperty* _tmp156_ = NULL; + ValaSymbol* _tmp157_ = NULL; + ValaSymbol* _tmp158_ = NULL; + gboolean _tmp159_ = FALSE; + _tmp156_ = prop; + _tmp157_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp156_); + _tmp158_ = _tmp157_; + _tmp159_ = vala_struct_is_simple_type (G_TYPE_CHECK_INSTANCE_CAST (_tmp158_, VALA_TYPE_STRUCT, ValaStruct)); + _tmp152_ = !_tmp159_; } else { - _tmp140_ = FALSE; + _tmp152_ = FALSE; } - if (_tmp140_) { + if (_tmp152_) { ValaTargetValue* instance_value = NULL; - ValaExpression* _tmp148_ = NULL; - ValaTargetValue* _tmp149_ = NULL; - ValaTargetValue* _tmp150_ = NULL; - ValaTargetValue* _tmp151_ = NULL; - ValaTargetValue* _tmp152_ = NULL; - gboolean _tmp153_ = FALSE; - ValaTargetValue* _tmp157_ = NULL; - ValaCCodeExpression* _tmp158_ = NULL; - ValaCCodeExpression* _tmp159_ = NULL; - ValaCCodeUnaryExpression* _tmp160_ = NULL; - _tmp148_ = instance; - _tmp149_ = vala_expression_get_target_value (_tmp148_); - _tmp150_ = _tmp149_; - _tmp151_ = _vala_target_value_ref0 (_tmp150_); - instance_value = _tmp151_; - _tmp152_ = instance_value; - _tmp153_ = vala_ccode_base_module_get_lvalue (self, _tmp152_); - if (!_tmp153_) { - ValaTargetValue* _tmp154_ = NULL; - ValaExpression* _tmp155_ = NULL; - ValaTargetValue* _tmp156_ = NULL; - _tmp154_ = instance_value; - _tmp155_ = instance; - _tmp156_ = vala_ccode_base_module_store_temp_value (self, _tmp154_, (ValaCodeNode*) _tmp155_, NULL); + ValaExpression* _tmp160_ = NULL; + ValaTargetValue* _tmp161_ = NULL; + ValaTargetValue* _tmp162_ = NULL; + ValaTargetValue* _tmp163_ = NULL; + ValaTargetValue* _tmp164_ = NULL; + gboolean _tmp165_ = FALSE; + ValaTargetValue* _tmp169_ = NULL; + ValaCCodeExpression* _tmp170_ = NULL; + ValaCCodeExpression* _tmp171_ = NULL; + ValaCCodeUnaryExpression* _tmp172_ = NULL; + _tmp160_ = instance; + _tmp161_ = vala_expression_get_target_value (_tmp160_); + _tmp162_ = _tmp161_; + _tmp163_ = _vala_target_value_ref0 (_tmp162_); + instance_value = _tmp163_; + _tmp164_ = instance_value; + _tmp165_ = vala_ccode_base_module_get_lvalue (self, _tmp164_); + if (!_tmp165_) { + ValaTargetValue* _tmp166_ = NULL; + ValaExpression* _tmp167_ = NULL; + ValaTargetValue* _tmp168_ = NULL; + _tmp166_ = instance_value; + _tmp167_ = instance; + _tmp168_ = vala_ccode_base_module_store_temp_value (self, _tmp166_, (ValaCodeNode*) _tmp167_, NULL); _vala_target_value_unref0 (instance_value); - instance_value = _tmp156_; + instance_value = _tmp168_; } - _tmp157_ = instance_value; - _tmp158_ = vala_ccode_base_module_get_cvalue_ (self, _tmp157_); - _tmp159_ = _tmp158_; - _tmp160_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, _tmp159_); + _tmp169_ = instance_value; + _tmp170_ = vala_ccode_base_module_get_cvalue_ (self, _tmp169_); + _tmp171_ = _tmp170_; + _tmp172_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, _tmp171_); _vala_ccode_node_unref0 (cinstance); - cinstance = (ValaCCodeExpression*) _tmp160_; - _vala_ccode_node_unref0 (_tmp159_); + cinstance = (ValaCCodeExpression*) _tmp172_; + _vala_ccode_node_unref0 (_tmp171_); _vala_target_value_unref0 (instance_value); } - _tmp161_ = ccall; - _tmp162_ = cinstance; - vala_ccode_function_call_add_argument (_tmp161_, _tmp162_); + _tmp173_ = ccall; + _tmp174_ = cinstance; + vala_ccode_function_call_add_argument (_tmp173_, _tmp174_); _vala_ccode_node_unref0 (cinstance); } - _tmp163_ = prop; - _tmp164_ = vala_ccode_base_module_get_ccode_no_accessor_method (_tmp163_); - if (_tmp164_) { - ValaCCodeFunctionCall* _tmp165_ = NULL; - ValaProperty* _tmp166_ = NULL; - ValaCCodeConstant* _tmp167_ = NULL; - ValaCCodeConstant* _tmp168_ = NULL; - _tmp165_ = ccall; - _tmp166_ = prop; - _tmp167_ = vala_ccode_base_module_get_property_canonical_cconstant (self, _tmp166_); - _tmp168_ = _tmp167_; - vala_ccode_function_call_add_argument (_tmp165_, (ValaCCodeExpression*) _tmp168_); - _vala_ccode_node_unref0 (_tmp168_); + _tmp175_ = prop; + _tmp176_ = vala_ccode_base_module_get_ccode_no_accessor_method (_tmp175_); + if (_tmp176_) { + ValaCCodeFunctionCall* _tmp177_ = NULL; + ValaProperty* _tmp178_ = NULL; + ValaCCodeConstant* _tmp179_ = NULL; + ValaCCodeConstant* _tmp180_ = NULL; + _tmp177_ = ccall; + _tmp178_ = prop; + _tmp179_ = vala_ccode_base_module_get_property_canonical_cconstant (self, _tmp178_); + _tmp180_ = _tmp179_; + vala_ccode_function_call_add_argument (_tmp177_, (ValaCCodeExpression*) _tmp180_); + _vala_ccode_node_unref0 (_tmp180_); } - _tmp169_ = value; - _tmp170_ = vala_ccode_base_module_get_cvalue_ (self, _tmp169_); - cexpr = _tmp170_; - _tmp171_ = prop; - _tmp172_ = vala_property_get_property_type (_tmp171_); - _tmp173_ = _tmp172_; - _tmp174_ = vala_data_type_is_real_non_null_struct_type (_tmp173_); - if (_tmp174_) { - ValaCCodeExpression* _tmp175_ = NULL; - ValaCCodeUnaryExpression* _tmp176_ = NULL; - _tmp175_ = cexpr; - _tmp176_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, _tmp175_); + _tmp181_ = value; + _tmp182_ = vala_ccode_base_module_get_cvalue_ (self, _tmp181_); + cexpr = _tmp182_; + _tmp183_ = prop; + _tmp184_ = vala_property_get_property_type (_tmp183_); + _tmp185_ = _tmp184_; + _tmp186_ = vala_data_type_is_real_non_null_struct_type (_tmp185_); + if (_tmp186_) { + ValaCCodeExpression* _tmp187_ = NULL; + ValaCCodeUnaryExpression* _tmp188_ = NULL; + _tmp187_ = cexpr; + _tmp188_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, _tmp187_); _vala_ccode_node_unref0 (cexpr); - cexpr = (ValaCCodeExpression*) _tmp176_; + cexpr = (ValaCCodeExpression*) _tmp188_; } - _tmp177_ = prop; - _tmp178_ = vala_property_get_property_type (_tmp177_); - _tmp179_ = _tmp178_; - _tmp180_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp179_, VALA_TYPE_ARRAY_TYPE) ? ((ValaArrayType*) _tmp179_) : NULL); - array_type = _tmp180_; - _tmp181_ = ccall; - _tmp182_ = cexpr; - vala_ccode_function_call_add_argument (_tmp181_, _tmp182_); - _tmp184_ = array_type; - if (_tmp184_ != NULL) { - ValaProperty* _tmp185_ = NULL; - gboolean _tmp186_ = FALSE; - _tmp185_ = prop; - _tmp186_ = vala_ccode_base_module_get_ccode_array_length ((ValaCodeNode*) _tmp185_); - _tmp183_ = _tmp186_; + _tmp189_ = prop; + _tmp190_ = vala_property_get_property_type (_tmp189_); + _tmp191_ = _tmp190_; + _tmp192_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp191_, VALA_TYPE_ARRAY_TYPE) ? ((ValaArrayType*) _tmp191_) : NULL); + array_type = _tmp192_; + _tmp193_ = ccall; + _tmp194_ = cexpr; + vala_ccode_function_call_add_argument (_tmp193_, _tmp194_); + _tmp196_ = array_type; + if (_tmp196_ != NULL) { + ValaProperty* _tmp197_ = NULL; + gboolean _tmp198_ = FALSE; + _tmp197_ = prop; + _tmp198_ = vala_ccode_base_module_get_ccode_array_length ((ValaCodeNode*) _tmp197_); + _tmp195_ = _tmp198_; } else { - _tmp183_ = FALSE; + _tmp195_ = FALSE; } - if (_tmp183_) { + if (_tmp195_) { { gint dim = 0; dim = 1; { - gboolean _tmp187_ = FALSE; - _tmp187_ = TRUE; + gboolean _tmp199_ = FALSE; + _tmp199_ = TRUE; while (TRUE) { - gint _tmp189_ = 0; - ValaArrayType* _tmp190_ = NULL; - gint _tmp191_ = 0; - gint _tmp192_ = 0; - ValaCCodeFunctionCall* _tmp193_ = NULL; - ValaTargetValue* _tmp194_ = NULL; - gint _tmp195_ = 0; - ValaCCodeExpression* _tmp196_ = NULL; - ValaCCodeExpression* _tmp197_ = NULL; - if (!_tmp187_) { - gint _tmp188_ = 0; - _tmp188_ = dim; - dim = _tmp188_ + 1; - } - _tmp187_ = FALSE; - _tmp189_ = dim; - _tmp190_ = array_type; - _tmp191_ = vala_array_type_get_rank (_tmp190_); - _tmp192_ = _tmp191_; - if (!(_tmp189_ <= _tmp192_)) { + gint _tmp201_ = 0; + ValaArrayType* _tmp202_ = NULL; + gint _tmp203_ = 0; + gint _tmp204_ = 0; + ValaCCodeFunctionCall* _tmp205_ = NULL; + ValaTargetValue* _tmp206_ = NULL; + gint _tmp207_ = 0; + ValaCCodeExpression* _tmp208_ = NULL; + ValaCCodeExpression* _tmp209_ = NULL; + if (!_tmp199_) { + gint _tmp200_ = 0; + _tmp200_ = dim; + dim = _tmp200_ + 1; + } + _tmp199_ = FALSE; + _tmp201_ = dim; + _tmp202_ = array_type; + _tmp203_ = vala_array_type_get_rank (_tmp202_); + _tmp204_ = _tmp203_; + if (!(_tmp201_ <= _tmp204_)) { break; } - _tmp193_ = ccall; - _tmp194_ = value; - _tmp195_ = dim; - _tmp196_ = vala_ccode_base_module_get_array_length_cvalue (self, _tmp194_, _tmp195_); - _tmp197_ = _tmp196_; - vala_ccode_function_call_add_argument (_tmp193_, _tmp197_); - _vala_ccode_node_unref0 (_tmp197_); + _tmp205_ = ccall; + _tmp206_ = value; + _tmp207_ = dim; + _tmp208_ = vala_ccode_base_module_get_array_length_cvalue (self, _tmp206_, _tmp207_); + _tmp209_ = _tmp208_; + vala_ccode_function_call_add_argument (_tmp205_, _tmp209_); + _vala_ccode_node_unref0 (_tmp209_); } } } } else { - ValaProperty* _tmp198_ = NULL; - ValaDataType* _tmp199_ = NULL; - ValaDataType* _tmp200_ = NULL; - _tmp198_ = prop; - _tmp199_ = vala_property_get_property_type (_tmp198_); - _tmp200_ = _tmp199_; - if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp200_, VALA_TYPE_DELEGATE_TYPE)) { + ValaProperty* _tmp210_ = NULL; + ValaDataType* _tmp211_ = NULL; + ValaDataType* _tmp212_ = NULL; + _tmp210_ = prop; + _tmp211_ = vala_property_get_property_type (_tmp210_); + _tmp212_ = _tmp211_; + if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp212_, VALA_TYPE_DELEGATE_TYPE)) { ValaDelegateType* delegate_type = NULL; - ValaProperty* _tmp201_ = NULL; - ValaDataType* _tmp202_ = NULL; - ValaDataType* _tmp203_ = NULL; - ValaDelegateType* _tmp204_ = NULL; - ValaDelegateType* _tmp205_ = NULL; - ValaDelegate* _tmp206_ = NULL; - ValaDelegate* _tmp207_ = NULL; - gboolean _tmp208_ = FALSE; - gboolean _tmp209_ = FALSE; - _tmp201_ = prop; - _tmp202_ = vala_property_get_property_type (_tmp201_); - _tmp203_ = _tmp202_; - _tmp204_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp203_, VALA_TYPE_DELEGATE_TYPE, ValaDelegateType)); - delegate_type = _tmp204_; - _tmp205_ = delegate_type; - _tmp206_ = vala_delegate_type_get_delegate_symbol (_tmp205_); - _tmp207_ = _tmp206_; - _tmp208_ = vala_delegate_get_has_target (_tmp207_); - _tmp209_ = _tmp208_; - if (_tmp209_) { - ValaCCodeFunctionCall* _tmp210_ = NULL; - ValaTargetValue* _tmp211_ = NULL; - ValaCCodeExpression* _tmp212_ = NULL; - ValaCCodeExpression* _tmp213_ = NULL; - ValaProperty* _tmp214_ = NULL; - ValaPropertyAccessor* _tmp215_ = NULL; - ValaPropertyAccessor* _tmp216_ = NULL; - ValaDataType* _tmp217_ = NULL; - ValaDataType* _tmp218_ = NULL; - gboolean _tmp219_ = FALSE; - gboolean _tmp220_ = FALSE; - _tmp210_ = ccall; - _tmp211_ = value; - _tmp212_ = vala_ccode_base_module_get_delegate_target_cvalue (self, _tmp211_); - _tmp213_ = _tmp212_; - vala_ccode_function_call_add_argument (_tmp210_, _tmp213_); - _vala_ccode_node_unref0 (_tmp213_); - _tmp214_ = base_property; - _tmp215_ = vala_property_get_set_accessor (_tmp214_); - _tmp216_ = _tmp215_; - _tmp217_ = vala_property_accessor_get_value_type (_tmp216_); - _tmp218_ = _tmp217_; - _tmp219_ = vala_data_type_get_value_owned (_tmp218_); - _tmp220_ = _tmp219_; - if (_tmp220_) { - ValaCCodeFunctionCall* _tmp221_ = NULL; - ValaTargetValue* _tmp222_ = NULL; - ValaCCodeExpression* _tmp223_ = NULL; - ValaCCodeExpression* _tmp224_ = NULL; - _tmp221_ = ccall; - _tmp222_ = value; - _tmp223_ = vala_ccode_base_module_get_delegate_target_destroy_notify_cvalue (self, _tmp222_); - _tmp224_ = _tmp223_; - vala_ccode_function_call_add_argument (_tmp221_, _tmp224_); - _vala_ccode_node_unref0 (_tmp224_); + ValaProperty* _tmp213_ = NULL; + ValaDataType* _tmp214_ = NULL; + ValaDataType* _tmp215_ = NULL; + ValaDelegateType* _tmp216_ = NULL; + ValaDelegateType* _tmp217_ = NULL; + ValaDelegate* _tmp218_ = NULL; + ValaDelegate* _tmp219_ = NULL; + gboolean _tmp220_ = FALSE; + gboolean _tmp221_ = FALSE; + _tmp213_ = prop; + _tmp214_ = vala_property_get_property_type (_tmp213_); + _tmp215_ = _tmp214_; + _tmp216_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp215_, VALA_TYPE_DELEGATE_TYPE, ValaDelegateType)); + delegate_type = _tmp216_; + _tmp217_ = delegate_type; + _tmp218_ = vala_delegate_type_get_delegate_symbol (_tmp217_); + _tmp219_ = _tmp218_; + _tmp220_ = vala_delegate_get_has_target (_tmp219_); + _tmp221_ = _tmp220_; + if (_tmp221_) { + ValaCCodeFunctionCall* _tmp222_ = NULL; + ValaTargetValue* _tmp223_ = NULL; + ValaCCodeExpression* _tmp224_ = NULL; + ValaCCodeExpression* _tmp225_ = NULL; + ValaProperty* _tmp226_ = NULL; + ValaPropertyAccessor* _tmp227_ = NULL; + ValaPropertyAccessor* _tmp228_ = NULL; + ValaDataType* _tmp229_ = NULL; + ValaDataType* _tmp230_ = NULL; + gboolean _tmp231_ = FALSE; + gboolean _tmp232_ = FALSE; + _tmp222_ = ccall; + _tmp223_ = value; + _tmp224_ = vala_ccode_base_module_get_delegate_target_cvalue (self, _tmp223_); + _tmp225_ = _tmp224_; + vala_ccode_function_call_add_argument (_tmp222_, _tmp225_); + _vala_ccode_node_unref0 (_tmp225_); + _tmp226_ = base_property; + _tmp227_ = vala_property_get_set_accessor (_tmp226_); + _tmp228_ = _tmp227_; + _tmp229_ = vala_property_accessor_get_value_type (_tmp228_); + _tmp230_ = _tmp229_; + _tmp231_ = vala_data_type_get_value_owned (_tmp230_); + _tmp232_ = _tmp231_; + if (_tmp232_) { + ValaCCodeFunctionCall* _tmp233_ = NULL; + ValaTargetValue* _tmp234_ = NULL; + ValaCCodeExpression* _tmp235_ = NULL; + ValaCCodeExpression* _tmp236_ = NULL; + _tmp233_ = ccall; + _tmp234_ = value; + _tmp235_ = vala_ccode_base_module_get_delegate_target_destroy_notify_cvalue (self, _tmp234_); + _tmp236_ = _tmp235_; + vala_ccode_function_call_add_argument (_tmp233_, _tmp236_); + _vala_ccode_node_unref0 (_tmp236_); } } _vala_code_node_unref0 (delegate_type); } } - _tmp225_ = prop; - _tmp226_ = vala_ccode_base_module_get_ccode_no_accessor_method (_tmp225_); - if (_tmp226_) { - ValaCCodeFunctionCall* _tmp227_ = NULL; - ValaCCodeConstant* _tmp228_ = NULL; - ValaCCodeConstant* _tmp229_ = NULL; - _tmp227_ = ccall; - _tmp228_ = vala_ccode_constant_new ("NULL"); - _tmp229_ = _tmp228_; - vala_ccode_function_call_add_argument (_tmp227_, (ValaCCodeExpression*) _tmp229_); - _vala_ccode_node_unref0 (_tmp229_); + _tmp237_ = prop; + _tmp238_ = vala_ccode_base_module_get_ccode_no_accessor_method (_tmp237_); + if (_tmp238_) { + ValaCCodeFunctionCall* _tmp239_ = NULL; + ValaCCodeConstant* _tmp240_ = NULL; + ValaCCodeConstant* _tmp241_ = NULL; + _tmp239_ = ccall; + _tmp240_ = vala_ccode_constant_new ("NULL"); + _tmp241_ = _tmp240_; + vala_ccode_function_call_add_argument (_tmp239_, (ValaCCodeExpression*) _tmp241_); + _vala_ccode_node_unref0 (_tmp241_); } - _tmp230_ = vala_ccode_base_module_get_ccode (self); - _tmp231_ = _tmp230_; - _tmp232_ = ccall; - vala_ccode_function_add_expression (_tmp231_, (ValaCCodeExpression*) _tmp232_); + _tmp242_ = vala_ccode_base_module_get_ccode (self); + _tmp243_ = _tmp242_; + _tmp244_ = ccall; + vala_ccode_function_add_expression (_tmp243_, (ValaCCodeExpression*) _tmp244_); _vala_code_node_unref0 (array_type); _vala_ccode_node_unref0 (cexpr); _vala_ccode_node_unref0 (ccall); diff -Nru vala-0.34.6/codegen/valaccodebasemodule.vala vala-0.34.7/codegen/valaccodebasemodule.vala --- vala-0.34.6/codegen/valaccodebasemodule.vala 2017-03-07 08:23:49.000000000 +0000 +++ vala-0.34.7/codegen/valaccodebasemodule.vala 2017-03-20 21:24:57.000000000 +0000 @@ -360,6 +360,9 @@ predefined_marshal_set.add ("STRING:OBJECT,POINTER"); predefined_marshal_set.add ("VOID:UINT,POINTER"); predefined_marshal_set.add ("BOOLEAN:FLAGS"); + predefined_marshal_set.add ("VOID:BOXED"); + predefined_marshal_set.add ("VOID:VARIANT"); + predefined_marshal_set.add ("BOOLEAN:BOXED,BOXED"); reserved_identifiers = new HashSet (str_hash, str_equal); @@ -5193,6 +5196,11 @@ creation_call.add_argument (new CCodeIdentifier ("sizeof (%s)".printf (get_ccode_name (expr.inner.value_type)))); ccode.add_expression (creation_call); } else if (expr.value_type is DelegateType) { + ccode.add_assignment (get_cvalue (expr.inner), new CCodeConstant ("NULL")); + var target = get_delegate_target_cvalue (expr.inner.target_value); + if (target != null) { + ccode.add_assignment (target, new CCodeConstant ("NULL")); + } var target_destroy_notify = get_delegate_target_destroy_notify_cvalue (expr.inner.target_value); if (target_destroy_notify != null) { ccode.add_assignment (target_destroy_notify, new CCodeConstant ("NULL")); @@ -5814,7 +5822,11 @@ var ccall = new CCodeFunctionCall (new CCodeMemberAccess.pointer (vcast, "set_%s".printf (prop.name))); ccall.add_argument ((CCodeExpression) get_ccodenode (instance)); - ccall.add_argument (get_cvalue_ (value)); + var cexpr = get_cvalue_ (value); + if (prop.property_type.is_real_non_null_struct_type ()) { + cexpr = new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, cexpr); + } + ccall.add_argument (cexpr); ccode.add_expression (ccall); } else if (prop.base_interface_property != null) { @@ -5823,7 +5835,11 @@ var ccall = new CCodeFunctionCall (new CCodeMemberAccess.pointer (new CCodeIdentifier (parent_iface_var), "set_%s".printf (prop.name))); ccall.add_argument ((CCodeExpression) get_ccodenode (instance)); - ccall.add_argument (get_cvalue_ (value)); + var cexpr = get_cvalue_ (value); + if (prop.property_type.is_real_non_null_struct_type ()) { + cexpr = new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, cexpr); + } + ccall.add_argument (cexpr); ccode.add_expression (ccall); } diff -Nru vala-0.34.6/codegen/valaccodememberaccessmodule.c vala-0.34.7/codegen/valaccodememberaccessmodule.c --- vala-0.34.6/codegen/valaccodememberaccessmodule.c 2017-03-07 09:40:04.000000000 +0000 +++ vala-0.34.7/codegen/valaccodememberaccessmodule.c 2017-03-20 21:31:16.000000000 +0000 @@ -354,16 +354,16 @@ void vala_ccode_base_module_generate_constant_declaration (ValaCCodeBaseModule* self, ValaConstant* c, ValaCCodeFile* decl_space, gboolean definition); void vala_ccode_base_module_append_array_length (ValaCCodeBaseModule* self, ValaExpression* expr, ValaCCodeExpression* size); void vala_ccode_base_module_generate_property_accessor_declaration (ValaCCodeBaseModule* self, ValaPropertyAccessor* acc, ValaCCodeFile* decl_space); +GType vala_glib_value_get_type (void) G_GNUC_CONST; +ValaTargetValue* vala_ccode_base_module_create_temp_value (ValaCCodeBaseModule* self, ValaDataType* type, gboolean init, ValaCodeNode* node_reference, gboolean* value_owned); +ValaTargetValue* vala_ccode_base_module_load_temp_value (ValaCCodeBaseModule* self, ValaTargetValue* lvalue); +ValaCCodeExpression* vala_ccode_base_module_get_cvalue_ (ValaCCodeBaseModule* self, ValaTargetValue* value); +ValaCCodeFunction* vala_ccode_base_module_get_ccode (ValaCCodeBaseModule* self); ValaTypeSymbol* vala_ccode_base_module_get_current_type_symbol (ValaCCodeBaseModule* self); gboolean vala_ccode_base_module_get_ccode_no_accessor_method (ValaProperty* p); gchar* vala_ccode_base_module_get_dynamic_property_getter_cname (ValaCCodeBaseModule* self, ValaDynamicProperty* node); gboolean vala_ccode_base_module_get_lvalue (ValaCCodeBaseModule* self, ValaTargetValue* value); ValaTargetValue* vala_ccode_base_module_store_temp_value (ValaCCodeBaseModule* self, ValaTargetValue* initializer, ValaCodeNode* node_reference, gboolean* value_owned); -ValaCCodeExpression* vala_ccode_base_module_get_cvalue_ (ValaCCodeBaseModule* self, ValaTargetValue* value); -GType vala_glib_value_get_type (void) G_GNUC_CONST; -ValaTargetValue* vala_ccode_base_module_create_temp_value (ValaCCodeBaseModule* self, ValaDataType* type, gboolean init, ValaCodeNode* node_reference, gboolean* value_owned); -ValaTargetValue* vala_ccode_base_module_load_temp_value (ValaCCodeBaseModule* self, ValaTargetValue* lvalue); -ValaCCodeFunction* vala_ccode_base_module_get_ccode (ValaCCodeBaseModule* self); gboolean vala_ccode_base_module_get_ccode_array_null_terminated (ValaCodeNode* node); gboolean vala_ccode_base_module_get_ccode_array_length (ValaCodeNode* node); ValaCCodeExpression* vala_ccode_base_module_get_array_length_cvalue (ValaCCodeBaseModule* self, ValaTargetValue* value, gint dim); @@ -1601,19 +1601,19 @@ ValaMemberAccess* _tmp456_ = NULL; ValaExpression* _tmp457_ = NULL; ValaExpression* _tmp458_ = NULL; - ValaMemberAccess* _tmp793_ = NULL; - ValaTargetValue* _tmp794_ = NULL; - ValaTargetValue* _tmp795_ = NULL; - ValaMemberAccess* _tmp796_ = NULL; - ValaDataType* _tmp797_ = NULL; - ValaDataType* _tmp798_ = NULL; - ValaMemberAccess* _tmp799_ = NULL; - ValaMemberAccess* _tmp800_ = NULL; - ValaTargetValue* _tmp801_ = NULL; - ValaTargetValue* _tmp802_ = NULL; - ValaMemberAccess* _tmp803_ = NULL; - ValaTargetValue* _tmp804_ = NULL; - ValaTargetValue* _tmp805_ = NULL; + ValaMemberAccess* _tmp841_ = NULL; + ValaTargetValue* _tmp842_ = NULL; + ValaTargetValue* _tmp843_ = NULL; + ValaMemberAccess* _tmp844_ = NULL; + ValaDataType* _tmp845_ = NULL; + ValaDataType* _tmp846_ = NULL; + ValaMemberAccess* _tmp847_ = NULL; + ValaMemberAccess* _tmp848_ = NULL; + ValaTargetValue* _tmp849_ = NULL; + ValaTargetValue* _tmp850_ = NULL; + ValaMemberAccess* _tmp851_ = NULL; + ValaTargetValue* _tmp852_ = NULL; + ValaTargetValue* _tmp853_ = NULL; _tmp437_ = expr; _tmp438_ = vala_expression_get_symbol_reference ((ValaExpression*) _tmp437_); _tmp439_ = _tmp438_; @@ -1755,8 +1755,10 @@ ValaExpression* _tmp513_ = NULL; ValaCCodeExpression* _tmp514_ = NULL; ValaCCodeExpression* _tmp515_ = NULL; - ValaMemberAccess* _tmp516_ = NULL; - ValaCCodeFunctionCall* _tmp517_ = NULL; + ValaProperty* _tmp516_ = NULL; + ValaDataType* _tmp517_ = NULL; + ValaDataType* _tmp518_ = NULL; + gboolean _tmp519_ = FALSE; _tmp478_ = base_prop; _tmp479_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp478_); _tmp480_ = _tmp479_; @@ -1809,100 +1811,222 @@ _tmp515_ = _tmp514_; vala_ccode_function_call_add_argument (_tmp510_, _tmp515_); _vala_ccode_node_unref0 (_tmp515_); - _tmp516_ = expr; - _tmp517_ = ccall; - vala_ccode_base_module_set_cvalue ((ValaCCodeBaseModule*) self, (ValaExpression*) _tmp516_, (ValaCCodeExpression*) _tmp517_); + _tmp516_ = prop; + _tmp517_ = vala_property_get_property_type (_tmp516_); + _tmp518_ = _tmp517_; + _tmp519_ = vala_data_type_is_real_non_null_struct_type (_tmp518_); + if (_tmp519_) { + ValaGLibValue* temp_value = NULL; + ValaProperty* _tmp520_ = NULL; + ValaPropertyAccessor* _tmp521_ = NULL; + ValaPropertyAccessor* _tmp522_ = NULL; + ValaDataType* _tmp523_ = NULL; + ValaDataType* _tmp524_ = NULL; + ValaMemberAccess* _tmp525_ = NULL; + ValaTargetValue* _tmp526_ = NULL; + ValaMemberAccess* _tmp527_ = NULL; + ValaGLibValue* _tmp528_ = NULL; + ValaTargetValue* _tmp529_ = NULL; + ValaTargetValue* _tmp530_ = NULL; + ValaCCodeExpression* ctemp = NULL; + ValaGLibValue* _tmp531_ = NULL; + ValaCCodeExpression* _tmp532_ = NULL; + ValaCCodeFunctionCall* _tmp533_ = NULL; + ValaCCodeExpression* _tmp534_ = NULL; + ValaCCodeUnaryExpression* _tmp535_ = NULL; + ValaCCodeUnaryExpression* _tmp536_ = NULL; + ValaCCodeFunction* _tmp537_ = NULL; + ValaCCodeFunction* _tmp538_ = NULL; + ValaCCodeFunctionCall* _tmp539_ = NULL; + _tmp520_ = prop; + _tmp521_ = vala_property_get_get_accessor (_tmp520_); + _tmp522_ = _tmp521_; + _tmp523_ = vala_property_accessor_get_value_type (_tmp522_); + _tmp524_ = _tmp523_; + _tmp525_ = expr; + _tmp526_ = vala_ccode_base_module_create_temp_value ((ValaCCodeBaseModule*) self, _tmp524_, FALSE, (ValaCodeNode*) _tmp525_, NULL); + temp_value = G_TYPE_CHECK_INSTANCE_CAST (_tmp526_, VALA_TYPE_GLIB_VALUE, ValaGLibValue); + _tmp527_ = expr; + _tmp528_ = temp_value; + _tmp529_ = vala_ccode_base_module_load_temp_value ((ValaCCodeBaseModule*) self, (ValaTargetValue*) _tmp528_); + _tmp530_ = _tmp529_; + vala_expression_set_target_value ((ValaExpression*) _tmp527_, _tmp530_); + _vala_target_value_unref0 (_tmp530_); + _tmp531_ = temp_value; + _tmp532_ = vala_ccode_base_module_get_cvalue_ ((ValaCCodeBaseModule*) self, (ValaTargetValue*) _tmp531_); + ctemp = _tmp532_; + _tmp533_ = ccall; + _tmp534_ = ctemp; + _tmp535_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, _tmp534_); + _tmp536_ = _tmp535_; + vala_ccode_function_call_add_argument (_tmp533_, (ValaCCodeExpression*) _tmp536_); + _vala_ccode_node_unref0 (_tmp536_); + _tmp537_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp538_ = _tmp537_; + _tmp539_ = ccall; + vala_ccode_function_add_expression (_tmp538_, (ValaCCodeExpression*) _tmp539_); + _vala_ccode_node_unref0 (ctemp); + _vala_target_value_unref0 (temp_value); + } else { + ValaMemberAccess* _tmp540_ = NULL; + ValaCCodeFunctionCall* _tmp541_ = NULL; + _tmp540_ = expr; + _tmp541_ = ccall; + vala_ccode_base_module_set_cvalue ((ValaCCodeBaseModule*) self, (ValaExpression*) _tmp540_, (ValaCCodeExpression*) _tmp541_); + } _vala_ccode_node_unref0 (ccall); _vala_ccode_node_unref0 (vcast); _vala_code_node_unref0 (base_class); } else { - ValaProperty* _tmp518_ = NULL; - ValaSymbol* _tmp519_ = NULL; - ValaSymbol* _tmp520_ = NULL; - _tmp518_ = base_prop; - _tmp519_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp518_); - _tmp520_ = _tmp519_; - if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp520_, VALA_TYPE_INTERFACE)) { + ValaProperty* _tmp542_ = NULL; + ValaSymbol* _tmp543_ = NULL; + ValaSymbol* _tmp544_ = NULL; + _tmp542_ = base_prop; + _tmp543_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp542_); + _tmp544_ = _tmp543_; + if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp544_, VALA_TYPE_INTERFACE)) { ValaInterface* base_iface = NULL; - ValaProperty* _tmp521_ = NULL; - ValaSymbol* _tmp522_ = NULL; - ValaSymbol* _tmp523_ = NULL; - ValaInterface* _tmp524_ = NULL; + ValaProperty* _tmp545_ = NULL; + ValaSymbol* _tmp546_ = NULL; + ValaSymbol* _tmp547_ = NULL; + ValaInterface* _tmp548_ = NULL; gchar* parent_iface_var = NULL; - ValaClass* _tmp525_ = NULL; - ValaClass* _tmp526_ = NULL; - gchar* _tmp527_ = NULL; - gchar* _tmp528_ = NULL; - ValaInterface* _tmp529_ = NULL; - gchar* _tmp530_ = NULL; - gchar* _tmp531_ = NULL; - gchar* _tmp532_ = NULL; - gchar* _tmp533_ = NULL; + ValaClass* _tmp549_ = NULL; + ValaClass* _tmp550_ = NULL; + gchar* _tmp551_ = NULL; + gchar* _tmp552_ = NULL; + ValaInterface* _tmp553_ = NULL; + gchar* _tmp554_ = NULL; + gchar* _tmp555_ = NULL; + gchar* _tmp556_ = NULL; + gchar* _tmp557_ = NULL; ValaCCodeFunctionCall* ccall = NULL; - const gchar* _tmp534_ = NULL; - ValaCCodeIdentifier* _tmp535_ = NULL; - ValaCCodeIdentifier* _tmp536_ = NULL; - ValaProperty* _tmp537_ = NULL; - const gchar* _tmp538_ = NULL; - const gchar* _tmp539_ = NULL; - gchar* _tmp540_ = NULL; - gchar* _tmp541_ = NULL; - ValaCCodeMemberAccess* _tmp542_ = NULL; - ValaCCodeMemberAccess* _tmp543_ = NULL; - ValaCCodeFunctionCall* _tmp544_ = NULL; - ValaCCodeFunctionCall* _tmp545_ = NULL; - ValaCCodeFunctionCall* _tmp546_ = NULL; - ValaMemberAccess* _tmp547_ = NULL; - ValaExpression* _tmp548_ = NULL; - ValaExpression* _tmp549_ = NULL; - ValaCCodeExpression* _tmp550_ = NULL; - ValaCCodeExpression* _tmp551_ = NULL; - ValaMemberAccess* _tmp552_ = NULL; - ValaCCodeFunctionCall* _tmp553_ = NULL; - _tmp521_ = base_prop; - _tmp522_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp521_); - _tmp523_ = _tmp522_; - _tmp524_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp523_, VALA_TYPE_INTERFACE, ValaInterface)); - base_iface = _tmp524_; - _tmp525_ = vala_ccode_base_module_get_current_class ((ValaCCodeBaseModule*) self); - _tmp526_ = _tmp525_; - _tmp527_ = vala_ccode_base_module_get_ccode_lower_case_name ((ValaCodeNode*) _tmp526_, NULL); - _tmp528_ = _tmp527_; - _tmp529_ = base_iface; - _tmp530_ = vala_ccode_base_module_get_ccode_lower_case_name ((ValaCodeNode*) _tmp529_, NULL); - _tmp531_ = _tmp530_; - _tmp532_ = g_strdup_printf ("%s_%s_parent_iface", _tmp528_, _tmp531_); - _tmp533_ = _tmp532_; - _g_free0 (_tmp531_); - _g_free0 (_tmp528_); - parent_iface_var = _tmp533_; - _tmp534_ = parent_iface_var; - _tmp535_ = vala_ccode_identifier_new (_tmp534_); - _tmp536_ = _tmp535_; - _tmp537_ = prop; - _tmp538_ = vala_symbol_get_name ((ValaSymbol*) _tmp537_); - _tmp539_ = _tmp538_; - _tmp540_ = g_strdup_printf ("get_%s", _tmp539_); - _tmp541_ = _tmp540_; - _tmp542_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp536_, _tmp541_); - _tmp543_ = _tmp542_; - _tmp544_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp543_); - _tmp545_ = _tmp544_; - _vala_ccode_node_unref0 (_tmp543_); - _g_free0 (_tmp541_); - _vala_ccode_node_unref0 (_tmp536_); - ccall = _tmp545_; - _tmp546_ = ccall; - _tmp547_ = expr; - _tmp548_ = vala_member_access_get_inner (_tmp547_); - _tmp549_ = _tmp548_; - _tmp550_ = vala_ccode_base_module_get_cvalue ((ValaCCodeBaseModule*) self, _tmp549_); - _tmp551_ = _tmp550_; - vala_ccode_function_call_add_argument (_tmp546_, _tmp551_); - _vala_ccode_node_unref0 (_tmp551_); - _tmp552_ = expr; - _tmp553_ = ccall; - vala_ccode_base_module_set_cvalue ((ValaCCodeBaseModule*) self, (ValaExpression*) _tmp552_, (ValaCCodeExpression*) _tmp553_); + const gchar* _tmp558_ = NULL; + ValaCCodeIdentifier* _tmp559_ = NULL; + ValaCCodeIdentifier* _tmp560_ = NULL; + ValaProperty* _tmp561_ = NULL; + const gchar* _tmp562_ = NULL; + const gchar* _tmp563_ = NULL; + gchar* _tmp564_ = NULL; + gchar* _tmp565_ = NULL; + ValaCCodeMemberAccess* _tmp566_ = NULL; + ValaCCodeMemberAccess* _tmp567_ = NULL; + ValaCCodeFunctionCall* _tmp568_ = NULL; + ValaCCodeFunctionCall* _tmp569_ = NULL; + ValaCCodeFunctionCall* _tmp570_ = NULL; + ValaMemberAccess* _tmp571_ = NULL; + ValaExpression* _tmp572_ = NULL; + ValaExpression* _tmp573_ = NULL; + ValaCCodeExpression* _tmp574_ = NULL; + ValaCCodeExpression* _tmp575_ = NULL; + ValaProperty* _tmp576_ = NULL; + ValaDataType* _tmp577_ = NULL; + ValaDataType* _tmp578_ = NULL; + gboolean _tmp579_ = FALSE; + _tmp545_ = base_prop; + _tmp546_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp545_); + _tmp547_ = _tmp546_; + _tmp548_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp547_, VALA_TYPE_INTERFACE, ValaInterface)); + base_iface = _tmp548_; + _tmp549_ = vala_ccode_base_module_get_current_class ((ValaCCodeBaseModule*) self); + _tmp550_ = _tmp549_; + _tmp551_ = vala_ccode_base_module_get_ccode_lower_case_name ((ValaCodeNode*) _tmp550_, NULL); + _tmp552_ = _tmp551_; + _tmp553_ = base_iface; + _tmp554_ = vala_ccode_base_module_get_ccode_lower_case_name ((ValaCodeNode*) _tmp553_, NULL); + _tmp555_ = _tmp554_; + _tmp556_ = g_strdup_printf ("%s_%s_parent_iface", _tmp552_, _tmp555_); + _tmp557_ = _tmp556_; + _g_free0 (_tmp555_); + _g_free0 (_tmp552_); + parent_iface_var = _tmp557_; + _tmp558_ = parent_iface_var; + _tmp559_ = vala_ccode_identifier_new (_tmp558_); + _tmp560_ = _tmp559_; + _tmp561_ = prop; + _tmp562_ = vala_symbol_get_name ((ValaSymbol*) _tmp561_); + _tmp563_ = _tmp562_; + _tmp564_ = g_strdup_printf ("get_%s", _tmp563_); + _tmp565_ = _tmp564_; + _tmp566_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp560_, _tmp565_); + _tmp567_ = _tmp566_; + _tmp568_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp567_); + _tmp569_ = _tmp568_; + _vala_ccode_node_unref0 (_tmp567_); + _g_free0 (_tmp565_); + _vala_ccode_node_unref0 (_tmp560_); + ccall = _tmp569_; + _tmp570_ = ccall; + _tmp571_ = expr; + _tmp572_ = vala_member_access_get_inner (_tmp571_); + _tmp573_ = _tmp572_; + _tmp574_ = vala_ccode_base_module_get_cvalue ((ValaCCodeBaseModule*) self, _tmp573_); + _tmp575_ = _tmp574_; + vala_ccode_function_call_add_argument (_tmp570_, _tmp575_); + _vala_ccode_node_unref0 (_tmp575_); + _tmp576_ = prop; + _tmp577_ = vala_property_get_property_type (_tmp576_); + _tmp578_ = _tmp577_; + _tmp579_ = vala_data_type_is_real_non_null_struct_type (_tmp578_); + if (_tmp579_) { + ValaGLibValue* temp_value = NULL; + ValaProperty* _tmp580_ = NULL; + ValaPropertyAccessor* _tmp581_ = NULL; + ValaPropertyAccessor* _tmp582_ = NULL; + ValaDataType* _tmp583_ = NULL; + ValaDataType* _tmp584_ = NULL; + ValaMemberAccess* _tmp585_ = NULL; + ValaTargetValue* _tmp586_ = NULL; + ValaMemberAccess* _tmp587_ = NULL; + ValaGLibValue* _tmp588_ = NULL; + ValaTargetValue* _tmp589_ = NULL; + ValaTargetValue* _tmp590_ = NULL; + ValaCCodeExpression* ctemp = NULL; + ValaGLibValue* _tmp591_ = NULL; + ValaCCodeExpression* _tmp592_ = NULL; + ValaCCodeFunctionCall* _tmp593_ = NULL; + ValaCCodeExpression* _tmp594_ = NULL; + ValaCCodeUnaryExpression* _tmp595_ = NULL; + ValaCCodeUnaryExpression* _tmp596_ = NULL; + ValaCCodeFunction* _tmp597_ = NULL; + ValaCCodeFunction* _tmp598_ = NULL; + ValaCCodeFunctionCall* _tmp599_ = NULL; + _tmp580_ = prop; + _tmp581_ = vala_property_get_get_accessor (_tmp580_); + _tmp582_ = _tmp581_; + _tmp583_ = vala_property_accessor_get_value_type (_tmp582_); + _tmp584_ = _tmp583_; + _tmp585_ = expr; + _tmp586_ = vala_ccode_base_module_create_temp_value ((ValaCCodeBaseModule*) self, _tmp584_, FALSE, (ValaCodeNode*) _tmp585_, NULL); + temp_value = G_TYPE_CHECK_INSTANCE_CAST (_tmp586_, VALA_TYPE_GLIB_VALUE, ValaGLibValue); + _tmp587_ = expr; + _tmp588_ = temp_value; + _tmp589_ = vala_ccode_base_module_load_temp_value ((ValaCCodeBaseModule*) self, (ValaTargetValue*) _tmp588_); + _tmp590_ = _tmp589_; + vala_expression_set_target_value ((ValaExpression*) _tmp587_, _tmp590_); + _vala_target_value_unref0 (_tmp590_); + _tmp591_ = temp_value; + _tmp592_ = vala_ccode_base_module_get_cvalue_ ((ValaCCodeBaseModule*) self, (ValaTargetValue*) _tmp591_); + ctemp = _tmp592_; + _tmp593_ = ccall; + _tmp594_ = ctemp; + _tmp595_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, _tmp594_); + _tmp596_ = _tmp595_; + vala_ccode_function_call_add_argument (_tmp593_, (ValaCCodeExpression*) _tmp596_); + _vala_ccode_node_unref0 (_tmp596_); + _tmp597_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp598_ = _tmp597_; + _tmp599_ = ccall; + vala_ccode_function_add_expression (_tmp598_, (ValaCCodeExpression*) _tmp599_); + _vala_ccode_node_unref0 (ctemp); + _vala_target_value_unref0 (temp_value); + } else { + ValaMemberAccess* _tmp600_ = NULL; + ValaCCodeFunctionCall* _tmp601_ = NULL; + _tmp600_ = expr; + _tmp601_ = ccall; + vala_ccode_base_module_set_cvalue ((ValaCCodeBaseModule*) self, (ValaExpression*) _tmp600_, (ValaCCodeExpression*) _tmp601_); + } _vala_ccode_node_unref0 (ccall); _g_free0 (parent_iface_var); _vala_code_node_unref0 (base_iface); @@ -1910,485 +2034,485 @@ } _vala_code_node_unref0 (base_prop); } else { - gboolean _tmp554_ = FALSE; - gboolean _tmp555_ = FALSE; - gboolean _tmp556_ = FALSE; - gboolean _tmp557_ = FALSE; - gboolean _tmp558_ = FALSE; - gboolean _tmp559_ = FALSE; - gboolean _tmp560_ = FALSE; - ValaProperty* _tmp561_ = NULL; - ValaMemberBinding _tmp562_ = 0; - ValaMemberBinding _tmp563_ = 0; - _tmp561_ = prop; - _tmp562_ = vala_property_get_binding (_tmp561_); - _tmp563_ = _tmp562_; - if (_tmp563_ == VALA_MEMBER_BINDING_INSTANCE) { - ValaProperty* _tmp564_ = NULL; - ValaPropertyAccessor* _tmp565_ = NULL; - ValaPropertyAccessor* _tmp566_ = NULL; - gboolean _tmp567_ = FALSE; - gboolean _tmp568_ = FALSE; - _tmp564_ = prop; - _tmp565_ = vala_property_get_get_accessor (_tmp564_); - _tmp566_ = _tmp565_; - _tmp567_ = vala_property_accessor_get_automatic_body (_tmp566_); - _tmp568_ = _tmp567_; - _tmp560_ = _tmp568_; + gboolean _tmp602_ = FALSE; + gboolean _tmp603_ = FALSE; + gboolean _tmp604_ = FALSE; + gboolean _tmp605_ = FALSE; + gboolean _tmp606_ = FALSE; + gboolean _tmp607_ = FALSE; + gboolean _tmp608_ = FALSE; + ValaProperty* _tmp609_ = NULL; + ValaMemberBinding _tmp610_ = 0; + ValaMemberBinding _tmp611_ = 0; + _tmp609_ = prop; + _tmp610_ = vala_property_get_binding (_tmp609_); + _tmp611_ = _tmp610_; + if (_tmp611_ == VALA_MEMBER_BINDING_INSTANCE) { + ValaProperty* _tmp612_ = NULL; + ValaPropertyAccessor* _tmp613_ = NULL; + ValaPropertyAccessor* _tmp614_ = NULL; + gboolean _tmp615_ = FALSE; + gboolean _tmp616_ = FALSE; + _tmp612_ = prop; + _tmp613_ = vala_property_get_get_accessor (_tmp612_); + _tmp614_ = _tmp613_; + _tmp615_ = vala_property_accessor_get_automatic_body (_tmp614_); + _tmp616_ = _tmp615_; + _tmp608_ = _tmp616_; } else { - _tmp560_ = FALSE; + _tmp608_ = FALSE; } - if (_tmp560_) { - ValaProperty* _tmp569_ = NULL; - ValaPropertyAccessor* _tmp570_ = NULL; - ValaPropertyAccessor* _tmp571_ = NULL; - ValaDataType* _tmp572_ = NULL; - ValaDataType* _tmp573_ = NULL; - gboolean _tmp574_ = FALSE; - gboolean _tmp575_ = FALSE; - _tmp569_ = prop; - _tmp570_ = vala_property_get_get_accessor (_tmp569_); - _tmp571_ = _tmp570_; - _tmp572_ = vala_property_accessor_get_value_type (_tmp571_); - _tmp573_ = _tmp572_; - _tmp574_ = vala_data_type_get_value_owned (_tmp573_); - _tmp575_ = _tmp574_; - _tmp559_ = !_tmp575_; + if (_tmp608_) { + ValaProperty* _tmp617_ = NULL; + ValaPropertyAccessor* _tmp618_ = NULL; + ValaPropertyAccessor* _tmp619_ = NULL; + ValaDataType* _tmp620_ = NULL; + ValaDataType* _tmp621_ = NULL; + gboolean _tmp622_ = FALSE; + gboolean _tmp623_ = FALSE; + _tmp617_ = prop; + _tmp618_ = vala_property_get_get_accessor (_tmp617_); + _tmp619_ = _tmp618_; + _tmp620_ = vala_property_accessor_get_value_type (_tmp619_); + _tmp621_ = _tmp620_; + _tmp622_ = vala_data_type_get_value_owned (_tmp621_); + _tmp623_ = _tmp622_; + _tmp607_ = !_tmp623_; } else { - _tmp559_ = FALSE; + _tmp607_ = FALSE; } - if (_tmp559_) { - ValaTypeSymbol* _tmp576_ = NULL; - ValaTypeSymbol* _tmp577_ = NULL; - ValaProperty* _tmp578_ = NULL; - ValaSymbol* _tmp579_ = NULL; - ValaSymbol* _tmp580_ = NULL; - _tmp576_ = vala_ccode_base_module_get_current_type_symbol ((ValaCCodeBaseModule*) self); - _tmp577_ = _tmp576_; - _tmp578_ = prop; - _tmp579_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp578_); - _tmp580_ = _tmp579_; - _tmp558_ = G_TYPE_CHECK_INSTANCE_CAST (_tmp577_, VALA_TYPE_SYMBOL, ValaSymbol) == _tmp580_; + if (_tmp607_) { + ValaTypeSymbol* _tmp624_ = NULL; + ValaTypeSymbol* _tmp625_ = NULL; + ValaProperty* _tmp626_ = NULL; + ValaSymbol* _tmp627_ = NULL; + ValaSymbol* _tmp628_ = NULL; + _tmp624_ = vala_ccode_base_module_get_current_type_symbol ((ValaCCodeBaseModule*) self); + _tmp625_ = _tmp624_; + _tmp626_ = prop; + _tmp627_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp626_); + _tmp628_ = _tmp627_; + _tmp606_ = G_TYPE_CHECK_INSTANCE_CAST (_tmp625_, VALA_TYPE_SYMBOL, ValaSymbol) == _tmp628_; } else { - _tmp558_ = FALSE; + _tmp606_ = FALSE; } - if (_tmp558_) { - ValaTypeSymbol* _tmp581_ = NULL; - ValaTypeSymbol* _tmp582_ = NULL; - _tmp581_ = vala_ccode_base_module_get_current_type_symbol ((ValaCCodeBaseModule*) self); - _tmp582_ = _tmp581_; - _tmp557_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp582_, VALA_TYPE_CLASS); + if (_tmp606_) { + ValaTypeSymbol* _tmp629_ = NULL; + ValaTypeSymbol* _tmp630_ = NULL; + _tmp629_ = vala_ccode_base_module_get_current_type_symbol ((ValaCCodeBaseModule*) self); + _tmp630_ = _tmp629_; + _tmp605_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp630_, VALA_TYPE_CLASS); } else { - _tmp557_ = FALSE; + _tmp605_ = FALSE; } - if (_tmp557_) { - ValaProperty* _tmp583_ = NULL; - ValaProperty* _tmp584_ = NULL; - ValaProperty* _tmp585_ = NULL; - _tmp583_ = prop; - _tmp584_ = vala_property_get_base_property (_tmp583_); - _tmp585_ = _tmp584_; - _tmp556_ = _tmp585_ == NULL; + if (_tmp605_) { + ValaProperty* _tmp631_ = NULL; + ValaProperty* _tmp632_ = NULL; + ValaProperty* _tmp633_ = NULL; + _tmp631_ = prop; + _tmp632_ = vala_property_get_base_property (_tmp631_); + _tmp633_ = _tmp632_; + _tmp604_ = _tmp633_ == NULL; } else { - _tmp556_ = FALSE; + _tmp604_ = FALSE; } - if (_tmp556_) { - ValaProperty* _tmp586_ = NULL; - ValaProperty* _tmp587_ = NULL; - ValaProperty* _tmp588_ = NULL; - _tmp586_ = prop; - _tmp587_ = vala_property_get_base_interface_property (_tmp586_); - _tmp588_ = _tmp587_; - _tmp555_ = _tmp588_ == NULL; + if (_tmp604_) { + ValaProperty* _tmp634_ = NULL; + ValaProperty* _tmp635_ = NULL; + ValaProperty* _tmp636_ = NULL; + _tmp634_ = prop; + _tmp635_ = vala_property_get_base_interface_property (_tmp634_); + _tmp636_ = _tmp635_; + _tmp603_ = _tmp636_ == NULL; } else { - _tmp555_ = FALSE; + _tmp603_ = FALSE; } - if (_tmp555_) { - gboolean _tmp589_ = FALSE; - ValaProperty* _tmp590_ = NULL; - ValaDataType* _tmp591_ = NULL; - ValaDataType* _tmp592_ = NULL; - _tmp590_ = prop; - _tmp591_ = vala_property_get_property_type (_tmp590_); - _tmp592_ = _tmp591_; - if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp592_, VALA_TYPE_ARRAY_TYPE)) { - _tmp589_ = TRUE; + if (_tmp603_) { + gboolean _tmp637_ = FALSE; + ValaProperty* _tmp638_ = NULL; + ValaDataType* _tmp639_ = NULL; + ValaDataType* _tmp640_ = NULL; + _tmp638_ = prop; + _tmp639_ = vala_property_get_property_type (_tmp638_); + _tmp640_ = _tmp639_; + if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp640_, VALA_TYPE_ARRAY_TYPE)) { + _tmp637_ = TRUE; } else { - ValaProperty* _tmp593_ = NULL; - ValaDataType* _tmp594_ = NULL; - ValaDataType* _tmp595_ = NULL; - _tmp593_ = prop; - _tmp594_ = vala_property_get_property_type (_tmp593_); - _tmp595_ = _tmp594_; - _tmp589_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp595_, VALA_TYPE_DELEGATE_TYPE); + ValaProperty* _tmp641_ = NULL; + ValaDataType* _tmp642_ = NULL; + ValaDataType* _tmp643_ = NULL; + _tmp641_ = prop; + _tmp642_ = vala_property_get_property_type (_tmp641_); + _tmp643_ = _tmp642_; + _tmp637_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp643_, VALA_TYPE_DELEGATE_TYPE); } - _tmp554_ = !_tmp589_; + _tmp602_ = !_tmp637_; } else { - _tmp554_ = FALSE; + _tmp602_ = FALSE; } - if (_tmp554_) { + if (_tmp602_) { ValaCCodeExpression* inst = NULL; - ValaCCodeExpression* _tmp596_ = NULL; - ValaCCodeMemberAccess* _tmp597_ = NULL; - ValaMemberAccess* _tmp598_ = NULL; - ValaCCodeExpression* _tmp599_ = NULL; - ValaProperty* _tmp600_ = NULL; - ValaField* _tmp601_ = NULL; - ValaField* _tmp602_ = NULL; - gchar* _tmp603_ = NULL; - gchar* _tmp604_ = NULL; - ValaCCodeMemberAccess* _tmp605_ = NULL; - ValaCCodeMemberAccess* _tmp606_ = NULL; - _tmp596_ = pub_inst; - _tmp597_ = vala_ccode_member_access_new_pointer (_tmp596_, "priv"); + ValaCCodeExpression* _tmp644_ = NULL; + ValaCCodeMemberAccess* _tmp645_ = NULL; + ValaMemberAccess* _tmp646_ = NULL; + ValaCCodeExpression* _tmp647_ = NULL; + ValaProperty* _tmp648_ = NULL; + ValaField* _tmp649_ = NULL; + ValaField* _tmp650_ = NULL; + gchar* _tmp651_ = NULL; + gchar* _tmp652_ = NULL; + ValaCCodeMemberAccess* _tmp653_ = NULL; + ValaCCodeMemberAccess* _tmp654_ = NULL; + _tmp644_ = pub_inst; + _tmp645_ = vala_ccode_member_access_new_pointer (_tmp644_, "priv"); _vala_ccode_node_unref0 (inst); - inst = (ValaCCodeExpression*) _tmp597_; - _tmp598_ = expr; - _tmp599_ = inst; - _tmp600_ = prop; - _tmp601_ = vala_property_get_field (_tmp600_); - _tmp602_ = _tmp601_; - _tmp603_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp602_); - _tmp604_ = _tmp603_; - _tmp605_ = vala_ccode_member_access_new_pointer (_tmp599_, _tmp604_); - _tmp606_ = _tmp605_; - vala_ccode_base_module_set_cvalue ((ValaCCodeBaseModule*) self, (ValaExpression*) _tmp598_, (ValaCCodeExpression*) _tmp606_); - _vala_ccode_node_unref0 (_tmp606_); - _g_free0 (_tmp604_); + inst = (ValaCCodeExpression*) _tmp645_; + _tmp646_ = expr; + _tmp647_ = inst; + _tmp648_ = prop; + _tmp649_ = vala_property_get_field (_tmp648_); + _tmp650_ = _tmp649_; + _tmp651_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp650_); + _tmp652_ = _tmp651_; + _tmp653_ = vala_ccode_member_access_new_pointer (_tmp647_, _tmp652_); + _tmp654_ = _tmp653_; + vala_ccode_base_module_set_cvalue ((ValaCCodeBaseModule*) self, (ValaExpression*) _tmp646_, (ValaCCodeExpression*) _tmp654_); + _vala_ccode_node_unref0 (_tmp654_); + _g_free0 (_tmp652_); _vala_ccode_node_unref0 (inst); } else { - ValaProperty* _tmp607_ = NULL; - gboolean _tmp608_ = FALSE; - _tmp607_ = prop; - _tmp608_ = vala_ccode_base_module_get_ccode_no_accessor_method (_tmp607_); - if (!_tmp608_) { + ValaProperty* _tmp655_ = NULL; + gboolean _tmp656_ = FALSE; + _tmp655_ = prop; + _tmp656_ = vala_ccode_base_module_get_ccode_no_accessor_method (_tmp655_); + if (!_tmp656_) { gchar* getter_cname = NULL; - ValaProperty* _tmp609_ = NULL; + ValaProperty* _tmp657_ = NULL; ValaCCodeFunctionCall* ccall = NULL; - const gchar* _tmp616_ = NULL; - ValaCCodeIdentifier* _tmp617_ = NULL; - ValaCCodeIdentifier* _tmp618_ = NULL; - ValaCCodeFunctionCall* _tmp619_ = NULL; - ValaCCodeFunctionCall* _tmp620_ = NULL; - ValaProperty* _tmp621_ = NULL; - ValaMemberBinding _tmp622_ = 0; - ValaMemberBinding _tmp623_ = 0; + const gchar* _tmp664_ = NULL; + ValaCCodeIdentifier* _tmp665_ = NULL; + ValaCCodeIdentifier* _tmp666_ = NULL; + ValaCCodeFunctionCall* _tmp667_ = NULL; + ValaCCodeFunctionCall* _tmp668_ = NULL; + ValaProperty* _tmp669_ = NULL; + ValaMemberBinding _tmp670_ = 0; + ValaMemberBinding _tmp671_ = 0; ValaGLibValue* temp_value = NULL; - ValaProperty* _tmp649_ = NULL; - ValaPropertyAccessor* _tmp650_ = NULL; - ValaPropertyAccessor* _tmp651_ = NULL; - ValaDataType* _tmp652_ = NULL; - ValaDataType* _tmp653_ = NULL; - ValaMemberAccess* _tmp654_ = NULL; - ValaTargetValue* _tmp655_ = NULL; - ValaMemberAccess* _tmp656_ = NULL; - ValaGLibValue* _tmp657_ = NULL; - ValaTargetValue* _tmp658_ = NULL; - ValaTargetValue* _tmp659_ = NULL; + ValaProperty* _tmp697_ = NULL; + ValaPropertyAccessor* _tmp698_ = NULL; + ValaPropertyAccessor* _tmp699_ = NULL; + ValaDataType* _tmp700_ = NULL; + ValaDataType* _tmp701_ = NULL; + ValaMemberAccess* _tmp702_ = NULL; + ValaTargetValue* _tmp703_ = NULL; + ValaMemberAccess* _tmp704_ = NULL; + ValaGLibValue* _tmp705_ = NULL; + ValaTargetValue* _tmp706_ = NULL; + ValaTargetValue* _tmp707_ = NULL; ValaCCodeExpression* ctemp = NULL; - ValaGLibValue* _tmp660_ = NULL; - ValaCCodeExpression* _tmp661_ = NULL; - ValaProperty* _tmp662_ = NULL; - ValaDataType* _tmp663_ = NULL; - ValaDataType* _tmp664_ = NULL; - gboolean _tmp665_ = FALSE; - _tmp609_ = prop; - if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp609_, VALA_TYPE_DYNAMIC_PROPERTY)) { - ValaProperty* _tmp610_ = NULL; - gchar* _tmp611_ = NULL; - _tmp610_ = prop; - _tmp611_ = vala_ccode_base_module_get_dynamic_property_getter_cname ((ValaCCodeBaseModule*) self, G_TYPE_CHECK_INSTANCE_CAST (_tmp610_, VALA_TYPE_DYNAMIC_PROPERTY, ValaDynamicProperty)); + ValaGLibValue* _tmp708_ = NULL; + ValaCCodeExpression* _tmp709_ = NULL; + ValaProperty* _tmp710_ = NULL; + ValaDataType* _tmp711_ = NULL; + ValaDataType* _tmp712_ = NULL; + gboolean _tmp713_ = FALSE; + _tmp657_ = prop; + if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp657_, VALA_TYPE_DYNAMIC_PROPERTY)) { + ValaProperty* _tmp658_ = NULL; + gchar* _tmp659_ = NULL; + _tmp658_ = prop; + _tmp659_ = vala_ccode_base_module_get_dynamic_property_getter_cname ((ValaCCodeBaseModule*) self, G_TYPE_CHECK_INSTANCE_CAST (_tmp658_, VALA_TYPE_DYNAMIC_PROPERTY, ValaDynamicProperty)); _g_free0 (getter_cname); - getter_cname = _tmp611_; + getter_cname = _tmp659_; } else { - ValaProperty* _tmp612_ = NULL; - ValaPropertyAccessor* _tmp613_ = NULL; - ValaPropertyAccessor* _tmp614_ = NULL; - gchar* _tmp615_ = NULL; - _tmp612_ = prop; - _tmp613_ = vala_property_get_get_accessor (_tmp612_); - _tmp614_ = _tmp613_; - _tmp615_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp614_); + ValaProperty* _tmp660_ = NULL; + ValaPropertyAccessor* _tmp661_ = NULL; + ValaPropertyAccessor* _tmp662_ = NULL; + gchar* _tmp663_ = NULL; + _tmp660_ = prop; + _tmp661_ = vala_property_get_get_accessor (_tmp660_); + _tmp662_ = _tmp661_; + _tmp663_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp662_); _g_free0 (getter_cname); - getter_cname = _tmp615_; + getter_cname = _tmp663_; } - _tmp616_ = getter_cname; - _tmp617_ = vala_ccode_identifier_new (_tmp616_); - _tmp618_ = _tmp617_; - _tmp619_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp618_); - _tmp620_ = _tmp619_; - _vala_ccode_node_unref0 (_tmp618_); - ccall = _tmp620_; - _tmp621_ = prop; - _tmp622_ = vala_property_get_binding (_tmp621_); - _tmp623_ = _tmp622_; - if (_tmp623_ == VALA_MEMBER_BINDING_INSTANCE) { - gboolean _tmp624_ = FALSE; - ValaProperty* _tmp625_ = NULL; - ValaSymbol* _tmp626_ = NULL; - ValaSymbol* _tmp627_ = NULL; - ValaCCodeFunctionCall* _tmp647_ = NULL; - ValaCCodeExpression* _tmp648_ = NULL; - _tmp625_ = prop; - _tmp626_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp625_); - _tmp627_ = _tmp626_; - if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp627_, VALA_TYPE_STRUCT)) { - ValaProperty* _tmp628_ = NULL; - ValaSymbol* _tmp629_ = NULL; - ValaSymbol* _tmp630_ = NULL; - gboolean _tmp631_ = FALSE; - _tmp628_ = prop; - _tmp629_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp628_); - _tmp630_ = _tmp629_; - _tmp631_ = vala_struct_is_simple_type (G_TYPE_CHECK_INSTANCE_CAST (_tmp630_, VALA_TYPE_STRUCT, ValaStruct)); - _tmp624_ = !_tmp631_; + _tmp664_ = getter_cname; + _tmp665_ = vala_ccode_identifier_new (_tmp664_); + _tmp666_ = _tmp665_; + _tmp667_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp666_); + _tmp668_ = _tmp667_; + _vala_ccode_node_unref0 (_tmp666_); + ccall = _tmp668_; + _tmp669_ = prop; + _tmp670_ = vala_property_get_binding (_tmp669_); + _tmp671_ = _tmp670_; + if (_tmp671_ == VALA_MEMBER_BINDING_INSTANCE) { + gboolean _tmp672_ = FALSE; + ValaProperty* _tmp673_ = NULL; + ValaSymbol* _tmp674_ = NULL; + ValaSymbol* _tmp675_ = NULL; + ValaCCodeFunctionCall* _tmp695_ = NULL; + ValaCCodeExpression* _tmp696_ = NULL; + _tmp673_ = prop; + _tmp674_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp673_); + _tmp675_ = _tmp674_; + if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp675_, VALA_TYPE_STRUCT)) { + ValaProperty* _tmp676_ = NULL; + ValaSymbol* _tmp677_ = NULL; + ValaSymbol* _tmp678_ = NULL; + gboolean _tmp679_ = FALSE; + _tmp676_ = prop; + _tmp677_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp676_); + _tmp678_ = _tmp677_; + _tmp679_ = vala_struct_is_simple_type (G_TYPE_CHECK_INSTANCE_CAST (_tmp678_, VALA_TYPE_STRUCT, ValaStruct)); + _tmp672_ = !_tmp679_; } else { - _tmp624_ = FALSE; + _tmp672_ = FALSE; } - if (_tmp624_) { + if (_tmp672_) { ValaTargetValue* instance = NULL; - ValaMemberAccess* _tmp632_ = NULL; - ValaExpression* _tmp633_ = NULL; - ValaExpression* _tmp634_ = NULL; - ValaTargetValue* _tmp635_ = NULL; - ValaTargetValue* _tmp636_ = NULL; - ValaTargetValue* _tmp637_ = NULL; - ValaTargetValue* _tmp638_ = NULL; - gboolean _tmp639_ = FALSE; - ValaTargetValue* _tmp643_ = NULL; - ValaCCodeExpression* _tmp644_ = NULL; - ValaCCodeExpression* _tmp645_ = NULL; - ValaCCodeUnaryExpression* _tmp646_ = NULL; - _tmp632_ = expr; - _tmp633_ = vala_member_access_get_inner (_tmp632_); - _tmp634_ = _tmp633_; - _tmp635_ = vala_expression_get_target_value (_tmp634_); - _tmp636_ = _tmp635_; - _tmp637_ = _vala_target_value_ref0 (_tmp636_); - instance = _tmp637_; - _tmp638_ = instance; - _tmp639_ = vala_ccode_base_module_get_lvalue ((ValaCCodeBaseModule*) self, _tmp638_); - if (!_tmp639_) { - ValaTargetValue* _tmp640_ = NULL; - ValaMemberAccess* _tmp641_ = NULL; - ValaTargetValue* _tmp642_ = NULL; - _tmp640_ = instance; - _tmp641_ = expr; - _tmp642_ = vala_ccode_base_module_store_temp_value ((ValaCCodeBaseModule*) self, _tmp640_, (ValaCodeNode*) _tmp641_, NULL); + ValaMemberAccess* _tmp680_ = NULL; + ValaExpression* _tmp681_ = NULL; + ValaExpression* _tmp682_ = NULL; + ValaTargetValue* _tmp683_ = NULL; + ValaTargetValue* _tmp684_ = NULL; + ValaTargetValue* _tmp685_ = NULL; + ValaTargetValue* _tmp686_ = NULL; + gboolean _tmp687_ = FALSE; + ValaTargetValue* _tmp691_ = NULL; + ValaCCodeExpression* _tmp692_ = NULL; + ValaCCodeExpression* _tmp693_ = NULL; + ValaCCodeUnaryExpression* _tmp694_ = NULL; + _tmp680_ = expr; + _tmp681_ = vala_member_access_get_inner (_tmp680_); + _tmp682_ = _tmp681_; + _tmp683_ = vala_expression_get_target_value (_tmp682_); + _tmp684_ = _tmp683_; + _tmp685_ = _vala_target_value_ref0 (_tmp684_); + instance = _tmp685_; + _tmp686_ = instance; + _tmp687_ = vala_ccode_base_module_get_lvalue ((ValaCCodeBaseModule*) self, _tmp686_); + if (!_tmp687_) { + ValaTargetValue* _tmp688_ = NULL; + ValaMemberAccess* _tmp689_ = NULL; + ValaTargetValue* _tmp690_ = NULL; + _tmp688_ = instance; + _tmp689_ = expr; + _tmp690_ = vala_ccode_base_module_store_temp_value ((ValaCCodeBaseModule*) self, _tmp688_, (ValaCodeNode*) _tmp689_, NULL); _vala_target_value_unref0 (instance); - instance = _tmp642_; + instance = _tmp690_; } - _tmp643_ = instance; - _tmp644_ = vala_ccode_base_module_get_cvalue_ ((ValaCCodeBaseModule*) self, _tmp643_); - _tmp645_ = _tmp644_; - _tmp646_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, _tmp645_); + _tmp691_ = instance; + _tmp692_ = vala_ccode_base_module_get_cvalue_ ((ValaCCodeBaseModule*) self, _tmp691_); + _tmp693_ = _tmp692_; + _tmp694_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, _tmp693_); _vala_ccode_node_unref0 (pub_inst); - pub_inst = (ValaCCodeExpression*) _tmp646_; - _vala_ccode_node_unref0 (_tmp645_); + pub_inst = (ValaCCodeExpression*) _tmp694_; + _vala_ccode_node_unref0 (_tmp693_); _vala_target_value_unref0 (instance); } - _tmp647_ = ccall; - _tmp648_ = pub_inst; - vala_ccode_function_call_add_argument (_tmp647_, _tmp648_); + _tmp695_ = ccall; + _tmp696_ = pub_inst; + vala_ccode_function_call_add_argument (_tmp695_, _tmp696_); } - _tmp649_ = prop; - _tmp650_ = vala_property_get_get_accessor (_tmp649_); - _tmp651_ = _tmp650_; - _tmp652_ = vala_property_accessor_get_value_type (_tmp651_); - _tmp653_ = _tmp652_; - _tmp654_ = expr; - _tmp655_ = vala_ccode_base_module_create_temp_value ((ValaCCodeBaseModule*) self, _tmp653_, FALSE, (ValaCodeNode*) _tmp654_, NULL); - temp_value = G_TYPE_CHECK_INSTANCE_CAST (_tmp655_, VALA_TYPE_GLIB_VALUE, ValaGLibValue); - _tmp656_ = expr; - _tmp657_ = temp_value; - _tmp658_ = vala_ccode_base_module_load_temp_value ((ValaCCodeBaseModule*) self, (ValaTargetValue*) _tmp657_); - _tmp659_ = _tmp658_; - vala_expression_set_target_value ((ValaExpression*) _tmp656_, _tmp659_); - _vala_target_value_unref0 (_tmp659_); - _tmp660_ = temp_value; - _tmp661_ = vala_ccode_base_module_get_cvalue_ ((ValaCCodeBaseModule*) self, (ValaTargetValue*) _tmp660_); - ctemp = _tmp661_; - _tmp662_ = prop; - _tmp663_ = vala_property_get_property_type (_tmp662_); - _tmp664_ = _tmp663_; - _tmp665_ = vala_data_type_is_real_non_null_struct_type (_tmp664_); - if (_tmp665_) { - ValaCCodeFunctionCall* _tmp666_ = NULL; - ValaCCodeExpression* _tmp667_ = NULL; - ValaCCodeUnaryExpression* _tmp668_ = NULL; - ValaCCodeUnaryExpression* _tmp669_ = NULL; - ValaCCodeFunction* _tmp670_ = NULL; - ValaCCodeFunction* _tmp671_ = NULL; - ValaCCodeFunctionCall* _tmp672_ = NULL; - _tmp666_ = ccall; - _tmp667_ = ctemp; - _tmp668_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, _tmp667_); - _tmp669_ = _tmp668_; - vala_ccode_function_call_add_argument (_tmp666_, (ValaCCodeExpression*) _tmp669_); - _vala_ccode_node_unref0 (_tmp669_); - _tmp670_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); - _tmp671_ = _tmp670_; - _tmp672_ = ccall; - vala_ccode_function_add_expression (_tmp671_, (ValaCCodeExpression*) _tmp672_); + _tmp697_ = prop; + _tmp698_ = vala_property_get_get_accessor (_tmp697_); + _tmp699_ = _tmp698_; + _tmp700_ = vala_property_accessor_get_value_type (_tmp699_); + _tmp701_ = _tmp700_; + _tmp702_ = expr; + _tmp703_ = vala_ccode_base_module_create_temp_value ((ValaCCodeBaseModule*) self, _tmp701_, FALSE, (ValaCodeNode*) _tmp702_, NULL); + temp_value = G_TYPE_CHECK_INSTANCE_CAST (_tmp703_, VALA_TYPE_GLIB_VALUE, ValaGLibValue); + _tmp704_ = expr; + _tmp705_ = temp_value; + _tmp706_ = vala_ccode_base_module_load_temp_value ((ValaCCodeBaseModule*) self, (ValaTargetValue*) _tmp705_); + _tmp707_ = _tmp706_; + vala_expression_set_target_value ((ValaExpression*) _tmp704_, _tmp707_); + _vala_target_value_unref0 (_tmp707_); + _tmp708_ = temp_value; + _tmp709_ = vala_ccode_base_module_get_cvalue_ ((ValaCCodeBaseModule*) self, (ValaTargetValue*) _tmp708_); + ctemp = _tmp709_; + _tmp710_ = prop; + _tmp711_ = vala_property_get_property_type (_tmp710_); + _tmp712_ = _tmp711_; + _tmp713_ = vala_data_type_is_real_non_null_struct_type (_tmp712_); + if (_tmp713_) { + ValaCCodeFunctionCall* _tmp714_ = NULL; + ValaCCodeExpression* _tmp715_ = NULL; + ValaCCodeUnaryExpression* _tmp716_ = NULL; + ValaCCodeUnaryExpression* _tmp717_ = NULL; + ValaCCodeFunction* _tmp718_ = NULL; + ValaCCodeFunction* _tmp719_ = NULL; + ValaCCodeFunctionCall* _tmp720_ = NULL; + _tmp714_ = ccall; + _tmp715_ = ctemp; + _tmp716_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, _tmp715_); + _tmp717_ = _tmp716_; + vala_ccode_function_call_add_argument (_tmp714_, (ValaCCodeExpression*) _tmp717_); + _vala_ccode_node_unref0 (_tmp717_); + _tmp718_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp719_ = _tmp718_; + _tmp720_ = ccall; + vala_ccode_function_add_expression (_tmp719_, (ValaCCodeExpression*) _tmp720_); } else { - ValaCCodeFunction* _tmp673_ = NULL; - ValaCCodeFunction* _tmp674_ = NULL; - ValaCCodeExpression* _tmp675_ = NULL; - ValaCCodeFunctionCall* _tmp676_ = NULL; - ValaProperty* _tmp677_ = NULL; - ValaDataType* _tmp678_ = NULL; - ValaDataType* _tmp679_ = NULL; - ValaArrayType* _tmp680_ = NULL; - ValaArrayType* _tmp681_ = NULL; - _tmp673_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); - _tmp674_ = _tmp673_; - _tmp675_ = ctemp; - _tmp676_ = ccall; - vala_ccode_function_add_assignment (_tmp674_, _tmp675_, (ValaCCodeExpression*) _tmp676_); - _tmp677_ = prop; - _tmp678_ = vala_property_get_property_type (_tmp677_); - _tmp679_ = _tmp678_; - _tmp680_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp679_, VALA_TYPE_ARRAY_TYPE) ? ((ValaArrayType*) _tmp679_) : NULL); + ValaCCodeFunction* _tmp721_ = NULL; + ValaCCodeFunction* _tmp722_ = NULL; + ValaCCodeExpression* _tmp723_ = NULL; + ValaCCodeFunctionCall* _tmp724_ = NULL; + ValaProperty* _tmp725_ = NULL; + ValaDataType* _tmp726_ = NULL; + ValaDataType* _tmp727_ = NULL; + ValaArrayType* _tmp728_ = NULL; + ValaArrayType* _tmp729_ = NULL; + _tmp721_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp722_ = _tmp721_; + _tmp723_ = ctemp; + _tmp724_ = ccall; + vala_ccode_function_add_assignment (_tmp722_, _tmp723_, (ValaCCodeExpression*) _tmp724_); + _tmp725_ = prop; + _tmp726_ = vala_property_get_property_type (_tmp725_); + _tmp727_ = _tmp726_; + _tmp728_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp727_, VALA_TYPE_ARRAY_TYPE) ? ((ValaArrayType*) _tmp727_) : NULL); _vala_code_node_unref0 (array_type); - array_type = _tmp680_; - _tmp681_ = array_type; - if (_tmp681_ != NULL) { - ValaProperty* _tmp682_ = NULL; - gboolean _tmp683_ = FALSE; - _tmp682_ = prop; - _tmp683_ = vala_ccode_base_module_get_ccode_array_null_terminated ((ValaCodeNode*) _tmp682_); - if (_tmp683_) { + array_type = _tmp728_; + _tmp729_ = array_type; + if (_tmp729_ != NULL) { + ValaProperty* _tmp730_ = NULL; + gboolean _tmp731_ = FALSE; + _tmp730_ = prop; + _tmp731_ = vala_ccode_base_module_get_ccode_array_null_terminated ((ValaCodeNode*) _tmp730_); + if (_tmp731_) { ValaCCodeFunctionCall* len_call = NULL; - ValaCCodeIdentifier* _tmp684_ = NULL; - ValaCCodeIdentifier* _tmp685_ = NULL; - ValaCCodeFunctionCall* _tmp686_ = NULL; - ValaCCodeFunctionCall* _tmp687_ = NULL; - ValaCCodeFunctionCall* _tmp688_ = NULL; - ValaCCodeExpression* _tmp689_ = NULL; - ValaCCodeFunction* _tmp690_ = NULL; - ValaCCodeFunction* _tmp691_ = NULL; - ValaGLibValue* _tmp692_ = NULL; - ValaList* _tmp693_ = NULL; - gpointer _tmp694_ = NULL; - ValaCCodeExpression* _tmp695_ = NULL; - ValaCCodeFunctionCall* _tmp696_ = NULL; + ValaCCodeIdentifier* _tmp732_ = NULL; + ValaCCodeIdentifier* _tmp733_ = NULL; + ValaCCodeFunctionCall* _tmp734_ = NULL; + ValaCCodeFunctionCall* _tmp735_ = NULL; + ValaCCodeFunctionCall* _tmp736_ = NULL; + ValaCCodeExpression* _tmp737_ = NULL; + ValaCCodeFunction* _tmp738_ = NULL; + ValaCCodeFunction* _tmp739_ = NULL; + ValaGLibValue* _tmp740_ = NULL; + ValaList* _tmp741_ = NULL; + gpointer _tmp742_ = NULL; + ValaCCodeExpression* _tmp743_ = NULL; + ValaCCodeFunctionCall* _tmp744_ = NULL; ((ValaCCodeBaseModule*) self)->requires_array_length = TRUE; - _tmp684_ = vala_ccode_identifier_new ("_vala_array_length"); - _tmp685_ = _tmp684_; - _tmp686_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp685_); - _tmp687_ = _tmp686_; - _vala_ccode_node_unref0 (_tmp685_); - len_call = _tmp687_; - _tmp688_ = len_call; - _tmp689_ = ctemp; - vala_ccode_function_call_add_argument (_tmp688_, _tmp689_); - _tmp690_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); - _tmp691_ = _tmp690_; - _tmp692_ = temp_value; - _tmp693_ = _tmp692_->array_length_cvalues; - _tmp694_ = vala_list_get (_tmp693_, 0); - _tmp695_ = (ValaCCodeExpression*) _tmp694_; - _tmp696_ = len_call; - vala_ccode_function_add_assignment (_tmp691_, _tmp695_, (ValaCCodeExpression*) _tmp696_); - _vala_ccode_node_unref0 (_tmp695_); + _tmp732_ = vala_ccode_identifier_new ("_vala_array_length"); + _tmp733_ = _tmp732_; + _tmp734_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp733_); + _tmp735_ = _tmp734_; + _vala_ccode_node_unref0 (_tmp733_); + len_call = _tmp735_; + _tmp736_ = len_call; + _tmp737_ = ctemp; + vala_ccode_function_call_add_argument (_tmp736_, _tmp737_); + _tmp738_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp739_ = _tmp738_; + _tmp740_ = temp_value; + _tmp741_ = _tmp740_->array_length_cvalues; + _tmp742_ = vala_list_get (_tmp741_, 0); + _tmp743_ = (ValaCCodeExpression*) _tmp742_; + _tmp744_ = len_call; + vala_ccode_function_add_assignment (_tmp739_, _tmp743_, (ValaCCodeExpression*) _tmp744_); + _vala_ccode_node_unref0 (_tmp743_); _vala_ccode_node_unref0 (len_call); } else { - ValaProperty* _tmp697_ = NULL; - gboolean _tmp698_ = FALSE; - _tmp697_ = prop; - _tmp698_ = vala_ccode_base_module_get_ccode_array_length ((ValaCodeNode*) _tmp697_); - if (_tmp698_) { + ValaProperty* _tmp745_ = NULL; + gboolean _tmp746_ = FALSE; + _tmp745_ = prop; + _tmp746_ = vala_ccode_base_module_get_ccode_array_length ((ValaCodeNode*) _tmp745_); + if (_tmp746_) { { gint dim = 0; dim = 1; { - gboolean _tmp699_ = FALSE; - _tmp699_ = TRUE; + gboolean _tmp747_ = FALSE; + _tmp747_ = TRUE; while (TRUE) { - gint _tmp701_ = 0; - ValaArrayType* _tmp702_ = NULL; - gint _tmp703_ = 0; - gint _tmp704_ = 0; - ValaCCodeFunctionCall* _tmp705_ = NULL; - ValaGLibValue* _tmp706_ = NULL; - gint _tmp707_ = 0; - ValaCCodeExpression* _tmp708_ = NULL; - ValaCCodeExpression* _tmp709_ = NULL; - ValaCCodeUnaryExpression* _tmp710_ = NULL; - ValaCCodeUnaryExpression* _tmp711_ = NULL; - if (!_tmp699_) { - gint _tmp700_ = 0; - _tmp700_ = dim; - dim = _tmp700_ + 1; + gint _tmp749_ = 0; + ValaArrayType* _tmp750_ = NULL; + gint _tmp751_ = 0; + gint _tmp752_ = 0; + ValaCCodeFunctionCall* _tmp753_ = NULL; + ValaGLibValue* _tmp754_ = NULL; + gint _tmp755_ = 0; + ValaCCodeExpression* _tmp756_ = NULL; + ValaCCodeExpression* _tmp757_ = NULL; + ValaCCodeUnaryExpression* _tmp758_ = NULL; + ValaCCodeUnaryExpression* _tmp759_ = NULL; + if (!_tmp747_) { + gint _tmp748_ = 0; + _tmp748_ = dim; + dim = _tmp748_ + 1; } - _tmp699_ = FALSE; - _tmp701_ = dim; - _tmp702_ = array_type; - _tmp703_ = vala_array_type_get_rank (_tmp702_); - _tmp704_ = _tmp703_; - if (!(_tmp701_ <= _tmp704_)) { + _tmp747_ = FALSE; + _tmp749_ = dim; + _tmp750_ = array_type; + _tmp751_ = vala_array_type_get_rank (_tmp750_); + _tmp752_ = _tmp751_; + if (!(_tmp749_ <= _tmp752_)) { break; } - _tmp705_ = ccall; - _tmp706_ = temp_value; - _tmp707_ = dim; - _tmp708_ = vala_ccode_base_module_get_array_length_cvalue ((ValaCCodeBaseModule*) self, (ValaTargetValue*) _tmp706_, _tmp707_); - _tmp709_ = _tmp708_; - _tmp710_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, _tmp709_); - _tmp711_ = _tmp710_; - vala_ccode_function_call_add_argument (_tmp705_, (ValaCCodeExpression*) _tmp711_); - _vala_ccode_node_unref0 (_tmp711_); - _vala_ccode_node_unref0 (_tmp709_); + _tmp753_ = ccall; + _tmp754_ = temp_value; + _tmp755_ = dim; + _tmp756_ = vala_ccode_base_module_get_array_length_cvalue ((ValaCCodeBaseModule*) self, (ValaTargetValue*) _tmp754_, _tmp755_); + _tmp757_ = _tmp756_; + _tmp758_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, _tmp757_); + _tmp759_ = _tmp758_; + vala_ccode_function_call_add_argument (_tmp753_, (ValaCCodeExpression*) _tmp759_); + _vala_ccode_node_unref0 (_tmp759_); + _vala_ccode_node_unref0 (_tmp757_); } } } } } } else { - ValaProperty* _tmp712_ = NULL; - ValaDataType* _tmp713_ = NULL; - ValaDataType* _tmp714_ = NULL; - ValaDelegateType* _tmp715_ = NULL; - gboolean _tmp716_ = FALSE; - ValaDelegateType* _tmp717_ = NULL; - _tmp712_ = prop; - _tmp713_ = vala_property_get_property_type (_tmp712_); - _tmp714_ = _tmp713_; - _tmp715_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp714_, VALA_TYPE_DELEGATE_TYPE) ? ((ValaDelegateType*) _tmp714_) : NULL); + ValaProperty* _tmp760_ = NULL; + ValaDataType* _tmp761_ = NULL; + ValaDataType* _tmp762_ = NULL; + ValaDelegateType* _tmp763_ = NULL; + gboolean _tmp764_ = FALSE; + ValaDelegateType* _tmp765_ = NULL; + _tmp760_ = prop; + _tmp761_ = vala_property_get_property_type (_tmp760_); + _tmp762_ = _tmp761_; + _tmp763_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp762_, VALA_TYPE_DELEGATE_TYPE) ? ((ValaDelegateType*) _tmp762_) : NULL); _vala_code_node_unref0 (delegate_type); - delegate_type = _tmp715_; - _tmp717_ = delegate_type; - if (_tmp717_ != NULL) { - ValaDelegateType* _tmp718_ = NULL; - ValaDelegate* _tmp719_ = NULL; - ValaDelegate* _tmp720_ = NULL; - gboolean _tmp721_ = FALSE; - gboolean _tmp722_ = FALSE; - _tmp718_ = delegate_type; - _tmp719_ = vala_delegate_type_get_delegate_symbol (_tmp718_); - _tmp720_ = _tmp719_; - _tmp721_ = vala_delegate_get_has_target (_tmp720_); - _tmp722_ = _tmp721_; - _tmp716_ = _tmp722_; + delegate_type = _tmp763_; + _tmp765_ = delegate_type; + if (_tmp765_ != NULL) { + ValaDelegateType* _tmp766_ = NULL; + ValaDelegate* _tmp767_ = NULL; + ValaDelegate* _tmp768_ = NULL; + gboolean _tmp769_ = FALSE; + gboolean _tmp770_ = FALSE; + _tmp766_ = delegate_type; + _tmp767_ = vala_delegate_type_get_delegate_symbol (_tmp766_); + _tmp768_ = _tmp767_; + _tmp769_ = vala_delegate_get_has_target (_tmp768_); + _tmp770_ = _tmp769_; + _tmp764_ = _tmp770_; } else { - _tmp716_ = FALSE; + _tmp764_ = FALSE; } - if (_tmp716_) { - ValaCCodeFunctionCall* _tmp723_ = NULL; - ValaGLibValue* _tmp724_ = NULL; - ValaCCodeExpression* _tmp725_ = NULL; - ValaCCodeExpression* _tmp726_ = NULL; - ValaCCodeUnaryExpression* _tmp727_ = NULL; - ValaCCodeUnaryExpression* _tmp728_ = NULL; - _tmp723_ = ccall; - _tmp724_ = temp_value; - _tmp725_ = vala_ccode_base_module_get_delegate_target_cvalue ((ValaCCodeBaseModule*) self, (ValaTargetValue*) _tmp724_); - _tmp726_ = _tmp725_; - _tmp727_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, _tmp726_); - _tmp728_ = _tmp727_; - vala_ccode_function_call_add_argument (_tmp723_, (ValaCCodeExpression*) _tmp728_); - _vala_ccode_node_unref0 (_tmp728_); - _vala_ccode_node_unref0 (_tmp726_); + if (_tmp764_) { + ValaCCodeFunctionCall* _tmp771_ = NULL; + ValaGLibValue* _tmp772_ = NULL; + ValaCCodeExpression* _tmp773_ = NULL; + ValaCCodeExpression* _tmp774_ = NULL; + ValaCCodeUnaryExpression* _tmp775_ = NULL; + ValaCCodeUnaryExpression* _tmp776_ = NULL; + _tmp771_ = ccall; + _tmp772_ = temp_value; + _tmp773_ = vala_ccode_base_module_get_delegate_target_cvalue ((ValaCCodeBaseModule*) self, (ValaTargetValue*) _tmp772_); + _tmp774_ = _tmp773_; + _tmp775_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, _tmp774_); + _tmp776_ = _tmp775_; + vala_ccode_function_call_add_argument (_tmp771_, (ValaCCodeExpression*) _tmp776_); + _vala_ccode_node_unref0 (_tmp776_); + _vala_ccode_node_unref0 (_tmp774_); } } } @@ -2398,417 +2522,417 @@ _g_free0 (getter_cname); } else { ValaCCodeFunctionCall* ccall = NULL; - ValaCCodeIdentifier* _tmp729_ = NULL; - ValaCCodeIdentifier* _tmp730_ = NULL; - ValaCCodeFunctionCall* _tmp731_ = NULL; - ValaCCodeFunctionCall* _tmp732_ = NULL; - ValaCCodeFunctionCall* _tmp733_ = NULL; - ValaCCodeExpression* _tmp734_ = NULL; - ValaCCodeFunctionCall* _tmp735_ = NULL; - ValaProperty* _tmp736_ = NULL; - ValaCCodeConstant* _tmp737_ = NULL; - ValaCCodeConstant* _tmp738_ = NULL; - ValaProperty* _tmp739_ = NULL; - ValaPropertyAccessor* _tmp740_ = NULL; - ValaPropertyAccessor* _tmp741_ = NULL; - ValaDataType* _tmp742_ = NULL; - ValaDataType* _tmp743_ = NULL; - gboolean _tmp744_ = FALSE; - gboolean _tmp745_ = FALSE; - ValaMemberAccess* _tmp765_ = NULL; - ValaDataType* _tmp766_ = NULL; - ValaDataType* _tmp767_ = NULL; - gboolean _tmp768_ = FALSE; - ValaLocalVariable* temp_var = NULL; - ValaMemberAccess* _tmp772_ = NULL; - ValaDataType* _tmp773_ = NULL; - ValaDataType* _tmp774_ = NULL; - ValaLocalVariable* _tmp775_ = NULL; - ValaCCodeExpression* ctemp = NULL; - ValaLocalVariable* _tmp776_ = NULL; - const gchar* _tmp777_ = NULL; - const gchar* _tmp778_ = NULL; - ValaCCodeExpression* _tmp779_ = NULL; - ValaLocalVariable* _tmp780_ = NULL; + ValaCCodeIdentifier* _tmp777_ = NULL; + ValaCCodeIdentifier* _tmp778_ = NULL; + ValaCCodeFunctionCall* _tmp779_ = NULL; + ValaCCodeFunctionCall* _tmp780_ = NULL; ValaCCodeFunctionCall* _tmp781_ = NULL; ValaCCodeExpression* _tmp782_ = NULL; - ValaCCodeUnaryExpression* _tmp783_ = NULL; - ValaCCodeUnaryExpression* _tmp784_ = NULL; - ValaCCodeFunctionCall* _tmp785_ = NULL; + ValaCCodeFunctionCall* _tmp783_ = NULL; + ValaProperty* _tmp784_ = NULL; + ValaCCodeConstant* _tmp785_ = NULL; ValaCCodeConstant* _tmp786_ = NULL; - ValaCCodeConstant* _tmp787_ = NULL; - ValaCCodeFunction* _tmp788_ = NULL; - ValaCCodeFunction* _tmp789_ = NULL; - ValaCCodeFunctionCall* _tmp790_ = NULL; - ValaMemberAccess* _tmp791_ = NULL; - ValaCCodeExpression* _tmp792_ = NULL; - _tmp729_ = vala_ccode_identifier_new ("g_object_get"); - _tmp730_ = _tmp729_; - _tmp731_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp730_); - _tmp732_ = _tmp731_; - _vala_ccode_node_unref0 (_tmp730_); - ccall = _tmp732_; - _tmp733_ = ccall; - _tmp734_ = pub_inst; - vala_ccode_function_call_add_argument (_tmp733_, _tmp734_); - _tmp735_ = ccall; - _tmp736_ = prop; - _tmp737_ = vala_ccode_base_module_get_property_canonical_cconstant ((ValaCCodeBaseModule*) self, _tmp736_); - _tmp738_ = _tmp737_; - vala_ccode_function_call_add_argument (_tmp735_, (ValaCCodeExpression*) _tmp738_); - _vala_ccode_node_unref0 (_tmp738_); - _tmp739_ = prop; - _tmp740_ = vala_property_get_get_accessor (_tmp739_); - _tmp741_ = _tmp740_; - _tmp742_ = vala_property_accessor_get_value_type (_tmp741_); - _tmp743_ = _tmp742_; - _tmp744_ = vala_data_type_get_value_owned (_tmp743_); - _tmp745_ = _tmp744_; - if (!_tmp745_) { + ValaProperty* _tmp787_ = NULL; + ValaPropertyAccessor* _tmp788_ = NULL; + ValaPropertyAccessor* _tmp789_ = NULL; + ValaDataType* _tmp790_ = NULL; + ValaDataType* _tmp791_ = NULL; + gboolean _tmp792_ = FALSE; + gboolean _tmp793_ = FALSE; + ValaMemberAccess* _tmp813_ = NULL; + ValaDataType* _tmp814_ = NULL; + ValaDataType* _tmp815_ = NULL; + gboolean _tmp816_ = FALSE; + ValaLocalVariable* temp_var = NULL; + ValaMemberAccess* _tmp820_ = NULL; + ValaDataType* _tmp821_ = NULL; + ValaDataType* _tmp822_ = NULL; + ValaLocalVariable* _tmp823_ = NULL; + ValaCCodeExpression* ctemp = NULL; + ValaLocalVariable* _tmp824_ = NULL; + const gchar* _tmp825_ = NULL; + const gchar* _tmp826_ = NULL; + ValaCCodeExpression* _tmp827_ = NULL; + ValaLocalVariable* _tmp828_ = NULL; + ValaCCodeFunctionCall* _tmp829_ = NULL; + ValaCCodeExpression* _tmp830_ = NULL; + ValaCCodeUnaryExpression* _tmp831_ = NULL; + ValaCCodeUnaryExpression* _tmp832_ = NULL; + ValaCCodeFunctionCall* _tmp833_ = NULL; + ValaCCodeConstant* _tmp834_ = NULL; + ValaCCodeConstant* _tmp835_ = NULL; + ValaCCodeFunction* _tmp836_ = NULL; + ValaCCodeFunction* _tmp837_ = NULL; + ValaCCodeFunctionCall* _tmp838_ = NULL; + ValaMemberAccess* _tmp839_ = NULL; + ValaCCodeExpression* _tmp840_ = NULL; + _tmp777_ = vala_ccode_identifier_new ("g_object_get"); + _tmp778_ = _tmp777_; + _tmp779_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp778_); + _tmp780_ = _tmp779_; + _vala_ccode_node_unref0 (_tmp778_); + ccall = _tmp780_; + _tmp781_ = ccall; + _tmp782_ = pub_inst; + vala_ccode_function_call_add_argument (_tmp781_, _tmp782_); + _tmp783_ = ccall; + _tmp784_ = prop; + _tmp785_ = vala_ccode_base_module_get_property_canonical_cconstant ((ValaCCodeBaseModule*) self, _tmp784_); + _tmp786_ = _tmp785_; + vala_ccode_function_call_add_argument (_tmp783_, (ValaCCodeExpression*) _tmp786_); + _vala_ccode_node_unref0 (_tmp786_); + _tmp787_ = prop; + _tmp788_ = vala_property_get_get_accessor (_tmp787_); + _tmp789_ = _tmp788_; + _tmp790_ = vala_property_accessor_get_value_type (_tmp789_); + _tmp791_ = _tmp790_; + _tmp792_ = vala_data_type_get_value_owned (_tmp791_); + _tmp793_ = _tmp792_; + if (!_tmp793_) { ValaDataType* owned_value_type = NULL; - ValaProperty* _tmp746_ = NULL; - ValaPropertyAccessor* _tmp747_ = NULL; - ValaPropertyAccessor* _tmp748_ = NULL; - ValaDataType* _tmp749_ = NULL; - ValaDataType* _tmp750_ = NULL; - ValaDataType* _tmp751_ = NULL; - ValaDataType* _tmp752_ = NULL; - ValaDataType* _tmp753_ = NULL; - gboolean _tmp754_ = FALSE; - _tmp746_ = prop; - _tmp747_ = vala_property_get_get_accessor (_tmp746_); - _tmp748_ = _tmp747_; - _tmp749_ = vala_property_accessor_get_value_type (_tmp748_); - _tmp750_ = _tmp749_; - _tmp751_ = vala_data_type_copy (_tmp750_); - owned_value_type = _tmp751_; - _tmp752_ = owned_value_type; - vala_data_type_set_value_owned (_tmp752_, TRUE); - _tmp753_ = owned_value_type; - _tmp754_ = vala_ccode_base_module_requires_copy ((ValaCCodeBaseModule*) self, _tmp753_); - if (_tmp754_) { - ValaProperty* _tmp755_ = NULL; - ValaPropertyAccessor* _tmp756_ = NULL; - ValaPropertyAccessor* _tmp757_ = NULL; - ValaSourceReference* _tmp758_ = NULL; - ValaSourceReference* _tmp759_ = NULL; - ValaProperty* _tmp760_ = NULL; - gchar* _tmp761_ = NULL; - gchar* _tmp762_ = NULL; - gchar* _tmp763_ = NULL; - gchar* _tmp764_ = NULL; - _tmp755_ = prop; - _tmp756_ = vala_property_get_get_accessor (_tmp755_); - _tmp757_ = _tmp756_; - _tmp758_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp757_); - _tmp759_ = _tmp758_; - _tmp760_ = prop; - _tmp761_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp760_); - _tmp762_ = _tmp761_; - _tmp763_ = g_strdup_printf ("unowned return value for getter of property `%s' not supported without" \ -" accessor", _tmp762_); - _tmp764_ = _tmp763_; - vala_report_error (_tmp759_, _tmp764_); - _g_free0 (_tmp764_); - _g_free0 (_tmp762_); + ValaProperty* _tmp794_ = NULL; + ValaPropertyAccessor* _tmp795_ = NULL; + ValaPropertyAccessor* _tmp796_ = NULL; + ValaDataType* _tmp797_ = NULL; + ValaDataType* _tmp798_ = NULL; + ValaDataType* _tmp799_ = NULL; + ValaDataType* _tmp800_ = NULL; + ValaDataType* _tmp801_ = NULL; + gboolean _tmp802_ = FALSE; + _tmp794_ = prop; + _tmp795_ = vala_property_get_get_accessor (_tmp794_); + _tmp796_ = _tmp795_; + _tmp797_ = vala_property_accessor_get_value_type (_tmp796_); + _tmp798_ = _tmp797_; + _tmp799_ = vala_data_type_copy (_tmp798_); + owned_value_type = _tmp799_; + _tmp800_ = owned_value_type; + vala_data_type_set_value_owned (_tmp800_, TRUE); + _tmp801_ = owned_value_type; + _tmp802_ = vala_ccode_base_module_requires_copy ((ValaCCodeBaseModule*) self, _tmp801_); + if (_tmp802_) { + ValaProperty* _tmp803_ = NULL; + ValaPropertyAccessor* _tmp804_ = NULL; + ValaPropertyAccessor* _tmp805_ = NULL; + ValaSourceReference* _tmp806_ = NULL; + ValaSourceReference* _tmp807_ = NULL; + ValaProperty* _tmp808_ = NULL; + gchar* _tmp809_ = NULL; + gchar* _tmp810_ = NULL; + gchar* _tmp811_ = NULL; + gchar* _tmp812_ = NULL; + _tmp803_ = prop; + _tmp804_ = vala_property_get_get_accessor (_tmp803_); + _tmp805_ = _tmp804_; + _tmp806_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp805_); + _tmp807_ = _tmp806_; + _tmp808_ = prop; + _tmp809_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp808_); + _tmp810_ = _tmp809_; + _tmp811_ = g_strdup_printf ("unowned return value for getter of property `%s' not supported without" \ +" accessor", _tmp810_); + _tmp812_ = _tmp811_; + vala_report_error (_tmp807_, _tmp812_); + _g_free0 (_tmp812_); + _g_free0 (_tmp810_); } _vala_code_node_unref0 (owned_value_type); } - _tmp765_ = expr; - _tmp766_ = vala_expression_get_value_type ((ValaExpression*) _tmp765_); - _tmp767_ = _tmp766_; - _tmp768_ = vala_data_type_is_real_struct_type (_tmp767_); - if (_tmp768_) { - ValaMemberAccess* _tmp769_ = NULL; - ValaDataType* _tmp770_ = NULL; - ValaDataType* _tmp771_ = NULL; - _tmp769_ = expr; - _tmp770_ = vala_expression_get_value_type ((ValaExpression*) _tmp769_); - _tmp771_ = _tmp770_; - vala_data_type_set_nullable (_tmp771_, TRUE); + _tmp813_ = expr; + _tmp814_ = vala_expression_get_value_type ((ValaExpression*) _tmp813_); + _tmp815_ = _tmp814_; + _tmp816_ = vala_data_type_is_real_struct_type (_tmp815_); + if (_tmp816_) { + ValaMemberAccess* _tmp817_ = NULL; + ValaDataType* _tmp818_ = NULL; + ValaDataType* _tmp819_ = NULL; + _tmp817_ = expr; + _tmp818_ = vala_expression_get_value_type ((ValaExpression*) _tmp817_); + _tmp819_ = _tmp818_; + vala_data_type_set_nullable (_tmp819_, TRUE); } - _tmp772_ = expr; - _tmp773_ = vala_expression_get_value_type ((ValaExpression*) _tmp772_); - _tmp774_ = _tmp773_; - _tmp775_ = vala_ccode_base_module_get_temp_variable ((ValaCCodeBaseModule*) self, _tmp774_, TRUE, NULL, TRUE); - temp_var = _tmp775_; - _tmp776_ = temp_var; - _tmp777_ = vala_symbol_get_name ((ValaSymbol*) _tmp776_); - _tmp778_ = _tmp777_; - _tmp779_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, _tmp778_); - ctemp = _tmp779_; - _tmp780_ = temp_var; - vala_ccode_base_module_emit_temp_var ((ValaCCodeBaseModule*) self, _tmp780_); - _tmp781_ = ccall; - _tmp782_ = ctemp; - _tmp783_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, _tmp782_); - _tmp784_ = _tmp783_; - vala_ccode_function_call_add_argument (_tmp781_, (ValaCCodeExpression*) _tmp784_); - _vala_ccode_node_unref0 (_tmp784_); - _tmp785_ = ccall; - _tmp786_ = vala_ccode_constant_new ("NULL"); - _tmp787_ = _tmp786_; - vala_ccode_function_call_add_argument (_tmp785_, (ValaCCodeExpression*) _tmp787_); - _vala_ccode_node_unref0 (_tmp787_); - _tmp788_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); - _tmp789_ = _tmp788_; - _tmp790_ = ccall; - vala_ccode_function_add_expression (_tmp789_, (ValaCCodeExpression*) _tmp790_); - _tmp791_ = expr; - _tmp792_ = ctemp; - vala_ccode_base_module_set_cvalue ((ValaCCodeBaseModule*) self, (ValaExpression*) _tmp791_, _tmp792_); + _tmp820_ = expr; + _tmp821_ = vala_expression_get_value_type ((ValaExpression*) _tmp820_); + _tmp822_ = _tmp821_; + _tmp823_ = vala_ccode_base_module_get_temp_variable ((ValaCCodeBaseModule*) self, _tmp822_, TRUE, NULL, TRUE); + temp_var = _tmp823_; + _tmp824_ = temp_var; + _tmp825_ = vala_symbol_get_name ((ValaSymbol*) _tmp824_); + _tmp826_ = _tmp825_; + _tmp827_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, _tmp826_); + ctemp = _tmp827_; + _tmp828_ = temp_var; + vala_ccode_base_module_emit_temp_var ((ValaCCodeBaseModule*) self, _tmp828_); + _tmp829_ = ccall; + _tmp830_ = ctemp; + _tmp831_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, _tmp830_); + _tmp832_ = _tmp831_; + vala_ccode_function_call_add_argument (_tmp829_, (ValaCCodeExpression*) _tmp832_); + _vala_ccode_node_unref0 (_tmp832_); + _tmp833_ = ccall; + _tmp834_ = vala_ccode_constant_new ("NULL"); + _tmp835_ = _tmp834_; + vala_ccode_function_call_add_argument (_tmp833_, (ValaCCodeExpression*) _tmp835_); + _vala_ccode_node_unref0 (_tmp835_); + _tmp836_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp837_ = _tmp836_; + _tmp838_ = ccall; + vala_ccode_function_add_expression (_tmp837_, (ValaCCodeExpression*) _tmp838_); + _tmp839_ = expr; + _tmp840_ = ctemp; + vala_ccode_base_module_set_cvalue ((ValaCCodeBaseModule*) self, (ValaExpression*) _tmp839_, _tmp840_); _vala_ccode_node_unref0 (ctemp); _vala_code_node_unref0 (temp_var); _vala_ccode_node_unref0 (ccall); } } } - _tmp793_ = expr; - _tmp794_ = vala_expression_get_target_value ((ValaExpression*) _tmp793_); - _tmp795_ = _tmp794_; - _tmp796_ = expr; - _tmp797_ = vala_expression_get_value_type ((ValaExpression*) _tmp796_); - _tmp798_ = _tmp797_; - vala_target_value_set_value_type (_tmp795_, _tmp798_); - _tmp799_ = expr; - _tmp800_ = expr; - _tmp801_ = vala_expression_get_target_value ((ValaExpression*) _tmp800_); - _tmp802_ = _tmp801_; - _tmp803_ = expr; - _tmp804_ = vala_ccode_base_module_store_temp_value ((ValaCCodeBaseModule*) self, _tmp802_, (ValaCodeNode*) _tmp803_, NULL); - _tmp805_ = _tmp804_; - vala_expression_set_target_value ((ValaExpression*) _tmp799_, _tmp805_); - _vala_target_value_unref0 (_tmp805_); + _tmp841_ = expr; + _tmp842_ = vala_expression_get_target_value ((ValaExpression*) _tmp841_); + _tmp843_ = _tmp842_; + _tmp844_ = expr; + _tmp845_ = vala_expression_get_value_type ((ValaExpression*) _tmp844_); + _tmp846_ = _tmp845_; + vala_target_value_set_value_type (_tmp843_, _tmp846_); + _tmp847_ = expr; + _tmp848_ = expr; + _tmp849_ = vala_expression_get_target_value ((ValaExpression*) _tmp848_); + _tmp850_ = _tmp849_; + _tmp851_ = expr; + _tmp852_ = vala_ccode_base_module_store_temp_value ((ValaCCodeBaseModule*) self, _tmp850_, (ValaCodeNode*) _tmp851_, NULL); + _tmp853_ = _tmp852_; + vala_expression_set_target_value ((ValaExpression*) _tmp847_, _tmp853_); + _vala_target_value_unref0 (_tmp853_); _vala_code_node_unref0 (prop); } else { - ValaMemberAccess* _tmp806_ = NULL; - ValaSymbol* _tmp807_ = NULL; - ValaSymbol* _tmp808_ = NULL; - _tmp806_ = expr; - _tmp807_ = vala_expression_get_symbol_reference ((ValaExpression*) _tmp806_); - _tmp808_ = _tmp807_; - if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp808_, VALA_TYPE_LOCAL_VARIABLE)) { + ValaMemberAccess* _tmp854_ = NULL; + ValaSymbol* _tmp855_ = NULL; + ValaSymbol* _tmp856_ = NULL; + _tmp854_ = expr; + _tmp855_ = vala_expression_get_symbol_reference ((ValaExpression*) _tmp854_); + _tmp856_ = _tmp855_; + if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp856_, VALA_TYPE_LOCAL_VARIABLE)) { ValaLocalVariable* local = NULL; - ValaMemberAccess* _tmp809_ = NULL; - ValaSymbol* _tmp810_ = NULL; - ValaSymbol* _tmp811_ = NULL; - ValaLocalVariable* _tmp812_ = NULL; - gboolean _tmp813_ = FALSE; - gboolean _tmp814_ = FALSE; - gboolean _tmp815_ = FALSE; - gboolean _tmp816_ = FALSE; - gboolean _tmp817_ = FALSE; - ValaMemberAccess* _tmp818_ = NULL; - ValaCodeNode* _tmp819_ = NULL; - ValaCodeNode* _tmp820_ = NULL; - _tmp809_ = expr; - _tmp810_ = vala_expression_get_symbol_reference ((ValaExpression*) _tmp809_); - _tmp811_ = _tmp810_; - _tmp812_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp811_, VALA_TYPE_LOCAL_VARIABLE, ValaLocalVariable)); - local = _tmp812_; - _tmp818_ = expr; - _tmp819_ = vala_code_node_get_parent_node ((ValaCodeNode*) _tmp818_); - _tmp820_ = _tmp819_; - if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp820_, VALA_TYPE_RETURN_STATEMENT)) { - ValaDataType* _tmp821_ = NULL; - ValaDataType* _tmp822_ = NULL; - gboolean _tmp823_ = FALSE; - gboolean _tmp824_ = FALSE; - _tmp821_ = vala_ccode_base_module_get_current_return_type ((ValaCCodeBaseModule*) self); - _tmp822_ = _tmp821_; - _tmp823_ = vala_data_type_get_value_owned (_tmp822_); - _tmp824_ = _tmp823_; - _tmp817_ = _tmp824_; + ValaMemberAccess* _tmp857_ = NULL; + ValaSymbol* _tmp858_ = NULL; + ValaSymbol* _tmp859_ = NULL; + ValaLocalVariable* _tmp860_ = NULL; + gboolean _tmp861_ = FALSE; + gboolean _tmp862_ = FALSE; + gboolean _tmp863_ = FALSE; + gboolean _tmp864_ = FALSE; + gboolean _tmp865_ = FALSE; + ValaMemberAccess* _tmp866_ = NULL; + ValaCodeNode* _tmp867_ = NULL; + ValaCodeNode* _tmp868_ = NULL; + _tmp857_ = expr; + _tmp858_ = vala_expression_get_symbol_reference ((ValaExpression*) _tmp857_); + _tmp859_ = _tmp858_; + _tmp860_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp859_, VALA_TYPE_LOCAL_VARIABLE, ValaLocalVariable)); + local = _tmp860_; + _tmp866_ = expr; + _tmp867_ = vala_code_node_get_parent_node ((ValaCodeNode*) _tmp866_); + _tmp868_ = _tmp867_; + if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp868_, VALA_TYPE_RETURN_STATEMENT)) { + ValaDataType* _tmp869_ = NULL; + ValaDataType* _tmp870_ = NULL; + gboolean _tmp871_ = FALSE; + gboolean _tmp872_ = FALSE; + _tmp869_ = vala_ccode_base_module_get_current_return_type ((ValaCCodeBaseModule*) self); + _tmp870_ = _tmp869_; + _tmp871_ = vala_data_type_get_value_owned (_tmp870_); + _tmp872_ = _tmp871_; + _tmp865_ = _tmp872_; } else { - _tmp817_ = FALSE; + _tmp865_ = FALSE; } - if (_tmp817_) { - ValaLocalVariable* _tmp825_ = NULL; - ValaDataType* _tmp826_ = NULL; - ValaDataType* _tmp827_ = NULL; - gboolean _tmp828_ = FALSE; - gboolean _tmp829_ = FALSE; - _tmp825_ = local; - _tmp826_ = vala_variable_get_variable_type ((ValaVariable*) _tmp825_); - _tmp827_ = _tmp826_; - _tmp828_ = vala_data_type_get_value_owned (_tmp827_); - _tmp829_ = _tmp828_; - _tmp816_ = _tmp829_; + if (_tmp865_) { + ValaLocalVariable* _tmp873_ = NULL; + ValaDataType* _tmp874_ = NULL; + ValaDataType* _tmp875_ = NULL; + gboolean _tmp876_ = FALSE; + gboolean _tmp877_ = FALSE; + _tmp873_ = local; + _tmp874_ = vala_variable_get_variable_type ((ValaVariable*) _tmp873_); + _tmp875_ = _tmp874_; + _tmp876_ = vala_data_type_get_value_owned (_tmp875_); + _tmp877_ = _tmp876_; + _tmp864_ = _tmp877_; } else { - _tmp816_ = FALSE; + _tmp864_ = FALSE; } - if (_tmp816_) { - ValaLocalVariable* _tmp830_ = NULL; - gboolean _tmp831_ = FALSE; - gboolean _tmp832_ = FALSE; - _tmp830_ = local; - _tmp831_ = vala_local_variable_get_captured (_tmp830_); - _tmp832_ = _tmp831_; - _tmp815_ = !_tmp832_; + if (_tmp864_) { + ValaLocalVariable* _tmp878_ = NULL; + gboolean _tmp879_ = FALSE; + gboolean _tmp880_ = FALSE; + _tmp878_ = local; + _tmp879_ = vala_local_variable_get_captured (_tmp878_); + _tmp880_ = _tmp879_; + _tmp863_ = !_tmp880_; } else { - _tmp815_ = FALSE; + _tmp863_ = FALSE; } - if (_tmp815_) { - ValaLocalVariable* _tmp833_ = NULL; - gboolean _tmp834_ = FALSE; - _tmp833_ = local; - _tmp834_ = vala_ccode_base_module_variable_accessible_in_finally ((ValaCCodeBaseModule*) self, _tmp833_); - _tmp814_ = !_tmp834_; + if (_tmp863_) { + ValaLocalVariable* _tmp881_ = NULL; + gboolean _tmp882_ = FALSE; + _tmp881_ = local; + _tmp882_ = vala_ccode_base_module_variable_accessible_in_finally ((ValaCCodeBaseModule*) self, _tmp881_); + _tmp862_ = !_tmp882_; } else { - _tmp814_ = FALSE; + _tmp862_ = FALSE; } - if (_tmp814_) { - gboolean _tmp835_ = FALSE; - ValaLocalVariable* _tmp836_ = NULL; - ValaDataType* _tmp837_ = NULL; - ValaDataType* _tmp838_ = NULL; - _tmp836_ = local; - _tmp837_ = vala_variable_get_variable_type ((ValaVariable*) _tmp836_); - _tmp838_ = _tmp837_; - if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp838_, VALA_TYPE_ARRAY_TYPE)) { - ValaLocalVariable* _tmp839_ = NULL; - ValaDataType* _tmp840_ = NULL; - ValaDataType* _tmp841_ = NULL; - gboolean _tmp842_ = FALSE; - gboolean _tmp843_ = FALSE; - _tmp839_ = local; - _tmp840_ = vala_variable_get_variable_type ((ValaVariable*) _tmp839_); - _tmp841_ = _tmp840_; - _tmp842_ = vala_array_type_get_inline_allocated (G_TYPE_CHECK_INSTANCE_CAST (_tmp841_, VALA_TYPE_ARRAY_TYPE, ValaArrayType)); - _tmp843_ = _tmp842_; - _tmp835_ = _tmp843_; + if (_tmp862_) { + gboolean _tmp883_ = FALSE; + ValaLocalVariable* _tmp884_ = NULL; + ValaDataType* _tmp885_ = NULL; + ValaDataType* _tmp886_ = NULL; + _tmp884_ = local; + _tmp885_ = vala_variable_get_variable_type ((ValaVariable*) _tmp884_); + _tmp886_ = _tmp885_; + if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp886_, VALA_TYPE_ARRAY_TYPE)) { + ValaLocalVariable* _tmp887_ = NULL; + ValaDataType* _tmp888_ = NULL; + ValaDataType* _tmp889_ = NULL; + gboolean _tmp890_ = FALSE; + gboolean _tmp891_ = FALSE; + _tmp887_ = local; + _tmp888_ = vala_variable_get_variable_type ((ValaVariable*) _tmp887_); + _tmp889_ = _tmp888_; + _tmp890_ = vala_array_type_get_inline_allocated (G_TYPE_CHECK_INSTANCE_CAST (_tmp889_, VALA_TYPE_ARRAY_TYPE, ValaArrayType)); + _tmp891_ = _tmp890_; + _tmp883_ = _tmp891_; } else { - _tmp835_ = FALSE; + _tmp883_ = FALSE; } - _tmp813_ = !_tmp835_; + _tmp861_ = !_tmp883_; } else { - _tmp813_ = FALSE; + _tmp861_ = FALSE; } - if (_tmp813_) { - ValaMemberAccess* _tmp844_ = NULL; - ValaDataType* _tmp845_ = NULL; - ValaDataType* _tmp846_ = NULL; - ValaLocalVariable* _tmp847_ = NULL; + if (_tmp861_) { + ValaMemberAccess* _tmp892_ = NULL; + ValaDataType* _tmp893_ = NULL; + ValaDataType* _tmp894_ = NULL; + ValaLocalVariable* _tmp895_ = NULL; ValaGLibValue* glib_value = NULL; - ValaLocalVariable* _tmp848_ = NULL; - ValaTargetValue* _tmp849_ = NULL; - ValaMemberAccess* _tmp850_ = NULL; - ValaGLibValue* _tmp851_ = NULL; - ValaGLibValue* _tmp852_ = NULL; - ValaCCodeExpression* _tmp853_ = NULL; - ValaGLibValue* _tmp856_ = NULL; - ValaCCodeExpression* _tmp857_ = NULL; - _tmp844_ = expr; - _tmp845_ = vala_expression_get_value_type ((ValaExpression*) _tmp844_); - _tmp846_ = _tmp845_; - vala_data_type_set_value_owned (_tmp846_, TRUE); - _tmp847_ = local; - vala_symbol_set_active ((ValaSymbol*) _tmp847_, FALSE); - _tmp848_ = local; - _tmp849_ = vala_ccode_base_module_get_local_cvalue ((ValaCCodeBaseModule*) self, _tmp848_); - glib_value = G_TYPE_CHECK_INSTANCE_CAST (_tmp849_, VALA_TYPE_GLIB_VALUE, ValaGLibValue); - _tmp850_ = expr; - _tmp851_ = glib_value; - vala_expression_set_target_value ((ValaExpression*) _tmp850_, (ValaTargetValue*) _tmp851_); - _tmp852_ = glib_value; - _tmp853_ = _tmp852_->delegate_target_cvalue; - if (_tmp853_ == NULL) { - ValaGLibValue* _tmp854_ = NULL; - ValaCCodeConstant* _tmp855_ = NULL; - _tmp854_ = glib_value; - _tmp855_ = vala_ccode_constant_new ("NULL"); - _vala_ccode_node_unref0 (_tmp854_->delegate_target_cvalue); - _tmp854_->delegate_target_cvalue = (ValaCCodeExpression*) _tmp855_; + ValaLocalVariable* _tmp896_ = NULL; + ValaTargetValue* _tmp897_ = NULL; + ValaMemberAccess* _tmp898_ = NULL; + ValaGLibValue* _tmp899_ = NULL; + ValaGLibValue* _tmp900_ = NULL; + ValaCCodeExpression* _tmp901_ = NULL; + ValaGLibValue* _tmp904_ = NULL; + ValaCCodeExpression* _tmp905_ = NULL; + _tmp892_ = expr; + _tmp893_ = vala_expression_get_value_type ((ValaExpression*) _tmp892_); + _tmp894_ = _tmp893_; + vala_data_type_set_value_owned (_tmp894_, TRUE); + _tmp895_ = local; + vala_symbol_set_active ((ValaSymbol*) _tmp895_, FALSE); + _tmp896_ = local; + _tmp897_ = vala_ccode_base_module_get_local_cvalue ((ValaCCodeBaseModule*) self, _tmp896_); + glib_value = G_TYPE_CHECK_INSTANCE_CAST (_tmp897_, VALA_TYPE_GLIB_VALUE, ValaGLibValue); + _tmp898_ = expr; + _tmp899_ = glib_value; + vala_expression_set_target_value ((ValaExpression*) _tmp898_, (ValaTargetValue*) _tmp899_); + _tmp900_ = glib_value; + _tmp901_ = _tmp900_->delegate_target_cvalue; + if (_tmp901_ == NULL) { + ValaGLibValue* _tmp902_ = NULL; + ValaCCodeConstant* _tmp903_ = NULL; + _tmp902_ = glib_value; + _tmp903_ = vala_ccode_constant_new ("NULL"); + _vala_ccode_node_unref0 (_tmp902_->delegate_target_cvalue); + _tmp902_->delegate_target_cvalue = (ValaCCodeExpression*) _tmp903_; } - _tmp856_ = glib_value; - _tmp857_ = _tmp856_->delegate_target_destroy_notify_cvalue; - if (_tmp857_ == NULL) { - ValaGLibValue* _tmp858_ = NULL; - ValaCCodeConstant* _tmp859_ = NULL; - _tmp858_ = glib_value; - _tmp859_ = vala_ccode_constant_new ("NULL"); - _vala_ccode_node_unref0 (_tmp858_->delegate_target_destroy_notify_cvalue); - _tmp858_->delegate_target_destroy_notify_cvalue = (ValaCCodeExpression*) _tmp859_; + _tmp904_ = glib_value; + _tmp905_ = _tmp904_->delegate_target_destroy_notify_cvalue; + if (_tmp905_ == NULL) { + ValaGLibValue* _tmp906_ = NULL; + ValaCCodeConstant* _tmp907_ = NULL; + _tmp906_ = glib_value; + _tmp907_ = vala_ccode_constant_new ("NULL"); + _vala_ccode_node_unref0 (_tmp906_->delegate_target_destroy_notify_cvalue); + _tmp906_->delegate_target_destroy_notify_cvalue = (ValaCCodeExpression*) _tmp907_; } _vala_target_value_unref0 (glib_value); } else { - ValaMemberAccess* _tmp860_ = NULL; - gboolean _tmp861_ = FALSE; - gboolean _tmp862_ = FALSE; - _tmp860_ = expr; - _tmp861_ = vala_expression_get_lvalue ((ValaExpression*) _tmp860_); - _tmp862_ = _tmp861_; - if (_tmp862_) { - ValaMemberAccess* _tmp863_ = NULL; - ValaLocalVariable* _tmp864_ = NULL; - ValaTargetValue* _tmp865_ = NULL; - ValaTargetValue* _tmp866_ = NULL; - _tmp863_ = expr; - _tmp864_ = local; - _tmp865_ = vala_ccode_base_module_get_local_cvalue ((ValaCCodeBaseModule*) self, _tmp864_); - _tmp866_ = _tmp865_; - vala_expression_set_target_value ((ValaExpression*) _tmp863_, _tmp866_); - _vala_target_value_unref0 (_tmp866_); + ValaMemberAccess* _tmp908_ = NULL; + gboolean _tmp909_ = FALSE; + gboolean _tmp910_ = FALSE; + _tmp908_ = expr; + _tmp909_ = vala_expression_get_lvalue ((ValaExpression*) _tmp908_); + _tmp910_ = _tmp909_; + if (_tmp910_) { + ValaMemberAccess* _tmp911_ = NULL; + ValaLocalVariable* _tmp912_ = NULL; + ValaTargetValue* _tmp913_ = NULL; + ValaTargetValue* _tmp914_ = NULL; + _tmp911_ = expr; + _tmp912_ = local; + _tmp913_ = vala_ccode_base_module_get_local_cvalue ((ValaCCodeBaseModule*) self, _tmp912_); + _tmp914_ = _tmp913_; + vala_expression_set_target_value ((ValaExpression*) _tmp911_, _tmp914_); + _vala_target_value_unref0 (_tmp914_); } else { - ValaMemberAccess* _tmp867_ = NULL; - ValaLocalVariable* _tmp868_ = NULL; - ValaTargetValue* _tmp869_ = NULL; - ValaTargetValue* _tmp870_ = NULL; - _tmp867_ = expr; - _tmp868_ = local; - _tmp869_ = vala_code_generator_load_local ((ValaCodeGenerator*) self, _tmp868_); - _tmp870_ = _tmp869_; - vala_expression_set_target_value ((ValaExpression*) _tmp867_, _tmp870_); - _vala_target_value_unref0 (_tmp870_); + ValaMemberAccess* _tmp915_ = NULL; + ValaLocalVariable* _tmp916_ = NULL; + ValaTargetValue* _tmp917_ = NULL; + ValaTargetValue* _tmp918_ = NULL; + _tmp915_ = expr; + _tmp916_ = local; + _tmp917_ = vala_code_generator_load_local ((ValaCodeGenerator*) self, _tmp916_); + _tmp918_ = _tmp917_; + vala_expression_set_target_value ((ValaExpression*) _tmp915_, _tmp918_); + _vala_target_value_unref0 (_tmp918_); } } _vala_code_node_unref0 (local); } else { - ValaMemberAccess* _tmp871_ = NULL; - ValaSymbol* _tmp872_ = NULL; - ValaSymbol* _tmp873_ = NULL; - _tmp871_ = expr; - _tmp872_ = vala_expression_get_symbol_reference ((ValaExpression*) _tmp871_); - _tmp873_ = _tmp872_; - if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp873_, VALA_TYPE_PARAMETER)) { + ValaMemberAccess* _tmp919_ = NULL; + ValaSymbol* _tmp920_ = NULL; + ValaSymbol* _tmp921_ = NULL; + _tmp919_ = expr; + _tmp920_ = vala_expression_get_symbol_reference ((ValaExpression*) _tmp919_); + _tmp921_ = _tmp920_; + if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp921_, VALA_TYPE_PARAMETER)) { ValaParameter* param = NULL; - ValaMemberAccess* _tmp874_ = NULL; - ValaSymbol* _tmp875_ = NULL; - ValaSymbol* _tmp876_ = NULL; - ValaParameter* _tmp877_ = NULL; - ValaMemberAccess* _tmp878_ = NULL; - gboolean _tmp879_ = FALSE; - gboolean _tmp880_ = FALSE; - _tmp874_ = expr; - _tmp875_ = vala_expression_get_symbol_reference ((ValaExpression*) _tmp874_); - _tmp876_ = _tmp875_; - _tmp877_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp876_, VALA_TYPE_PARAMETER, ValaParameter)); - param = _tmp877_; - _tmp878_ = expr; - _tmp879_ = vala_expression_get_lvalue ((ValaExpression*) _tmp878_); - _tmp880_ = _tmp879_; - if (_tmp880_) { - ValaMemberAccess* _tmp881_ = NULL; - ValaParameter* _tmp882_ = NULL; - ValaTargetValue* _tmp883_ = NULL; - ValaTargetValue* _tmp884_ = NULL; - _tmp881_ = expr; - _tmp882_ = param; - _tmp883_ = vala_ccode_base_module_get_parameter_cvalue ((ValaCCodeBaseModule*) self, _tmp882_); - _tmp884_ = _tmp883_; - vala_expression_set_target_value ((ValaExpression*) _tmp881_, _tmp884_); - _vala_target_value_unref0 (_tmp884_); + ValaMemberAccess* _tmp922_ = NULL; + ValaSymbol* _tmp923_ = NULL; + ValaSymbol* _tmp924_ = NULL; + ValaParameter* _tmp925_ = NULL; + ValaMemberAccess* _tmp926_ = NULL; + gboolean _tmp927_ = FALSE; + gboolean _tmp928_ = FALSE; + _tmp922_ = expr; + _tmp923_ = vala_expression_get_symbol_reference ((ValaExpression*) _tmp922_); + _tmp924_ = _tmp923_; + _tmp925_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp924_, VALA_TYPE_PARAMETER, ValaParameter)); + param = _tmp925_; + _tmp926_ = expr; + _tmp927_ = vala_expression_get_lvalue ((ValaExpression*) _tmp926_); + _tmp928_ = _tmp927_; + if (_tmp928_) { + ValaMemberAccess* _tmp929_ = NULL; + ValaParameter* _tmp930_ = NULL; + ValaTargetValue* _tmp931_ = NULL; + ValaTargetValue* _tmp932_ = NULL; + _tmp929_ = expr; + _tmp930_ = param; + _tmp931_ = vala_ccode_base_module_get_parameter_cvalue ((ValaCCodeBaseModule*) self, _tmp930_); + _tmp932_ = _tmp931_; + vala_expression_set_target_value ((ValaExpression*) _tmp929_, _tmp932_); + _vala_target_value_unref0 (_tmp932_); } else { - ValaMemberAccess* _tmp885_ = NULL; - ValaParameter* _tmp886_ = NULL; - ValaTargetValue* _tmp887_ = NULL; - ValaTargetValue* _tmp888_ = NULL; - _tmp885_ = expr; - _tmp886_ = param; - _tmp887_ = vala_code_generator_load_parameter ((ValaCodeGenerator*) self, _tmp886_); - _tmp888_ = _tmp887_; - vala_expression_set_target_value ((ValaExpression*) _tmp885_, _tmp888_); - _vala_target_value_unref0 (_tmp888_); + ValaMemberAccess* _tmp933_ = NULL; + ValaParameter* _tmp934_ = NULL; + ValaTargetValue* _tmp935_ = NULL; + ValaTargetValue* _tmp936_ = NULL; + _tmp933_ = expr; + _tmp934_ = param; + _tmp935_ = vala_code_generator_load_parameter ((ValaCodeGenerator*) self, _tmp934_); + _tmp936_ = _tmp935_; + vala_expression_set_target_value ((ValaExpression*) _tmp933_, _tmp936_); + _vala_target_value_unref0 (_tmp936_); } _vala_code_node_unref0 (param); } diff -Nru vala-0.34.6/codegen/valaccodememberaccessmodule.vala vala-0.34.7/codegen/valaccodememberaccessmodule.vala --- vala-0.34.6/codegen/valaccodememberaccessmodule.vala 2017-03-07 08:23:49.000000000 +0000 +++ vala-0.34.7/codegen/valaccodememberaccessmodule.vala 2017-03-20 21:24:57.000000000 +0000 @@ -182,14 +182,30 @@ var ccall = new CCodeFunctionCall (new CCodeMemberAccess.pointer (vcast, "get_%s".printf (prop.name))); ccall.add_argument (get_cvalue (expr.inner)); - set_cvalue (expr, ccall); + if (prop.property_type.is_real_non_null_struct_type ()) { + var temp_value = (GLibValue) create_temp_value (prop.get_accessor.value_type, false, expr); + expr.target_value = load_temp_value (temp_value); + var ctemp = get_cvalue_ (temp_value); + ccall.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, ctemp)); + ccode.add_expression (ccall); + } else { + set_cvalue (expr, ccall); + } } else if (base_prop.parent_symbol is Interface) { var base_iface = (Interface) base_prop.parent_symbol; string parent_iface_var = "%s_%s_parent_iface".printf (get_ccode_lower_case_name (current_class), get_ccode_lower_case_name (base_iface)); var ccall = new CCodeFunctionCall (new CCodeMemberAccess.pointer (new CCodeIdentifier (parent_iface_var), "get_%s".printf (prop.name))); ccall.add_argument (get_cvalue (expr.inner)); - set_cvalue (expr, ccall); + if (prop.property_type.is_real_non_null_struct_type ()) { + var temp_value = (GLibValue) create_temp_value (prop.get_accessor.value_type, false, expr); + expr.target_value = load_temp_value (temp_value); + var ctemp = get_cvalue_ (temp_value); + ccall.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, ctemp)); + ccode.add_expression (ccall); + } else { + set_cvalue (expr, ccall); + } } } else if (prop.binding == MemberBinding.INSTANCE && prop.get_accessor.automatic_body && diff -Nru vala-0.34.6/codegen/valagsignalmodule.c vala-0.34.7/codegen/valagsignalmodule.c --- vala-0.34.6/codegen/valagsignalmodule.c 2017-03-07 09:40:05.000000000 +0000 +++ vala-0.34.7/codegen/valagsignalmodule.c 2017-03-20 21:31:17.000000000 +0000 @@ -618,13 +618,10 @@ gchar* _tmp2_ = NULL; gchar* ret = NULL; const gchar* _tmp3_ = NULL; - const gchar* _tmp7_ = NULL; + gboolean _tmp7_ = FALSE; ValaDataType* _tmp8_ = NULL; - gchar* _tmp9_ = NULL; - gchar* _tmp10_ = NULL; - gchar* _tmp11_ = NULL; - gboolean _tmp12_ = FALSE; - ValaList* _tmp13_ = NULL; + gboolean _tmp19_ = FALSE; + ValaList* _tmp20_ = NULL; g_return_val_if_fail (self != NULL, NULL); g_return_val_if_fail (params != NULL, NULL); g_return_val_if_fail (return_type != NULL, NULL); @@ -646,88 +643,114 @@ prefix = "g_cclosure_user_marshal"; } } - _tmp7_ = prefix; _tmp8_ = return_type; - _tmp9_ = vala_ccode_base_module_get_ccode_marshaller_type_name ((ValaCodeNode*) _tmp8_); - _tmp10_ = _tmp9_; - _tmp11_ = g_strdup_printf ("%s_%s_", _tmp7_, _tmp10_); - _g_free0 (ret); - ret = _tmp11_; - _g_free0 (_tmp10_); - _tmp13_ = params; - if (_tmp13_ == NULL) { - _tmp12_ = TRUE; - } else { - ValaList* _tmp14_ = NULL; - gint _tmp15_ = 0; - gint _tmp16_ = 0; - _tmp14_ = params; - _tmp15_ = vala_collection_get_size ((ValaCollection*) _tmp14_); - _tmp16_ = _tmp15_; - _tmp12_ = _tmp16_ == 0; + if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp8_, VALA_TYPE_VALUE_TYPE)) { + ValaDataType* _tmp9_ = NULL; + gboolean _tmp10_ = FALSE; + gboolean _tmp11_ = FALSE; + _tmp9_ = return_type; + _tmp10_ = vala_data_type_get_nullable (_tmp9_); + _tmp11_ = _tmp10_; + _tmp7_ = _tmp11_; + } else { + _tmp7_ = FALSE; } - if (_tmp12_) { - const gchar* _tmp17_ = NULL; + if (_tmp7_) { + const gchar* _tmp12_ = NULL; + gchar* _tmp13_ = NULL; + _tmp12_ = prefix; + _tmp13_ = g_strdup_printf ("%s_POINTER_", _tmp12_); + _g_free0 (ret); + ret = _tmp13_; + } else { + const gchar* _tmp14_ = NULL; + ValaDataType* _tmp15_ = NULL; + gchar* _tmp16_ = NULL; + gchar* _tmp17_ = NULL; gchar* _tmp18_ = NULL; - _tmp17_ = ret; - _tmp18_ = g_strconcat (_tmp17_, "_VOID", NULL); + _tmp14_ = prefix; + _tmp15_ = return_type; + _tmp16_ = vala_ccode_base_module_get_ccode_marshaller_type_name ((ValaCodeNode*) _tmp15_); + _tmp17_ = _tmp16_; + _tmp18_ = g_strdup_printf ("%s_%s_", _tmp14_, _tmp17_); _g_free0 (ret); ret = _tmp18_; + _g_free0 (_tmp17_); + } + _tmp20_ = params; + if (_tmp20_ == NULL) { + _tmp19_ = TRUE; + } else { + ValaList* _tmp21_ = NULL; + gint _tmp22_ = 0; + gint _tmp23_ = 0; + _tmp21_ = params; + _tmp22_ = vala_collection_get_size ((ValaCollection*) _tmp21_); + _tmp23_ = _tmp22_; + _tmp19_ = _tmp23_ == 0; + } + if (_tmp19_) { + const gchar* _tmp24_ = NULL; + gchar* _tmp25_ = NULL; + _tmp24_ = ret; + _tmp25_ = g_strconcat (_tmp24_, "_VOID", NULL); + _g_free0 (ret); + ret = _tmp25_; } else { { ValaList* _p_list = NULL; - ValaList* _tmp19_ = NULL; - ValaList* _tmp20_ = NULL; + ValaList* _tmp26_ = NULL; + ValaList* _tmp27_ = NULL; gint _p_size = 0; - ValaList* _tmp21_ = NULL; - gint _tmp22_ = 0; - gint _tmp23_ = 0; + ValaList* _tmp28_ = NULL; + gint _tmp29_ = 0; + gint _tmp30_ = 0; gint _p_index = 0; - _tmp19_ = params; - _tmp20_ = _vala_iterable_ref0 (_tmp19_); - _p_list = _tmp20_; - _tmp21_ = _p_list; - _tmp22_ = vala_collection_get_size ((ValaCollection*) _tmp21_); - _tmp23_ = _tmp22_; - _p_size = _tmp23_; + _tmp26_ = params; + _tmp27_ = _vala_iterable_ref0 (_tmp26_); + _p_list = _tmp27_; + _tmp28_ = _p_list; + _tmp29_ = vala_collection_get_size ((ValaCollection*) _tmp28_); + _tmp30_ = _tmp29_; + _p_size = _tmp30_; _p_index = -1; while (TRUE) { - gint _tmp24_ = 0; - gint _tmp25_ = 0; - gint _tmp26_ = 0; + gint _tmp31_ = 0; + gint _tmp32_ = 0; + gint _tmp33_ = 0; ValaParameter* p = NULL; - ValaList* _tmp27_ = NULL; - gint _tmp28_ = 0; - gpointer _tmp29_ = NULL; - const gchar* _tmp30_ = NULL; - ValaParameter* _tmp31_ = NULL; - gchar* _tmp32_ = NULL; - gchar* _tmp33_ = NULL; - gchar* _tmp34_ = NULL; - gchar* _tmp35_ = NULL; - gchar* _tmp36_ = NULL; - _tmp24_ = _p_index; - _p_index = _tmp24_ + 1; - _tmp25_ = _p_index; - _tmp26_ = _p_size; - if (!(_tmp25_ < _tmp26_)) { + ValaList* _tmp34_ = NULL; + gint _tmp35_ = 0; + gpointer _tmp36_ = NULL; + const gchar* _tmp37_ = NULL; + ValaParameter* _tmp38_ = NULL; + gchar* _tmp39_ = NULL; + gchar* _tmp40_ = NULL; + gchar* _tmp41_ = NULL; + gchar* _tmp42_ = NULL; + gchar* _tmp43_ = NULL; + _tmp31_ = _p_index; + _p_index = _tmp31_ + 1; + _tmp32_ = _p_index; + _tmp33_ = _p_size; + if (!(_tmp32_ < _tmp33_)) { break; } - _tmp27_ = _p_list; - _tmp28_ = _p_index; - _tmp29_ = vala_list_get (_tmp27_, _tmp28_); - p = (ValaParameter*) _tmp29_; - _tmp30_ = ret; - _tmp31_ = p; - _tmp32_ = vala_ccode_base_module_get_ccode_marshaller_type_name ((ValaCodeNode*) _tmp31_); - _tmp33_ = _tmp32_; - _tmp34_ = string_replace (_tmp33_, ",", "_"); - _tmp35_ = _tmp34_; - _tmp36_ = g_strdup_printf ("%s_%s", _tmp30_, _tmp35_); + _tmp34_ = _p_list; + _tmp35_ = _p_index; + _tmp36_ = vala_list_get (_tmp34_, _tmp35_); + p = (ValaParameter*) _tmp36_; + _tmp37_ = ret; + _tmp38_ = p; + _tmp39_ = vala_ccode_base_module_get_ccode_marshaller_type_name ((ValaCodeNode*) _tmp38_); + _tmp40_ = _tmp39_; + _tmp41_ = string_replace (_tmp40_, ",", "_"); + _tmp42_ = _tmp41_; + _tmp43_ = g_strdup_printf ("%s_%s", _tmp37_, _tmp42_); _g_free0 (ret); - ret = _tmp36_; - _g_free0 (_tmp35_); - _g_free0 (_tmp33_); + ret = _tmp43_; + _g_free0 (_tmp42_); + _g_free0 (_tmp40_); _vala_code_node_unref0 (p); } _vala_iterable_unref0 (_p_list); @@ -822,75 +845,96 @@ result = _tmp23_; return result; } else { - ValaDataType* _tmp24_ = NULL; - ValaTypeSymbol* _tmp25_ = NULL; - ValaTypeSymbol* _tmp26_ = NULL; - _tmp24_ = t; - _tmp25_ = vala_data_type_get_data_type (_tmp24_); - _tmp26_ = _tmp25_; - if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp26_, VALA_TYPE_STRUCT)) { - ValaStruct* st = NULL; - ValaDataType* _tmp27_ = NULL; - ValaTypeSymbol* _tmp28_ = NULL; - ValaTypeSymbol* _tmp29_ = NULL; - ValaStruct* _tmp30_ = NULL; - ValaStruct* _tmp31_ = NULL; - gboolean _tmp32_ = FALSE; - _tmp27_ = t; - _tmp28_ = vala_data_type_get_data_type (_tmp27_); - _tmp29_ = _tmp28_; - _tmp30_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp29_, VALA_TYPE_STRUCT, ValaStruct)); - st = _tmp30_; - _tmp31_ = st; - _tmp32_ = vala_struct_is_simple_type (_tmp31_); - if (_tmp32_) { + gboolean _tmp24_ = FALSE; + ValaDataType* _tmp25_ = NULL; + _tmp25_ = t; + if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp25_, VALA_TYPE_VALUE_TYPE)) { + ValaDataType* _tmp26_ = NULL; + gboolean _tmp27_ = FALSE; + gboolean _tmp28_ = FALSE; + _tmp26_ = t; + _tmp27_ = vala_data_type_get_nullable (_tmp26_); + _tmp28_ = _tmp27_; + _tmp24_ = _tmp28_; + } else { + _tmp24_ = FALSE; + } + if (_tmp24_) { + gchar* _tmp29_ = NULL; + _tmp29_ = g_strdup ("gpointer"); + result = _tmp29_; + return result; + } else { + ValaDataType* _tmp30_ = NULL; + ValaTypeSymbol* _tmp31_ = NULL; + ValaTypeSymbol* _tmp32_ = NULL; + _tmp30_ = t; + _tmp31_ = vala_data_type_get_data_type (_tmp30_); + _tmp32_ = _tmp31_; + if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp32_, VALA_TYPE_STRUCT)) { + ValaStruct* st = NULL; ValaDataType* _tmp33_ = NULL; ValaTypeSymbol* _tmp34_ = NULL; ValaTypeSymbol* _tmp35_ = NULL; - gchar* _tmp36_ = NULL; + ValaStruct* _tmp36_ = NULL; + ValaStruct* _tmp37_ = NULL; + gboolean _tmp38_ = FALSE; _tmp33_ = t; _tmp34_ = vala_data_type_get_data_type (_tmp33_); _tmp35_ = _tmp34_; - _tmp36_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp35_); - result = _tmp36_; - _vala_code_node_unref0 (st); - return result; - } else { - gchar* _tmp37_ = NULL; - _tmp37_ = g_strdup ("gpointer"); - result = _tmp37_; - _vala_code_node_unref0 (st); - return result; - } - _vala_code_node_unref0 (st); - } else { - ValaDataType* _tmp38_ = NULL; - ValaTypeSymbol* _tmp39_ = NULL; - ValaTypeSymbol* _tmp40_ = NULL; - _tmp38_ = t; - _tmp39_ = vala_data_type_get_data_type (_tmp38_); - _tmp40_ = _tmp39_; - if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp40_, VALA_TYPE_ENUM)) { - gchar* _tmp41_ = NULL; - _tmp41_ = g_strdup ("gint"); - result = _tmp41_; - return result; - } else { - ValaDataType* _tmp42_ = NULL; - _tmp42_ = t; - if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp42_, VALA_TYPE_ARRAY_TYPE)) { + _tmp36_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp35_, VALA_TYPE_STRUCT, ValaStruct)); + st = _tmp36_; + _tmp37_ = st; + _tmp38_ = vala_struct_is_simple_type (_tmp37_); + if (_tmp38_) { + ValaDataType* _tmp39_ = NULL; + ValaTypeSymbol* _tmp40_ = NULL; + ValaTypeSymbol* _tmp41_ = NULL; + gchar* _tmp42_ = NULL; + _tmp39_ = t; + _tmp40_ = vala_data_type_get_data_type (_tmp39_); + _tmp41_ = _tmp40_; + _tmp42_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp41_); + result = _tmp42_; + _vala_code_node_unref0 (st); + return result; + } else { gchar* _tmp43_ = NULL; _tmp43_ = g_strdup ("gpointer"); result = _tmp43_; + _vala_code_node_unref0 (st); + return result; + } + _vala_code_node_unref0 (st); + } else { + ValaDataType* _tmp44_ = NULL; + ValaTypeSymbol* _tmp45_ = NULL; + ValaTypeSymbol* _tmp46_ = NULL; + _tmp44_ = t; + _tmp45_ = vala_data_type_get_data_type (_tmp44_); + _tmp46_ = _tmp45_; + if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp46_, VALA_TYPE_ENUM)) { + gchar* _tmp47_ = NULL; + _tmp47_ = g_strdup ("gint"); + result = _tmp47_; return result; } else { - ValaDataType* _tmp44_ = NULL; - _tmp44_ = t; - if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp44_, VALA_TYPE_ERROR_TYPE)) { - gchar* _tmp45_ = NULL; - _tmp45_ = g_strdup ("gpointer"); - result = _tmp45_; + ValaDataType* _tmp48_ = NULL; + _tmp48_ = t; + if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp48_, VALA_TYPE_ARRAY_TYPE)) { + gchar* _tmp49_ = NULL; + _tmp49_ = g_strdup ("gpointer"); + result = _tmp49_; return result; + } else { + ValaDataType* _tmp50_ = NULL; + _tmp50_ = t; + if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp50_, VALA_TYPE_ERROR_TYPE)) { + gchar* _tmp51_ = NULL; + _tmp51_ = g_strdup ("gpointer"); + result = _tmp51_; + return result; + } } } } @@ -937,111 +981,132 @@ static gchar* vala_gsignal_module_get_marshaller_signature (ValaGSignalModule* self, ValaList* params, ValaDataType* return_type) { gchar* result = NULL; gchar* signature = NULL; - ValaDataType* _tmp0_ = NULL; - gchar* _tmp1_ = NULL; - gchar* _tmp2_ = NULL; - gchar* _tmp3_ = NULL; - gboolean _tmp4_ = FALSE; - ValaList* _tmp5_ = NULL; + gboolean _tmp0_ = FALSE; + ValaDataType* _tmp1_ = NULL; + gboolean _tmp10_ = FALSE; + ValaList* _tmp11_ = NULL; g_return_val_if_fail (self != NULL, NULL); g_return_val_if_fail (params != NULL, NULL); g_return_val_if_fail (return_type != NULL, NULL); - _tmp0_ = return_type; - _tmp1_ = vala_ccode_base_module_get_ccode_marshaller_type_name ((ValaCodeNode*) _tmp0_); - _tmp2_ = _tmp1_; - _tmp3_ = g_strdup_printf ("%s:", _tmp2_); - _g_free0 (signature); - signature = _tmp3_; - _g_free0 (_tmp2_); - _tmp5_ = params; - if (_tmp5_ == NULL) { - _tmp4_ = TRUE; - } else { - ValaList* _tmp6_ = NULL; - gint _tmp7_ = 0; - gint _tmp8_ = 0; - _tmp6_ = params; - _tmp7_ = vala_collection_get_size ((ValaCollection*) _tmp6_); + _tmp1_ = return_type; + if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp1_, VALA_TYPE_VALUE_TYPE)) { + ValaDataType* _tmp2_ = NULL; + gboolean _tmp3_ = FALSE; + gboolean _tmp4_ = FALSE; + _tmp2_ = return_type; + _tmp3_ = vala_data_type_get_nullable (_tmp2_); + _tmp4_ = _tmp3_; + _tmp0_ = _tmp4_; + } else { + _tmp0_ = FALSE; + } + if (_tmp0_) { + gchar* _tmp5_ = NULL; + _tmp5_ = g_strdup ("POINTER:"); + _g_free0 (signature); + signature = _tmp5_; + } else { + ValaDataType* _tmp6_ = NULL; + gchar* _tmp7_ = NULL; + gchar* _tmp8_ = NULL; + gchar* _tmp9_ = NULL; + _tmp6_ = return_type; + _tmp7_ = vala_ccode_base_module_get_ccode_marshaller_type_name ((ValaCodeNode*) _tmp6_); _tmp8_ = _tmp7_; - _tmp4_ = _tmp8_ == 0; + _tmp9_ = g_strdup_printf ("%s:", _tmp8_); + _g_free0 (signature); + signature = _tmp9_; + _g_free0 (_tmp8_); } - if (_tmp4_) { - const gchar* _tmp9_ = NULL; - gchar* _tmp10_ = NULL; - _tmp9_ = signature; - _tmp10_ = g_strconcat (_tmp9_, "VOID", NULL); + _tmp11_ = params; + if (_tmp11_ == NULL) { + _tmp10_ = TRUE; + } else { + ValaList* _tmp12_ = NULL; + gint _tmp13_ = 0; + gint _tmp14_ = 0; + _tmp12_ = params; + _tmp13_ = vala_collection_get_size ((ValaCollection*) _tmp12_); + _tmp14_ = _tmp13_; + _tmp10_ = _tmp14_ == 0; + } + if (_tmp10_) { + const gchar* _tmp15_ = NULL; + gchar* _tmp16_ = NULL; + _tmp15_ = signature; + _tmp16_ = g_strconcat (_tmp15_, "VOID", NULL); _g_free0 (signature); - signature = _tmp10_; + signature = _tmp16_; } else { gboolean first = FALSE; first = TRUE; { ValaList* _p_list = NULL; - ValaList* _tmp11_ = NULL; - ValaList* _tmp12_ = NULL; + ValaList* _tmp17_ = NULL; + ValaList* _tmp18_ = NULL; gint _p_size = 0; - ValaList* _tmp13_ = NULL; - gint _tmp14_ = 0; - gint _tmp15_ = 0; + ValaList* _tmp19_ = NULL; + gint _tmp20_ = 0; + gint _tmp21_ = 0; gint _p_index = 0; - _tmp11_ = params; - _tmp12_ = _vala_iterable_ref0 (_tmp11_); - _p_list = _tmp12_; - _tmp13_ = _p_list; - _tmp14_ = vala_collection_get_size ((ValaCollection*) _tmp13_); - _tmp15_ = _tmp14_; - _p_size = _tmp15_; + _tmp17_ = params; + _tmp18_ = _vala_iterable_ref0 (_tmp17_); + _p_list = _tmp18_; + _tmp19_ = _p_list; + _tmp20_ = vala_collection_get_size ((ValaCollection*) _tmp19_); + _tmp21_ = _tmp20_; + _p_size = _tmp21_; _p_index = -1; while (TRUE) { - gint _tmp16_ = 0; - gint _tmp17_ = 0; - gint _tmp18_ = 0; + gint _tmp22_ = 0; + gint _tmp23_ = 0; + gint _tmp24_ = 0; ValaParameter* p = NULL; - ValaList* _tmp19_ = NULL; - gint _tmp20_ = 0; - gpointer _tmp21_ = NULL; - gboolean _tmp22_ = FALSE; - _tmp16_ = _p_index; - _p_index = _tmp16_ + 1; - _tmp17_ = _p_index; - _tmp18_ = _p_size; - if (!(_tmp17_ < _tmp18_)) { + ValaList* _tmp25_ = NULL; + gint _tmp26_ = 0; + gpointer _tmp27_ = NULL; + gboolean _tmp28_ = FALSE; + _tmp22_ = _p_index; + _p_index = _tmp22_ + 1; + _tmp23_ = _p_index; + _tmp24_ = _p_size; + if (!(_tmp23_ < _tmp24_)) { break; } - _tmp19_ = _p_list; - _tmp20_ = _p_index; - _tmp21_ = vala_list_get (_tmp19_, _tmp20_); - p = (ValaParameter*) _tmp21_; - _tmp22_ = first; - if (_tmp22_) { - const gchar* _tmp23_ = NULL; - ValaParameter* _tmp24_ = NULL; - gchar* _tmp25_ = NULL; - gchar* _tmp26_ = NULL; - gchar* _tmp27_ = NULL; - _tmp23_ = signature; - _tmp24_ = p; - _tmp25_ = vala_ccode_base_module_get_ccode_marshaller_type_name ((ValaCodeNode*) _tmp24_); - _tmp26_ = _tmp25_; - _tmp27_ = g_strconcat (_tmp23_, _tmp26_, NULL); + _tmp25_ = _p_list; + _tmp26_ = _p_index; + _tmp27_ = vala_list_get (_tmp25_, _tmp26_); + p = (ValaParameter*) _tmp27_; + _tmp28_ = first; + if (_tmp28_) { + const gchar* _tmp29_ = NULL; + ValaParameter* _tmp30_ = NULL; + gchar* _tmp31_ = NULL; + gchar* _tmp32_ = NULL; + gchar* _tmp33_ = NULL; + _tmp29_ = signature; + _tmp30_ = p; + _tmp31_ = vala_ccode_base_module_get_ccode_marshaller_type_name ((ValaCodeNode*) _tmp30_); + _tmp32_ = _tmp31_; + _tmp33_ = g_strconcat (_tmp29_, _tmp32_, NULL); _g_free0 (signature); - signature = _tmp27_; - _g_free0 (_tmp26_); + signature = _tmp33_; + _g_free0 (_tmp32_); first = FALSE; } else { - const gchar* _tmp28_ = NULL; - ValaParameter* _tmp29_ = NULL; - gchar* _tmp30_ = NULL; - gchar* _tmp31_ = NULL; - gchar* _tmp32_ = NULL; - _tmp28_ = signature; - _tmp29_ = p; - _tmp30_ = vala_ccode_base_module_get_ccode_marshaller_type_name ((ValaCodeNode*) _tmp29_); - _tmp31_ = _tmp30_; - _tmp32_ = g_strdup_printf ("%s,%s", _tmp28_, _tmp31_); + const gchar* _tmp34_ = NULL; + ValaParameter* _tmp35_ = NULL; + gchar* _tmp36_ = NULL; + gchar* _tmp37_ = NULL; + gchar* _tmp38_ = NULL; + _tmp34_ = signature; + _tmp35_ = p; + _tmp36_ = vala_ccode_base_module_get_ccode_marshaller_type_name ((ValaCodeNode*) _tmp35_); + _tmp37_ = _tmp36_; + _tmp38_ = g_strdup_printf ("%s,%s", _tmp34_, _tmp37_); _g_free0 (signature); - signature = _tmp32_; - _g_free0 (_tmp31_); + signature = _tmp38_; + _g_free0 (_tmp37_); } _vala_code_node_unref0 (p); } @@ -1590,19 +1655,19 @@ ValaCCodeFunctionCall* _tmp222_ = NULL; ValaCCodeIdentifier* _tmp223_ = NULL; ValaCCodeIdentifier* _tmp224_ = NULL; - ValaCCodeFunctionCall* _tmp312_ = NULL; - ValaCCodeIdentifier* _tmp313_ = NULL; - ValaCCodeIdentifier* _tmp314_ = NULL; - gboolean _tmp315_ = FALSE; - ValaDataType* _tmp316_ = NULL; - ValaTypeSymbol* _tmp317_ = NULL; - ValaTypeSymbol* _tmp318_ = NULL; - ValaCCodeFile* _tmp391_ = NULL; - ValaCCodeFunction* _tmp392_ = NULL; - ValaCCodeFile* _tmp393_ = NULL; - ValaCCodeFunction* _tmp394_ = NULL; - ValaSet* _tmp395_ = NULL; - const gchar* _tmp396_ = NULL; + ValaCCodeFunctionCall* _tmp322_ = NULL; + ValaCCodeIdentifier* _tmp323_ = NULL; + ValaCCodeIdentifier* _tmp324_ = NULL; + gboolean _tmp325_ = FALSE; + ValaDataType* _tmp326_ = NULL; + ValaTypeSymbol* _tmp327_ = NULL; + ValaTypeSymbol* _tmp328_ = NULL; + ValaCCodeFile* _tmp409_ = NULL; + ValaCCodeFunction* _tmp410_ = NULL; + ValaCCodeFile* _tmp411_ = NULL; + ValaCCodeFunction* _tmp412_ = NULL; + ValaSet* _tmp413_ = NULL; + const gchar* _tmp414_ = NULL; g_return_if_fail (self != NULL); g_return_if_fail (params != NULL); g_return_if_fail (return_type != NULL); @@ -2060,25 +2125,25 @@ ValaParameterDirection _tmp241_ = 0; ValaParameterDirection _tmp242_ = 0; ValaCCodeFunctionCall* inner_fc = NULL; - const gchar* _tmp277_ = NULL; - ValaCCodeIdentifier* _tmp278_ = NULL; - ValaCCodeIdentifier* _tmp279_ = NULL; - ValaCCodeFunctionCall* _tmp280_ = NULL; - ValaCCodeFunctionCall* _tmp281_ = NULL; - ValaCCodeFunctionCall* _tmp282_ = NULL; - ValaCCodeIdentifier* _tmp283_ = NULL; - ValaCCodeIdentifier* _tmp284_ = NULL; - gint _tmp285_ = 0; - gchar* _tmp286_ = NULL; - gchar* _tmp287_ = NULL; + const gchar* _tmp287_ = NULL; ValaCCodeIdentifier* _tmp288_ = NULL; ValaCCodeIdentifier* _tmp289_ = NULL; - ValaCCodeBinaryExpression* _tmp290_ = NULL; - ValaCCodeBinaryExpression* _tmp291_ = NULL; + ValaCCodeFunctionCall* _tmp290_ = NULL; + ValaCCodeFunctionCall* _tmp291_ = NULL; ValaCCodeFunctionCall* _tmp292_ = NULL; - ValaCCodeFunctionCall* _tmp293_ = NULL; - gint _tmp294_ = 0; - gboolean _tmp295_ = FALSE; + ValaCCodeIdentifier* _tmp293_ = NULL; + ValaCCodeIdentifier* _tmp294_ = NULL; + gint _tmp295_ = 0; + gchar* _tmp296_ = NULL; + gchar* _tmp297_ = NULL; + ValaCCodeIdentifier* _tmp298_ = NULL; + ValaCCodeIdentifier* _tmp299_ = NULL; + ValaCCodeBinaryExpression* _tmp300_ = NULL; + ValaCCodeBinaryExpression* _tmp301_ = NULL; + ValaCCodeFunctionCall* _tmp302_ = NULL; + ValaCCodeFunctionCall* _tmp303_ = NULL; + gint _tmp304_ = 0; + gboolean _tmp305_ = FALSE; _tmp230_ = _p_index; _p_index = _tmp230_ + 1; _tmp231_ = _p_index; @@ -2179,95 +2244,124 @@ _g_free0 (get_value_function); get_value_function = _tmp270_; } else { - ValaParameter* _tmp271_ = NULL; - ValaDataType* _tmp272_ = NULL; + gboolean _tmp271_ = FALSE; + ValaParameter* _tmp272_ = NULL; ValaDataType* _tmp273_ = NULL; - ValaTypeSymbol* _tmp274_ = NULL; - ValaTypeSymbol* _tmp275_ = NULL; - gchar* _tmp276_ = NULL; - _tmp271_ = p; - _tmp272_ = vala_variable_get_variable_type ((ValaVariable*) _tmp271_); - _tmp273_ = _tmp272_; - _tmp274_ = vala_data_type_get_data_type (_tmp273_); - _tmp275_ = _tmp274_; - _tmp276_ = vala_ccode_base_module_get_ccode_get_value_function ((ValaCodeNode*) _tmp275_); - _g_free0 (get_value_function); - get_value_function = _tmp276_; + ValaDataType* _tmp274_ = NULL; + _tmp272_ = p; + _tmp273_ = vala_variable_get_variable_type ((ValaVariable*) _tmp272_); + _tmp274_ = _tmp273_; + if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp274_, VALA_TYPE_VALUE_TYPE)) { + ValaParameter* _tmp275_ = NULL; + ValaDataType* _tmp276_ = NULL; + ValaDataType* _tmp277_ = NULL; + gboolean _tmp278_ = FALSE; + gboolean _tmp279_ = FALSE; + _tmp275_ = p; + _tmp276_ = vala_variable_get_variable_type ((ValaVariable*) _tmp275_); + _tmp277_ = _tmp276_; + _tmp278_ = vala_data_type_get_nullable (_tmp277_); + _tmp279_ = _tmp278_; + _tmp271_ = _tmp279_; + } else { + _tmp271_ = FALSE; + } + if (_tmp271_) { + gchar* _tmp280_ = NULL; + _tmp280_ = g_strdup ("g_value_get_pointer"); + _g_free0 (get_value_function); + get_value_function = _tmp280_; + } else { + ValaParameter* _tmp281_ = NULL; + ValaDataType* _tmp282_ = NULL; + ValaDataType* _tmp283_ = NULL; + ValaTypeSymbol* _tmp284_ = NULL; + ValaTypeSymbol* _tmp285_ = NULL; + gchar* _tmp286_ = NULL; + _tmp281_ = p; + _tmp282_ = vala_variable_get_variable_type ((ValaVariable*) _tmp281_); + _tmp283_ = _tmp282_; + _tmp284_ = vala_data_type_get_data_type (_tmp283_); + _tmp285_ = _tmp284_; + _tmp286_ = vala_ccode_base_module_get_ccode_get_value_function ((ValaCodeNode*) _tmp285_); + _g_free0 (get_value_function); + get_value_function = _tmp286_; + } } } } } - _tmp277_ = get_value_function; - _tmp278_ = vala_ccode_identifier_new (_tmp277_); - _tmp279_ = _tmp278_; - _tmp280_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp279_); - _tmp281_ = _tmp280_; - _vala_ccode_node_unref0 (_tmp279_); - inner_fc = _tmp281_; - _tmp282_ = inner_fc; - _tmp283_ = vala_ccode_identifier_new ("param_values"); - _tmp284_ = _tmp283_; - _tmp285_ = i; - _tmp286_ = g_strdup_printf ("%i", _tmp285_); - _tmp287_ = _tmp286_; + _tmp287_ = get_value_function; _tmp288_ = vala_ccode_identifier_new (_tmp287_); _tmp289_ = _tmp288_; - _tmp290_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_PLUS, (ValaCCodeExpression*) _tmp284_, (ValaCCodeExpression*) _tmp289_); + _tmp290_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp289_); _tmp291_ = _tmp290_; - vala_ccode_function_call_add_argument (_tmp282_, (ValaCCodeExpression*) _tmp291_); - _vala_ccode_node_unref0 (_tmp291_); _vala_ccode_node_unref0 (_tmp289_); - _g_free0 (_tmp287_); - _vala_ccode_node_unref0 (_tmp284_); - _tmp292_ = fc; - _tmp293_ = inner_fc; - vala_ccode_function_call_add_argument (_tmp292_, (ValaCCodeExpression*) _tmp293_); - _tmp294_ = i; - i = _tmp294_ + 1; - _tmp295_ = is_array; - if (_tmp295_) { - ValaCCodeIdentifier* _tmp296_ = NULL; - ValaCCodeIdentifier* _tmp297_ = NULL; - ValaCCodeFunctionCall* _tmp298_ = NULL; - ValaCCodeFunctionCall* _tmp299_ = NULL; - ValaCCodeIdentifier* _tmp300_ = NULL; - ValaCCodeIdentifier* _tmp301_ = NULL; - gint _tmp302_ = 0; - gchar* _tmp303_ = NULL; - gchar* _tmp304_ = NULL; - ValaCCodeIdentifier* _tmp305_ = NULL; + inner_fc = _tmp291_; + _tmp292_ = inner_fc; + _tmp293_ = vala_ccode_identifier_new ("param_values"); + _tmp294_ = _tmp293_; + _tmp295_ = i; + _tmp296_ = g_strdup_printf ("%i", _tmp295_); + _tmp297_ = _tmp296_; + _tmp298_ = vala_ccode_identifier_new (_tmp297_); + _tmp299_ = _tmp298_; + _tmp300_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_PLUS, (ValaCCodeExpression*) _tmp294_, (ValaCCodeExpression*) _tmp299_); + _tmp301_ = _tmp300_; + vala_ccode_function_call_add_argument (_tmp292_, (ValaCCodeExpression*) _tmp301_); + _vala_ccode_node_unref0 (_tmp301_); + _vala_ccode_node_unref0 (_tmp299_); + _g_free0 (_tmp297_); + _vala_ccode_node_unref0 (_tmp294_); + _tmp302_ = fc; + _tmp303_ = inner_fc; + vala_ccode_function_call_add_argument (_tmp302_, (ValaCCodeExpression*) _tmp303_); + _tmp304_ = i; + i = _tmp304_ + 1; + _tmp305_ = is_array; + if (_tmp305_) { ValaCCodeIdentifier* _tmp306_ = NULL; - ValaCCodeBinaryExpression* _tmp307_ = NULL; - ValaCCodeBinaryExpression* _tmp308_ = NULL; + ValaCCodeIdentifier* _tmp307_ = NULL; + ValaCCodeFunctionCall* _tmp308_ = NULL; ValaCCodeFunctionCall* _tmp309_ = NULL; - ValaCCodeFunctionCall* _tmp310_ = NULL; - gint _tmp311_ = 0; - _tmp296_ = vala_ccode_identifier_new ("g_value_get_int"); - _tmp297_ = _tmp296_; - _tmp298_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp297_); + ValaCCodeIdentifier* _tmp310_ = NULL; + ValaCCodeIdentifier* _tmp311_ = NULL; + gint _tmp312_ = 0; + gchar* _tmp313_ = NULL; + gchar* _tmp314_ = NULL; + ValaCCodeIdentifier* _tmp315_ = NULL; + ValaCCodeIdentifier* _tmp316_ = NULL; + ValaCCodeBinaryExpression* _tmp317_ = NULL; + ValaCCodeBinaryExpression* _tmp318_ = NULL; + ValaCCodeFunctionCall* _tmp319_ = NULL; + ValaCCodeFunctionCall* _tmp320_ = NULL; + gint _tmp321_ = 0; + _tmp306_ = vala_ccode_identifier_new ("g_value_get_int"); + _tmp307_ = _tmp306_; + _tmp308_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp307_); _vala_ccode_node_unref0 (inner_fc); - inner_fc = _tmp298_; - _vala_ccode_node_unref0 (_tmp297_); - _tmp299_ = inner_fc; - _tmp300_ = vala_ccode_identifier_new ("param_values"); - _tmp301_ = _tmp300_; - _tmp302_ = i; - _tmp303_ = g_strdup_printf ("%i", _tmp302_); - _tmp304_ = _tmp303_; - _tmp305_ = vala_ccode_identifier_new (_tmp304_); - _tmp306_ = _tmp305_; - _tmp307_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_PLUS, (ValaCCodeExpression*) _tmp301_, (ValaCCodeExpression*) _tmp306_); - _tmp308_ = _tmp307_; - vala_ccode_function_call_add_argument (_tmp299_, (ValaCCodeExpression*) _tmp308_); - _vala_ccode_node_unref0 (_tmp308_); - _vala_ccode_node_unref0 (_tmp306_); - _g_free0 (_tmp304_); - _vala_ccode_node_unref0 (_tmp301_); - _tmp309_ = fc; - _tmp310_ = inner_fc; - vala_ccode_function_call_add_argument (_tmp309_, (ValaCCodeExpression*) _tmp310_); - _tmp311_ = i; - i = _tmp311_ + 1; + inner_fc = _tmp308_; + _vala_ccode_node_unref0 (_tmp307_); + _tmp309_ = inner_fc; + _tmp310_ = vala_ccode_identifier_new ("param_values"); + _tmp311_ = _tmp310_; + _tmp312_ = i; + _tmp313_ = g_strdup_printf ("%i", _tmp312_); + _tmp314_ = _tmp313_; + _tmp315_ = vala_ccode_identifier_new (_tmp314_); + _tmp316_ = _tmp315_; + _tmp317_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_PLUS, (ValaCCodeExpression*) _tmp311_, (ValaCCodeExpression*) _tmp316_); + _tmp318_ = _tmp317_; + vala_ccode_function_call_add_argument (_tmp309_, (ValaCCodeExpression*) _tmp318_); + _vala_ccode_node_unref0 (_tmp318_); + _vala_ccode_node_unref0 (_tmp316_); + _g_free0 (_tmp314_); + _vala_ccode_node_unref0 (_tmp311_); + _tmp319_ = fc; + _tmp320_ = inner_fc; + vala_ccode_function_call_add_argument (_tmp319_, (ValaCCodeExpression*) _tmp320_); + _tmp321_ = i; + i = _tmp321_ + 1; } _vala_ccode_node_unref0 (inner_fc); _g_free0 (get_value_function); @@ -2275,230 +2369,256 @@ } _vala_iterable_unref0 (_p_list); } - _tmp312_ = fc; - _tmp313_ = vala_ccode_identifier_new ("data2"); - _tmp314_ = _tmp313_; - vala_ccode_function_call_add_argument (_tmp312_, (ValaCCodeExpression*) _tmp314_); - _vala_ccode_node_unref0 (_tmp314_); - _tmp316_ = return_type; - _tmp317_ = vala_data_type_get_data_type (_tmp316_); - _tmp318_ = _tmp317_; - if (_tmp318_ != NULL) { - _tmp315_ = TRUE; - } else { - ValaDataType* _tmp319_ = NULL; - gboolean _tmp320_ = FALSE; - _tmp319_ = return_type; - _tmp320_ = vala_data_type_is_array (_tmp319_); - _tmp315_ = _tmp320_; - } - if (_tmp315_) { - ValaCCodeFunction* _tmp321_ = NULL; - ValaCCodeFunction* _tmp322_ = NULL; - ValaCCodeIdentifier* _tmp323_ = NULL; - ValaCCodeIdentifier* _tmp324_ = NULL; - ValaCCodeFunctionCall* _tmp325_ = NULL; + _tmp322_ = fc; + _tmp323_ = vala_ccode_identifier_new ("data2"); + _tmp324_ = _tmp323_; + vala_ccode_function_call_add_argument (_tmp322_, (ValaCCodeExpression*) _tmp324_); + _vala_ccode_node_unref0 (_tmp324_); + _tmp326_ = return_type; + _tmp327_ = vala_data_type_get_data_type (_tmp326_); + _tmp328_ = _tmp327_; + if (_tmp328_ != NULL) { + _tmp325_ = TRUE; + } else { + ValaDataType* _tmp329_ = NULL; + gboolean _tmp330_ = FALSE; + _tmp329_ = return_type; + _tmp330_ = vala_data_type_is_array (_tmp329_); + _tmp325_ = _tmp330_; + } + if (_tmp325_) { + ValaCCodeFunction* _tmp331_ = NULL; + ValaCCodeFunction* _tmp332_ = NULL; + ValaCCodeIdentifier* _tmp333_ = NULL; + ValaCCodeIdentifier* _tmp334_ = NULL; + ValaCCodeFunctionCall* _tmp335_ = NULL; ValaCCodeFunctionCall* set_fc = NULL; - ValaDataType* _tmp326_ = NULL; - gboolean _tmp327_ = FALSE; - ValaCCodeFunctionCall* _tmp379_ = NULL; - ValaCCodeIdentifier* _tmp380_ = NULL; - ValaCCodeIdentifier* _tmp381_ = NULL; - ValaCCodeFunctionCall* _tmp382_ = NULL; - ValaCCodeIdentifier* _tmp383_ = NULL; - ValaCCodeIdentifier* _tmp384_ = NULL; - ValaCCodeFunction* _tmp385_ = NULL; - ValaCCodeFunction* _tmp386_ = NULL; - ValaCCodeFunctionCall* _tmp387_ = NULL; - _tmp321_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); - _tmp322_ = _tmp321_; - _tmp323_ = vala_ccode_identifier_new ("v_return"); - _tmp324_ = _tmp323_; - _tmp325_ = fc; - vala_ccode_function_add_assignment (_tmp322_, (ValaCCodeExpression*) _tmp324_, (ValaCCodeExpression*) _tmp325_); - _vala_ccode_node_unref0 (_tmp324_); - _tmp326_ = return_type; - _tmp327_ = vala_data_type_is_array (_tmp326_); - if (_tmp327_) { - ValaDataType* _tmp328_ = NULL; - ValaDataType* _tmp329_ = NULL; - ValaDataType* _tmp330_ = NULL; - ValaTypeSymbol* _tmp331_ = NULL; - ValaTypeSymbol* _tmp332_ = NULL; - ValaDataType* _tmp333_ = NULL; - ValaTypeSymbol* _tmp334_ = NULL; - ValaTypeSymbol* _tmp335_ = NULL; - _tmp328_ = return_type; - _tmp329_ = vala_array_type_get_element_type (G_TYPE_CHECK_INSTANCE_CAST (_tmp328_, VALA_TYPE_ARRAY_TYPE, ValaArrayType)); - _tmp330_ = _tmp329_; - _tmp331_ = vala_data_type_get_data_type (_tmp330_); - _tmp332_ = _tmp331_; - _tmp333_ = ((ValaCCodeBaseModule*) self)->string_type; - _tmp334_ = vala_data_type_get_data_type (_tmp333_); - _tmp335_ = _tmp334_; - if (_tmp332_ == _tmp335_) { - ValaCCodeIdentifier* _tmp336_ = NULL; - ValaCCodeIdentifier* _tmp337_ = NULL; - ValaCCodeFunctionCall* _tmp338_ = NULL; - _tmp336_ = vala_ccode_identifier_new ("g_value_take_boxed"); - _tmp337_ = _tmp336_; - _tmp338_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp337_); + ValaDataType* _tmp336_ = NULL; + gboolean _tmp337_ = FALSE; + ValaCCodeFunctionCall* _tmp397_ = NULL; + ValaCCodeIdentifier* _tmp398_ = NULL; + ValaCCodeIdentifier* _tmp399_ = NULL; + ValaCCodeFunctionCall* _tmp400_ = NULL; + ValaCCodeIdentifier* _tmp401_ = NULL; + ValaCCodeIdentifier* _tmp402_ = NULL; + ValaCCodeFunction* _tmp403_ = NULL; + ValaCCodeFunction* _tmp404_ = NULL; + ValaCCodeFunctionCall* _tmp405_ = NULL; + _tmp331_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp332_ = _tmp331_; + _tmp333_ = vala_ccode_identifier_new ("v_return"); + _tmp334_ = _tmp333_; + _tmp335_ = fc; + vala_ccode_function_add_assignment (_tmp332_, (ValaCCodeExpression*) _tmp334_, (ValaCCodeExpression*) _tmp335_); + _vala_ccode_node_unref0 (_tmp334_); + _tmp336_ = return_type; + _tmp337_ = vala_data_type_is_array (_tmp336_); + if (_tmp337_) { + ValaDataType* _tmp338_ = NULL; + ValaDataType* _tmp339_ = NULL; + ValaDataType* _tmp340_ = NULL; + ValaTypeSymbol* _tmp341_ = NULL; + ValaTypeSymbol* _tmp342_ = NULL; + ValaDataType* _tmp343_ = NULL; + ValaTypeSymbol* _tmp344_ = NULL; + ValaTypeSymbol* _tmp345_ = NULL; + _tmp338_ = return_type; + _tmp339_ = vala_array_type_get_element_type (G_TYPE_CHECK_INSTANCE_CAST (_tmp338_, VALA_TYPE_ARRAY_TYPE, ValaArrayType)); + _tmp340_ = _tmp339_; + _tmp341_ = vala_data_type_get_data_type (_tmp340_); + _tmp342_ = _tmp341_; + _tmp343_ = ((ValaCCodeBaseModule*) self)->string_type; + _tmp344_ = vala_data_type_get_data_type (_tmp343_); + _tmp345_ = _tmp344_; + if (_tmp342_ == _tmp345_) { + ValaCCodeIdentifier* _tmp346_ = NULL; + ValaCCodeIdentifier* _tmp347_ = NULL; + ValaCCodeFunctionCall* _tmp348_ = NULL; + _tmp346_ = vala_ccode_identifier_new ("g_value_take_boxed"); + _tmp347_ = _tmp346_; + _tmp348_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp347_); _vala_ccode_node_unref0 (set_fc); - set_fc = _tmp338_; - _vala_ccode_node_unref0 (_tmp337_); + set_fc = _tmp348_; + _vala_ccode_node_unref0 (_tmp347_); } else { - ValaCCodeIdentifier* _tmp339_ = NULL; - ValaCCodeIdentifier* _tmp340_ = NULL; - ValaCCodeFunctionCall* _tmp341_ = NULL; - _tmp339_ = vala_ccode_identifier_new ("g_value_set_pointer"); - _tmp340_ = _tmp339_; - _tmp341_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp340_); + ValaCCodeIdentifier* _tmp349_ = NULL; + ValaCCodeIdentifier* _tmp350_ = NULL; + ValaCCodeFunctionCall* _tmp351_ = NULL; + _tmp349_ = vala_ccode_identifier_new ("g_value_set_pointer"); + _tmp350_ = _tmp349_; + _tmp351_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp350_); _vala_ccode_node_unref0 (set_fc); - set_fc = _tmp341_; - _vala_ccode_node_unref0 (_tmp340_); + set_fc = _tmp351_; + _vala_ccode_node_unref0 (_tmp350_); } } else { - ValaDataType* _tmp342_ = NULL; - ValaTypeParameter* _tmp343_ = NULL; - ValaTypeParameter* _tmp344_ = NULL; - _tmp342_ = return_type; - _tmp343_ = vala_data_type_get_type_parameter (_tmp342_); - _tmp344_ = _tmp343_; - if (_tmp344_ != NULL) { - ValaCCodeIdentifier* _tmp345_ = NULL; - ValaCCodeIdentifier* _tmp346_ = NULL; - ValaCCodeFunctionCall* _tmp347_ = NULL; - _tmp345_ = vala_ccode_identifier_new ("g_value_set_pointer"); - _tmp346_ = _tmp345_; - _tmp347_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp346_); + ValaDataType* _tmp352_ = NULL; + ValaTypeParameter* _tmp353_ = NULL; + ValaTypeParameter* _tmp354_ = NULL; + _tmp352_ = return_type; + _tmp353_ = vala_data_type_get_type_parameter (_tmp352_); + _tmp354_ = _tmp353_; + if (_tmp354_ != NULL) { + ValaCCodeIdentifier* _tmp355_ = NULL; + ValaCCodeIdentifier* _tmp356_ = NULL; + ValaCCodeFunctionCall* _tmp357_ = NULL; + _tmp355_ = vala_ccode_identifier_new ("g_value_set_pointer"); + _tmp356_ = _tmp355_; + _tmp357_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp356_); _vala_ccode_node_unref0 (set_fc); - set_fc = _tmp347_; - _vala_ccode_node_unref0 (_tmp346_); + set_fc = _tmp357_; + _vala_ccode_node_unref0 (_tmp356_); } else { - ValaDataType* _tmp348_ = NULL; - _tmp348_ = return_type; - if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp348_, VALA_TYPE_ERROR_TYPE)) { - ValaCCodeIdentifier* _tmp349_ = NULL; - ValaCCodeIdentifier* _tmp350_ = NULL; - ValaCCodeFunctionCall* _tmp351_ = NULL; - _tmp349_ = vala_ccode_identifier_new ("g_value_set_pointer"); - _tmp350_ = _tmp349_; - _tmp351_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp350_); + ValaDataType* _tmp358_ = NULL; + _tmp358_ = return_type; + if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp358_, VALA_TYPE_ERROR_TYPE)) { + ValaCCodeIdentifier* _tmp359_ = NULL; + ValaCCodeIdentifier* _tmp360_ = NULL; + ValaCCodeFunctionCall* _tmp361_ = NULL; + _tmp359_ = vala_ccode_identifier_new ("g_value_set_pointer"); + _tmp360_ = _tmp359_; + _tmp361_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp360_); _vala_ccode_node_unref0 (set_fc); - set_fc = _tmp351_; - _vala_ccode_node_unref0 (_tmp350_); + set_fc = _tmp361_; + _vala_ccode_node_unref0 (_tmp360_); } else { - ValaDataType* _tmp352_ = NULL; - ValaTypeSymbol* _tmp353_ = NULL; - ValaTypeSymbol* _tmp354_ = NULL; - ValaDataType* _tmp355_ = NULL; - ValaTypeSymbol* _tmp356_ = NULL; - ValaTypeSymbol* _tmp357_ = NULL; - _tmp352_ = return_type; - _tmp353_ = vala_data_type_get_data_type (_tmp352_); - _tmp354_ = _tmp353_; - _tmp355_ = ((ValaCCodeBaseModule*) self)->string_type; - _tmp356_ = vala_data_type_get_data_type (_tmp355_); - _tmp357_ = _tmp356_; - if (_tmp354_ == _tmp357_) { - ValaCCodeIdentifier* _tmp358_ = NULL; - ValaCCodeIdentifier* _tmp359_ = NULL; - ValaCCodeFunctionCall* _tmp360_ = NULL; - _tmp358_ = vala_ccode_identifier_new ("g_value_take_string"); - _tmp359_ = _tmp358_; - _tmp360_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp359_); + ValaDataType* _tmp362_ = NULL; + ValaTypeSymbol* _tmp363_ = NULL; + ValaTypeSymbol* _tmp364_ = NULL; + ValaDataType* _tmp365_ = NULL; + ValaTypeSymbol* _tmp366_ = NULL; + ValaTypeSymbol* _tmp367_ = NULL; + _tmp362_ = return_type; + _tmp363_ = vala_data_type_get_data_type (_tmp362_); + _tmp364_ = _tmp363_; + _tmp365_ = ((ValaCCodeBaseModule*) self)->string_type; + _tmp366_ = vala_data_type_get_data_type (_tmp365_); + _tmp367_ = _tmp366_; + if (_tmp364_ == _tmp367_) { + ValaCCodeIdentifier* _tmp368_ = NULL; + ValaCCodeIdentifier* _tmp369_ = NULL; + ValaCCodeFunctionCall* _tmp370_ = NULL; + _tmp368_ = vala_ccode_identifier_new ("g_value_take_string"); + _tmp369_ = _tmp368_; + _tmp370_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp369_); _vala_ccode_node_unref0 (set_fc); - set_fc = _tmp360_; - _vala_ccode_node_unref0 (_tmp359_); + set_fc = _tmp370_; + _vala_ccode_node_unref0 (_tmp369_); } else { - gboolean _tmp361_ = FALSE; - ValaDataType* _tmp362_ = NULL; - ValaTypeSymbol* _tmp363_ = NULL; - ValaTypeSymbol* _tmp364_ = NULL; - _tmp362_ = return_type; - _tmp363_ = vala_data_type_get_data_type (_tmp362_); - _tmp364_ = _tmp363_; - if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp364_, VALA_TYPE_CLASS)) { - _tmp361_ = TRUE; + gboolean _tmp371_ = FALSE; + ValaDataType* _tmp372_ = NULL; + ValaTypeSymbol* _tmp373_ = NULL; + ValaTypeSymbol* _tmp374_ = NULL; + _tmp372_ = return_type; + _tmp373_ = vala_data_type_get_data_type (_tmp372_); + _tmp374_ = _tmp373_; + if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp374_, VALA_TYPE_CLASS)) { + _tmp371_ = TRUE; } else { - ValaDataType* _tmp365_ = NULL; - ValaTypeSymbol* _tmp366_ = NULL; - ValaTypeSymbol* _tmp367_ = NULL; - _tmp365_ = return_type; - _tmp366_ = vala_data_type_get_data_type (_tmp365_); - _tmp367_ = _tmp366_; - _tmp361_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp367_, VALA_TYPE_INTERFACE); + ValaDataType* _tmp375_ = NULL; + ValaTypeSymbol* _tmp376_ = NULL; + ValaTypeSymbol* _tmp377_ = NULL; + _tmp375_ = return_type; + _tmp376_ = vala_data_type_get_data_type (_tmp375_); + _tmp377_ = _tmp376_; + _tmp371_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp377_, VALA_TYPE_INTERFACE); } - if (_tmp361_) { - ValaCCodeIdentifier* _tmp368_ = NULL; - ValaCCodeIdentifier* _tmp369_ = NULL; - ValaCCodeFunctionCall* _tmp370_ = NULL; - _tmp368_ = vala_ccode_identifier_new ("g_value_take_object"); - _tmp369_ = _tmp368_; - _tmp370_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp369_); + if (_tmp371_) { + ValaCCodeIdentifier* _tmp378_ = NULL; + ValaCCodeIdentifier* _tmp379_ = NULL; + ValaCCodeFunctionCall* _tmp380_ = NULL; + _tmp378_ = vala_ccode_identifier_new ("g_value_take_object"); + _tmp379_ = _tmp378_; + _tmp380_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp379_); _vala_ccode_node_unref0 (set_fc); - set_fc = _tmp370_; - _vala_ccode_node_unref0 (_tmp369_); + set_fc = _tmp380_; + _vala_ccode_node_unref0 (_tmp379_); } else { - ValaDataType* _tmp371_ = NULL; - ValaTypeSymbol* _tmp372_ = NULL; - ValaTypeSymbol* _tmp373_ = NULL; - gchar* _tmp374_ = NULL; - gchar* _tmp375_ = NULL; - ValaCCodeIdentifier* _tmp376_ = NULL; - ValaCCodeIdentifier* _tmp377_ = NULL; - ValaCCodeFunctionCall* _tmp378_ = NULL; - _tmp371_ = return_type; - _tmp372_ = vala_data_type_get_data_type (_tmp371_); - _tmp373_ = _tmp372_; - _tmp374_ = vala_ccode_base_module_get_ccode_set_value_function ((ValaCodeNode*) _tmp373_); - _tmp375_ = _tmp374_; - _tmp376_ = vala_ccode_identifier_new (_tmp375_); - _tmp377_ = _tmp376_; - _tmp378_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp377_); - _vala_ccode_node_unref0 (set_fc); - set_fc = _tmp378_; - _vala_ccode_node_unref0 (_tmp377_); - _g_free0 (_tmp375_); + gboolean _tmp381_ = FALSE; + ValaDataType* _tmp382_ = NULL; + _tmp382_ = return_type; + if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp382_, VALA_TYPE_VALUE_TYPE)) { + ValaDataType* _tmp383_ = NULL; + gboolean _tmp384_ = FALSE; + gboolean _tmp385_ = FALSE; + _tmp383_ = return_type; + _tmp384_ = vala_data_type_get_nullable (_tmp383_); + _tmp385_ = _tmp384_; + _tmp381_ = _tmp385_; + } else { + _tmp381_ = FALSE; + } + if (_tmp381_) { + ValaCCodeIdentifier* _tmp386_ = NULL; + ValaCCodeIdentifier* _tmp387_ = NULL; + ValaCCodeFunctionCall* _tmp388_ = NULL; + _tmp386_ = vala_ccode_identifier_new ("g_value_set_pointer"); + _tmp387_ = _tmp386_; + _tmp388_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp387_); + _vala_ccode_node_unref0 (set_fc); + set_fc = _tmp388_; + _vala_ccode_node_unref0 (_tmp387_); + } else { + ValaDataType* _tmp389_ = NULL; + ValaTypeSymbol* _tmp390_ = NULL; + ValaTypeSymbol* _tmp391_ = NULL; + gchar* _tmp392_ = NULL; + gchar* _tmp393_ = NULL; + ValaCCodeIdentifier* _tmp394_ = NULL; + ValaCCodeIdentifier* _tmp395_ = NULL; + ValaCCodeFunctionCall* _tmp396_ = NULL; + _tmp389_ = return_type; + _tmp390_ = vala_data_type_get_data_type (_tmp389_); + _tmp391_ = _tmp390_; + _tmp392_ = vala_ccode_base_module_get_ccode_set_value_function ((ValaCodeNode*) _tmp391_); + _tmp393_ = _tmp392_; + _tmp394_ = vala_ccode_identifier_new (_tmp393_); + _tmp395_ = _tmp394_; + _tmp396_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp395_); + _vala_ccode_node_unref0 (set_fc); + set_fc = _tmp396_; + _vala_ccode_node_unref0 (_tmp395_); + _g_free0 (_tmp393_); + } } } } } } - _tmp379_ = set_fc; - _tmp380_ = vala_ccode_identifier_new ("return_value"); - _tmp381_ = _tmp380_; - vala_ccode_function_call_add_argument (_tmp379_, (ValaCCodeExpression*) _tmp381_); - _vala_ccode_node_unref0 (_tmp381_); - _tmp382_ = set_fc; - _tmp383_ = vala_ccode_identifier_new ("v_return"); - _tmp384_ = _tmp383_; - vala_ccode_function_call_add_argument (_tmp382_, (ValaCCodeExpression*) _tmp384_); - _vala_ccode_node_unref0 (_tmp384_); - _tmp385_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); - _tmp386_ = _tmp385_; - _tmp387_ = set_fc; - vala_ccode_function_add_expression (_tmp386_, (ValaCCodeExpression*) _tmp387_); + _tmp397_ = set_fc; + _tmp398_ = vala_ccode_identifier_new ("return_value"); + _tmp399_ = _tmp398_; + vala_ccode_function_call_add_argument (_tmp397_, (ValaCCodeExpression*) _tmp399_); + _vala_ccode_node_unref0 (_tmp399_); + _tmp400_ = set_fc; + _tmp401_ = vala_ccode_identifier_new ("v_return"); + _tmp402_ = _tmp401_; + vala_ccode_function_call_add_argument (_tmp400_, (ValaCCodeExpression*) _tmp402_); + _vala_ccode_node_unref0 (_tmp402_); + _tmp403_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp404_ = _tmp403_; + _tmp405_ = set_fc; + vala_ccode_function_add_expression (_tmp404_, (ValaCCodeExpression*) _tmp405_); _vala_ccode_node_unref0 (set_fc); } else { - ValaCCodeFunction* _tmp388_ = NULL; - ValaCCodeFunction* _tmp389_ = NULL; - ValaCCodeFunctionCall* _tmp390_ = NULL; - _tmp388_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); - _tmp389_ = _tmp388_; - _tmp390_ = fc; - vala_ccode_function_add_expression (_tmp389_, (ValaCCodeExpression*) _tmp390_); + ValaCCodeFunction* _tmp406_ = NULL; + ValaCCodeFunction* _tmp407_ = NULL; + ValaCCodeFunctionCall* _tmp408_ = NULL; + _tmp406_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp407_ = _tmp406_; + _tmp408_ = fc; + vala_ccode_function_add_expression (_tmp407_, (ValaCCodeExpression*) _tmp408_); } vala_ccode_base_module_pop_function ((ValaCCodeBaseModule*) self); - _tmp391_ = ((ValaCCodeBaseModule*) self)->cfile; - _tmp392_ = signal_marshaller; - vala_ccode_file_add_function_declaration (_tmp391_, _tmp392_); - _tmp393_ = ((ValaCCodeBaseModule*) self)->cfile; - _tmp394_ = signal_marshaller; - vala_ccode_file_add_function (_tmp393_, _tmp394_); - _tmp395_ = ((ValaCCodeBaseModule*) self)->user_marshal_set; - _tmp396_ = signature; - vala_collection_add ((ValaCollection*) _tmp395_, _tmp396_); + _tmp409_ = ((ValaCCodeBaseModule*) self)->cfile; + _tmp410_ = signal_marshaller; + vala_ccode_file_add_function_declaration (_tmp409_, _tmp410_); + _tmp411_ = ((ValaCCodeBaseModule*) self)->cfile; + _tmp412_ = signal_marshaller; + vala_ccode_file_add_function (_tmp411_, _tmp412_); + _tmp413_ = ((ValaCCodeBaseModule*) self)->user_marshal_set; + _tmp414_ = signature; + vala_collection_add ((ValaCollection*) _tmp413_, _tmp414_); _vala_ccode_node_unref0 (c_assign_rhs); _vala_ccode_node_unref0 (cond); _vala_ccode_node_unref0 (param); @@ -2873,55 +2993,56 @@ ValaSignal* _tmp41_ = NULL; gboolean _tmp42_ = FALSE; ValaSignal* _tmp45_ = NULL; - ValaAttribute* _tmp46_ = NULL; - ValaAttribute* _tmp47_ = NULL; + ValaVersionAttribute* _tmp46_ = NULL; + ValaVersionAttribute* _tmp47_ = NULL; gboolean _tmp48_ = FALSE; - ValaCCodeFunctionCall* _tmp51_ = NULL; - gchar** _tmp52_ = NULL; - gint _tmp52__length1 = 0; - gchar* _tmp53_ = NULL; + gboolean _tmp49_ = FALSE; + ValaCCodeFunctionCall* _tmp52_ = NULL; + gchar** _tmp53_ = NULL; + gint _tmp53__length1 = 0; gchar* _tmp54_ = NULL; - ValaCCodeConstant* _tmp55_ = NULL; + gchar* _tmp55_ = NULL; ValaCCodeConstant* _tmp56_ = NULL; - ValaSignal* _tmp57_ = NULL; - ValaMethod* _tmp58_ = NULL; + ValaCCodeConstant* _tmp57_ = NULL; + ValaSignal* _tmp58_ = NULL; ValaMethod* _tmp59_ = NULL; - ValaCCodeFunctionCall* _tmp92_ = NULL; - ValaCCodeConstant* _tmp93_ = NULL; + ValaMethod* _tmp60_ = NULL; + ValaCCodeFunctionCall* _tmp93_ = NULL; ValaCCodeConstant* _tmp94_ = NULL; - ValaCCodeFunctionCall* _tmp95_ = NULL; - ValaCCodeConstant* _tmp96_ = NULL; + ValaCCodeConstant* _tmp95_ = NULL; + ValaCCodeFunctionCall* _tmp96_ = NULL; ValaCCodeConstant* _tmp97_ = NULL; + ValaCCodeConstant* _tmp98_ = NULL; gchar* marshaller = NULL; - ValaSignal* _tmp98_ = NULL; - ValaList* _tmp99_ = NULL; + ValaSignal* _tmp99_ = NULL; ValaList* _tmp100_ = NULL; - ValaSignal* _tmp101_ = NULL; - ValaDataType* _tmp102_ = NULL; + ValaList* _tmp101_ = NULL; + ValaSignal* _tmp102_ = NULL; ValaDataType* _tmp103_ = NULL; - gchar* _tmp104_ = NULL; + ValaDataType* _tmp104_ = NULL; gchar* _tmp105_ = NULL; + gchar* _tmp106_ = NULL; ValaCCodeIdentifier* marshal_arg = NULL; - const gchar* _tmp106_ = NULL; - ValaCCodeIdentifier* _tmp107_ = NULL; - ValaCCodeFunctionCall* _tmp108_ = NULL; - ValaCCodeIdentifier* _tmp109_ = NULL; + const gchar* _tmp107_ = NULL; + ValaCCodeIdentifier* _tmp108_ = NULL; + ValaCCodeFunctionCall* _tmp109_ = NULL; + ValaCCodeIdentifier* _tmp110_ = NULL; ValaList* params = NULL; - ValaSignal* _tmp110_ = NULL; - ValaList* _tmp111_ = NULL; - gboolean _tmp112_ = FALSE; - ValaSignal* _tmp113_ = NULL; - ValaDataType* _tmp114_ = NULL; + ValaSignal* _tmp111_ = NULL; + ValaList* _tmp112_ = NULL; + gboolean _tmp113_ = FALSE; + ValaSignal* _tmp114_ = NULL; ValaDataType* _tmp115_ = NULL; + ValaDataType* _tmp116_ = NULL; gint params_len = 0; - ValaCCodeFunctionCall* _tmp165_ = NULL; - gint _tmp166_ = 0; - gchar* _tmp167_ = NULL; - gchar* _tmp168_ = NULL; - ValaCCodeConstant* _tmp169_ = NULL; - ValaCCodeConstant* _tmp170_ = NULL; - ValaCCodeIdentifier* _tmp237_ = NULL; - const gchar* _tmp238_ = NULL; + ValaCCodeFunctionCall* _tmp178_ = NULL; + gint _tmp179_ = 0; + gchar* _tmp180_ = NULL; + gchar* _tmp181_ = NULL; + ValaCCodeConstant* _tmp182_ = NULL; + ValaCCodeConstant* _tmp183_ = NULL; + ValaCCodeIdentifier* _tmp262_ = NULL; + const gchar* _tmp263_ = NULL; self = (ValaGSignalModule*) base; g_return_val_if_fail (sig != NULL, NULL); g_return_val_if_fail (type != NULL, NULL); @@ -3034,480 +3155,546 @@ _vala_array_add7 (&flags, &flags_length1, &_flags_size_, _tmp44_); } _tmp45_ = sig; - _tmp46_ = vala_code_node_get_attribute ((ValaCodeNode*) _tmp45_, "Deprecated"); + _tmp46_ = vala_symbol_get_version ((ValaSymbol*) _tmp45_); _tmp47_ = _tmp46_; - _tmp48_ = _tmp47_ != NULL; - _vala_code_node_unref0 (_tmp47_); - if (_tmp48_) { - gchar** _tmp49_ = NULL; - gint _tmp49__length1 = 0; - gchar* _tmp50_ = NULL; - _tmp49_ = flags; - _tmp49__length1 = flags_length1; - _tmp50_ = g_strdup ("G_SIGNAL_DEPRECATED"); - _vala_array_add8 (&flags, &flags_length1, &_flags_size_, _tmp50_); - } - _tmp51_ = csignew; - _tmp52_ = flags; - _tmp52__length1 = flags_length1; - _tmp53_ = _vala_g_strjoinv (" | ", _tmp52_, _tmp52__length1); - _tmp54_ = _tmp53_; - _tmp55_ = vala_ccode_constant_new (_tmp54_); - _tmp56_ = _tmp55_; - vala_ccode_function_call_add_argument (_tmp51_, (ValaCCodeExpression*) _tmp56_); - _vala_ccode_node_unref0 (_tmp56_); - _g_free0 (_tmp54_); - _tmp57_ = sig; - _tmp58_ = vala_signal_get_default_handler (_tmp57_); - _tmp59_ = _tmp58_; - if (_tmp59_ == NULL) { - ValaCCodeFunctionCall* _tmp60_ = NULL; - ValaCCodeConstant* _tmp61_ = NULL; + _tmp48_ = vala_version_attribute_get_deprecated (_tmp47_); + _tmp49_ = _tmp48_; + if (_tmp49_) { + gchar** _tmp50_ = NULL; + gint _tmp50__length1 = 0; + gchar* _tmp51_ = NULL; + _tmp50_ = flags; + _tmp50__length1 = flags_length1; + _tmp51_ = g_strdup ("G_SIGNAL_DEPRECATED"); + _vala_array_add8 (&flags, &flags_length1, &_flags_size_, _tmp51_); + } + _tmp52_ = csignew; + _tmp53_ = flags; + _tmp53__length1 = flags_length1; + _tmp54_ = _vala_g_strjoinv (" | ", _tmp53_, _tmp53__length1); + _tmp55_ = _tmp54_; + _tmp56_ = vala_ccode_constant_new (_tmp55_); + _tmp57_ = _tmp56_; + vala_ccode_function_call_add_argument (_tmp52_, (ValaCCodeExpression*) _tmp57_); + _vala_ccode_node_unref0 (_tmp57_); + _g_free0 (_tmp55_); + _tmp58_ = sig; + _tmp59_ = vala_signal_get_default_handler (_tmp58_); + _tmp60_ = _tmp59_; + if (_tmp60_ == NULL) { + ValaCCodeFunctionCall* _tmp61_ = NULL; ValaCCodeConstant* _tmp62_ = NULL; - _tmp60_ = csignew; - _tmp61_ = vala_ccode_constant_new ("0"); - _tmp62_ = _tmp61_; - vala_ccode_function_call_add_argument (_tmp60_, (ValaCCodeExpression*) _tmp62_); - _vala_ccode_node_unref0 (_tmp62_); + ValaCCodeConstant* _tmp63_ = NULL; + _tmp61_ = csignew; + _tmp62_ = vala_ccode_constant_new ("0"); + _tmp63_ = _tmp62_; + vala_ccode_function_call_add_argument (_tmp61_, (ValaCCodeExpression*) _tmp63_); + _vala_ccode_node_unref0 (_tmp63_); } else { ValaCCodeFunctionCall* struct_offset = NULL; - ValaCCodeIdentifier* _tmp63_ = NULL; ValaCCodeIdentifier* _tmp64_ = NULL; - ValaCCodeFunctionCall* _tmp65_ = NULL; + ValaCCodeIdentifier* _tmp65_ = NULL; ValaCCodeFunctionCall* _tmp66_ = NULL; - ValaTypeSymbol* _tmp67_ = NULL; - ValaCCodeFunctionCall* _tmp82_ = NULL; - ValaSignal* _tmp83_ = NULL; - ValaMethod* _tmp84_ = NULL; + ValaCCodeFunctionCall* _tmp67_ = NULL; + ValaTypeSymbol* _tmp68_ = NULL; + ValaCCodeFunctionCall* _tmp83_ = NULL; + ValaSignal* _tmp84_ = NULL; ValaMethod* _tmp85_ = NULL; - gchar* _tmp86_ = NULL; + ValaMethod* _tmp86_ = NULL; gchar* _tmp87_ = NULL; - ValaCCodeIdentifier* _tmp88_ = NULL; + gchar* _tmp88_ = NULL; ValaCCodeIdentifier* _tmp89_ = NULL; - ValaCCodeFunctionCall* _tmp90_ = NULL; + ValaCCodeIdentifier* _tmp90_ = NULL; ValaCCodeFunctionCall* _tmp91_ = NULL; - _tmp63_ = vala_ccode_identifier_new ("G_STRUCT_OFFSET"); - _tmp64_ = _tmp63_; - _tmp65_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp64_); - _tmp66_ = _tmp65_; - _vala_ccode_node_unref0 (_tmp64_); - struct_offset = _tmp66_; - _tmp67_ = type; - if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp67_, VALA_TYPE_CLASS)) { - ValaCCodeFunctionCall* _tmp68_ = NULL; - ValaTypeSymbol* _tmp69_ = NULL; - gchar* _tmp70_ = NULL; + ValaCCodeFunctionCall* _tmp92_ = NULL; + _tmp64_ = vala_ccode_identifier_new ("G_STRUCT_OFFSET"); + _tmp65_ = _tmp64_; + _tmp66_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp65_); + _tmp67_ = _tmp66_; + _vala_ccode_node_unref0 (_tmp65_); + struct_offset = _tmp67_; + _tmp68_ = type; + if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp68_, VALA_TYPE_CLASS)) { + ValaCCodeFunctionCall* _tmp69_ = NULL; + ValaTypeSymbol* _tmp70_ = NULL; gchar* _tmp71_ = NULL; gchar* _tmp72_ = NULL; gchar* _tmp73_ = NULL; - ValaCCodeIdentifier* _tmp74_ = NULL; + gchar* _tmp74_ = NULL; ValaCCodeIdentifier* _tmp75_ = NULL; - _tmp68_ = struct_offset; - _tmp69_ = type; - _tmp70_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp69_); - _tmp71_ = _tmp70_; - _tmp72_ = g_strdup_printf ("%sClass", _tmp71_); - _tmp73_ = _tmp72_; - _tmp74_ = vala_ccode_identifier_new (_tmp73_); - _tmp75_ = _tmp74_; - vala_ccode_function_call_add_argument (_tmp68_, (ValaCCodeExpression*) _tmp75_); - _vala_ccode_node_unref0 (_tmp75_); - _g_free0 (_tmp73_); - _g_free0 (_tmp71_); + ValaCCodeIdentifier* _tmp76_ = NULL; + _tmp69_ = struct_offset; + _tmp70_ = type; + _tmp71_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp70_); + _tmp72_ = _tmp71_; + _tmp73_ = g_strdup_printf ("%sClass", _tmp72_); + _tmp74_ = _tmp73_; + _tmp75_ = vala_ccode_identifier_new (_tmp74_); + _tmp76_ = _tmp75_; + vala_ccode_function_call_add_argument (_tmp69_, (ValaCCodeExpression*) _tmp76_); + _vala_ccode_node_unref0 (_tmp76_); + _g_free0 (_tmp74_); + _g_free0 (_tmp72_); } else { - ValaCCodeFunctionCall* _tmp76_ = NULL; - ValaTypeSymbol* _tmp77_ = NULL; - gchar* _tmp78_ = NULL; + ValaCCodeFunctionCall* _tmp77_ = NULL; + ValaTypeSymbol* _tmp78_ = NULL; gchar* _tmp79_ = NULL; - ValaCCodeIdentifier* _tmp80_ = NULL; + gchar* _tmp80_ = NULL; ValaCCodeIdentifier* _tmp81_ = NULL; - _tmp76_ = struct_offset; - _tmp77_ = type; - _tmp78_ = vala_ccode_base_module_get_ccode_type_name (G_TYPE_CHECK_INSTANCE_CAST (_tmp77_, VALA_TYPE_INTERFACE, ValaInterface)); - _tmp79_ = _tmp78_; - _tmp80_ = vala_ccode_identifier_new (_tmp79_); - _tmp81_ = _tmp80_; - vala_ccode_function_call_add_argument (_tmp76_, (ValaCCodeExpression*) _tmp81_); - _vala_ccode_node_unref0 (_tmp81_); - _g_free0 (_tmp79_); + ValaCCodeIdentifier* _tmp82_ = NULL; + _tmp77_ = struct_offset; + _tmp78_ = type; + _tmp79_ = vala_ccode_base_module_get_ccode_type_name (G_TYPE_CHECK_INSTANCE_CAST (_tmp78_, VALA_TYPE_INTERFACE, ValaInterface)); + _tmp80_ = _tmp79_; + _tmp81_ = vala_ccode_identifier_new (_tmp80_); + _tmp82_ = _tmp81_; + vala_ccode_function_call_add_argument (_tmp77_, (ValaCCodeExpression*) _tmp82_); + _vala_ccode_node_unref0 (_tmp82_); + _g_free0 (_tmp80_); } - _tmp82_ = struct_offset; - _tmp83_ = sig; - _tmp84_ = vala_signal_get_default_handler (_tmp83_); - _tmp85_ = _tmp84_; - _tmp86_ = vala_ccode_base_module_get_ccode_vfunc_name (_tmp85_); - _tmp87_ = _tmp86_; - _tmp88_ = vala_ccode_identifier_new (_tmp87_); - _tmp89_ = _tmp88_; - vala_ccode_function_call_add_argument (_tmp82_, (ValaCCodeExpression*) _tmp89_); - _vala_ccode_node_unref0 (_tmp89_); - _g_free0 (_tmp87_); - _tmp90_ = csignew; - _tmp91_ = struct_offset; - vala_ccode_function_call_add_argument (_tmp90_, (ValaCCodeExpression*) _tmp91_); + _tmp83_ = struct_offset; + _tmp84_ = sig; + _tmp85_ = vala_signal_get_default_handler (_tmp84_); + _tmp86_ = _tmp85_; + _tmp87_ = vala_ccode_base_module_get_ccode_vfunc_name (_tmp86_); + _tmp88_ = _tmp87_; + _tmp89_ = vala_ccode_identifier_new (_tmp88_); + _tmp90_ = _tmp89_; + vala_ccode_function_call_add_argument (_tmp83_, (ValaCCodeExpression*) _tmp90_); + _vala_ccode_node_unref0 (_tmp90_); + _g_free0 (_tmp88_); + _tmp91_ = csignew; + _tmp92_ = struct_offset; + vala_ccode_function_call_add_argument (_tmp91_, (ValaCCodeExpression*) _tmp92_); _vala_ccode_node_unref0 (struct_offset); } - _tmp92_ = csignew; - _tmp93_ = vala_ccode_constant_new ("NULL"); - _tmp94_ = _tmp93_; - vala_ccode_function_call_add_argument (_tmp92_, (ValaCCodeExpression*) _tmp94_); - _vala_ccode_node_unref0 (_tmp94_); - _tmp95_ = csignew; - _tmp96_ = vala_ccode_constant_new ("NULL"); - _tmp97_ = _tmp96_; - vala_ccode_function_call_add_argument (_tmp95_, (ValaCCodeExpression*) _tmp97_); - _vala_ccode_node_unref0 (_tmp97_); - _tmp98_ = sig; - _tmp99_ = vala_signal_get_parameters (_tmp98_); - _tmp100_ = _tmp99_; - _tmp101_ = sig; - _tmp102_ = vala_signal_get_return_type (_tmp101_); - _tmp103_ = _tmp102_; - _tmp104_ = vala_gsignal_module_get_marshaller_function (self, _tmp100_, _tmp103_, NULL); - _tmp105_ = _tmp104_; - _vala_iterable_unref0 (_tmp100_); - marshaller = _tmp105_; - _tmp106_ = marshaller; - _tmp107_ = vala_ccode_identifier_new (_tmp106_); - marshal_arg = _tmp107_; - _tmp108_ = csignew; - _tmp109_ = marshal_arg; - vala_ccode_function_call_add_argument (_tmp108_, (ValaCCodeExpression*) _tmp109_); - _tmp110_ = sig; - _tmp111_ = vala_signal_get_parameters (_tmp110_); - params = _tmp111_; - _tmp113_ = sig; - _tmp114_ = vala_signal_get_return_type (_tmp113_); - _tmp115_ = _tmp114_; - if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp115_, VALA_TYPE_POINTER_TYPE)) { - _tmp112_ = TRUE; + _tmp93_ = csignew; + _tmp94_ = vala_ccode_constant_new ("NULL"); + _tmp95_ = _tmp94_; + vala_ccode_function_call_add_argument (_tmp93_, (ValaCCodeExpression*) _tmp95_); + _vala_ccode_node_unref0 (_tmp95_); + _tmp96_ = csignew; + _tmp97_ = vala_ccode_constant_new ("NULL"); + _tmp98_ = _tmp97_; + vala_ccode_function_call_add_argument (_tmp96_, (ValaCCodeExpression*) _tmp98_); + _vala_ccode_node_unref0 (_tmp98_); + _tmp99_ = sig; + _tmp100_ = vala_signal_get_parameters (_tmp99_); + _tmp101_ = _tmp100_; + _tmp102_ = sig; + _tmp103_ = vala_signal_get_return_type (_tmp102_); + _tmp104_ = _tmp103_; + _tmp105_ = vala_gsignal_module_get_marshaller_function (self, _tmp101_, _tmp104_, NULL); + _tmp106_ = _tmp105_; + _vala_iterable_unref0 (_tmp101_); + marshaller = _tmp106_; + _tmp107_ = marshaller; + _tmp108_ = vala_ccode_identifier_new (_tmp107_); + marshal_arg = _tmp108_; + _tmp109_ = csignew; + _tmp110_ = marshal_arg; + vala_ccode_function_call_add_argument (_tmp109_, (ValaCCodeExpression*) _tmp110_); + _tmp111_ = sig; + _tmp112_ = vala_signal_get_parameters (_tmp111_); + params = _tmp112_; + _tmp114_ = sig; + _tmp115_ = vala_signal_get_return_type (_tmp114_); + _tmp116_ = _tmp115_; + if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp116_, VALA_TYPE_POINTER_TYPE)) { + _tmp113_ = TRUE; } else { - ValaSignal* _tmp116_ = NULL; - ValaDataType* _tmp117_ = NULL; + ValaSignal* _tmp117_ = NULL; ValaDataType* _tmp118_ = NULL; - ValaTypeParameter* _tmp119_ = NULL; + ValaDataType* _tmp119_ = NULL; ValaTypeParameter* _tmp120_ = NULL; - _tmp116_ = sig; - _tmp117_ = vala_signal_get_return_type (_tmp116_); - _tmp118_ = _tmp117_; - _tmp119_ = vala_data_type_get_type_parameter (_tmp118_); - _tmp120_ = _tmp119_; - _tmp112_ = _tmp120_ != NULL; + ValaTypeParameter* _tmp121_ = NULL; + _tmp117_ = sig; + _tmp118_ = vala_signal_get_return_type (_tmp117_); + _tmp119_ = _tmp118_; + _tmp120_ = vala_data_type_get_type_parameter (_tmp119_); + _tmp121_ = _tmp120_; + _tmp113_ = _tmp121_ != NULL; } - if (_tmp112_) { - ValaCCodeFunctionCall* _tmp121_ = NULL; - ValaCCodeConstant* _tmp122_ = NULL; + if (_tmp113_) { + ValaCCodeFunctionCall* _tmp122_ = NULL; ValaCCodeConstant* _tmp123_ = NULL; - _tmp121_ = csignew; - _tmp122_ = vala_ccode_constant_new ("G_TYPE_POINTER"); - _tmp123_ = _tmp122_; - vala_ccode_function_call_add_argument (_tmp121_, (ValaCCodeExpression*) _tmp123_); - _vala_ccode_node_unref0 (_tmp123_); + ValaCCodeConstant* _tmp124_ = NULL; + _tmp122_ = csignew; + _tmp123_ = vala_ccode_constant_new ("G_TYPE_POINTER"); + _tmp124_ = _tmp123_; + vala_ccode_function_call_add_argument (_tmp122_, (ValaCCodeExpression*) _tmp124_); + _vala_ccode_node_unref0 (_tmp124_); } else { - ValaSignal* _tmp124_ = NULL; - ValaDataType* _tmp125_ = NULL; + ValaSignal* _tmp125_ = NULL; ValaDataType* _tmp126_ = NULL; - _tmp124_ = sig; - _tmp125_ = vala_signal_get_return_type (_tmp124_); - _tmp126_ = _tmp125_; - if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp126_, VALA_TYPE_ERROR_TYPE)) { - ValaCCodeFunctionCall* _tmp127_ = NULL; - ValaCCodeConstant* _tmp128_ = NULL; + ValaDataType* _tmp127_ = NULL; + _tmp125_ = sig; + _tmp126_ = vala_signal_get_return_type (_tmp125_); + _tmp127_ = _tmp126_; + if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp127_, VALA_TYPE_ERROR_TYPE)) { + ValaCCodeFunctionCall* _tmp128_ = NULL; ValaCCodeConstant* _tmp129_ = NULL; - _tmp127_ = csignew; - _tmp128_ = vala_ccode_constant_new ("G_TYPE_POINTER"); - _tmp129_ = _tmp128_; - vala_ccode_function_call_add_argument (_tmp127_, (ValaCCodeExpression*) _tmp129_); - _vala_ccode_node_unref0 (_tmp129_); + ValaCCodeConstant* _tmp130_ = NULL; + _tmp128_ = csignew; + _tmp129_ = vala_ccode_constant_new ("G_TYPE_POINTER"); + _tmp130_ = _tmp129_; + vala_ccode_function_call_add_argument (_tmp128_, (ValaCCodeExpression*) _tmp130_); + _vala_ccode_node_unref0 (_tmp130_); } else { - ValaSignal* _tmp130_ = NULL; - ValaDataType* _tmp131_ = NULL; - ValaDataType* _tmp132_ = NULL; - ValaTypeSymbol* _tmp133_ = NULL; - ValaTypeSymbol* _tmp134_ = NULL; - _tmp130_ = sig; - _tmp131_ = vala_signal_get_return_type (_tmp130_); - _tmp132_ = _tmp131_; - _tmp133_ = vala_data_type_get_data_type (_tmp132_); + gboolean _tmp131_ = FALSE; + ValaSignal* _tmp132_ = NULL; + ValaDataType* _tmp133_ = NULL; + ValaDataType* _tmp134_ = NULL; + _tmp132_ = sig; + _tmp133_ = vala_signal_get_return_type (_tmp132_); _tmp134_ = _tmp133_; - if (_tmp134_ == NULL) { - ValaCCodeFunctionCall* _tmp135_ = NULL; - ValaCCodeConstant* _tmp136_ = NULL; - ValaCCodeConstant* _tmp137_ = NULL; - _tmp135_ = csignew; - _tmp136_ = vala_ccode_constant_new ("G_TYPE_NONE"); + if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp134_, VALA_TYPE_VALUE_TYPE)) { + ValaSignal* _tmp135_ = NULL; + ValaDataType* _tmp136_ = NULL; + ValaDataType* _tmp137_ = NULL; + gboolean _tmp138_ = FALSE; + gboolean _tmp139_ = FALSE; + _tmp135_ = sig; + _tmp136_ = vala_signal_get_return_type (_tmp135_); _tmp137_ = _tmp136_; - vala_ccode_function_call_add_argument (_tmp135_, (ValaCCodeExpression*) _tmp137_); - _vala_ccode_node_unref0 (_tmp137_); + _tmp138_ = vala_data_type_get_nullable (_tmp137_); + _tmp139_ = _tmp138_; + _tmp131_ = _tmp139_; } else { - ValaCCodeFunctionCall* _tmp138_ = NULL; - ValaSignal* _tmp139_ = NULL; - ValaDataType* _tmp140_ = NULL; - ValaDataType* _tmp141_ = NULL; - ValaTypeSymbol* _tmp142_ = NULL; - ValaTypeSymbol* _tmp143_ = NULL; - gchar* _tmp144_ = NULL; - gchar* _tmp145_ = NULL; - ValaCCodeConstant* _tmp146_ = NULL; - ValaCCodeConstant* _tmp147_ = NULL; - _tmp138_ = csignew; - _tmp139_ = sig; - _tmp140_ = vala_signal_get_return_type (_tmp139_); - _tmp141_ = _tmp140_; - _tmp142_ = vala_data_type_get_data_type (_tmp141_); - _tmp143_ = _tmp142_; - _tmp144_ = vala_ccode_base_module_get_ccode_type_id ((ValaCodeNode*) _tmp143_); + _tmp131_ = FALSE; + } + if (_tmp131_) { + ValaCCodeFunctionCall* _tmp140_ = NULL; + ValaCCodeConstant* _tmp141_ = NULL; + ValaCCodeConstant* _tmp142_ = NULL; + _tmp140_ = csignew; + _tmp141_ = vala_ccode_constant_new ("G_TYPE_POINTER"); + _tmp142_ = _tmp141_; + vala_ccode_function_call_add_argument (_tmp140_, (ValaCCodeExpression*) _tmp142_); + _vala_ccode_node_unref0 (_tmp142_); + } else { + ValaSignal* _tmp143_ = NULL; + ValaDataType* _tmp144_ = NULL; + ValaDataType* _tmp145_ = NULL; + ValaTypeSymbol* _tmp146_ = NULL; + ValaTypeSymbol* _tmp147_ = NULL; + _tmp143_ = sig; + _tmp144_ = vala_signal_get_return_type (_tmp143_); _tmp145_ = _tmp144_; - _tmp146_ = vala_ccode_constant_new (_tmp145_); + _tmp146_ = vala_data_type_get_data_type (_tmp145_); _tmp147_ = _tmp146_; - vala_ccode_function_call_add_argument (_tmp138_, (ValaCCodeExpression*) _tmp147_); - _vala_ccode_node_unref0 (_tmp147_); - _g_free0 (_tmp145_); + if (_tmp147_ == NULL) { + ValaCCodeFunctionCall* _tmp148_ = NULL; + ValaCCodeConstant* _tmp149_ = NULL; + ValaCCodeConstant* _tmp150_ = NULL; + _tmp148_ = csignew; + _tmp149_ = vala_ccode_constant_new ("G_TYPE_NONE"); + _tmp150_ = _tmp149_; + vala_ccode_function_call_add_argument (_tmp148_, (ValaCCodeExpression*) _tmp150_); + _vala_ccode_node_unref0 (_tmp150_); + } else { + ValaCCodeFunctionCall* _tmp151_ = NULL; + ValaSignal* _tmp152_ = NULL; + ValaDataType* _tmp153_ = NULL; + ValaDataType* _tmp154_ = NULL; + ValaTypeSymbol* _tmp155_ = NULL; + ValaTypeSymbol* _tmp156_ = NULL; + gchar* _tmp157_ = NULL; + gchar* _tmp158_ = NULL; + ValaCCodeConstant* _tmp159_ = NULL; + ValaCCodeConstant* _tmp160_ = NULL; + _tmp151_ = csignew; + _tmp152_ = sig; + _tmp153_ = vala_signal_get_return_type (_tmp152_); + _tmp154_ = _tmp153_; + _tmp155_ = vala_data_type_get_data_type (_tmp154_); + _tmp156_ = _tmp155_; + _tmp157_ = vala_ccode_base_module_get_ccode_type_id ((ValaCodeNode*) _tmp156_); + _tmp158_ = _tmp157_; + _tmp159_ = vala_ccode_constant_new (_tmp158_); + _tmp160_ = _tmp159_; + vala_ccode_function_call_add_argument (_tmp151_, (ValaCCodeExpression*) _tmp160_); + _vala_ccode_node_unref0 (_tmp160_); + _g_free0 (_tmp158_); + } } } } params_len = 0; { ValaList* _param_list = NULL; - ValaList* _tmp148_ = NULL; - ValaList* _tmp149_ = NULL; + ValaList* _tmp161_ = NULL; + ValaList* _tmp162_ = NULL; gint _param_size = 0; - ValaList* _tmp150_ = NULL; - gint _tmp151_ = 0; - gint _tmp152_ = 0; + ValaList* _tmp163_ = NULL; + gint _tmp164_ = 0; + gint _tmp165_ = 0; gint _param_index = 0; - _tmp148_ = params; - _tmp149_ = _vala_iterable_ref0 (_tmp148_); - _param_list = _tmp149_; - _tmp150_ = _param_list; - _tmp151_ = vala_collection_get_size ((ValaCollection*) _tmp150_); - _tmp152_ = _tmp151_; - _param_size = _tmp152_; + _tmp161_ = params; + _tmp162_ = _vala_iterable_ref0 (_tmp161_); + _param_list = _tmp162_; + _tmp163_ = _param_list; + _tmp164_ = vala_collection_get_size ((ValaCollection*) _tmp163_); + _tmp165_ = _tmp164_; + _param_size = _tmp165_; _param_index = -1; while (TRUE) { - gint _tmp153_ = 0; - gint _tmp154_ = 0; - gint _tmp155_ = 0; + gint _tmp166_ = 0; + gint _tmp167_ = 0; + gint _tmp168_ = 0; ValaParameter* param = NULL; - ValaList* _tmp156_ = NULL; - gint _tmp157_ = 0; - gpointer _tmp158_ = NULL; - gint _tmp159_ = 0; - ValaParameter* _tmp160_ = NULL; - ValaDataType* _tmp161_ = NULL; - ValaDataType* _tmp162_ = NULL; - gboolean _tmp163_ = FALSE; - _tmp153_ = _param_index; - _param_index = _tmp153_ + 1; - _tmp154_ = _param_index; - _tmp155_ = _param_size; - if (!(_tmp154_ < _tmp155_)) { + ValaList* _tmp169_ = NULL; + gint _tmp170_ = 0; + gpointer _tmp171_ = NULL; + gint _tmp172_ = 0; + ValaParameter* _tmp173_ = NULL; + ValaDataType* _tmp174_ = NULL; + ValaDataType* _tmp175_ = NULL; + gboolean _tmp176_ = FALSE; + _tmp166_ = _param_index; + _param_index = _tmp166_ + 1; + _tmp167_ = _param_index; + _tmp168_ = _param_size; + if (!(_tmp167_ < _tmp168_)) { break; } - _tmp156_ = _param_list; - _tmp157_ = _param_index; - _tmp158_ = vala_list_get (_tmp156_, _tmp157_); - param = (ValaParameter*) _tmp158_; - _tmp159_ = params_len; - params_len = _tmp159_ + 1; - _tmp160_ = param; - _tmp161_ = vala_variable_get_variable_type ((ValaVariable*) _tmp160_); - _tmp162_ = _tmp161_; - _tmp163_ = vala_data_type_is_array (_tmp162_); - if (_tmp163_) { - gint _tmp164_ = 0; - _tmp164_ = params_len; - params_len = _tmp164_ + 1; + _tmp169_ = _param_list; + _tmp170_ = _param_index; + _tmp171_ = vala_list_get (_tmp169_, _tmp170_); + param = (ValaParameter*) _tmp171_; + _tmp172_ = params_len; + params_len = _tmp172_ + 1; + _tmp173_ = param; + _tmp174_ = vala_variable_get_variable_type ((ValaVariable*) _tmp173_); + _tmp175_ = _tmp174_; + _tmp176_ = vala_data_type_is_array (_tmp175_); + if (_tmp176_) { + gint _tmp177_ = 0; + _tmp177_ = params_len; + params_len = _tmp177_ + 1; } _vala_code_node_unref0 (param); } _vala_iterable_unref0 (_param_list); } - _tmp165_ = csignew; - _tmp166_ = params_len; - _tmp167_ = g_strdup_printf ("%d", _tmp166_); - _tmp168_ = _tmp167_; - _tmp169_ = vala_ccode_constant_new (_tmp168_); - _tmp170_ = _tmp169_; - vala_ccode_function_call_add_argument (_tmp165_, (ValaCCodeExpression*) _tmp170_); - _vala_ccode_node_unref0 (_tmp170_); - _g_free0 (_tmp168_); + _tmp178_ = csignew; + _tmp179_ = params_len; + _tmp180_ = g_strdup_printf ("%d", _tmp179_); + _tmp181_ = _tmp180_; + _tmp182_ = vala_ccode_constant_new (_tmp181_); + _tmp183_ = _tmp182_; + vala_ccode_function_call_add_argument (_tmp178_, (ValaCCodeExpression*) _tmp183_); + _vala_ccode_node_unref0 (_tmp183_); + _g_free0 (_tmp181_); { ValaList* _param_list = NULL; - ValaList* _tmp171_ = NULL; - ValaList* _tmp172_ = NULL; + ValaList* _tmp184_ = NULL; + ValaList* _tmp185_ = NULL; gint _param_size = 0; - ValaList* _tmp173_ = NULL; - gint _tmp174_ = 0; - gint _tmp175_ = 0; + ValaList* _tmp186_ = NULL; + gint _tmp187_ = 0; + gint _tmp188_ = 0; gint _param_index = 0; - _tmp171_ = params; - _tmp172_ = _vala_iterable_ref0 (_tmp171_); - _param_list = _tmp172_; - _tmp173_ = _param_list; - _tmp174_ = vala_collection_get_size ((ValaCollection*) _tmp173_); - _tmp175_ = _tmp174_; - _param_size = _tmp175_; + _tmp184_ = params; + _tmp185_ = _vala_iterable_ref0 (_tmp184_); + _param_list = _tmp185_; + _tmp186_ = _param_list; + _tmp187_ = vala_collection_get_size ((ValaCollection*) _tmp186_); + _tmp188_ = _tmp187_; + _param_size = _tmp188_; _param_index = -1; while (TRUE) { - gint _tmp176_ = 0; - gint _tmp177_ = 0; - gint _tmp178_ = 0; + gint _tmp189_ = 0; + gint _tmp190_ = 0; + gint _tmp191_ = 0; ValaParameter* param = NULL; - ValaList* _tmp179_ = NULL; - gint _tmp180_ = 0; - gpointer _tmp181_ = NULL; - ValaParameter* _tmp182_ = NULL; - ValaDataType* _tmp183_ = NULL; - ValaDataType* _tmp184_ = NULL; - gboolean _tmp185_ = FALSE; - _tmp176_ = _param_index; - _param_index = _tmp176_ + 1; - _tmp177_ = _param_index; - _tmp178_ = _param_size; - if (!(_tmp177_ < _tmp178_)) { + ValaList* _tmp192_ = NULL; + gint _tmp193_ = 0; + gpointer _tmp194_ = NULL; + ValaParameter* _tmp195_ = NULL; + ValaDataType* _tmp196_ = NULL; + ValaDataType* _tmp197_ = NULL; + gboolean _tmp198_ = FALSE; + _tmp189_ = _param_index; + _param_index = _tmp189_ + 1; + _tmp190_ = _param_index; + _tmp191_ = _param_size; + if (!(_tmp190_ < _tmp191_)) { break; } - _tmp179_ = _param_list; - _tmp180_ = _param_index; - _tmp181_ = vala_list_get (_tmp179_, _tmp180_); - param = (ValaParameter*) _tmp181_; - _tmp182_ = param; - _tmp183_ = vala_variable_get_variable_type ((ValaVariable*) _tmp182_); - _tmp184_ = _tmp183_; - _tmp185_ = vala_data_type_is_array (_tmp184_); - if (_tmp185_) { - ValaParameter* _tmp186_ = NULL; - ValaDataType* _tmp187_ = NULL; - ValaDataType* _tmp188_ = NULL; - ValaDataType* _tmp189_ = NULL; - ValaDataType* _tmp190_ = NULL; - ValaTypeSymbol* _tmp191_ = NULL; - ValaTypeSymbol* _tmp192_ = NULL; - ValaDataType* _tmp193_ = NULL; - ValaTypeSymbol* _tmp194_ = NULL; - ValaTypeSymbol* _tmp195_ = NULL; - ValaCCodeFunctionCall* _tmp202_ = NULL; - ValaCCodeConstant* _tmp203_ = NULL; - ValaCCodeConstant* _tmp204_ = NULL; - _tmp186_ = param; - _tmp187_ = vala_variable_get_variable_type ((ValaVariable*) _tmp186_); - _tmp188_ = _tmp187_; - _tmp189_ = vala_array_type_get_element_type (G_TYPE_CHECK_INSTANCE_CAST (_tmp188_, VALA_TYPE_ARRAY_TYPE, ValaArrayType)); - _tmp190_ = _tmp189_; - _tmp191_ = vala_data_type_get_data_type (_tmp190_); - _tmp192_ = _tmp191_; - _tmp193_ = ((ValaCCodeBaseModule*) self)->string_type; - _tmp194_ = vala_data_type_get_data_type (_tmp193_); - _tmp195_ = _tmp194_; - if (_tmp192_ == _tmp195_) { - ValaCCodeFunctionCall* _tmp196_ = NULL; - ValaCCodeConstant* _tmp197_ = NULL; - ValaCCodeConstant* _tmp198_ = NULL; - _tmp196_ = csignew; - _tmp197_ = vala_ccode_constant_new ("G_TYPE_STRV"); - _tmp198_ = _tmp197_; - vala_ccode_function_call_add_argument (_tmp196_, (ValaCCodeExpression*) _tmp198_); - _vala_ccode_node_unref0 (_tmp198_); + _tmp192_ = _param_list; + _tmp193_ = _param_index; + _tmp194_ = vala_list_get (_tmp192_, _tmp193_); + param = (ValaParameter*) _tmp194_; + _tmp195_ = param; + _tmp196_ = vala_variable_get_variable_type ((ValaVariable*) _tmp195_); + _tmp197_ = _tmp196_; + _tmp198_ = vala_data_type_is_array (_tmp197_); + if (_tmp198_) { + ValaParameter* _tmp199_ = NULL; + ValaDataType* _tmp200_ = NULL; + ValaDataType* _tmp201_ = NULL; + ValaDataType* _tmp202_ = NULL; + ValaDataType* _tmp203_ = NULL; + ValaTypeSymbol* _tmp204_ = NULL; + ValaTypeSymbol* _tmp205_ = NULL; + ValaDataType* _tmp206_ = NULL; + ValaTypeSymbol* _tmp207_ = NULL; + ValaTypeSymbol* _tmp208_ = NULL; + ValaCCodeFunctionCall* _tmp215_ = NULL; + ValaCCodeConstant* _tmp216_ = NULL; + ValaCCodeConstant* _tmp217_ = NULL; + _tmp199_ = param; + _tmp200_ = vala_variable_get_variable_type ((ValaVariable*) _tmp199_); + _tmp201_ = _tmp200_; + _tmp202_ = vala_array_type_get_element_type (G_TYPE_CHECK_INSTANCE_CAST (_tmp201_, VALA_TYPE_ARRAY_TYPE, ValaArrayType)); + _tmp203_ = _tmp202_; + _tmp204_ = vala_data_type_get_data_type (_tmp203_); + _tmp205_ = _tmp204_; + _tmp206_ = ((ValaCCodeBaseModule*) self)->string_type; + _tmp207_ = vala_data_type_get_data_type (_tmp206_); + _tmp208_ = _tmp207_; + if (_tmp205_ == _tmp208_) { + ValaCCodeFunctionCall* _tmp209_ = NULL; + ValaCCodeConstant* _tmp210_ = NULL; + ValaCCodeConstant* _tmp211_ = NULL; + _tmp209_ = csignew; + _tmp210_ = vala_ccode_constant_new ("G_TYPE_STRV"); + _tmp211_ = _tmp210_; + vala_ccode_function_call_add_argument (_tmp209_, (ValaCCodeExpression*) _tmp211_); + _vala_ccode_node_unref0 (_tmp211_); } else { - ValaCCodeFunctionCall* _tmp199_ = NULL; - ValaCCodeConstant* _tmp200_ = NULL; - ValaCCodeConstant* _tmp201_ = NULL; - _tmp199_ = csignew; - _tmp200_ = vala_ccode_constant_new ("G_TYPE_POINTER"); - _tmp201_ = _tmp200_; - vala_ccode_function_call_add_argument (_tmp199_, (ValaCCodeExpression*) _tmp201_); - _vala_ccode_node_unref0 (_tmp201_); - } - _tmp202_ = csignew; - _tmp203_ = vala_ccode_constant_new ("G_TYPE_INT"); - _tmp204_ = _tmp203_; - vala_ccode_function_call_add_argument (_tmp202_, (ValaCCodeExpression*) _tmp204_); - _vala_ccode_node_unref0 (_tmp204_); + ValaCCodeFunctionCall* _tmp212_ = NULL; + ValaCCodeConstant* _tmp213_ = NULL; + ValaCCodeConstant* _tmp214_ = NULL; + _tmp212_ = csignew; + _tmp213_ = vala_ccode_constant_new ("G_TYPE_POINTER"); + _tmp214_ = _tmp213_; + vala_ccode_function_call_add_argument (_tmp212_, (ValaCCodeExpression*) _tmp214_); + _vala_ccode_node_unref0 (_tmp214_); + } + _tmp215_ = csignew; + _tmp216_ = vala_ccode_constant_new ("G_TYPE_INT"); + _tmp217_ = _tmp216_; + vala_ccode_function_call_add_argument (_tmp215_, (ValaCCodeExpression*) _tmp217_); + _vala_ccode_node_unref0 (_tmp217_); } else { - gboolean _tmp205_ = FALSE; - gboolean _tmp206_ = FALSE; - ValaParameter* _tmp207_ = NULL; - ValaDataType* _tmp208_ = NULL; - ValaDataType* _tmp209_ = NULL; - _tmp207_ = param; - _tmp208_ = vala_variable_get_variable_type ((ValaVariable*) _tmp207_); - _tmp209_ = _tmp208_; - if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp209_, VALA_TYPE_POINTER_TYPE)) { - _tmp206_ = TRUE; + gboolean _tmp218_ = FALSE; + gboolean _tmp219_ = FALSE; + ValaParameter* _tmp220_ = NULL; + ValaDataType* _tmp221_ = NULL; + ValaDataType* _tmp222_ = NULL; + _tmp220_ = param; + _tmp221_ = vala_variable_get_variable_type ((ValaVariable*) _tmp220_); + _tmp222_ = _tmp221_; + if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp222_, VALA_TYPE_POINTER_TYPE)) { + _tmp219_ = TRUE; } else { - ValaParameter* _tmp210_ = NULL; - ValaDataType* _tmp211_ = NULL; - ValaDataType* _tmp212_ = NULL; - ValaTypeParameter* _tmp213_ = NULL; - ValaTypeParameter* _tmp214_ = NULL; - _tmp210_ = param; - _tmp211_ = vala_variable_get_variable_type ((ValaVariable*) _tmp210_); - _tmp212_ = _tmp211_; - _tmp213_ = vala_data_type_get_type_parameter (_tmp212_); - _tmp214_ = _tmp213_; - _tmp206_ = _tmp214_ != NULL; + ValaParameter* _tmp223_ = NULL; + ValaDataType* _tmp224_ = NULL; + ValaDataType* _tmp225_ = NULL; + ValaTypeParameter* _tmp226_ = NULL; + ValaTypeParameter* _tmp227_ = NULL; + _tmp223_ = param; + _tmp224_ = vala_variable_get_variable_type ((ValaVariable*) _tmp223_); + _tmp225_ = _tmp224_; + _tmp226_ = vala_data_type_get_type_parameter (_tmp225_); + _tmp227_ = _tmp226_; + _tmp219_ = _tmp227_ != NULL; } - if (_tmp206_) { - _tmp205_ = TRUE; + if (_tmp219_) { + _tmp218_ = TRUE; } else { - ValaParameter* _tmp215_ = NULL; - ValaParameterDirection _tmp216_ = 0; - ValaParameterDirection _tmp217_ = 0; - _tmp215_ = param; - _tmp216_ = vala_parameter_get_direction (_tmp215_); - _tmp217_ = _tmp216_; - _tmp205_ = _tmp217_ != VALA_PARAMETER_DIRECTION_IN; - } - if (_tmp205_) { - ValaCCodeFunctionCall* _tmp218_ = NULL; - ValaCCodeConstant* _tmp219_ = NULL; - ValaCCodeConstant* _tmp220_ = NULL; - _tmp218_ = csignew; - _tmp219_ = vala_ccode_constant_new ("G_TYPE_POINTER"); - _tmp220_ = _tmp219_; - vala_ccode_function_call_add_argument (_tmp218_, (ValaCCodeExpression*) _tmp220_); - _vala_ccode_node_unref0 (_tmp220_); + ValaParameter* _tmp228_ = NULL; + ValaParameterDirection _tmp229_ = 0; + ValaParameterDirection _tmp230_ = 0; + _tmp228_ = param; + _tmp229_ = vala_parameter_get_direction (_tmp228_); + _tmp230_ = _tmp229_; + _tmp218_ = _tmp230_ != VALA_PARAMETER_DIRECTION_IN; + } + if (_tmp218_) { + ValaCCodeFunctionCall* _tmp231_ = NULL; + ValaCCodeConstant* _tmp232_ = NULL; + ValaCCodeConstant* _tmp233_ = NULL; + _tmp231_ = csignew; + _tmp232_ = vala_ccode_constant_new ("G_TYPE_POINTER"); + _tmp233_ = _tmp232_; + vala_ccode_function_call_add_argument (_tmp231_, (ValaCCodeExpression*) _tmp233_); + _vala_ccode_node_unref0 (_tmp233_); } else { - ValaParameter* _tmp221_ = NULL; - ValaDataType* _tmp222_ = NULL; - ValaDataType* _tmp223_ = NULL; - _tmp221_ = param; - _tmp222_ = vala_variable_get_variable_type ((ValaVariable*) _tmp221_); - _tmp223_ = _tmp222_; - if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp223_, VALA_TYPE_ERROR_TYPE)) { - ValaCCodeFunctionCall* _tmp224_ = NULL; - ValaCCodeConstant* _tmp225_ = NULL; - ValaCCodeConstant* _tmp226_ = NULL; - _tmp224_ = csignew; - _tmp225_ = vala_ccode_constant_new ("G_TYPE_POINTER"); - _tmp226_ = _tmp225_; - vala_ccode_function_call_add_argument (_tmp224_, (ValaCCodeExpression*) _tmp226_); - _vala_ccode_node_unref0 (_tmp226_); + ValaParameter* _tmp234_ = NULL; + ValaDataType* _tmp235_ = NULL; + ValaDataType* _tmp236_ = NULL; + _tmp234_ = param; + _tmp235_ = vala_variable_get_variable_type ((ValaVariable*) _tmp234_); + _tmp236_ = _tmp235_; + if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp236_, VALA_TYPE_ERROR_TYPE)) { + ValaCCodeFunctionCall* _tmp237_ = NULL; + ValaCCodeConstant* _tmp238_ = NULL; + ValaCCodeConstant* _tmp239_ = NULL; + _tmp237_ = csignew; + _tmp238_ = vala_ccode_constant_new ("G_TYPE_POINTER"); + _tmp239_ = _tmp238_; + vala_ccode_function_call_add_argument (_tmp237_, (ValaCCodeExpression*) _tmp239_); + _vala_ccode_node_unref0 (_tmp239_); } else { - ValaCCodeFunctionCall* _tmp227_ = NULL; - ValaParameter* _tmp228_ = NULL; - ValaDataType* _tmp229_ = NULL; - ValaDataType* _tmp230_ = NULL; - ValaTypeSymbol* _tmp231_ = NULL; - ValaTypeSymbol* _tmp232_ = NULL; - gchar* _tmp233_ = NULL; - gchar* _tmp234_ = NULL; - ValaCCodeConstant* _tmp235_ = NULL; - ValaCCodeConstant* _tmp236_ = NULL; - _tmp227_ = csignew; - _tmp228_ = param; - _tmp229_ = vala_variable_get_variable_type ((ValaVariable*) _tmp228_); - _tmp230_ = _tmp229_; - _tmp231_ = vala_data_type_get_data_type (_tmp230_); - _tmp232_ = _tmp231_; - _tmp233_ = vala_ccode_base_module_get_ccode_type_id ((ValaCodeNode*) _tmp232_); - _tmp234_ = _tmp233_; - _tmp235_ = vala_ccode_constant_new (_tmp234_); - _tmp236_ = _tmp235_; - vala_ccode_function_call_add_argument (_tmp227_, (ValaCCodeExpression*) _tmp236_); - _vala_ccode_node_unref0 (_tmp236_); - _g_free0 (_tmp234_); + gboolean _tmp240_ = FALSE; + ValaParameter* _tmp241_ = NULL; + ValaDataType* _tmp242_ = NULL; + ValaDataType* _tmp243_ = NULL; + _tmp241_ = param; + _tmp242_ = vala_variable_get_variable_type ((ValaVariable*) _tmp241_); + _tmp243_ = _tmp242_; + if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp243_, VALA_TYPE_VALUE_TYPE)) { + ValaParameter* _tmp244_ = NULL; + ValaDataType* _tmp245_ = NULL; + ValaDataType* _tmp246_ = NULL; + gboolean _tmp247_ = FALSE; + gboolean _tmp248_ = FALSE; + _tmp244_ = param; + _tmp245_ = vala_variable_get_variable_type ((ValaVariable*) _tmp244_); + _tmp246_ = _tmp245_; + _tmp247_ = vala_data_type_get_nullable (_tmp246_); + _tmp248_ = _tmp247_; + _tmp240_ = _tmp248_; + } else { + _tmp240_ = FALSE; + } + if (_tmp240_) { + ValaCCodeFunctionCall* _tmp249_ = NULL; + ValaCCodeConstant* _tmp250_ = NULL; + ValaCCodeConstant* _tmp251_ = NULL; + _tmp249_ = csignew; + _tmp250_ = vala_ccode_constant_new ("G_TYPE_POINTER"); + _tmp251_ = _tmp250_; + vala_ccode_function_call_add_argument (_tmp249_, (ValaCCodeExpression*) _tmp251_); + _vala_ccode_node_unref0 (_tmp251_); + } else { + ValaCCodeFunctionCall* _tmp252_ = NULL; + ValaParameter* _tmp253_ = NULL; + ValaDataType* _tmp254_ = NULL; + ValaDataType* _tmp255_ = NULL; + ValaTypeSymbol* _tmp256_ = NULL; + ValaTypeSymbol* _tmp257_ = NULL; + gchar* _tmp258_ = NULL; + gchar* _tmp259_ = NULL; + ValaCCodeConstant* _tmp260_ = NULL; + ValaCCodeConstant* _tmp261_ = NULL; + _tmp252_ = csignew; + _tmp253_ = param; + _tmp254_ = vala_variable_get_variable_type ((ValaVariable*) _tmp253_); + _tmp255_ = _tmp254_; + _tmp256_ = vala_data_type_get_data_type (_tmp255_); + _tmp257_ = _tmp256_; + _tmp258_ = vala_ccode_base_module_get_ccode_type_id ((ValaCodeNode*) _tmp257_); + _tmp259_ = _tmp258_; + _tmp260_ = vala_ccode_constant_new (_tmp259_); + _tmp261_ = _tmp260_; + vala_ccode_function_call_add_argument (_tmp252_, (ValaCCodeExpression*) _tmp261_); + _vala_ccode_node_unref0 (_tmp261_); + _g_free0 (_tmp259_); + } } } } @@ -3515,9 +3702,9 @@ } _vala_iterable_unref0 (_param_list); } - _tmp237_ = marshal_arg; - _tmp238_ = marshaller; - vala_ccode_identifier_set_name (_tmp237_, _tmp238_); + _tmp262_ = marshal_arg; + _tmp263_ = marshaller; + vala_ccode_identifier_set_name (_tmp262_, _tmp263_); result = csignew; _vala_iterable_unref0 (params); _vala_ccode_node_unref0 (marshal_arg); diff -Nru vala-0.34.6/codegen/valagsignalmodule.vala vala-0.34.7/codegen/valagsignalmodule.vala --- vala-0.34.6/codegen/valagsignalmodule.vala 2017-03-07 08:23:50.000000000 +0000 +++ vala-0.34.7/codegen/valagsignalmodule.vala 2017-03-20 21:24:57.000000000 +0000 @@ -36,7 +36,11 @@ } } - ret = "%s_%s_".printf (prefix, get_ccode_marshaller_type_name (return_type)); + if (return_type is ValueType && return_type.nullable) { + ret = "%s_POINTER_".printf (prefix); + } else { + ret = "%s_%s_".printf (prefix, get_ccode_marshaller_type_name (return_type)); + } if (params == null || params.size == 0) { ret = ret + "_VOID"; @@ -58,6 +62,8 @@ return "const char*"; } else if (t.data_type is Class || t.data_type is Interface) { return "gpointer"; + } else if (t is ValueType && t.nullable) { + return "gpointer"; } else if (t.data_type is Struct) { var st = (Struct) t.data_type; if (st.is_simple_type ()) { @@ -87,7 +93,11 @@ private string get_marshaller_signature (List params, DataType return_type) { string signature; - signature = "%s:".printf (get_ccode_marshaller_type_name (return_type)); + if (return_type is ValueType && return_type.nullable) { + signature = "POINTER:"; + } else { + signature = "%s:".printf (get_ccode_marshaller_type_name (return_type)); + } if (params == null || params.size == 0) { signature = signature + "VOID"; } else { @@ -252,6 +262,8 @@ get_value_function = "g_value_get_pointer"; } else if (p.variable_type is ErrorType) { get_value_function = "g_value_get_pointer"; + } else if (p.variable_type is ValueType && p.variable_type.nullable) { + get_value_function = "g_value_get_pointer"; } else { get_value_function = get_ccode_get_value_function (p.variable_type.data_type); } @@ -286,6 +298,8 @@ set_fc = new CCodeFunctionCall (new CCodeIdentifier ("g_value_take_string")); } else if (return_type.data_type is Class || return_type.data_type is Interface) { set_fc = new CCodeFunctionCall (new CCodeIdentifier ("g_value_take_object")); + } else if (return_type is ValueType && return_type.nullable) { + set_fc = new CCodeFunctionCall (new CCodeIdentifier ("g_value_set_pointer")); } else { set_fc = new CCodeFunctionCall (new CCodeIdentifier (get_ccode_set_value_function (return_type.data_type))); } @@ -333,7 +347,7 @@ flags += "G_SIGNAL_NO_HOOKS"; } - if (sig.get_attribute ("Deprecated") != null) { + if (sig.version.deprecated) { flags += "G_SIGNAL_DEPRECATED"; } @@ -365,6 +379,8 @@ csignew.add_argument (new CCodeConstant ("G_TYPE_POINTER")); } else if (sig.return_type is ErrorType) { csignew.add_argument (new CCodeConstant ("G_TYPE_POINTER")); + } else if (sig.return_type is ValueType && sig.return_type.nullable) { + csignew.add_argument (new CCodeConstant ("G_TYPE_POINTER")); } else if (sig.return_type.data_type == null) { csignew.add_argument (new CCodeConstant ("G_TYPE_NONE")); } else { @@ -392,6 +408,8 @@ csignew.add_argument (new CCodeConstant ("G_TYPE_POINTER")); } else if (param.variable_type is ErrorType) { csignew.add_argument (new CCodeConstant ("G_TYPE_POINTER")); + } else if (param.variable_type is ValueType && param.variable_type.nullable) { + csignew.add_argument (new CCodeConstant ("G_TYPE_POINTER")); } else { csignew.add_argument (new CCodeConstant (get_ccode_type_id (param.variable_type.data_type))); } diff -Nru vala-0.34.6/codegen/valagtypemodule.c vala-0.34.7/codegen/valagtypemodule.c --- vala-0.34.6/codegen/valagtypemodule.c 2017-03-07 09:40:05.000000000 +0000 +++ vala-0.34.7/codegen/valagtypemodule.c 2017-03-20 21:31:17.000000000 +0000 @@ -15776,7 +15776,7 @@ _tmp93_ = vala_data_type_get_data_type (_tmp92_); _tmp94_ = _tmp93_; _tmp95_ = vala_struct_is_simple_type (G_TYPE_CHECK_INSTANCE_CAST (_tmp94_, VALA_TYPE_STRUCT, ValaStruct)); - _tmp88_ = _tmp95_; + _tmp88_ = !_tmp95_; } else { _tmp88_ = FALSE; } diff -Nru vala-0.34.6/codegen/valagtypemodule.vala vala-0.34.7/codegen/valagtypemodule.vala --- vala-0.34.6/codegen/valagtypemodule.vala 2017-03-07 08:23:50.000000000 +0000 +++ vala-0.34.7/codegen/valagtypemodule.vala 2017-03-20 21:24:57.000000000 +0000 @@ -2266,7 +2266,7 @@ var cdefault = default_value_for_type (ret_type, false); if (cdefault != null) { ccheck.add_argument (cdefault); - } else if (ret_type.data_type is Struct && ((Struct) ret_type.data_type).is_simple_type ()) { + } else if (ret_type.data_type is Struct && !((Struct) ret_type.data_type).is_simple_type ()) { ccheck.add_argument (new CCodeIdentifier ("result")); } else { return; diff -Nru vala-0.34.6/compiler/valacompiler.c vala-0.34.7/compiler/valacompiler.c --- vala-0.34.6/compiler/valacompiler.c 2017-03-07 09:40:18.000000000 +0000 +++ vala-0.34.7/compiler/valacompiler.c 2017-03-20 21:31:31.000000000 +0000 @@ -233,7 +233,7 @@ static void _vala_array_free (gpointer array, gint array_length, GDestroyNotify destroy_func); static gint _vala_array_length (gpointer array); -static const GOptionEntry VALA_COMPILER_options[56] = {{"vapidir", (gchar) 0, 0, G_OPTION_ARG_FILENAME_ARRAY, &vala_compiler_vapi_directories, "Look for package bindings in DIRECTORY", "DIRECTORY..."}, {"girdir", (gchar) 0, 0, G_OPTION_ARG_FILENAME_ARRAY, &vala_compiler_gir_directories, "Look for .gir files in DIRECTORY", "DIRECTORY..."}, {"metadatadir", (gchar) 0, 0, G_OPTION_ARG_FILENAME_ARRAY, &vala_compiler_metadata_directories, "Look for GIR .metadata files in DIRECTORY", "DIRECTORY..."}, {"pkg", (gchar) 0, 0, G_OPTION_ARG_STRING_ARRAY, &vala_compiler_packages, "Include binding for PACKAGE", "PACKAGE..."}, {"vapi", (gchar) 0, 0, G_OPTION_ARG_FILENAME, &vala_compiler_vapi_filename, "Output VAPI file name", "FILE"}, {"library", (gchar) 0, 0, G_OPTION_ARG_STRING, &vala_compiler_library, "Library name", "NAME"}, {"shared-library", (gchar) 0, 0, G_OPTION_ARG_STRING, &vala_compiler_shared_library, "Shared library name used in generated gir", "NAME"}, {"gir", (gchar) 0, 0, G_OPTION_ARG_STRING, &vala_compiler_gir, "GObject-Introspection repository file name", "NAME-VERSION.gir"}, {"basedir", 'b', 0, G_OPTION_ARG_FILENAME, &vala_compiler_basedir, "Base source directory", "DIRECTORY"}, {"directory", 'd', 0, G_OPTION_ARG_FILENAME, &vala_compiler_directory, "Output directory", "DIRECTORY"}, {"version", (gchar) 0, 0, G_OPTION_ARG_NONE, &vala_compiler_version, "Display version number", NULL}, {"api-version", (gchar) 0, 0, G_OPTION_ARG_NONE, &vala_compiler_api_version, "Display API version number", NULL}, {"ccode", 'C', 0, G_OPTION_ARG_NONE, &vala_compiler_ccode_only, "Output C code", NULL}, {"header", 'H', 0, G_OPTION_ARG_FILENAME, &vala_compiler_header_filename, "Output C header file", "FILE"}, {"use-header", (gchar) 0, 0, G_OPTION_ARG_NONE, &vala_compiler_use_header, "Use C header file", NULL}, {"includedir", (gchar) 0, 0, G_OPTION_ARG_FILENAME, &vala_compiler_includedir, "Directory used to include the C header file", "DIRECTORY"}, {"internal-header", 'h', 0, G_OPTION_ARG_FILENAME, &vala_compiler_internal_header_filename, "Output internal C header file", "FILE"}, {"internal-vapi", (gchar) 0, 0, G_OPTION_ARG_FILENAME, &vala_compiler_internal_vapi_filename, "Output vapi with internal api", "FILE"}, {"fast-vapi", (gchar) 0, 0, G_OPTION_ARG_STRING, &vala_compiler_fast_vapi_filename, "Output vapi without performing symbol resolution", NULL}, {"use-fast-vapi", (gchar) 0, 0, G_OPTION_ARG_STRING_ARRAY, &vala_compiler_fast_vapis, "Use --fast-vapi output during this compile", NULL}, {"vapi-comments", (gchar) 0, 0, G_OPTION_ARG_NONE, &vala_compiler_vapi_comments, "Include comments in generated vapi", NULL}, {"deps", (gchar) 0, 0, G_OPTION_ARG_STRING, &vala_compiler_dependencies, "Write make-style dependency information to this file", NULL}, {"symbols", (gchar) 0, 0, G_OPTION_ARG_FILENAME, &vala_compiler_symbols_filename, "Output symbols file", "FILE"}, {"compile", 'c', 0, G_OPTION_ARG_NONE, &vala_compiler_compile_only, "Compile but do not link", NULL}, {"output", 'o', 0, G_OPTION_ARG_FILENAME, &vala_compiler_output, "Place output in file FILE", "FILE"}, {"debug", 'g', 0, G_OPTION_ARG_NONE, &vala_compiler_debug, "Produce debug information", NULL}, {"thread", (gchar) 0, 0, G_OPTION_ARG_NONE, &vala_compiler_thread, "Enable multithreading support", NULL}, {"enable-mem-profiler", (gchar) 0, 0, G_OPTION_ARG_NONE, &vala_compiler_mem_profiler, "Enable GLib memory profiler", NULL}, {"define", 'D', 0, G_OPTION_ARG_STRING_ARRAY, &vala_compiler_defines, "Define SYMBOL", "SYMBOL..."}, {"main", (gchar) 0, 0, G_OPTION_ARG_STRING, &vala_compiler_entry_point, "Use SYMBOL as entry point", "SYMBOL..."}, {"nostdpkg", (gchar) 0, 0, G_OPTION_ARG_NONE, &vala_compiler_nostdpkg, "Do not include standard packages", NULL}, {"disable-assert", (gchar) 0, 0, G_OPTION_ARG_NONE, &vala_compiler_disable_assert, "Disable assertions", NULL}, {"enable-checking", (gchar) 0, 0, G_OPTION_ARG_NONE, &vala_compiler_enable_checking, "Enable additional run-time checks", NULL}, {"enable-deprecated", (gchar) 0, 0, G_OPTION_ARG_NONE, &vala_compiler_deprecated, "Enable deprecated features", NULL}, {"hide-internal", (gchar) 0, 0, G_OPTION_ARG_NONE, &vala_compiler_hide_internal, "Hide symbols marked as internal", NULL}, {"enable-experimental", (gchar) 0, 0, G_OPTION_ARG_NONE, &vala_compiler_experimental, "Enable experimental features", NULL}, {"disable-warnings", (gchar) 0, 0, G_OPTION_ARG_NONE, &vala_compiler_disable_warnings, "Disable warnings", NULL}, {"fatal-warnings", (gchar) 0, 0, G_OPTION_ARG_NONE, &vala_compiler_fatal_warnings, "Treat warnings as fatal", NULL}, {"disable-since-check", (gchar) 0, 0, G_OPTION_ARG_NONE, &vala_compiler_disable_since_check, "Do not check whether used symbols exist in local packages", NULL}, {"enable-experimental-non-null", (gchar) 0, 0, G_OPTION_ARG_NONE, &vala_compiler_experimental_non_null, "Enable experimental enhancements for non-null types", NULL}, {"enable-gobject-tracing", (gchar) 0, 0, G_OPTION_ARG_NONE, &vala_compiler_gobject_tracing, "Enable GObject creation tracing", NULL}, {"cc", (gchar) 0, 0, G_OPTION_ARG_STRING, &vala_compiler_cc_command, "Use COMMAND as C compiler command", "COMMAND"}, {"Xcc", 'X', 0, G_OPTION_ARG_STRING_ARRAY, &vala_compiler_cc_options, "Pass OPTION to the C compiler", "OPTION..."}, {"pkg-config", (gchar) 0, 0, G_OPTION_ARG_STRING, &vala_compiler_pkg_config_command, "Use COMMAND as pkg-config command", "COMMAND"}, {"dump-tree", (gchar) 0, 0, G_OPTION_ARG_FILENAME, &vala_compiler_dump_tree, "Write code tree to FILE", "FILE"}, {"save-temps", (gchar) 0, 0, G_OPTION_ARG_NONE, &vala_compiler_save_temps, "Keep temporary files", NULL}, {"profile", (gchar) 0, 0, G_OPTION_ARG_STRING, &vala_compiler_profile, "Use the given profile instead of the default", "PROFILE"}, {"quiet", 'q', 0, G_OPTION_ARG_NONE, &vala_compiler_quiet_mode, "Do not print messages to the console", NULL}, {"verbose", 'v', 0, G_OPTION_ARG_NONE, &vala_compiler_verbose_mode, "Print additional messages to the console", NULL}, {"no-color", (gchar) 0, 0, G_OPTION_ARG_NONE, &vala_compiler_disable_diagnostic_colors, "Disable colored output", NULL}, {"target-glib", (gchar) 0, 0, G_OPTION_ARG_STRING, &vala_compiler_target_glib, "Target version of glib for code generation", "MAJOR.MINOR"}, {"gresources", (gchar) 0, 0, G_OPTION_ARG_STRING_ARRAY, &vala_compiler_gresources, "XML of gresources", "FILE..."}, {"enable-version-header", (gchar) 0, 0, G_OPTION_ARG_NONE, &vala_compiler_enable_version_header, "Write vala build version in generated files", NULL}, {"disable-version-header", (gchar) 0, 0, G_OPTION_ARG_NONE, &vala_compiler_disable_version_header, "Do not write vala build version in generated files", NULL}, {"", (gchar) 0, 0, G_OPTION_ARG_FILENAME_ARRAY, &vala_compiler_sources, NULL, "FILE..."}, {NULL}}; +static const GOptionEntry VALA_COMPILER_options[56] = {{"vapidir", (gchar) 0, 0, G_OPTION_ARG_FILENAME_ARRAY, &vala_compiler_vapi_directories, "Look for package bindings in DIRECTORY", "DIRECTORY..."}, {"girdir", (gchar) 0, 0, G_OPTION_ARG_FILENAME_ARRAY, &vala_compiler_gir_directories, "Look for .gir files in DIRECTORY", "DIRECTORY..."}, {"metadatadir", (gchar) 0, 0, G_OPTION_ARG_FILENAME_ARRAY, &vala_compiler_metadata_directories, "Look for GIR .metadata files in DIRECTORY", "DIRECTORY..."}, {"pkg", (gchar) 0, 0, G_OPTION_ARG_STRING_ARRAY, &vala_compiler_packages, "Include binding for PACKAGE", "PACKAGE..."}, {"vapi", (gchar) 0, 0, G_OPTION_ARG_FILENAME, &vala_compiler_vapi_filename, "Output VAPI file name", "FILE"}, {"library", (gchar) 0, 0, G_OPTION_ARG_STRING, &vala_compiler_library, "Library name", "NAME"}, {"shared-library", (gchar) 0, 0, G_OPTION_ARG_STRING, &vala_compiler_shared_library, "Shared library name used in generated gir", "NAME"}, {"gir", (gchar) 0, 0, G_OPTION_ARG_STRING, &vala_compiler_gir, "GObject-Introspection repository file name", "NAME-VERSION.gir"}, {"basedir", 'b', 0, G_OPTION_ARG_FILENAME, &vala_compiler_basedir, "Base source directory", "DIRECTORY"}, {"directory", 'd', 0, G_OPTION_ARG_FILENAME, &vala_compiler_directory, "Change output directory from current working directory", "DIRECTORY"}, {"version", (gchar) 0, 0, G_OPTION_ARG_NONE, &vala_compiler_version, "Display version number", NULL}, {"api-version", (gchar) 0, 0, G_OPTION_ARG_NONE, &vala_compiler_api_version, "Display API version number", NULL}, {"ccode", 'C', 0, G_OPTION_ARG_NONE, &vala_compiler_ccode_only, "Output C code", NULL}, {"header", 'H', 0, G_OPTION_ARG_FILENAME, &vala_compiler_header_filename, "Output C header file", "FILE"}, {"use-header", (gchar) 0, 0, G_OPTION_ARG_NONE, &vala_compiler_use_header, "Use C header file", NULL}, {"includedir", (gchar) 0, 0, G_OPTION_ARG_FILENAME, &vala_compiler_includedir, "Directory used to include the C header file", "DIRECTORY"}, {"internal-header", 'h', 0, G_OPTION_ARG_FILENAME, &vala_compiler_internal_header_filename, "Output internal C header file", "FILE"}, {"internal-vapi", (gchar) 0, 0, G_OPTION_ARG_FILENAME, &vala_compiler_internal_vapi_filename, "Output vapi with internal api", "FILE"}, {"fast-vapi", (gchar) 0, 0, G_OPTION_ARG_STRING, &vala_compiler_fast_vapi_filename, "Output vapi without performing symbol resolution", NULL}, {"use-fast-vapi", (gchar) 0, 0, G_OPTION_ARG_STRING_ARRAY, &vala_compiler_fast_vapis, "Use --fast-vapi output during this compile", NULL}, {"vapi-comments", (gchar) 0, 0, G_OPTION_ARG_NONE, &vala_compiler_vapi_comments, "Include comments in generated vapi", NULL}, {"deps", (gchar) 0, 0, G_OPTION_ARG_STRING, &vala_compiler_dependencies, "Write make-style dependency information to this file", NULL}, {"symbols", (gchar) 0, 0, G_OPTION_ARG_FILENAME, &vala_compiler_symbols_filename, "Output symbols file", "FILE"}, {"compile", 'c', 0, G_OPTION_ARG_NONE, &vala_compiler_compile_only, "Compile but do not link", NULL}, {"output", 'o', 0, G_OPTION_ARG_FILENAME, &vala_compiler_output, "Place output in file FILE", "FILE"}, {"debug", 'g', 0, G_OPTION_ARG_NONE, &vala_compiler_debug, "Produce debug information", NULL}, {"thread", (gchar) 0, 0, G_OPTION_ARG_NONE, &vala_compiler_thread, "Enable multithreading support", NULL}, {"enable-mem-profiler", (gchar) 0, 0, G_OPTION_ARG_NONE, &vala_compiler_mem_profiler, "Enable GLib memory profiler", NULL}, {"define", 'D', 0, G_OPTION_ARG_STRING_ARRAY, &vala_compiler_defines, "Define SYMBOL", "SYMBOL..."}, {"main", (gchar) 0, 0, G_OPTION_ARG_STRING, &vala_compiler_entry_point, "Use SYMBOL as entry point", "SYMBOL..."}, {"nostdpkg", (gchar) 0, 0, G_OPTION_ARG_NONE, &vala_compiler_nostdpkg, "Do not include standard packages", NULL}, {"disable-assert", (gchar) 0, 0, G_OPTION_ARG_NONE, &vala_compiler_disable_assert, "Disable assertions", NULL}, {"enable-checking", (gchar) 0, 0, G_OPTION_ARG_NONE, &vala_compiler_enable_checking, "Enable additional run-time checks", NULL}, {"enable-deprecated", (gchar) 0, 0, G_OPTION_ARG_NONE, &vala_compiler_deprecated, "Enable deprecated features", NULL}, {"hide-internal", (gchar) 0, 0, G_OPTION_ARG_NONE, &vala_compiler_hide_internal, "Hide symbols marked as internal", NULL}, {"enable-experimental", (gchar) 0, 0, G_OPTION_ARG_NONE, &vala_compiler_experimental, "Enable experimental features", NULL}, {"disable-warnings", (gchar) 0, 0, G_OPTION_ARG_NONE, &vala_compiler_disable_warnings, "Disable warnings", NULL}, {"fatal-warnings", (gchar) 0, 0, G_OPTION_ARG_NONE, &vala_compiler_fatal_warnings, "Treat warnings as fatal", NULL}, {"disable-since-check", (gchar) 0, 0, G_OPTION_ARG_NONE, &vala_compiler_disable_since_check, "Do not check whether used symbols exist in local packages", NULL}, {"enable-experimental-non-null", (gchar) 0, 0, G_OPTION_ARG_NONE, &vala_compiler_experimental_non_null, "Enable experimental enhancements for non-null types", NULL}, {"enable-gobject-tracing", (gchar) 0, 0, G_OPTION_ARG_NONE, &vala_compiler_gobject_tracing, "Enable GObject creation tracing", NULL}, {"cc", (gchar) 0, 0, G_OPTION_ARG_STRING, &vala_compiler_cc_command, "Use COMMAND as C compiler command", "COMMAND"}, {"Xcc", 'X', 0, G_OPTION_ARG_STRING_ARRAY, &vala_compiler_cc_options, "Pass OPTION to the C compiler", "OPTION..."}, {"pkg-config", (gchar) 0, 0, G_OPTION_ARG_STRING, &vala_compiler_pkg_config_command, "Use COMMAND as pkg-config command", "COMMAND"}, {"dump-tree", (gchar) 0, 0, G_OPTION_ARG_FILENAME, &vala_compiler_dump_tree, "Write code tree to FILE", "FILE"}, {"save-temps", (gchar) 0, 0, G_OPTION_ARG_NONE, &vala_compiler_save_temps, "Keep temporary files", NULL}, {"profile", (gchar) 0, 0, G_OPTION_ARG_STRING, &vala_compiler_profile, "Use the given profile instead of the default", "PROFILE"}, {"quiet", 'q', 0, G_OPTION_ARG_NONE, &vala_compiler_quiet_mode, "Do not print messages to the console", NULL}, {"verbose", 'v', 0, G_OPTION_ARG_NONE, &vala_compiler_verbose_mode, "Print additional messages to the console", NULL}, {"no-color", (gchar) 0, 0, G_OPTION_ARG_NONE, &vala_compiler_disable_diagnostic_colors, "Disable colored output", NULL}, {"target-glib", (gchar) 0, 0, G_OPTION_ARG_STRING, &vala_compiler_target_glib, "Target version of glib for code generation", "MAJOR.MINOR"}, {"gresources", (gchar) 0, 0, G_OPTION_ARG_STRING_ARRAY, &vala_compiler_gresources, "XML of gresources", "FILE..."}, {"enable-version-header", (gchar) 0, 0, G_OPTION_ARG_NONE, &vala_compiler_enable_version_header, "Write vala build version in generated files", NULL}, {"disable-version-header", (gchar) 0, 0, G_OPTION_ARG_NONE, &vala_compiler_disable_version_header, "Do not write vala build version in generated files", NULL}, {"", (gchar) 0, 0, G_OPTION_ARG_FILENAME_ARRAY, &vala_compiler_sources, NULL, "FILE..."}, {NULL}}; static gint vala_compiler_quit (ValaCompiler* self) { gint result = 0; diff -Nru vala-0.34.6/compiler/valacompiler.vala vala-0.34.7/compiler/valacompiler.vala --- vala-0.34.6/compiler/valacompiler.vala 2017-03-07 08:23:50.000000000 +0000 +++ vala-0.34.7/compiler/valacompiler.vala 2017-03-20 21:24:57.000000000 +0000 @@ -107,7 +107,7 @@ { "shared-library", 0, 0, OptionArg.STRING, ref shared_library, "Shared library name used in generated gir", "NAME" }, { "gir", 0, 0, OptionArg.STRING, ref gir, "GObject-Introspection repository file name", "NAME-VERSION.gir" }, { "basedir", 'b', 0, OptionArg.FILENAME, ref basedir, "Base source directory", "DIRECTORY" }, - { "directory", 'd', 0, OptionArg.FILENAME, ref directory, "Output directory", "DIRECTORY" }, + { "directory", 'd', 0, OptionArg.FILENAME, ref directory, "Change output directory from current working directory", "DIRECTORY" }, { "version", 0, 0, OptionArg.NONE, ref version, "Display version number", null }, { "api-version", 0, 0, OptionArg.NONE, ref api_version, "Display API version number", null }, { "ccode", 'C', 0, OptionArg.NONE, ref ccode_only, "Output C code", null }, diff -Nru vala-0.34.6/configure vala-0.34.7/configure --- vala-0.34.6/configure 2017-03-07 09:39:15.000000000 +0000 +++ vala-0.34.7/configure 2017-03-20 21:30:26.000000000 +0000 @@ -1,6 +1,6 @@ #! /bin/sh # Guess values for system-dependent variables and create Makefiles. -# Generated by GNU Autoconf 2.69 for vala 0.34.6. +# Generated by GNU Autoconf 2.69 for vala 0.34.7. # # Report bugs to . # @@ -591,8 +591,8 @@ # Identity of this package. PACKAGE_NAME='vala' PACKAGE_TARNAME='vala' -PACKAGE_VERSION='0.34.6' -PACKAGE_STRING='vala 0.34.6' +PACKAGE_VERSION='0.34.7' +PACKAGE_STRING='vala 0.34.7' PACKAGE_BUGREPORT='https://bugzilla.gnome.org/browse.cgi?product=vala' PACKAGE_URL='https://wiki.gnome.org/Projects/Vala' @@ -1370,7 +1370,7 @@ # Omit some internal or obsolete options to make the list less imposing. # This message is too long to be a string in the A/UX 3.1 sh. cat <<_ACEOF -\`configure' configures vala 0.34.6 to adapt to many kinds of systems. +\`configure' configures vala 0.34.7 to adapt to many kinds of systems. Usage: $0 [OPTION]... [VAR=VALUE]... @@ -1441,7 +1441,7 @@ if test -n "$ac_init_help"; then case $ac_init_help in - short | recursive ) echo "Configuration of vala 0.34.6:";; + short | recursive ) echo "Configuration of vala 0.34.7:";; esac cat <<\_ACEOF @@ -1572,7 +1572,7 @@ test -n "$ac_init_help" && exit $ac_status if $ac_init_version; then cat <<\_ACEOF -vala configure 0.34.6 +vala configure 0.34.7 generated by GNU Autoconf 2.69 Copyright (C) 2012 Free Software Foundation, Inc. @@ -1850,7 +1850,7 @@ This file contains any messages produced by compilers while running configure, to aid debugging if configure makes a mistake. -It was created by vala $as_me 0.34.6, which was +It was created by vala $as_me 0.34.7, which was generated by GNU Autoconf 2.69. Invocation command line was $ $0 $@ @@ -2717,7 +2717,7 @@ # Define the identity of the package. PACKAGE='vala' - VERSION='0.34.6' + VERSION='0.34.7' cat >>confdefs.h <<_ACEOF @@ -13381,7 +13381,7 @@ # report actual input values of CONFIG_FILES etc. instead of their # values after options handling. ac_log=" -This file was extended by vala $as_me 0.34.6, which was +This file was extended by vala $as_me 0.34.7, which was generated by GNU Autoconf 2.69. Invocation command line was CONFIG_FILES = $CONFIG_FILES @@ -13448,7 +13448,7 @@ cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 ac_cs_config="`$as_echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`" ac_cs_version="\\ -vala config.status 0.34.6 +vala config.status 0.34.7 configured by $0, generated by GNU Autoconf 2.69, with options \\"\$ac_cs_config\\" diff -Nru vala-0.34.6/debian/changelog vala-0.34.7/debian/changelog --- vala-0.34.6/debian/changelog 2017-03-08 19:18:18.000000000 +0000 +++ vala-0.34.7/debian/changelog 2017-03-21 00:30:58.000000000 +0000 @@ -1,3 +1,9 @@ +vala (0.34.7-1) unstable; urgency=medium + + * New upstream version 0.34.7 + + -- Michael Biebl Tue, 21 Mar 2017 01:30:58 +0100 + vala (0.34.6-1) unstable; urgency=medium * New upstream version 0.34.6 diff -Nru vala-0.34.6/doc/manual/devhelp.xsl vala-0.34.7/doc/manual/devhelp.xsl --- vala-0.34.6/doc/manual/devhelp.xsl 2017-03-07 08:35:38.000000000 +0000 +++ vala-0.34.7/doc/manual/devhelp.xsl 2017-03-20 18:51:50.000000000 +0000 @@ -13,7 +13,7 @@ /> - + diff -Nru vala-0.34.6/doc/manual/Makefile.am vala-0.34.7/doc/manual/Makefile.am --- vala-0.34.6/doc/manual/Makefile.am 2017-03-07 08:35:39.000000000 +0000 +++ vala-0.34.7/doc/manual/Makefile.am 2017-03-20 21:24:57.000000000 +0000 @@ -24,6 +24,7 @@ $(srcdir)/xhtml.xsl \ $(srcdir)/manual.xml @cp $(srcdir)/default.css $@ + @touch $@ html: manual.xml xhtml.xsl @$(MKDIR_P) $@ @@ -34,6 +35,7 @@ $(srcdir)/xhtml.xsl \ $(srcdir)/manual.xml @cp $(srcdir)/default.css $@ + @touch $@ mostlyclean-local: rm -rf devhelp diff -Nru vala-0.34.6/doc/manual/Makefile.in vala-0.34.7/doc/manual/Makefile.in --- vala-0.34.6/doc/manual/Makefile.in 2017-03-07 09:39:17.000000000 +0000 +++ vala-0.34.7/doc/manual/Makefile.in 2017-03-20 21:30:27.000000000 +0000 @@ -536,6 +536,7 @@ $(srcdir)/xhtml.xsl \ $(srcdir)/manual.xml @cp $(srcdir)/default.css $@ + @touch $@ html: manual.xml xhtml.xsl @$(MKDIR_P) $@ @@ -546,6 +547,7 @@ $(srcdir)/xhtml.xsl \ $(srcdir)/manual.xml @cp $(srcdir)/default.css $@ + @touch $@ mostlyclean-local: rm -rf devhelp diff -Nru vala-0.34.6/doc/manual/manual.xml vala-0.34.7/doc/manual/manual.xml --- vala-0.34.6/doc/manual/manual.xml 2017-03-07 08:42:40.000000000 +0000 +++ vala-0.34.7/doc/manual/manual.xml 2017-03-20 18:51:50.000000000 +0000 @@ -1,7 +1,8 @@
-Vala Reference Manual [Draft] +Vala Reference Manual +This is a draft version of the Vala Reference Manual, and so is not guaranteed to be correct. Back to Vala Reference Manual
@@ -153,7 +154,7 @@ Named scopes can be created directly with declarations like namespaces. These are always in existence when the program is running, and can be referred to by their name. Transient scopes are created automatically as the program executes. Every time a new code block is entered, a new scope is created. For example, a new scope is created when a method is invoked. There is no way to refer to this type of scope from outside. Instance scopes are created when a data type is instantiated, for example when a new instance of a classed type is created. These scopes can be accessed via identifiers defined in other scopes, e.g. a variable to which the new instance is assigned. -To refer to an identifier in another scope, you must generally qualify the name. For named scopes, the scope name is used; for instance scopes, any identifier to which the instance is assigned can be used. See Expressions/Member access expressions for the syntax of accessing other scopes. +To refer to an identifier in another scope, you must generally qualify the name. For named scopes, the scope name is used; for instance scopes, any identifier to which the instance is assigned can be used. See Expressions/Member access for the syntax of accessing other scopes. Scopes have parent scopes. If an identifier is not recognised in the current scope, the parent scope is searched. This continues up to the the global scope. The parent scope of any scope is inferred from its position in the program - the parent scope can easily be identified as it is the scope the current declaration is in. For example, a namespace method creates a transient scope when it is invoked - the parent of this scope if the namespace which contains the definition of the method. There are slightly different rules applied when instances are involved, as are described at Classes/Class scope. The ultimate parent of all other scopes is the global scope. The scope contains the fundamental data types, e.g. int, float, string. If a program has a declaration outside of any other, it is placed in this scope. diff -Nru vala-0.34.6/doc/valac.1 vala-0.34.7/doc/valac.1 --- vala-0.34.6/doc/valac.1 2017-03-07 08:28:44.000000000 +0000 +++ vala-0.34.7/doc/valac.1 2017-03-20 21:24:57.000000000 +0000 @@ -52,7 +52,7 @@ Base source directory .TP \fB\-d\fR, \fB\-\-directory\fR=\fI\,DIRECTORY\/\fR -Output directory +Change output directory from current working directory .TP \fB\-\-version\fR Display version number diff -Nru vala-0.34.6/NEWS vala-0.34.7/NEWS --- vala-0.34.6/NEWS 2017-03-07 09:37:38.000000000 +0000 +++ vala-0.34.7/NEWS 2017-03-20 21:26:35.000000000 +0000 @@ -1,3 +1,8 @@ +Vala 0.34.7 +=========== + + * Bug fixes and binding updates. + Vala 0.34.6 =========== diff -Nru vala-0.34.6/.tarball-version vala-0.34.7/.tarball-version --- vala-0.34.6/.tarball-version 2017-03-07 09:40:30.000000000 +0000 +++ vala-0.34.7/.tarball-version 2017-03-20 21:32:41.000000000 +0000 @@ -1 +1 @@ -0.34.6 +0.34.7 diff -Nru vala-0.34.6/tests/basic-types/bug777697.test vala-0.34.7/tests/basic-types/bug777697.test --- vala-0.34.6/tests/basic-types/bug777697.test 1970-01-01 00:00:00.000000000 +0000 +++ vala-0.34.7/tests/basic-types/bug777697.test 2017-03-20 18:51:50.000000000 +0000 @@ -0,0 +1,8 @@ +Invalid Code + +namespace Foo { + string bar = "bar"; +} + +void main () { +} diff -Nru vala-0.34.6/tests/delegates/reference_transfer.vala vala-0.34.7/tests/delegates/reference_transfer.vala --- vala-0.34.6/tests/delegates/reference_transfer.vala 1970-01-01 00:00:00.000000000 +0000 +++ vala-0.34.7/tests/delegates/reference_transfer.vala 2017-03-20 18:51:50.000000000 +0000 @@ -0,0 +1,14 @@ +delegate void FooFunc (); + +class Foo { + FooFunc f; + + public Foo (owned FooFunc d) { + f = (owned) d; + assert (d == null); + } +} + +void main () { + var foo = new Foo (() => {}); +} diff -Nru vala-0.34.6/tests/enums/bug780050.vala vala-0.34.7/tests/enums/bug780050.vala --- vala-0.34.6/tests/enums/bug780050.vala 1970-01-01 00:00:00.000000000 +0000 +++ vala-0.34.7/tests/enums/bug780050.vala 2017-03-20 18:51:50.000000000 +0000 @@ -0,0 +1,10 @@ +enum Bar { + FOO +} + +namespace Foo { + Bar bar = Bar.FOO; +} + +void main () { +} diff -Nru vala-0.34.6/tests/Makefile.am vala-0.34.7/tests/Makefile.am --- vala-0.34.6/tests/Makefile.am 2017-03-07 08:23:50.000000000 +0000 +++ vala-0.34.7/tests/Makefile.am 2017-03-20 21:24:57.000000000 +0000 @@ -42,6 +42,7 @@ basic-types/bug731017.vala \ basic-types/bug761307.vala \ basic-types/bug771626.test \ + basic-types/bug777697.test \ namespaces.vala \ methods/lambda.vala \ methods/closures.vala \ @@ -90,6 +91,7 @@ enums/flags.vala \ enums/bug673879.vala \ enums/bug763831.vala \ + enums/bug780050.vala \ structs/structs.vala \ structs/gvalue.vala \ structs/bug530605.vala \ @@ -122,6 +124,7 @@ structs/bug749952.vala \ structs/bug775761.vala \ delegates/delegates.vala \ + delegates/reference_transfer.vala \ delegates/bug539166.vala \ delegates/bug595610.vala \ delegates/bug595639.vala \ @@ -172,6 +175,8 @@ objects/bug702736.vala \ objects/bug702846.vala \ objects/bug751338.vala \ + objects/bug758816.vala \ + objects/bug764481.vala \ objects/bug767092.test \ objects/bug768823.test \ objects/bug766739.vala \ diff -Nru vala-0.34.6/tests/Makefile.in vala-0.34.7/tests/Makefile.in --- vala-0.34.6/tests/Makefile.in 2017-03-07 09:39:17.000000000 +0000 +++ vala-0.34.7/tests/Makefile.in 2017-03-20 21:30:28.000000000 +0000 @@ -101,23 +101,23 @@ basic-types/bug659975.vala basic-types/bug678791.vala \ basic-types/bug686336.vala basic-types/bug729907.vala \ basic-types/bug731017.vala basic-types/bug761307.vala \ - basic-types/bug771626.test namespaces.vala methods/lambda.vala \ - methods/closures.vala methods/prepostconditions.vala \ - methods/symbolresolution.vala methods/bug595538.vala \ - methods/bug596726.vala methods/bug597426.vala \ - methods/bug598738.vala methods/bug599892.vala \ - methods/bug613483.vala methods/bug620673.vala \ - methods/bug622570.vala methods/bug626783.vala \ - methods/bug639054.vala methods/bug642885.vala \ - methods/bug642899.vala methods/bug646345.vala \ - methods/bug648320.vala methods/bug649562.vala \ - methods/bug652098.vala methods/bug653391.vala \ - methods/bug653908.vala methods/bug663210.vala \ - methods/bug723009.vala methods/bug723195.vala \ - methods/bug726347.vala methods/bug736235.vala \ - methods/bug737222.vala methods/bug743877.vala \ - methods/bug771964.vala methods/generics.vala \ - control-flow/break.vala \ + basic-types/bug771626.test basic-types/bug777697.test \ + namespaces.vala methods/lambda.vala methods/closures.vala \ + methods/prepostconditions.vala methods/symbolresolution.vala \ + methods/bug595538.vala methods/bug596726.vala \ + methods/bug597426.vala methods/bug598738.vala \ + methods/bug599892.vala methods/bug613483.vala \ + methods/bug620673.vala methods/bug622570.vala \ + methods/bug626783.vala methods/bug639054.vala \ + methods/bug642885.vala methods/bug642899.vala \ + methods/bug646345.vala methods/bug648320.vala \ + methods/bug649562.vala methods/bug652098.vala \ + methods/bug653391.vala methods/bug653908.vala \ + methods/bug663210.vala methods/bug723009.vala \ + methods/bug723195.vala methods/bug726347.vala \ + methods/bug736235.vala methods/bug737222.vala \ + methods/bug743877.vala methods/bug771964.vala \ + methods/generics.vala control-flow/break.vala \ control-flow/expressions-conditional.vala \ control-flow/for.vala control-flow/foreach.vala \ control-flow/nested-conditional.vala control-flow/switch.vala \ @@ -125,22 +125,23 @@ control-flow/bug652549.vala control-flow/bug661985.vala \ control-flow/bug665904.vala control-flow/bug691514.vala \ enums/enums.vala enums/flags.vala enums/bug673879.vala \ - enums/bug763831.vala structs/structs.vala structs/gvalue.vala \ - structs/bug530605.vala structs/bug572091.vala \ - structs/bug583603.vala structs/bug595587.vala \ - structs/bug596144.vala structs/bug603056.vala \ - structs/bug606202.vala structs/bug609642.vala \ - structs/bug613513.vala structs/bug613825.vala \ - structs/bug621176.vala structs/bug622422.vala \ - structs/bug623092.vala structs/bug651441.vala \ - structs/bug654646.vala structs/bug654753.vala \ - structs/bug656693.vala structs/bug657378.vala \ - structs/bug658048.vala structs/bug660426.vala \ - structs/bug661945.vala structs/bug667890.vala \ - structs/bug669580.vala structs/bug685177.vala \ - structs/bug686190.vala structs/bug690380.vala \ - structs/bug694140.vala structs/bug749952.vala \ - structs/bug775761.vala delegates/delegates.vala \ + enums/bug763831.vala enums/bug780050.vala structs/structs.vala \ + structs/gvalue.vala structs/bug530605.vala \ + structs/bug572091.vala structs/bug583603.vala \ + structs/bug595587.vala structs/bug596144.vala \ + structs/bug603056.vala structs/bug606202.vala \ + structs/bug609642.vala structs/bug613513.vala \ + structs/bug613825.vala structs/bug621176.vala \ + structs/bug622422.vala structs/bug623092.vala \ + structs/bug651441.vala structs/bug654646.vala \ + structs/bug654753.vala structs/bug656693.vala \ + structs/bug657378.vala structs/bug658048.vala \ + structs/bug660426.vala structs/bug661945.vala \ + structs/bug667890.vala structs/bug669580.vala \ + structs/bug685177.vala structs/bug686190.vala \ + structs/bug690380.vala structs/bug694140.vala \ + structs/bug749952.vala structs/bug775761.vala \ + delegates/delegates.vala delegates/reference_transfer.vala \ delegates/bug539166.vala delegates/bug595610.vala \ delegates/bug595639.vala delegates/bug638415.vala \ delegates/bug639751.vala delegates/bug659778.vala \ @@ -166,6 +167,7 @@ objects/bug683646.vala objects/bug695671.vala \ objects/bug701978.vala objects/bug702736.vala \ objects/bug702846.vala objects/bug751338.vala \ + objects/bug758816.vala objects/bug764481.vala \ objects/bug767092.test objects/bug768823.test \ objects/bug766739.vala objects/bug779219.vala \ errors/errors.vala errors/bug567181.vala errors/bug579101.vala \ @@ -1295,6 +1297,13 @@ --log-file $$b.log --trs-file $$b.trs \ $(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \ "$$tst" $(AM_TESTS_FD_REDIRECT) +enums/bug780050.vala.log: enums/bug780050.vala + @p='enums/bug780050.vala'; \ + b='enums/bug780050.vala'; \ + $(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \ + --log-file $$b.log --trs-file $$b.trs \ + $(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \ + "$$tst" $(AM_TESTS_FD_REDIRECT) structs/structs.vala.log: structs/structs.vala @p='structs/structs.vala'; \ b='structs/structs.vala'; \ @@ -1519,6 +1528,13 @@ --log-file $$b.log --trs-file $$b.trs \ $(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \ "$$tst" $(AM_TESTS_FD_REDIRECT) +delegates/reference_transfer.vala.log: delegates/reference_transfer.vala + @p='delegates/reference_transfer.vala'; \ + b='delegates/reference_transfer.vala'; \ + $(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \ + --log-file $$b.log --trs-file $$b.trs \ + $(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \ + "$$tst" $(AM_TESTS_FD_REDIRECT) delegates/bug539166.vala.log: delegates/bug539166.vala @p='delegates/bug539166.vala'; \ b='delegates/bug539166.vala'; \ @@ -1868,6 +1884,20 @@ $(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \ --log-file $$b.log --trs-file $$b.trs \ $(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \ + "$$tst" $(AM_TESTS_FD_REDIRECT) +objects/bug758816.vala.log: objects/bug758816.vala + @p='objects/bug758816.vala'; \ + b='objects/bug758816.vala'; \ + $(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \ + --log-file $$b.log --trs-file $$b.trs \ + $(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \ + "$$tst" $(AM_TESTS_FD_REDIRECT) +objects/bug764481.vala.log: objects/bug764481.vala + @p='objects/bug764481.vala'; \ + b='objects/bug764481.vala'; \ + $(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \ + --log-file $$b.log --trs-file $$b.trs \ + $(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \ "$$tst" $(AM_TESTS_FD_REDIRECT) objects/bug766739.vala.log: objects/bug766739.vala @p='objects/bug766739.vala'; \ diff -Nru vala-0.34.6/tests/objects/bug758816.vala vala-0.34.7/tests/objects/bug758816.vala --- vala-0.34.6/tests/objects/bug758816.vala 1970-01-01 00:00:00.000000000 +0000 +++ vala-0.34.7/tests/objects/bug758816.vala 2017-03-20 18:51:50.000000000 +0000 @@ -0,0 +1,70 @@ +enum Bar { + FAIL, + FOO, + BAR, + BAZ +} + +public struct Manam { + public int i; + public int j; +} + +class Foo : Object { + public signal Bar? bar (); + public signal Bar? bar2 (Bar? bar); + + public signal Manam? manam (); + public signal Manam? manam2 (Manam? manam); + + public void emit_bar () { + assert (bar () == Bar.FOO); + } + + public void emit_bar2 () { + assert (bar2 (Bar.BAZ) == Bar.BAZ); + } + + public void emit_manam () { + Manam? m = {23, 42}; + assert (manam () == m); + } + + public void emit_manam2 () { + Manam? m = {23, 42}; + assert (manam2 ({23, 42}) == m); + } +} + +Bar? callback_bar () { + return Bar.FOO; +} + +Bar? callback_bar2 (Bar? bar) { + assert (bar == Bar.BAZ); + return bar; +} + +Manam? callback_manam () { + return {23, 42}; +} + +Manam? callback_manam2 (Manam? manam) { + Manam? m = {23, 42}; + assert (manam == m); + return manam; +} + +void main () { + var foo = new Foo (); + + foo.bar.connect (callback_bar); + foo.emit_bar (); + foo.bar2.connect (callback_bar2); + foo.emit_bar2 (); + + foo.manam.connect (callback_manam); + foo.emit_manam (); + foo.manam2.connect (callback_manam2); + foo.emit_manam2 (); +} diff -Nru vala-0.34.6/tests/objects/bug764481.vala vala-0.34.7/tests/objects/bug764481.vala --- vala-0.34.6/tests/objects/bug764481.vala 1970-01-01 00:00:00.000000000 +0000 +++ vala-0.34.7/tests/objects/bug764481.vala 2017-03-20 18:51:50.000000000 +0000 @@ -0,0 +1,55 @@ +[SimpleType] +[CCode (has_type_id = false)] +struct Minim { + int a; +} + +struct Manam { + int a; +} + +class BaseFoo : Object { + public virtual Manam st { get; set; } + public virtual Minim sst { get; set; } +} + +class Foo : Object { + public virtual Manam st { get; set; } + public virtual Minim sst { get; set; } +} + +class Bar : Foo { + public override Manam st { + get { return base.st; } + set { base.st = value; } + } + public override Minim sst { + get { return base.sst; } + set { base.sst = value; } + } +} + +class Baz : BaseFoo { + public override Manam st { + get { return base.st; } + set { base.st = value; } + } + public override Minim sst { + get { return base.sst; } + set { base.sst = value; } + } +} + +void main () { + var bar = new Bar (); + bar.st = { 42 }; + bar.sst = { 42 }; + assert (bar.st.a == 42); + assert (bar.sst.a == 42); + + var baz = new Baz (); + baz.st = { 23 }; + baz.sst = { 23 }; + assert (baz.st.a == 23); + assert (baz.sst.a == 23); +} diff -Nru vala-0.34.6/vala/valafield.c vala-0.34.7/vala/valafield.c --- vala-0.34.6/vala/valafield.c 2017-03-07 09:39:32.000000000 +0000 +++ vala-0.34.7/vala/valafield.c 2017-03-20 21:30:42.000000000 +0000 @@ -571,6 +571,7 @@ gboolean vala_data_type_get_value_owned (ValaDataType* self); ValaSymbol* vala_symbol_get_parent_symbol (ValaSymbol* self); gboolean vala_expression_is_constant (ValaExpression* self); +gboolean vala_expression_is_non_null (ValaExpression* self); ValaMemberBinding vala_field_get_binding (ValaField* self); gboolean vala_class_get_is_compact (ValaClass* self); gboolean vala_symbol_get_external (ValaSymbol* self); @@ -779,26 +780,26 @@ gboolean _tmp40_ = FALSE; ValaExpression* _tmp51_ = NULL; ValaExpression* _tmp52_ = NULL; - gboolean _tmp129_ = FALSE; - ValaMemberBinding _tmp130_ = 0; - gboolean field_in_header = FALSE; - gboolean _tmp135_ = FALSE; - ValaSymbol* _tmp136_ = NULL; - ValaSymbol* _tmp137_ = NULL; - gboolean _tmp147_ = FALSE; - gboolean _tmp148_ = FALSE; gboolean _tmp149_ = FALSE; - gboolean _tmp150_ = FALSE; - ValaCodeContext* _tmp165_ = NULL; - ValaSemanticAnalyzer* _tmp166_ = NULL; - ValaSemanticAnalyzer* _tmp167_ = NULL; - ValaSourceFile* _tmp168_ = NULL; - ValaCodeContext* _tmp169_ = NULL; - ValaSemanticAnalyzer* _tmp170_ = NULL; - ValaSemanticAnalyzer* _tmp171_ = NULL; - ValaSymbol* _tmp172_ = NULL; - gboolean _tmp173_ = FALSE; - gboolean _tmp174_ = FALSE; + ValaMemberBinding _tmp150_ = 0; + gboolean field_in_header = FALSE; + gboolean _tmp155_ = FALSE; + ValaSymbol* _tmp156_ = NULL; + ValaSymbol* _tmp157_ = NULL; + gboolean _tmp167_ = FALSE; + gboolean _tmp168_ = FALSE; + gboolean _tmp169_ = FALSE; + gboolean _tmp170_ = FALSE; + ValaCodeContext* _tmp185_ = NULL; + ValaSemanticAnalyzer* _tmp186_ = NULL; + ValaSemanticAnalyzer* _tmp187_ = NULL; + ValaSourceFile* _tmp188_ = NULL; + ValaCodeContext* _tmp189_ = NULL; + ValaSemanticAnalyzer* _tmp190_ = NULL; + ValaSemanticAnalyzer* _tmp191_ = NULL; + ValaSymbol* _tmp192_ = NULL; + gboolean _tmp193_ = FALSE; + gboolean _tmp194_ = FALSE; self = (ValaField*) base; g_return_val_if_fail (context != NULL, FALSE); _tmp0_ = vala_code_node_get_checked ((ValaCodeNode*) self); @@ -936,10 +937,14 @@ ValaSymbol* _tmp104_ = NULL; gboolean _tmp110_ = FALSE; gboolean _tmp111_ = FALSE; - gboolean _tmp112_ = FALSE; - ValaMemberBinding _tmp113_ = 0; - gboolean _tmp125_ = FALSE; - gboolean _tmp126_ = FALSE; + ValaSymbol* _tmp112_ = NULL; + ValaSymbol* _tmp113_ = NULL; + gboolean _tmp130_ = FALSE; + gboolean _tmp131_ = FALSE; + gboolean _tmp132_ = FALSE; + ValaMemberBinding _tmp133_ = 0; + gboolean _tmp145_ = FALSE; + gboolean _tmp146_ = FALSE; _tmp53_ = vala_variable_get_initializer ((ValaVariable*) self); _tmp54_ = _tmp53_; _tmp55_ = vala_variable_get_variable_type ((ValaVariable*) self); @@ -1080,181 +1085,239 @@ _vala_source_file_unref0 (old_source_file); return result; } - _tmp113_ = self->priv->_binding; - if (_tmp113_ == VALA_MEMBER_BINDING_STATIC) { - ValaSymbol* _tmp114_ = NULL; - ValaSymbol* _tmp115_ = NULL; - _tmp114_ = vala_symbol_get_parent_symbol ((ValaSymbol*) self); + _tmp112_ = vala_symbol_get_parent_symbol ((ValaSymbol*) self); + _tmp113_ = _tmp112_; + if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp113_, VALA_TYPE_NAMESPACE)) { + ValaExpression* _tmp114_ = NULL; + ValaExpression* _tmp115_ = NULL; + gboolean _tmp116_ = FALSE; + _tmp114_ = vala_variable_get_initializer ((ValaVariable*) self); _tmp115_ = _tmp114_; - _tmp112_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp115_, VALA_TYPE_CLASS); - } else { - _tmp112_ = FALSE; - } - if (_tmp112_) { - ValaSymbol* _tmp116_ = NULL; - ValaSymbol* _tmp117_ = NULL; - gboolean _tmp118_ = FALSE; - gboolean _tmp119_ = FALSE; - _tmp116_ = vala_symbol_get_parent_symbol ((ValaSymbol*) self); - _tmp117_ = _tmp116_; - _tmp118_ = vala_class_get_is_compact (G_TYPE_CHECK_INSTANCE_CAST (_tmp117_, VALA_TYPE_CLASS, ValaClass)); - _tmp119_ = _tmp118_; - _tmp111_ = _tmp119_; + _tmp116_ = vala_expression_is_constant (_tmp115_); + _tmp111_ = _tmp116_; } else { _tmp111_ = FALSE; } if (_tmp111_) { - ValaExpression* _tmp120_ = NULL; - ValaExpression* _tmp121_ = NULL; - gboolean _tmp122_ = FALSE; - _tmp120_ = vala_variable_get_initializer ((ValaVariable*) self); - _tmp121_ = _tmp120_; - _tmp122_ = vala_expression_is_constant (_tmp121_); - _tmp110_ = !_tmp122_; + ValaExpression* _tmp117_ = NULL; + ValaExpression* _tmp118_ = NULL; + gboolean _tmp119_ = FALSE; + _tmp117_ = vala_variable_get_initializer ((ValaVariable*) self); + _tmp118_ = _tmp117_; + _tmp119_ = vala_expression_is_non_null (_tmp118_); + _tmp110_ = _tmp119_; } else { _tmp110_ = FALSE; } if (_tmp110_) { - ValaSourceReference* _tmp123_ = NULL; - ValaSourceReference* _tmp124_ = NULL; + gboolean _tmp120_ = FALSE; + ValaDataType* _tmp121_ = NULL; + ValaDataType* _tmp122_ = NULL; + gboolean _tmp123_ = FALSE; + _tmp121_ = vala_variable_get_variable_type ((ValaVariable*) self); + _tmp122_ = _tmp121_; + _tmp123_ = vala_data_type_is_disposable (_tmp122_); + if (_tmp123_) { + ValaDataType* _tmp124_ = NULL; + ValaDataType* _tmp125_ = NULL; + gboolean _tmp126_ = FALSE; + gboolean _tmp127_ = FALSE; + _tmp124_ = vala_variable_get_variable_type ((ValaVariable*) self); + _tmp125_ = _tmp124_; + _tmp126_ = vala_data_type_get_value_owned (_tmp125_); + _tmp127_ = _tmp126_; + _tmp120_ = _tmp127_; + } else { + _tmp120_ = FALSE; + } + if (_tmp120_) { + ValaSourceReference* _tmp128_ = NULL; + ValaSourceReference* _tmp129_ = NULL; + vala_code_node_set_error ((ValaCodeNode*) self, TRUE); + _tmp128_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); + _tmp129_ = _tmp128_; + vala_report_error (_tmp129_, "Owned namespace fields can only be initialized in a function or method"); + result = FALSE; + _vala_code_node_unref0 (old_symbol); + _vala_source_file_unref0 (old_source_file); + return result; + } + } + _tmp133_ = self->priv->_binding; + if (_tmp133_ == VALA_MEMBER_BINDING_STATIC) { + ValaSymbol* _tmp134_ = NULL; + ValaSymbol* _tmp135_ = NULL; + _tmp134_ = vala_symbol_get_parent_symbol ((ValaSymbol*) self); + _tmp135_ = _tmp134_; + _tmp132_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp135_, VALA_TYPE_CLASS); + } else { + _tmp132_ = FALSE; + } + if (_tmp132_) { + ValaSymbol* _tmp136_ = NULL; + ValaSymbol* _tmp137_ = NULL; + gboolean _tmp138_ = FALSE; + gboolean _tmp139_ = FALSE; + _tmp136_ = vala_symbol_get_parent_symbol ((ValaSymbol*) self); + _tmp137_ = _tmp136_; + _tmp138_ = vala_class_get_is_compact (G_TYPE_CHECK_INSTANCE_CAST (_tmp137_, VALA_TYPE_CLASS, ValaClass)); + _tmp139_ = _tmp138_; + _tmp131_ = _tmp139_; + } else { + _tmp131_ = FALSE; + } + if (_tmp131_) { + ValaExpression* _tmp140_ = NULL; + ValaExpression* _tmp141_ = NULL; + gboolean _tmp142_ = FALSE; + _tmp140_ = vala_variable_get_initializer ((ValaVariable*) self); + _tmp141_ = _tmp140_; + _tmp142_ = vala_expression_is_constant (_tmp141_); + _tmp130_ = !_tmp142_; + } else { + _tmp130_ = FALSE; + } + if (_tmp130_) { + ValaSourceReference* _tmp143_ = NULL; + ValaSourceReference* _tmp144_ = NULL; vala_code_node_set_error ((ValaCodeNode*) self, TRUE); - _tmp123_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); - _tmp124_ = _tmp123_; - vala_report_error (_tmp124_, "Static fields in compact classes cannot have non-constant initializers"); + _tmp143_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); + _tmp144_ = _tmp143_; + vala_report_error (_tmp144_, "Static fields in compact classes cannot have non-constant initializers"); result = FALSE; _vala_code_node_unref0 (old_symbol); _vala_source_file_unref0 (old_source_file); return result; } - _tmp125_ = vala_symbol_get_external ((ValaSymbol*) self); - _tmp126_ = _tmp125_; - if (_tmp126_) { - ValaSourceReference* _tmp127_ = NULL; - ValaSourceReference* _tmp128_ = NULL; + _tmp145_ = vala_symbol_get_external ((ValaSymbol*) self); + _tmp146_ = _tmp145_; + if (_tmp146_) { + ValaSourceReference* _tmp147_ = NULL; + ValaSourceReference* _tmp148_ = NULL; vala_code_node_set_error ((ValaCodeNode*) self, TRUE); - _tmp127_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); - _tmp128_ = _tmp127_; - vala_report_error (_tmp128_, "External fields cannot use initializers"); + _tmp147_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); + _tmp148_ = _tmp147_; + vala_report_error (_tmp148_, "External fields cannot use initializers"); } } - _tmp130_ = self->priv->_binding; - if (_tmp130_ == VALA_MEMBER_BINDING_INSTANCE) { - ValaSymbol* _tmp131_ = NULL; - ValaSymbol* _tmp132_ = NULL; - _tmp131_ = vala_symbol_get_parent_symbol ((ValaSymbol*) self); - _tmp132_ = _tmp131_; - _tmp129_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp132_, VALA_TYPE_INTERFACE); + _tmp150_ = self->priv->_binding; + if (_tmp150_ == VALA_MEMBER_BINDING_INSTANCE) { + ValaSymbol* _tmp151_ = NULL; + ValaSymbol* _tmp152_ = NULL; + _tmp151_ = vala_symbol_get_parent_symbol ((ValaSymbol*) self); + _tmp152_ = _tmp151_; + _tmp149_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp152_, VALA_TYPE_INTERFACE); } else { - _tmp129_ = FALSE; + _tmp149_ = FALSE; } - if (_tmp129_) { - ValaSourceReference* _tmp133_ = NULL; - ValaSourceReference* _tmp134_ = NULL; + if (_tmp149_) { + ValaSourceReference* _tmp153_ = NULL; + ValaSourceReference* _tmp154_ = NULL; vala_code_node_set_error ((ValaCodeNode*) self, TRUE); - _tmp133_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); - _tmp134_ = _tmp133_; - vala_report_error (_tmp134_, "Interfaces may not have instance fields"); + _tmp153_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); + _tmp154_ = _tmp153_; + vala_report_error (_tmp154_, "Interfaces may not have instance fields"); result = FALSE; _vala_code_node_unref0 (old_symbol); _vala_source_file_unref0 (old_source_file); return result; } - _tmp135_ = vala_symbol_is_internal_symbol ((ValaSymbol*) self); - field_in_header = !_tmp135_; - _tmp136_ = vala_symbol_get_parent_symbol ((ValaSymbol*) self); - _tmp137_ = _tmp136_; - if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp137_, VALA_TYPE_CLASS)) { + _tmp155_ = vala_symbol_is_internal_symbol ((ValaSymbol*) self); + field_in_header = !_tmp155_; + _tmp156_ = vala_symbol_get_parent_symbol ((ValaSymbol*) self); + _tmp157_ = _tmp156_; + if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp157_, VALA_TYPE_CLASS)) { ValaClass* cl = NULL; - ValaSymbol* _tmp138_ = NULL; - ValaSymbol* _tmp139_ = NULL; - ValaClass* _tmp140_ = NULL; - gboolean _tmp141_ = FALSE; - ValaClass* _tmp142_ = NULL; - gboolean _tmp143_ = FALSE; - gboolean _tmp144_ = FALSE; - _tmp138_ = vala_symbol_get_parent_symbol ((ValaSymbol*) self); - _tmp139_ = _tmp138_; - _tmp140_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp139_, VALA_TYPE_CLASS, ValaClass)); - cl = _tmp140_; - _tmp142_ = cl; - _tmp143_ = vala_class_get_is_compact (_tmp142_); - _tmp144_ = _tmp143_; - if (_tmp144_) { - ValaClass* _tmp145_ = NULL; - gboolean _tmp146_ = FALSE; - _tmp145_ = cl; - _tmp146_ = vala_symbol_is_internal_symbol ((ValaSymbol*) _tmp145_); - _tmp141_ = !_tmp146_; + ValaSymbol* _tmp158_ = NULL; + ValaSymbol* _tmp159_ = NULL; + ValaClass* _tmp160_ = NULL; + gboolean _tmp161_ = FALSE; + ValaClass* _tmp162_ = NULL; + gboolean _tmp163_ = FALSE; + gboolean _tmp164_ = FALSE; + _tmp158_ = vala_symbol_get_parent_symbol ((ValaSymbol*) self); + _tmp159_ = _tmp158_; + _tmp160_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp159_, VALA_TYPE_CLASS, ValaClass)); + cl = _tmp160_; + _tmp162_ = cl; + _tmp163_ = vala_class_get_is_compact (_tmp162_); + _tmp164_ = _tmp163_; + if (_tmp164_) { + ValaClass* _tmp165_ = NULL; + gboolean _tmp166_ = FALSE; + _tmp165_ = cl; + _tmp166_ = vala_symbol_is_internal_symbol ((ValaSymbol*) _tmp165_); + _tmp161_ = !_tmp166_; } else { - _tmp141_ = FALSE; + _tmp161_ = FALSE; } - if (_tmp141_) { + if (_tmp161_) { field_in_header = TRUE; } _vala_code_node_unref0 (cl); } - _tmp149_ = vala_symbol_get_external_package ((ValaSymbol*) self); - _tmp150_ = _tmp149_; - if (!_tmp150_) { - gboolean _tmp151_ = FALSE; - gboolean _tmp152_ = FALSE; - _tmp151_ = vala_symbol_get_hides ((ValaSymbol*) self); - _tmp152_ = _tmp151_; - _tmp148_ = !_tmp152_; + _tmp169_ = vala_symbol_get_external_package ((ValaSymbol*) self); + _tmp170_ = _tmp169_; + if (!_tmp170_) { + gboolean _tmp171_ = FALSE; + gboolean _tmp172_ = FALSE; + _tmp171_ = vala_symbol_get_hides ((ValaSymbol*) self); + _tmp172_ = _tmp171_; + _tmp168_ = !_tmp172_; } else { - _tmp148_ = FALSE; + _tmp168_ = FALSE; } - if (_tmp148_) { - ValaSymbol* _tmp153_ = NULL; - ValaSymbol* _tmp154_ = NULL; - _tmp153_ = vala_symbol_get_hidden_member ((ValaSymbol*) self); - _tmp154_ = _tmp153_; - _tmp147_ = _tmp154_ != NULL; - _vala_code_node_unref0 (_tmp154_); + if (_tmp168_) { + ValaSymbol* _tmp173_ = NULL; + ValaSymbol* _tmp174_ = NULL; + _tmp173_ = vala_symbol_get_hidden_member ((ValaSymbol*) self); + _tmp174_ = _tmp173_; + _tmp167_ = _tmp174_ != NULL; + _vala_code_node_unref0 (_tmp174_); } else { - _tmp147_ = FALSE; + _tmp167_ = FALSE; } - if (_tmp147_) { - ValaSourceReference* _tmp155_ = NULL; - ValaSourceReference* _tmp156_ = NULL; - gchar* _tmp157_ = NULL; - gchar* _tmp158_ = NULL; - ValaSymbol* _tmp159_ = NULL; - ValaSymbol* _tmp160_ = NULL; - gchar* _tmp161_ = NULL; - gchar* _tmp162_ = NULL; - gchar* _tmp163_ = NULL; - gchar* _tmp164_ = NULL; - _tmp155_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); - _tmp156_ = _tmp155_; - _tmp157_ = vala_symbol_get_full_name ((ValaSymbol*) self); - _tmp158_ = _tmp157_; - _tmp159_ = vala_symbol_get_hidden_member ((ValaSymbol*) self); - _tmp160_ = _tmp159_; - _tmp161_ = vala_symbol_get_full_name (_tmp160_); - _tmp162_ = _tmp161_; - _tmp163_ = g_strdup_printf ("%s hides inherited field `%s'. Use the `new' keyword if hiding was int" \ -"entional", _tmp158_, _tmp162_); - _tmp164_ = _tmp163_; - vala_report_warning (_tmp156_, _tmp164_); - _g_free0 (_tmp164_); - _g_free0 (_tmp162_); - _vala_code_node_unref0 (_tmp160_); - _g_free0 (_tmp158_); - } - _tmp165_ = context; - _tmp166_ = vala_code_context_get_analyzer (_tmp165_); - _tmp167_ = _tmp166_; - _tmp168_ = old_source_file; - vala_semantic_analyzer_set_current_source_file (_tmp167_, _tmp168_); - _tmp169_ = context; - _tmp170_ = vala_code_context_get_analyzer (_tmp169_); - _tmp171_ = _tmp170_; - _tmp172_ = old_symbol; - vala_semantic_analyzer_set_current_symbol (_tmp171_, _tmp172_); - _tmp173_ = vala_code_node_get_error ((ValaCodeNode*) self); - _tmp174_ = _tmp173_; - result = !_tmp174_; + if (_tmp167_) { + ValaSourceReference* _tmp175_ = NULL; + ValaSourceReference* _tmp176_ = NULL; + gchar* _tmp177_ = NULL; + gchar* _tmp178_ = NULL; + ValaSymbol* _tmp179_ = NULL; + ValaSymbol* _tmp180_ = NULL; + gchar* _tmp181_ = NULL; + gchar* _tmp182_ = NULL; + gchar* _tmp183_ = NULL; + gchar* _tmp184_ = NULL; + _tmp175_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); + _tmp176_ = _tmp175_; + _tmp177_ = vala_symbol_get_full_name ((ValaSymbol*) self); + _tmp178_ = _tmp177_; + _tmp179_ = vala_symbol_get_hidden_member ((ValaSymbol*) self); + _tmp180_ = _tmp179_; + _tmp181_ = vala_symbol_get_full_name (_tmp180_); + _tmp182_ = _tmp181_; + _tmp183_ = g_strdup_printf ("%s hides inherited field `%s'. Use the `new' keyword if hiding was int" \ +"entional", _tmp178_, _tmp182_); + _tmp184_ = _tmp183_; + vala_report_warning (_tmp176_, _tmp184_); + _g_free0 (_tmp184_); + _g_free0 (_tmp182_); + _vala_code_node_unref0 (_tmp180_); + _g_free0 (_tmp178_); + } + _tmp185_ = context; + _tmp186_ = vala_code_context_get_analyzer (_tmp185_); + _tmp187_ = _tmp186_; + _tmp188_ = old_source_file; + vala_semantic_analyzer_set_current_source_file (_tmp187_, _tmp188_); + _tmp189_ = context; + _tmp190_ = vala_code_context_get_analyzer (_tmp189_); + _tmp191_ = _tmp190_; + _tmp192_ = old_symbol; + vala_semantic_analyzer_set_current_symbol (_tmp191_, _tmp192_); + _tmp193_ = vala_code_node_get_error ((ValaCodeNode*) self); + _tmp194_ = _tmp193_; + result = !_tmp194_; _vala_code_node_unref0 (old_symbol); _vala_source_file_unref0 (old_source_file); return result; diff -Nru vala-0.34.6/vala/valafield.vala vala-0.34.7/vala/valafield.vala --- vala-0.34.6/vala/valafield.vala 2017-03-07 08:23:50.000000000 +0000 +++ vala-0.34.7/vala/valafield.vala 2017-03-20 21:24:57.000000000 +0000 @@ -159,6 +159,14 @@ return false; } + if (parent_symbol is Namespace && initializer.is_constant () && initializer.is_non_null ()) { + if (variable_type.is_disposable () && variable_type.value_owned) { + error = true; + Report.error (source_reference, "Owned namespace fields can only be initialized in a function or method"); + return false; + } + } + if (binding == MemberBinding.STATIC && parent_symbol is Class && ((Class)parent_symbol).is_compact && !initializer.is_constant ()) { error = true; Report.error (source_reference, "Static fields in compact classes cannot have non-constant initializers"); diff -Nru vala-0.34.6/vala/valagirparser.c vala-0.34.7/vala/valagirparser.c --- vala-0.34.6/vala/valagirparser.c 2017-03-07 09:39:33.000000000 +0000 +++ vala-0.34.7/vala/valagirparser.c 2017-03-20 21:30:42.000000000 +0000 @@ -1407,6 +1407,7 @@ VALA_GIR_PARSER_ARGUMENT_TYPE_FLOATING, VALA_GIR_PARSER_ARGUMENT_TYPE_TYPE_ID, VALA_GIR_PARSER_ARGUMENT_TYPE_RETURN_VOID, + VALA_GIR_PARSER_ARGUMENT_TYPE_RETURNS_MODIFIED_POINTER, VALA_GIR_PARSER_ARGUMENT_TYPE_DELEGATE_TARGET_CNAME, VALA_GIR_PARSER_ARGUMENT_TYPE_FINISH_VFUNC_NAME } ValaGirParserArgumentType; @@ -2511,7 +2512,7 @@ static GType vala_gir_parser_argument_type_get_type (void) { static volatile gsize vala_gir_parser_argument_type_type_id__volatile = 0; if (g_once_init_enter (&vala_gir_parser_argument_type_type_id__volatile)) { - 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_SINCE, "VALA_GIR_PARSER_ARGUMENT_TYPE_SINCE", "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_ARRAY_NULL_TERMINATED, "VALA_GIR_PARSER_ARGUMENT_TYPE_ARRAY_NULL_TERMINATED", "array-null-terminated"}, {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"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_DESTROYS_INSTANCE, "VALA_GIR_PARSER_ARGUMENT_TYPE_DESTROYS_INSTANCE", "destroys-instance"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_BASE_TYPE, "VALA_GIR_PARSER_ARGUMENT_TYPE_BASE_TYPE", "base-type"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_FINISH_NAME, "VALA_GIR_PARSER_ARGUMENT_TYPE_FINISH_NAME", "finish-name"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_SYMBOL_TYPE, "VALA_GIR_PARSER_ARGUMENT_TYPE_SYMBOL_TYPE", "symbol-type"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_INSTANCE_IDX, "VALA_GIR_PARSER_ARGUMENT_TYPE_INSTANCE_IDX", "instance-idx"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_EXPERIMENTAL, "VALA_GIR_PARSER_ARGUMENT_TYPE_EXPERIMENTAL", "experimental"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_FLOATING, "VALA_GIR_PARSER_ARGUMENT_TYPE_FLOATING", "floating"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_TYPE_ID, "VALA_GIR_PARSER_ARGUMENT_TYPE_TYPE_ID", "type-id"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_RETURN_VOID, "VALA_GIR_PARSER_ARGUMENT_TYPE_RETURN_VOID", "return-void"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_DELEGATE_TARGET_CNAME, "VALA_GIR_PARSER_ARGUMENT_TYPE_DELEGATE_TARGET_CNAME", "delegate-target-cname"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_FINISH_VFUNC_NAME, "VALA_GIR_PARSER_ARGUMENT_TYPE_FINISH_VFUNC_NAME", "finish-vfunc-name"}, {0, NULL, NULL}}; + 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_SINCE, "VALA_GIR_PARSER_ARGUMENT_TYPE_SINCE", "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_ARRAY_NULL_TERMINATED, "VALA_GIR_PARSER_ARGUMENT_TYPE_ARRAY_NULL_TERMINATED", "array-null-terminated"}, {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"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_DESTROYS_INSTANCE, "VALA_GIR_PARSER_ARGUMENT_TYPE_DESTROYS_INSTANCE", "destroys-instance"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_BASE_TYPE, "VALA_GIR_PARSER_ARGUMENT_TYPE_BASE_TYPE", "base-type"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_FINISH_NAME, "VALA_GIR_PARSER_ARGUMENT_TYPE_FINISH_NAME", "finish-name"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_SYMBOL_TYPE, "VALA_GIR_PARSER_ARGUMENT_TYPE_SYMBOL_TYPE", "symbol-type"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_INSTANCE_IDX, "VALA_GIR_PARSER_ARGUMENT_TYPE_INSTANCE_IDX", "instance-idx"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_EXPERIMENTAL, "VALA_GIR_PARSER_ARGUMENT_TYPE_EXPERIMENTAL", "experimental"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_FLOATING, "VALA_GIR_PARSER_ARGUMENT_TYPE_FLOATING", "floating"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_TYPE_ID, "VALA_GIR_PARSER_ARGUMENT_TYPE_TYPE_ID", "type-id"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_RETURN_VOID, "VALA_GIR_PARSER_ARGUMENT_TYPE_RETURN_VOID", "return-void"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_RETURNS_MODIFIED_POINTER, "VALA_GIR_PARSER_ARGUMENT_TYPE_RETURNS_MODIFIED_POINTER", "returns-modified-pointer"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_DELEGATE_TARGET_CNAME, "VALA_GIR_PARSER_ARGUMENT_TYPE_DELEGATE_TARGET_CNAME", "delegate-target-cname"}, {VALA_GIR_PARSER_ARGUMENT_TYPE_FINISH_VFUNC_NAME, "VALA_GIR_PARSER_ARGUMENT_TYPE_FINISH_VFUNC_NAME", "finish-vfunc-name"}, {0, NULL, NULL}}; GType vala_gir_parser_argument_type_type_id; vala_gir_parser_argument_type_type_id = g_enum_register_static ("ValaGirParserArgumentType", values); g_once_init_leave (&vala_gir_parser_argument_type_type_id__volatile, vala_gir_parser_argument_type_type_id); @@ -4570,7 +4571,7 @@ e = _inner_error_; _inner_error_ = NULL; _tmp4_ = e->message; - g_error ("valagirparser.vala:1660: Unable to compile regex: %s", _tmp4_); + g_error ("valagirparser.vala:1664: Unable to compile regex: %s", _tmp4_); _g_error_free0 (e); } __finally6: @@ -19136,9 +19137,9 @@ gboolean _tmp48_ = FALSE; ValaSymbol* _tmp49_ = NULL; ValaMap* _tmp96_ = NULL; - gboolean _tmp844_ = FALSE; - gboolean _tmp845_ = FALSE; - gboolean _tmp846_ = FALSE; + gboolean _tmp849_ = FALSE; + gboolean _tmp850_ = FALSE; + gboolean _tmp851_ = FALSE; g_return_if_fail (self != NULL); g_return_if_fail (parser != NULL); _tmp0_ = self->processed; @@ -19450,42 +19451,42 @@ _tmp96_ = self->girdata; if (_tmp96_ != NULL) { ValaSymbol* _tmp97_ = NULL; - ValaGirParserMetadata* _tmp745_ = NULL; - gboolean _tmp746_ = FALSE; - ValaGirParserMetadata* _tmp749_ = NULL; - gboolean _tmp750_ = FALSE; - ValaGirParserMetadata* _tmp759_ = NULL; - gboolean _tmp760_ = FALSE; - const gchar* _tmp768_ = NULL; - ValaGirParserMetadata* _tmp771_ = NULL; - gboolean _tmp772_ = FALSE; + ValaGirParserMetadata* _tmp750_ = NULL; + gboolean _tmp751_ = FALSE; + ValaGirParserMetadata* _tmp754_ = NULL; + gboolean _tmp755_ = FALSE; + ValaGirParserMetadata* _tmp764_ = NULL; + gboolean _tmp765_ = FALSE; + const gchar* _tmp773_ = NULL; ValaGirParserMetadata* _tmp776_ = NULL; gboolean _tmp777_ = FALSE; - ValaGirParserNode* _tmp795_ = NULL; - ValaSymbol* _tmp796_ = NULL; - gchar* _tmp806_ = NULL; - gchar* _tmp807_ = NULL; - gchar* _tmp808_ = NULL; - gchar* _tmp809_ = NULL; - gboolean _tmp810_ = FALSE; + ValaGirParserMetadata* _tmp781_ = NULL; + gboolean _tmp782_ = FALSE; + ValaGirParserNode* _tmp800_ = NULL; + ValaSymbol* _tmp801_ = NULL; + gchar* _tmp811_ = NULL; + gchar* _tmp812_ = NULL; + gchar* _tmp813_ = NULL; gchar* _tmp814_ = NULL; - gchar* _tmp815_ = NULL; - gchar* _tmp816_ = NULL; - gchar* _tmp817_ = NULL; - gboolean _tmp818_ = FALSE; + gboolean _tmp815_ = FALSE; + gchar* _tmp819_ = NULL; + gchar* _tmp820_ = NULL; + gchar* _tmp821_ = NULL; gchar* _tmp822_ = NULL; - gchar* _tmp823_ = NULL; - gchar* _tmp824_ = NULL; - gchar* _tmp825_ = NULL; - gboolean _tmp826_ = FALSE; - gchar* gir_name = NULL; + gboolean _tmp823_ = FALSE; + gchar* _tmp827_ = NULL; + gchar* _tmp828_ = NULL; + gchar* _tmp829_ = NULL; gchar* _tmp830_ = NULL; + gboolean _tmp831_ = FALSE; + gchar* gir_name = NULL; + gchar* _tmp835_ = NULL; gchar* default_gir_name = NULL; - gchar* _tmp831_ = NULL; - gboolean _tmp832_ = FALSE; - gboolean _tmp833_ = FALSE; - ValaSymbol* _tmp834_ = NULL; - gboolean _tmp835_ = FALSE; + gchar* _tmp836_ = NULL; + gboolean _tmp837_ = FALSE; + gboolean _tmp838_ = FALSE; + ValaSymbol* _tmp839_ = NULL; + gboolean _tmp840_ = FALSE; _tmp97_ = self->symbol; if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp97_, VALA_TYPE_METHOD)) { ValaMethod* m = NULL; @@ -19497,9 +19498,9 @@ const gchar* _tmp102_ = NULL; ValaArrayList* _tmp103_ = NULL; ValaMethod* _tmp203_ = NULL; - ValaMethod* _tmp222_ = NULL; - gboolean _tmp223_ = FALSE; - gboolean _tmp224_ = FALSE; + ValaMethod* _tmp227_ = NULL; + gboolean _tmp228_ = FALSE; + gboolean _tmp229_ = FALSE; _tmp98_ = self->symbol; _tmp99_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp98_, VALA_TYPE_METHOD, ValaMethod)); m = _tmp99_; @@ -19813,6 +19814,8 @@ gboolean _tmp205_ = FALSE; ValaGirParserMetadata* _tmp209_ = NULL; gboolean _tmp210_ = FALSE; + ValaGirParserMetadata* _tmp214_ = NULL; + gboolean _tmp215_ = FALSE; _tmp204_ = self->metadata; _tmp205_ = vala_gir_parser_metadata_has_argument (_tmp204_, VALA_GIR_PARSER_ARGUMENT_TYPE_DESTROYS_INSTANCE); if (_tmp205_) { @@ -19825,366 +19828,377 @@ vala_code_node_set_attribute ((ValaCodeNode*) _tmp206_, "DestroysInstance", _tmp208_, NULL); } _tmp209_ = self->metadata; - _tmp210_ = vala_gir_parser_metadata_has_argument (_tmp209_, VALA_GIR_PARSER_ARGUMENT_TYPE_VFUNC_NAME); + _tmp210_ = vala_gir_parser_metadata_has_argument (_tmp209_, VALA_GIR_PARSER_ARGUMENT_TYPE_RETURNS_MODIFIED_POINTER); if (_tmp210_) { - ValaGirParserNode* vfunc = NULL; - ValaGirParserNode* _tmp211_ = NULL; + ValaMethod* _tmp211_ = NULL; ValaGirParserMetadata* _tmp212_ = NULL; - gchar* _tmp213_ = NULL; - gchar* _tmp214_ = NULL; - ValaGirParserNode* _tmp215_ = NULL; - ValaGirParserNode* _tmp216_ = NULL; - gboolean _tmp217_ = FALSE; - ValaGirParserNode* _tmp218_ = NULL; - _tmp211_ = self->parent; + gboolean _tmp213_ = FALSE; + _tmp211_ = m; _tmp212_ = self->metadata; - _tmp213_ = vala_gir_parser_metadata_get_string (_tmp212_, VALA_GIR_PARSER_ARGUMENT_TYPE_VFUNC_NAME); - _tmp214_ = _tmp213_; - _tmp215_ = vala_gir_parser_node_lookup (_tmp211_, _tmp214_, FALSE, NULL); - _tmp216_ = _tmp215_; - _g_free0 (_tmp214_); - vfunc = _tmp216_; - _tmp218_ = vfunc; - if (_tmp218_ != NULL) { - ValaGirParserNode* _tmp219_ = NULL; - _tmp219_ = vfunc; - _tmp217_ = _tmp219_ != self; + _tmp213_ = vala_gir_parser_metadata_get_bool (_tmp212_, VALA_GIR_PARSER_ARGUMENT_TYPE_RETURNS_MODIFIED_POINTER, FALSE); + vala_code_node_set_attribute ((ValaCodeNode*) _tmp211_, "ReturnsModifiedPointer", _tmp213_, NULL); + } + _tmp214_ = self->metadata; + _tmp215_ = vala_gir_parser_metadata_has_argument (_tmp214_, VALA_GIR_PARSER_ARGUMENT_TYPE_VFUNC_NAME); + if (_tmp215_) { + ValaGirParserNode* vfunc = NULL; + ValaGirParserNode* _tmp216_ = NULL; + ValaGirParserMetadata* _tmp217_ = NULL; + gchar* _tmp218_ = NULL; + gchar* _tmp219_ = NULL; + ValaGirParserNode* _tmp220_ = NULL; + ValaGirParserNode* _tmp221_ = NULL; + gboolean _tmp222_ = FALSE; + ValaGirParserNode* _tmp223_ = NULL; + _tmp216_ = self->parent; + _tmp217_ = self->metadata; + _tmp218_ = vala_gir_parser_metadata_get_string (_tmp217_, VALA_GIR_PARSER_ARGUMENT_TYPE_VFUNC_NAME); + _tmp219_ = _tmp218_; + _tmp220_ = vala_gir_parser_node_lookup (_tmp216_, _tmp219_, FALSE, NULL); + _tmp221_ = _tmp220_; + _g_free0 (_tmp219_); + vfunc = _tmp221_; + _tmp223_ = vfunc; + if (_tmp223_ != NULL) { + ValaGirParserNode* _tmp224_ = NULL; + _tmp224_ = vfunc; + _tmp222_ = _tmp224_ != self; } else { - _tmp217_ = FALSE; + _tmp222_ = FALSE; } - if (_tmp217_) { - ValaGirParserNode* _tmp220_ = NULL; - ValaGirParserNode* _tmp221_ = NULL; - _tmp220_ = vfunc; - _tmp220_->processed = TRUE; - _tmp221_ = vfunc; - _tmp221_->merged = TRUE; + if (_tmp222_) { + ValaGirParserNode* _tmp225_ = NULL; + ValaGirParserNode* _tmp226_ = NULL; + _tmp225_ = vfunc; + _tmp225_->processed = TRUE; + _tmp226_ = vfunc; + _tmp226_->merged = TRUE; } _vala_gir_parser_node_unref0 (vfunc); } } - _tmp222_ = m; - _tmp223_ = vala_method_get_coroutine (_tmp222_); - _tmp224_ = _tmp223_; - if (_tmp224_) { - ValaGirParser* _tmp225_ = NULL; - _tmp225_ = parser; - vala_gir_parser_process_async_method (_tmp225_, self); + _tmp227_ = m; + _tmp228_ = vala_method_get_coroutine (_tmp227_); + _tmp229_ = _tmp228_; + if (_tmp229_) { + ValaGirParser* _tmp230_ = NULL; + _tmp230_ = parser; + vala_gir_parser_process_async_method (_tmp230_, self); } _vala_iterable_unref0 (colliding); _vala_code_node_unref0 (m); } else { - ValaSymbol* _tmp226_ = NULL; - _tmp226_ = self->symbol; - if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp226_, VALA_TYPE_PROPERTY)) { + ValaSymbol* _tmp231_ = NULL; + _tmp231_ = self->symbol; + if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp231_, VALA_TYPE_PROPERTY)) { ValaArrayList* colliding = NULL; - ValaGirParserNode* _tmp227_ = NULL; - const gchar* _tmp228_ = NULL; - ValaArrayList* _tmp229_ = NULL; + ValaGirParserNode* _tmp232_ = NULL; + const gchar* _tmp233_ = NULL; + ValaArrayList* _tmp234_ = NULL; ValaProperty* prop = NULL; - ValaSymbol* _tmp248_ = NULL; - ValaProperty* _tmp249_ = NULL; + ValaSymbol* _tmp253_ = NULL; + ValaProperty* _tmp254_ = NULL; gchar* readable = NULL; - ValaMap* _tmp250_ = NULL; - gpointer _tmp251_ = NULL; + ValaMap* _tmp255_ = NULL; + gpointer _tmp256_ = NULL; gchar* writable = NULL; - ValaMap* _tmp252_ = NULL; - gpointer _tmp253_ = NULL; + ValaMap* _tmp257_ = NULL; + gpointer _tmp258_ = NULL; gchar* construct_ = NULL; - ValaMap* _tmp254_ = NULL; - gpointer _tmp255_ = NULL; + ValaMap* _tmp259_ = NULL; + gpointer _tmp260_ = NULL; gchar* construct_only = NULL; - ValaMap* _tmp256_ = NULL; - gpointer _tmp257_ = NULL; - const gchar* _tmp258_ = NULL; - gboolean _tmp267_ = FALSE; - const gchar* _tmp268_ = NULL; + ValaMap* _tmp261_ = NULL; + gpointer _tmp262_ = NULL; + const gchar* _tmp263_ = NULL; + gboolean _tmp272_ = FALSE; + const gchar* _tmp273_ = NULL; ValaGirParserNode* getter = NULL; ValaArrayList* getters = NULL; - ValaGirParserNode* _tmp284_ = NULL; - const gchar* _tmp285_ = NULL; - gchar* _tmp286_ = NULL; - gchar* _tmp287_ = NULL; - ValaArrayList* _tmp288_ = NULL; - ValaArrayList* _tmp289_ = NULL; - ValaArrayList* _tmp290_ = NULL; + ValaGirParserNode* _tmp289_ = NULL; + const gchar* _tmp290_ = NULL; + gchar* _tmp291_ = NULL; + gchar* _tmp292_ = NULL; + ValaArrayList* _tmp293_ = NULL; + ValaArrayList* _tmp294_ = NULL; + ValaArrayList* _tmp295_ = NULL; ValaGirParserNode* setter = NULL; ValaArrayList* setters = NULL; - ValaGirParserNode* _tmp320_ = NULL; - const gchar* _tmp321_ = NULL; - gchar* _tmp322_ = NULL; - gchar* _tmp323_ = NULL; - ValaArrayList* _tmp324_ = NULL; - ValaArrayList* _tmp325_ = NULL; - ValaArrayList* _tmp326_ = NULL; - ValaProperty* _tmp356_ = NULL; - ValaProperty* _tmp357_ = NULL; - ValaPropertyAccessor* _tmp358_ = NULL; - ValaPropertyAccessor* _tmp359_ = NULL; - gboolean _tmp418_ = FALSE; - gboolean _tmp419_ = FALSE; - ValaProperty* _tmp420_ = NULL; - ValaAttribute* _tmp421_ = NULL; - ValaAttribute* _tmp422_ = NULL; + ValaGirParserNode* _tmp325_ = NULL; + const gchar* _tmp326_ = NULL; + gchar* _tmp327_ = NULL; + gchar* _tmp328_ = NULL; + ValaArrayList* _tmp329_ = NULL; + ValaArrayList* _tmp330_ = NULL; + ValaArrayList* _tmp331_ = NULL; + ValaProperty* _tmp361_ = NULL; + ValaProperty* _tmp362_ = NULL; + ValaPropertyAccessor* _tmp363_ = NULL; + ValaPropertyAccessor* _tmp364_ = NULL; gboolean _tmp423_ = FALSE; - ValaProperty* _tmp485_ = NULL; - ValaAttribute* _tmp486_ = NULL; - ValaAttribute* _tmp487_ = NULL; - gboolean _tmp488_ = FALSE; - ValaProperty* _tmp538_ = NULL; - ValaAttribute* _tmp539_ = NULL; - ValaAttribute* _tmp540_ = NULL; - gboolean _tmp541_ = FALSE; - _tmp227_ = self->parent; - _tmp228_ = self->name; - _tmp229_ = vala_gir_parser_node_lookup_all (_tmp227_, _tmp228_); - colliding = _tmp229_; + gboolean _tmp424_ = FALSE; + ValaProperty* _tmp425_ = NULL; + ValaAttribute* _tmp426_ = NULL; + ValaAttribute* _tmp427_ = NULL; + gboolean _tmp428_ = FALSE; + ValaProperty* _tmp490_ = NULL; + ValaAttribute* _tmp491_ = NULL; + ValaAttribute* _tmp492_ = NULL; + gboolean _tmp493_ = FALSE; + ValaProperty* _tmp543_ = NULL; + ValaAttribute* _tmp544_ = NULL; + ValaAttribute* _tmp545_ = NULL; + gboolean _tmp546_ = FALSE; + _tmp232_ = self->parent; + _tmp233_ = self->name; + _tmp234_ = vala_gir_parser_node_lookup_all (_tmp232_, _tmp233_); + colliding = _tmp234_; { ValaArrayList* _node_list = NULL; - ValaArrayList* _tmp230_ = NULL; - ValaArrayList* _tmp231_ = NULL; + ValaArrayList* _tmp235_ = NULL; + ValaArrayList* _tmp236_ = NULL; gint _node_size = 0; - ValaArrayList* _tmp232_ = NULL; - gint _tmp233_ = 0; - gint _tmp234_ = 0; + ValaArrayList* _tmp237_ = NULL; + gint _tmp238_ = 0; + gint _tmp239_ = 0; gint _node_index = 0; - _tmp230_ = colliding; - _tmp231_ = _vala_iterable_ref0 (_tmp230_); - _node_list = _tmp231_; - _tmp232_ = _node_list; - _tmp233_ = vala_collection_get_size ((ValaCollection*) _tmp232_); - _tmp234_ = _tmp233_; - _node_size = _tmp234_; + _tmp235_ = colliding; + _tmp236_ = _vala_iterable_ref0 (_tmp235_); + _node_list = _tmp236_; + _tmp237_ = _node_list; + _tmp238_ = vala_collection_get_size ((ValaCollection*) _tmp237_); + _tmp239_ = _tmp238_; + _node_size = _tmp239_; _node_index = -1; while (TRUE) { - gint _tmp235_ = 0; - gint _tmp236_ = 0; - gint _tmp237_ = 0; + gint _tmp240_ = 0; + gint _tmp241_ = 0; + gint _tmp242_ = 0; ValaGirParserNode* node = NULL; - ValaArrayList* _tmp238_ = NULL; - gint _tmp239_ = 0; - gpointer _tmp240_ = NULL; - ValaGirParserNode* _tmp241_ = NULL; - ValaSymbol* _tmp242_ = NULL; - _tmp235_ = _node_index; - _node_index = _tmp235_ + 1; - _tmp236_ = _node_index; - _tmp237_ = _node_size; - if (!(_tmp236_ < _tmp237_)) { + ValaArrayList* _tmp243_ = NULL; + gint _tmp244_ = 0; + gpointer _tmp245_ = NULL; + ValaGirParserNode* _tmp246_ = NULL; + ValaSymbol* _tmp247_ = NULL; + _tmp240_ = _node_index; + _node_index = _tmp240_ + 1; + _tmp241_ = _node_index; + _tmp242_ = _node_size; + if (!(_tmp241_ < _tmp242_)) { break; } - _tmp238_ = _node_list; - _tmp239_ = _node_index; - _tmp240_ = vala_list_get ((ValaList*) _tmp238_, _tmp239_); - node = (ValaGirParserNode*) _tmp240_; - _tmp241_ = node; - _tmp242_ = _tmp241_->symbol; - if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp242_, VALA_TYPE_SIGNAL)) { - ValaGirParserNode* _tmp243_ = NULL; - ValaGirParserNode* _tmp244_ = NULL; - _tmp243_ = node; - _tmp243_->processed = TRUE; - _tmp244_ = node; - _tmp244_->merged = TRUE; + _tmp243_ = _node_list; + _tmp244_ = _node_index; + _tmp245_ = vala_list_get ((ValaList*) _tmp243_, _tmp244_); + node = (ValaGirParserNode*) _tmp245_; + _tmp246_ = node; + _tmp247_ = _tmp246_->symbol; + if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp247_, VALA_TYPE_SIGNAL)) { + ValaGirParserNode* _tmp248_ = NULL; + ValaGirParserNode* _tmp249_ = NULL; + _tmp248_ = node; + _tmp248_->processed = TRUE; + _tmp249_ = node; + _tmp249_->merged = TRUE; } else { - ValaGirParserNode* _tmp245_ = NULL; - ValaSymbol* _tmp246_ = NULL; - _tmp245_ = node; - _tmp246_ = _tmp245_->symbol; - if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp246_, VALA_TYPE_METHOD)) { - ValaGirParserNode* _tmp247_ = NULL; - _tmp247_ = node; - _tmp247_->merged = TRUE; + ValaGirParserNode* _tmp250_ = NULL; + ValaSymbol* _tmp251_ = NULL; + _tmp250_ = node; + _tmp251_ = _tmp250_->symbol; + if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp251_, VALA_TYPE_METHOD)) { + ValaGirParserNode* _tmp252_ = NULL; + _tmp252_ = node; + _tmp252_->merged = TRUE; } } _vala_gir_parser_node_unref0 (node); } _vala_iterable_unref0 (_node_list); } - _tmp248_ = self->symbol; - _tmp249_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp248_, VALA_TYPE_PROPERTY, ValaProperty)); - prop = _tmp249_; - _tmp250_ = self->girdata; - _tmp251_ = vala_map_get (_tmp250_, "readable"); - readable = (gchar*) _tmp251_; - _tmp252_ = self->girdata; - _tmp253_ = vala_map_get (_tmp252_, "writable"); - writable = (gchar*) _tmp253_; - _tmp254_ = self->girdata; - _tmp255_ = vala_map_get (_tmp254_, "construct"); - construct_ = (gchar*) _tmp255_; - _tmp256_ = self->girdata; - _tmp257_ = vala_map_get (_tmp256_, "construct-only"); - construct_only = (gchar*) _tmp257_; - _tmp258_ = readable; - if (g_strcmp0 (_tmp258_, "0") != 0) { - ValaProperty* _tmp259_ = NULL; - ValaProperty* _tmp260_ = NULL; - ValaDataType* _tmp261_ = NULL; - ValaDataType* _tmp262_ = NULL; - ValaDataType* _tmp263_ = NULL; - ValaDataType* _tmp264_ = NULL; - ValaPropertyAccessor* _tmp265_ = NULL; - ValaPropertyAccessor* _tmp266_ = NULL; - _tmp259_ = prop; - _tmp260_ = prop; - _tmp261_ = vala_property_get_property_type (_tmp260_); - _tmp262_ = _tmp261_; - _tmp263_ = vala_data_type_copy (_tmp262_); - _tmp264_ = _tmp263_; - _tmp265_ = vala_property_accessor_new (TRUE, FALSE, FALSE, _tmp264_, NULL, NULL, NULL); - _tmp266_ = _tmp265_; - vala_property_set_get_accessor (_tmp259_, _tmp266_); - _vala_code_node_unref0 (_tmp266_); - _vala_code_node_unref0 (_tmp264_); - } - _tmp268_ = writable; - if (g_strcmp0 (_tmp268_, "1") == 0) { - _tmp267_ = TRUE; + _tmp253_ = self->symbol; + _tmp254_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp253_, VALA_TYPE_PROPERTY, ValaProperty)); + prop = _tmp254_; + _tmp255_ = self->girdata; + _tmp256_ = vala_map_get (_tmp255_, "readable"); + readable = (gchar*) _tmp256_; + _tmp257_ = self->girdata; + _tmp258_ = vala_map_get (_tmp257_, "writable"); + writable = (gchar*) _tmp258_; + _tmp259_ = self->girdata; + _tmp260_ = vala_map_get (_tmp259_, "construct"); + construct_ = (gchar*) _tmp260_; + _tmp261_ = self->girdata; + _tmp262_ = vala_map_get (_tmp261_, "construct-only"); + construct_only = (gchar*) _tmp262_; + _tmp263_ = readable; + if (g_strcmp0 (_tmp263_, "0") != 0) { + ValaProperty* _tmp264_ = NULL; + ValaProperty* _tmp265_ = NULL; + ValaDataType* _tmp266_ = NULL; + ValaDataType* _tmp267_ = NULL; + ValaDataType* _tmp268_ = NULL; + ValaDataType* _tmp269_ = NULL; + ValaPropertyAccessor* _tmp270_ = NULL; + ValaPropertyAccessor* _tmp271_ = NULL; + _tmp264_ = prop; + _tmp265_ = prop; + _tmp266_ = vala_property_get_property_type (_tmp265_); + _tmp267_ = _tmp266_; + _tmp268_ = vala_data_type_copy (_tmp267_); + _tmp269_ = _tmp268_; + _tmp270_ = vala_property_accessor_new (TRUE, FALSE, FALSE, _tmp269_, NULL, NULL, NULL); + _tmp271_ = _tmp270_; + vala_property_set_get_accessor (_tmp264_, _tmp271_); + _vala_code_node_unref0 (_tmp271_); + _vala_code_node_unref0 (_tmp269_); + } + _tmp273_ = writable; + if (g_strcmp0 (_tmp273_, "1") == 0) { + _tmp272_ = TRUE; } else { - const gchar* _tmp269_ = NULL; - _tmp269_ = construct_only; - _tmp267_ = g_strcmp0 (_tmp269_, "1") == 0; - } - if (_tmp267_) { - gboolean _tmp270_ = FALSE; - const gchar* _tmp271_ = NULL; - gboolean _tmp273_ = FALSE; const gchar* _tmp274_ = NULL; - ValaProperty* _tmp276_ = NULL; - ValaProperty* _tmp277_ = NULL; - ValaDataType* _tmp278_ = NULL; - ValaDataType* _tmp279_ = NULL; - ValaDataType* _tmp280_ = NULL; - ValaDataType* _tmp281_ = NULL; - ValaPropertyAccessor* _tmp282_ = NULL; - ValaPropertyAccessor* _tmp283_ = NULL; - _tmp271_ = construct_only; - if (g_strcmp0 (_tmp271_, "1") != 0) { - const gchar* _tmp272_ = NULL; - _tmp272_ = writable; - _tmp270_ = g_strcmp0 (_tmp272_, "1") == 0; + _tmp274_ = construct_only; + _tmp272_ = g_strcmp0 (_tmp274_, "1") == 0; + } + if (_tmp272_) { + gboolean _tmp275_ = FALSE; + const gchar* _tmp276_ = NULL; + gboolean _tmp278_ = FALSE; + const gchar* _tmp279_ = NULL; + ValaProperty* _tmp281_ = NULL; + ValaProperty* _tmp282_ = NULL; + ValaDataType* _tmp283_ = NULL; + ValaDataType* _tmp284_ = NULL; + ValaDataType* _tmp285_ = NULL; + ValaDataType* _tmp286_ = NULL; + ValaPropertyAccessor* _tmp287_ = NULL; + ValaPropertyAccessor* _tmp288_ = NULL; + _tmp276_ = construct_only; + if (g_strcmp0 (_tmp276_, "1") != 0) { + const gchar* _tmp277_ = NULL; + _tmp277_ = writable; + _tmp275_ = g_strcmp0 (_tmp277_, "1") == 0; } else { - _tmp270_ = FALSE; + _tmp275_ = FALSE; } - _tmp274_ = construct_only; - if (g_strcmp0 (_tmp274_, "1") == 0) { - _tmp273_ = TRUE; + _tmp279_ = construct_only; + if (g_strcmp0 (_tmp279_, "1") == 0) { + _tmp278_ = TRUE; } else { - const gchar* _tmp275_ = NULL; - _tmp275_ = construct_; - _tmp273_ = g_strcmp0 (_tmp275_, "1") == 0; - } - _tmp276_ = prop; - _tmp277_ = prop; - _tmp278_ = vala_property_get_property_type (_tmp277_); - _tmp279_ = _tmp278_; - _tmp280_ = vala_data_type_copy (_tmp279_); - _tmp281_ = _tmp280_; - _tmp282_ = vala_property_accessor_new (FALSE, _tmp270_, _tmp273_, _tmp281_, NULL, NULL, NULL); - _tmp283_ = _tmp282_; - vala_property_set_set_accessor (_tmp276_, _tmp283_); - _vala_code_node_unref0 (_tmp283_); - _vala_code_node_unref0 (_tmp281_); + const gchar* _tmp280_ = NULL; + _tmp280_ = construct_; + _tmp278_ = g_strcmp0 (_tmp280_, "1") == 0; + } + _tmp281_ = prop; + _tmp282_ = prop; + _tmp283_ = vala_property_get_property_type (_tmp282_); + _tmp284_ = _tmp283_; + _tmp285_ = vala_data_type_copy (_tmp284_); + _tmp286_ = _tmp285_; + _tmp287_ = vala_property_accessor_new (FALSE, _tmp275_, _tmp278_, _tmp286_, NULL, NULL, NULL); + _tmp288_ = _tmp287_; + vala_property_set_set_accessor (_tmp281_, _tmp288_); + _vala_code_node_unref0 (_tmp288_); + _vala_code_node_unref0 (_tmp286_); } getter = NULL; - _tmp284_ = self->parent; - _tmp285_ = self->name; - _tmp286_ = g_strdup_printf ("get_%s", _tmp285_); - _tmp287_ = _tmp286_; - _tmp288_ = vala_gir_parser_node_lookup_all (_tmp284_, _tmp287_); - _tmp289_ = _tmp288_; - _g_free0 (_tmp287_); - getters = _tmp289_; - _tmp290_ = getters; - if (_tmp290_ != NULL) { + _tmp289_ = self->parent; + _tmp290_ = self->name; + _tmp291_ = g_strdup_printf ("get_%s", _tmp290_); + _tmp292_ = _tmp291_; + _tmp293_ = vala_gir_parser_node_lookup_all (_tmp289_, _tmp292_); + _tmp294_ = _tmp293_; + _g_free0 (_tmp292_); + getters = _tmp294_; + _tmp295_ = getters; + if (_tmp295_ != NULL) { { ValaArrayList* _g_list = NULL; - ValaArrayList* _tmp291_ = NULL; - ValaArrayList* _tmp292_ = NULL; + ValaArrayList* _tmp296_ = NULL; + ValaArrayList* _tmp297_ = NULL; gint _g_size = 0; - ValaArrayList* _tmp293_ = NULL; - gint _tmp294_ = 0; - gint _tmp295_ = 0; + ValaArrayList* _tmp298_ = NULL; + gint _tmp299_ = 0; + gint _tmp300_ = 0; gint _g_index = 0; - _tmp291_ = getters; - _tmp292_ = _vala_iterable_ref0 (_tmp291_); - _g_list = _tmp292_; - _tmp293_ = _g_list; - _tmp294_ = vala_collection_get_size ((ValaCollection*) _tmp293_); - _tmp295_ = _tmp294_; - _g_size = _tmp295_; + _tmp296_ = getters; + _tmp297_ = _vala_iterable_ref0 (_tmp296_); + _g_list = _tmp297_; + _tmp298_ = _g_list; + _tmp299_ = vala_collection_get_size ((ValaCollection*) _tmp298_); + _tmp300_ = _tmp299_; + _g_size = _tmp300_; _g_index = -1; while (TRUE) { - gint _tmp296_ = 0; - gint _tmp297_ = 0; - gint _tmp298_ = 0; + gint _tmp301_ = 0; + gint _tmp302_ = 0; + gint _tmp303_ = 0; ValaGirParserNode* g = NULL; - ValaArrayList* _tmp299_ = NULL; - gint _tmp300_ = 0; - gpointer _tmp301_ = NULL; - gboolean _tmp302_ = FALSE; - gboolean _tmp303_ = FALSE; - ValaGirParserNode* _tmp304_ = NULL; - _tmp296_ = _g_index; - _g_index = _tmp296_ + 1; - _tmp297_ = _g_index; - _tmp298_ = _g_size; - if (!(_tmp297_ < _tmp298_)) { + ValaArrayList* _tmp304_ = NULL; + gint _tmp305_ = 0; + gpointer _tmp306_ = NULL; + gboolean _tmp307_ = FALSE; + gboolean _tmp308_ = FALSE; + ValaGirParserNode* _tmp309_ = NULL; + _tmp301_ = _g_index; + _g_index = _tmp301_ + 1; + _tmp302_ = _g_index; + _tmp303_ = _g_size; + if (!(_tmp302_ < _tmp303_)) { break; } - _tmp299_ = _g_list; - _tmp300_ = _g_index; - _tmp301_ = vala_list_get ((ValaList*) _tmp299_, _tmp300_); - g = (ValaGirParserNode*) _tmp301_; - _tmp304_ = getter; - if (_tmp304_ == NULL) { - _tmp303_ = TRUE; + _tmp304_ = _g_list; + _tmp305_ = _g_index; + _tmp306_ = vala_list_get ((ValaList*) _tmp304_, _tmp305_); + g = (ValaGirParserNode*) _tmp306_; + _tmp309_ = getter; + if (_tmp309_ == NULL) { + _tmp308_ = TRUE; } else { - ValaGirParserNode* _tmp305_ = NULL; - gboolean _tmp306_ = FALSE; - _tmp305_ = g; - _tmp306_ = _tmp305_->merged; - _tmp303_ = !_tmp306_; - } - if (_tmp303_) { - ValaGirParserNode* _tmp307_ = NULL; - gchar* _tmp308_ = NULL; - gchar* _tmp309_ = NULL; ValaGirParserNode* _tmp310_ = NULL; - gchar* _tmp311_ = NULL; - gchar* _tmp312_ = NULL; + gboolean _tmp311_ = FALSE; + _tmp310_ = g; + _tmp311_ = _tmp310_->merged; + _tmp308_ = !_tmp311_; + } + if (_tmp308_) { + ValaGirParserNode* _tmp312_ = NULL; gchar* _tmp313_ = NULL; gchar* _tmp314_ = NULL; - const gchar* _tmp315_ = NULL; + ValaGirParserNode* _tmp315_ = NULL; gchar* _tmp316_ = NULL; gchar* _tmp317_ = NULL; - _tmp307_ = g; - _tmp308_ = vala_gir_parser_node_get_cname (_tmp307_); - _tmp309_ = _tmp308_; - _tmp310_ = self->parent; - _tmp311_ = vala_gir_parser_node_get_lower_case_cprefix (_tmp310_); - _tmp312_ = _tmp311_; - _tmp313_ = g_strconcat (_tmp312_, "get_", NULL); + gchar* _tmp318_ = NULL; + gchar* _tmp319_ = NULL; + const gchar* _tmp320_ = NULL; + gchar* _tmp321_ = NULL; + gchar* _tmp322_ = NULL; + _tmp312_ = g; + _tmp313_ = vala_gir_parser_node_get_cname (_tmp312_); _tmp314_ = _tmp313_; - _tmp315_ = self->name; - _tmp316_ = g_strconcat (_tmp314_, _tmp315_, NULL); + _tmp315_ = self->parent; + _tmp316_ = vala_gir_parser_node_get_lower_case_cprefix (_tmp315_); _tmp317_ = _tmp316_; - _tmp302_ = g_strcmp0 (_tmp309_, _tmp317_) == 0; + _tmp318_ = g_strconcat (_tmp317_, "get_", NULL); + _tmp319_ = _tmp318_; + _tmp320_ = self->name; + _tmp321_ = g_strconcat (_tmp319_, _tmp320_, NULL); + _tmp322_ = _tmp321_; + _tmp307_ = g_strcmp0 (_tmp314_, _tmp322_) == 0; + _g_free0 (_tmp322_); + _g_free0 (_tmp319_); _g_free0 (_tmp317_); _g_free0 (_tmp314_); - _g_free0 (_tmp312_); - _g_free0 (_tmp309_); } else { - _tmp302_ = FALSE; + _tmp307_ = FALSE; } - if (_tmp302_) { - ValaGirParserNode* _tmp318_ = NULL; - ValaGirParserNode* _tmp319_ = NULL; - _tmp318_ = g; - _tmp319_ = _vala_gir_parser_node_ref0 (_tmp318_); + if (_tmp307_) { + ValaGirParserNode* _tmp323_ = NULL; + ValaGirParserNode* _tmp324_ = NULL; + _tmp323_ = g; + _tmp324_ = _vala_gir_parser_node_ref0 (_tmp323_); _vala_gir_parser_node_unref0 (getter); - getter = _tmp319_; + getter = _tmp324_; } _vala_gir_parser_node_unref0 (g); } @@ -20192,593 +20206,593 @@ } } setter = NULL; - _tmp320_ = self->parent; - _tmp321_ = self->name; - _tmp322_ = g_strdup_printf ("set_%s", _tmp321_); - _tmp323_ = _tmp322_; - _tmp324_ = vala_gir_parser_node_lookup_all (_tmp320_, _tmp323_); - _tmp325_ = _tmp324_; - _g_free0 (_tmp323_); - setters = _tmp325_; - _tmp326_ = setters; - if (_tmp326_ != NULL) { + _tmp325_ = self->parent; + _tmp326_ = self->name; + _tmp327_ = g_strdup_printf ("set_%s", _tmp326_); + _tmp328_ = _tmp327_; + _tmp329_ = vala_gir_parser_node_lookup_all (_tmp325_, _tmp328_); + _tmp330_ = _tmp329_; + _g_free0 (_tmp328_); + setters = _tmp330_; + _tmp331_ = setters; + if (_tmp331_ != NULL) { { ValaArrayList* _s_list = NULL; - ValaArrayList* _tmp327_ = NULL; - ValaArrayList* _tmp328_ = NULL; + ValaArrayList* _tmp332_ = NULL; + ValaArrayList* _tmp333_ = NULL; gint _s_size = 0; - ValaArrayList* _tmp329_ = NULL; - gint _tmp330_ = 0; - gint _tmp331_ = 0; + ValaArrayList* _tmp334_ = NULL; + gint _tmp335_ = 0; + gint _tmp336_ = 0; gint _s_index = 0; - _tmp327_ = setters; - _tmp328_ = _vala_iterable_ref0 (_tmp327_); - _s_list = _tmp328_; - _tmp329_ = _s_list; - _tmp330_ = vala_collection_get_size ((ValaCollection*) _tmp329_); - _tmp331_ = _tmp330_; - _s_size = _tmp331_; + _tmp332_ = setters; + _tmp333_ = _vala_iterable_ref0 (_tmp332_); + _s_list = _tmp333_; + _tmp334_ = _s_list; + _tmp335_ = vala_collection_get_size ((ValaCollection*) _tmp334_); + _tmp336_ = _tmp335_; + _s_size = _tmp336_; _s_index = -1; while (TRUE) { - gint _tmp332_ = 0; - gint _tmp333_ = 0; - gint _tmp334_ = 0; + gint _tmp337_ = 0; + gint _tmp338_ = 0; + gint _tmp339_ = 0; ValaGirParserNode* s = NULL; - ValaArrayList* _tmp335_ = NULL; - gint _tmp336_ = 0; - gpointer _tmp337_ = NULL; - gboolean _tmp338_ = FALSE; - gboolean _tmp339_ = FALSE; - ValaGirParserNode* _tmp340_ = NULL; - _tmp332_ = _s_index; - _s_index = _tmp332_ + 1; - _tmp333_ = _s_index; - _tmp334_ = _s_size; - if (!(_tmp333_ < _tmp334_)) { + ValaArrayList* _tmp340_ = NULL; + gint _tmp341_ = 0; + gpointer _tmp342_ = NULL; + gboolean _tmp343_ = FALSE; + gboolean _tmp344_ = FALSE; + ValaGirParserNode* _tmp345_ = NULL; + _tmp337_ = _s_index; + _s_index = _tmp337_ + 1; + _tmp338_ = _s_index; + _tmp339_ = _s_size; + if (!(_tmp338_ < _tmp339_)) { break; } - _tmp335_ = _s_list; - _tmp336_ = _s_index; - _tmp337_ = vala_list_get ((ValaList*) _tmp335_, _tmp336_); - s = (ValaGirParserNode*) _tmp337_; - _tmp340_ = setter; - if (_tmp340_ == NULL) { - _tmp339_ = TRUE; + _tmp340_ = _s_list; + _tmp341_ = _s_index; + _tmp342_ = vala_list_get ((ValaList*) _tmp340_, _tmp341_); + s = (ValaGirParserNode*) _tmp342_; + _tmp345_ = setter; + if (_tmp345_ == NULL) { + _tmp344_ = TRUE; } else { - ValaGirParserNode* _tmp341_ = NULL; - gboolean _tmp342_ = FALSE; - _tmp341_ = s; - _tmp342_ = _tmp341_->merged; - _tmp339_ = !_tmp342_; - } - if (_tmp339_) { - ValaGirParserNode* _tmp343_ = NULL; - gchar* _tmp344_ = NULL; - gchar* _tmp345_ = NULL; ValaGirParserNode* _tmp346_ = NULL; - gchar* _tmp347_ = NULL; - gchar* _tmp348_ = NULL; + gboolean _tmp347_ = FALSE; + _tmp346_ = s; + _tmp347_ = _tmp346_->merged; + _tmp344_ = !_tmp347_; + } + if (_tmp344_) { + ValaGirParserNode* _tmp348_ = NULL; gchar* _tmp349_ = NULL; gchar* _tmp350_ = NULL; - const gchar* _tmp351_ = NULL; + ValaGirParserNode* _tmp351_ = NULL; gchar* _tmp352_ = NULL; gchar* _tmp353_ = NULL; - _tmp343_ = s; - _tmp344_ = vala_gir_parser_node_get_cname (_tmp343_); - _tmp345_ = _tmp344_; - _tmp346_ = self->parent; - _tmp347_ = vala_gir_parser_node_get_lower_case_cprefix (_tmp346_); - _tmp348_ = _tmp347_; - _tmp349_ = g_strconcat (_tmp348_, "set_", NULL); + gchar* _tmp354_ = NULL; + gchar* _tmp355_ = NULL; + const gchar* _tmp356_ = NULL; + gchar* _tmp357_ = NULL; + gchar* _tmp358_ = NULL; + _tmp348_ = s; + _tmp349_ = vala_gir_parser_node_get_cname (_tmp348_); _tmp350_ = _tmp349_; - _tmp351_ = self->name; - _tmp352_ = g_strconcat (_tmp350_, _tmp351_, NULL); + _tmp351_ = self->parent; + _tmp352_ = vala_gir_parser_node_get_lower_case_cprefix (_tmp351_); _tmp353_ = _tmp352_; - _tmp338_ = g_strcmp0 (_tmp345_, _tmp353_) == 0; + _tmp354_ = g_strconcat (_tmp353_, "set_", NULL); + _tmp355_ = _tmp354_; + _tmp356_ = self->name; + _tmp357_ = g_strconcat (_tmp355_, _tmp356_, NULL); + _tmp358_ = _tmp357_; + _tmp343_ = g_strcmp0 (_tmp350_, _tmp358_) == 0; + _g_free0 (_tmp358_); + _g_free0 (_tmp355_); _g_free0 (_tmp353_); _g_free0 (_tmp350_); - _g_free0 (_tmp348_); - _g_free0 (_tmp345_); } else { - _tmp338_ = FALSE; + _tmp343_ = FALSE; } - if (_tmp338_) { - ValaGirParserNode* _tmp354_ = NULL; - ValaGirParserNode* _tmp355_ = NULL; - _tmp354_ = s; - _tmp355_ = _vala_gir_parser_node_ref0 (_tmp354_); + if (_tmp343_) { + ValaGirParserNode* _tmp359_ = NULL; + ValaGirParserNode* _tmp360_ = NULL; + _tmp359_ = s; + _tmp360_ = _vala_gir_parser_node_ref0 (_tmp359_); _vala_gir_parser_node_unref0 (setter); - setter = _tmp355_; + setter = _tmp360_; } _vala_gir_parser_node_unref0 (s); } _vala_iterable_unref0 (_s_list); } } - _tmp356_ = prop; - vala_code_node_set_attribute ((ValaCodeNode*) _tmp356_, "NoAccessorMethod", FALSE, NULL); - _tmp357_ = prop; - _tmp358_ = vala_property_get_get_accessor (_tmp357_); - _tmp359_ = _tmp358_; - if (_tmp359_ != NULL) { - ValaMethod* _tmp360_ = NULL; - ValaGirParserNode* _tmp361_ = NULL; - ValaMethod* m = NULL; - ValaMethod* _tmp364_ = NULL; + _tmp361_ = prop; + vala_code_node_set_attribute ((ValaCodeNode*) _tmp361_, "NoAccessorMethod", FALSE, NULL); + _tmp362_ = prop; + _tmp363_ = vala_property_get_get_accessor (_tmp362_); + _tmp364_ = _tmp363_; + if (_tmp364_ != NULL) { ValaMethod* _tmp365_ = NULL; - _tmp361_ = getter; - if (_tmp361_ != NULL) { - ValaGirParserNode* _tmp362_ = NULL; - ValaSymbol* _tmp363_ = NULL; - _tmp362_ = getter; - _tmp363_ = _tmp362_->symbol; - _tmp360_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp363_, VALA_TYPE_METHOD) ? ((ValaMethod*) _tmp363_) : NULL; + ValaGirParserNode* _tmp366_ = NULL; + ValaMethod* m = NULL; + ValaMethod* _tmp369_ = NULL; + ValaMethod* _tmp370_ = NULL; + _tmp366_ = getter; + if (_tmp366_ != NULL) { + ValaGirParserNode* _tmp367_ = NULL; + ValaSymbol* _tmp368_ = NULL; + _tmp367_ = getter; + _tmp368_ = _tmp367_->symbol; + _tmp365_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp368_, VALA_TYPE_METHOD) ? ((ValaMethod*) _tmp368_) : NULL; } else { - _tmp360_ = NULL; + _tmp365_ = NULL; } - _tmp364_ = _vala_code_node_ref0 (_tmp360_); - m = _tmp364_; - _tmp365_ = m; - if (_tmp365_ != NULL) { - ValaGirParserNode* _tmp366_ = NULL; - ValaGirParser* _tmp367_ = NULL; - gboolean _tmp368_ = FALSE; - ValaMethod* _tmp369_ = NULL; - ValaDataType* _tmp370_ = NULL; - ValaDataType* _tmp371_ = NULL; - _tmp366_ = getter; - _tmp367_ = parser; - vala_gir_parser_node_process (_tmp366_, _tmp367_); - _tmp369_ = m; - _tmp370_ = vala_method_get_return_type (_tmp369_); - _tmp371_ = _tmp370_; - if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp371_, VALA_TYPE_VOID_TYPE)) { - _tmp368_ = TRUE; + _tmp369_ = _vala_code_node_ref0 (_tmp365_); + m = _tmp369_; + _tmp370_ = m; + if (_tmp370_ != NULL) { + ValaGirParserNode* _tmp371_ = NULL; + ValaGirParser* _tmp372_ = NULL; + gboolean _tmp373_ = FALSE; + ValaMethod* _tmp374_ = NULL; + ValaDataType* _tmp375_ = NULL; + ValaDataType* _tmp376_ = NULL; + _tmp371_ = getter; + _tmp372_ = parser; + vala_gir_parser_node_process (_tmp371_, _tmp372_); + _tmp374_ = m; + _tmp375_ = vala_method_get_return_type (_tmp374_); + _tmp376_ = _tmp375_; + if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp376_, VALA_TYPE_VOID_TYPE)) { + _tmp373_ = TRUE; } else { - ValaMethod* _tmp372_ = NULL; - ValaList* _tmp373_ = NULL; - ValaList* _tmp374_ = NULL; - gint _tmp375_ = 0; - gint _tmp376_ = 0; - _tmp372_ = m; - _tmp373_ = vala_method_get_parameters (_tmp372_); - _tmp374_ = _tmp373_; - _tmp375_ = vala_collection_get_size ((ValaCollection*) _tmp374_); - _tmp376_ = _tmp375_; - _tmp368_ = _tmp376_ != 0; - _vala_iterable_unref0 (_tmp374_); + ValaMethod* _tmp377_ = NULL; + ValaList* _tmp378_ = NULL; + ValaList* _tmp379_ = NULL; + gint _tmp380_ = 0; + gint _tmp381_ = 0; + _tmp377_ = m; + _tmp378_ = vala_method_get_parameters (_tmp377_); + _tmp379_ = _tmp378_; + _tmp380_ = vala_collection_get_size ((ValaCollection*) _tmp379_); + _tmp381_ = _tmp380_; + _tmp373_ = _tmp381_ != 0; + _vala_iterable_unref0 (_tmp379_); } - if (_tmp368_) { - ValaProperty* _tmp377_ = NULL; - _tmp377_ = prop; - vala_code_node_set_attribute ((ValaCodeNode*) _tmp377_, "NoAccessorMethod", TRUE, NULL); + if (_tmp373_) { + ValaProperty* _tmp382_ = NULL; + _tmp382_ = prop; + vala_code_node_set_attribute ((ValaCodeNode*) _tmp382_, "NoAccessorMethod", TRUE, NULL); } else { - ValaGirParserNode* _tmp378_ = NULL; - const gchar* _tmp379_ = NULL; - const gchar* _tmp380_ = NULL; - ValaProperty* _tmp395_ = NULL; - ValaPropertyAccessor* _tmp396_ = NULL; - ValaPropertyAccessor* _tmp397_ = NULL; - ValaDataType* _tmp398_ = NULL; - ValaDataType* _tmp399_ = NULL; - ValaMethod* _tmp400_ = NULL; - ValaDataType* _tmp401_ = NULL; - ValaDataType* _tmp402_ = NULL; - gboolean _tmp403_ = FALSE; - gboolean _tmp404_ = FALSE; - gboolean _tmp405_ = FALSE; - gboolean _tmp406_ = FALSE; - ValaMethod* _tmp407_ = NULL; + ValaGirParserNode* _tmp383_ = NULL; + const gchar* _tmp384_ = NULL; + const gchar* _tmp385_ = NULL; + ValaProperty* _tmp400_ = NULL; + ValaPropertyAccessor* _tmp401_ = NULL; + ValaPropertyAccessor* _tmp402_ = NULL; + ValaDataType* _tmp403_ = NULL; + ValaDataType* _tmp404_ = NULL; + ValaMethod* _tmp405_ = NULL; + ValaDataType* _tmp406_ = NULL; + ValaDataType* _tmp407_ = NULL; gboolean _tmp408_ = FALSE; gboolean _tmp409_ = FALSE; - _tmp378_ = getter; - _tmp379_ = _tmp378_->name; - _tmp380_ = self->name; - if (g_strcmp0 (_tmp379_, _tmp380_) == 0) { + gboolean _tmp410_ = FALSE; + gboolean _tmp411_ = FALSE; + ValaMethod* _tmp412_ = NULL; + gboolean _tmp413_ = FALSE; + gboolean _tmp414_ = FALSE; + _tmp383_ = getter; + _tmp384_ = _tmp383_->name; + _tmp385_ = self->name; + if (g_strcmp0 (_tmp384_, _tmp385_) == 0) { { ValaArrayList* _node_list = NULL; - ValaArrayList* _tmp381_ = NULL; - ValaArrayList* _tmp382_ = NULL; + ValaArrayList* _tmp386_ = NULL; + ValaArrayList* _tmp387_ = NULL; gint _node_size = 0; - ValaArrayList* _tmp383_ = NULL; - gint _tmp384_ = 0; - gint _tmp385_ = 0; + ValaArrayList* _tmp388_ = NULL; + gint _tmp389_ = 0; + gint _tmp390_ = 0; gint _node_index = 0; - _tmp381_ = colliding; - _tmp382_ = _vala_iterable_ref0 (_tmp381_); - _node_list = _tmp382_; - _tmp383_ = _node_list; - _tmp384_ = vala_collection_get_size ((ValaCollection*) _tmp383_); - _tmp385_ = _tmp384_; - _node_size = _tmp385_; + _tmp386_ = colliding; + _tmp387_ = _vala_iterable_ref0 (_tmp386_); + _node_list = _tmp387_; + _tmp388_ = _node_list; + _tmp389_ = vala_collection_get_size ((ValaCollection*) _tmp388_); + _tmp390_ = _tmp389_; + _node_size = _tmp390_; _node_index = -1; while (TRUE) { - gint _tmp386_ = 0; - gint _tmp387_ = 0; - gint _tmp388_ = 0; + gint _tmp391_ = 0; + gint _tmp392_ = 0; + gint _tmp393_ = 0; ValaGirParserNode* node = NULL; - ValaArrayList* _tmp389_ = NULL; - gint _tmp390_ = 0; - gpointer _tmp391_ = NULL; - ValaGirParserNode* _tmp392_ = NULL; - ValaSymbol* _tmp393_ = NULL; - _tmp386_ = _node_index; - _node_index = _tmp386_ + 1; - _tmp387_ = _node_index; - _tmp388_ = _node_size; - if (!(_tmp387_ < _tmp388_)) { + ValaArrayList* _tmp394_ = NULL; + gint _tmp395_ = 0; + gpointer _tmp396_ = NULL; + ValaGirParserNode* _tmp397_ = NULL; + ValaSymbol* _tmp398_ = NULL; + _tmp391_ = _node_index; + _node_index = _tmp391_ + 1; + _tmp392_ = _node_index; + _tmp393_ = _node_size; + if (!(_tmp392_ < _tmp393_)) { break; } - _tmp389_ = _node_list; - _tmp390_ = _node_index; - _tmp391_ = vala_list_get ((ValaList*) _tmp389_, _tmp390_); - node = (ValaGirParserNode*) _tmp391_; - _tmp392_ = node; - _tmp393_ = _tmp392_->symbol; - if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp393_, VALA_TYPE_METHOD)) { - ValaGirParserNode* _tmp394_ = NULL; - _tmp394_ = node; - _tmp394_->merged = TRUE; + _tmp394_ = _node_list; + _tmp395_ = _node_index; + _tmp396_ = vala_list_get ((ValaList*) _tmp394_, _tmp395_); + node = (ValaGirParserNode*) _tmp396_; + _tmp397_ = node; + _tmp398_ = _tmp397_->symbol; + if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp398_, VALA_TYPE_METHOD)) { + ValaGirParserNode* _tmp399_ = NULL; + _tmp399_ = node; + _tmp399_->merged = TRUE; } _vala_gir_parser_node_unref0 (node); } _vala_iterable_unref0 (_node_list); } } - _tmp395_ = prop; - _tmp396_ = vala_property_get_get_accessor (_tmp395_); - _tmp397_ = _tmp396_; - _tmp398_ = vala_property_accessor_get_value_type (_tmp397_); - _tmp399_ = _tmp398_; - _tmp400_ = m; - _tmp401_ = vala_method_get_return_type (_tmp400_); + _tmp400_ = prop; + _tmp401_ = vala_property_get_get_accessor (_tmp400_); _tmp402_ = _tmp401_; - _tmp403_ = vala_data_type_get_value_owned (_tmp402_); + _tmp403_ = vala_property_accessor_get_value_type (_tmp402_); _tmp404_ = _tmp403_; - vala_data_type_set_value_owned (_tmp399_, _tmp404_); - _tmp407_ = m; - _tmp408_ = vala_method_get_is_abstract (_tmp407_); + _tmp405_ = m; + _tmp406_ = vala_method_get_return_type (_tmp405_); + _tmp407_ = _tmp406_; + _tmp408_ = vala_data_type_get_value_owned (_tmp407_); _tmp409_ = _tmp408_; - if (!_tmp409_) { - ValaMethod* _tmp410_ = NULL; - gboolean _tmp411_ = FALSE; - gboolean _tmp412_ = FALSE; - _tmp410_ = m; - _tmp411_ = vala_method_get_is_virtual (_tmp410_); - _tmp412_ = _tmp411_; - _tmp406_ = !_tmp412_; + vala_data_type_set_value_owned (_tmp404_, _tmp409_); + _tmp412_ = m; + _tmp413_ = vala_method_get_is_abstract (_tmp412_); + _tmp414_ = _tmp413_; + if (!_tmp414_) { + ValaMethod* _tmp415_ = NULL; + gboolean _tmp416_ = FALSE; + gboolean _tmp417_ = FALSE; + _tmp415_ = m; + _tmp416_ = vala_method_get_is_virtual (_tmp415_); + _tmp417_ = _tmp416_; + _tmp411_ = !_tmp417_; } else { - _tmp406_ = FALSE; + _tmp411_ = FALSE; } - if (_tmp406_) { - ValaProperty* _tmp413_ = NULL; - gboolean _tmp414_ = FALSE; - gboolean _tmp415_ = FALSE; - _tmp413_ = prop; - _tmp414_ = vala_property_get_is_abstract (_tmp413_); - _tmp415_ = _tmp414_; - _tmp405_ = _tmp415_; + if (_tmp411_) { + ValaProperty* _tmp418_ = NULL; + gboolean _tmp419_ = FALSE; + gboolean _tmp420_ = FALSE; + _tmp418_ = prop; + _tmp419_ = vala_property_get_is_abstract (_tmp418_); + _tmp420_ = _tmp419_; + _tmp410_ = _tmp420_; } else { - _tmp405_ = FALSE; + _tmp410_ = FALSE; } - if (_tmp405_) { - ValaProperty* _tmp416_ = NULL; - _tmp416_ = prop; - vala_code_node_set_attribute ((ValaCodeNode*) _tmp416_, "ConcreteAccessor", TRUE, NULL); + if (_tmp410_) { + ValaProperty* _tmp421_ = NULL; + _tmp421_ = prop; + vala_code_node_set_attribute ((ValaCodeNode*) _tmp421_, "ConcreteAccessor", TRUE, NULL); } } } else { - ValaProperty* _tmp417_ = NULL; - _tmp417_ = prop; - vala_code_node_set_attribute ((ValaCodeNode*) _tmp417_, "NoAccessorMethod", TRUE, NULL); + ValaProperty* _tmp422_ = NULL; + _tmp422_ = prop; + vala_code_node_set_attribute ((ValaCodeNode*) _tmp422_, "NoAccessorMethod", TRUE, NULL); } _vala_code_node_unref0 (m); } - _tmp420_ = prop; - _tmp421_ = vala_code_node_get_attribute ((ValaCodeNode*) _tmp420_, "NoAccessorMethod"); - _tmp422_ = _tmp421_; - _tmp423_ = _tmp422_ == NULL; - _vala_code_node_unref0 (_tmp422_); - if (_tmp423_) { - ValaProperty* _tmp424_ = NULL; - ValaPropertyAccessor* _tmp425_ = NULL; - ValaPropertyAccessor* _tmp426_ = NULL; - _tmp424_ = prop; - _tmp425_ = vala_property_get_set_accessor (_tmp424_); - _tmp426_ = _tmp425_; - _tmp419_ = _tmp426_ != NULL; + _tmp425_ = prop; + _tmp426_ = vala_code_node_get_attribute ((ValaCodeNode*) _tmp425_, "NoAccessorMethod"); + _tmp427_ = _tmp426_; + _tmp428_ = _tmp427_ == NULL; + _vala_code_node_unref0 (_tmp427_); + if (_tmp428_) { + ValaProperty* _tmp429_ = NULL; + ValaPropertyAccessor* _tmp430_ = NULL; + ValaPropertyAccessor* _tmp431_ = NULL; + _tmp429_ = prop; + _tmp430_ = vala_property_get_set_accessor (_tmp429_); + _tmp431_ = _tmp430_; + _tmp424_ = _tmp431_ != NULL; } else { - _tmp419_ = FALSE; + _tmp424_ = FALSE; } - if (_tmp419_) { - ValaProperty* _tmp427_ = NULL; - ValaPropertyAccessor* _tmp428_ = NULL; - ValaPropertyAccessor* _tmp429_ = NULL; - gboolean _tmp430_ = FALSE; - gboolean _tmp431_ = FALSE; - _tmp427_ = prop; - _tmp428_ = vala_property_get_set_accessor (_tmp427_); - _tmp429_ = _tmp428_; - _tmp430_ = vala_property_accessor_get_writable (_tmp429_); - _tmp431_ = _tmp430_; - _tmp418_ = _tmp431_; + if (_tmp424_) { + ValaProperty* _tmp432_ = NULL; + ValaPropertyAccessor* _tmp433_ = NULL; + ValaPropertyAccessor* _tmp434_ = NULL; + gboolean _tmp435_ = FALSE; + gboolean _tmp436_ = FALSE; + _tmp432_ = prop; + _tmp433_ = vala_property_get_set_accessor (_tmp432_); + _tmp434_ = _tmp433_; + _tmp435_ = vala_property_accessor_get_writable (_tmp434_); + _tmp436_ = _tmp435_; + _tmp423_ = _tmp436_; } else { - _tmp418_ = FALSE; + _tmp423_ = FALSE; } - if (_tmp418_) { - ValaMethod* _tmp432_ = NULL; - ValaGirParserNode* _tmp433_ = NULL; - ValaMethod* m = NULL; - ValaMethod* _tmp436_ = NULL; + if (_tmp423_) { ValaMethod* _tmp437_ = NULL; - _tmp433_ = setter; - if (_tmp433_ != NULL) { - ValaGirParserNode* _tmp434_ = NULL; - ValaSymbol* _tmp435_ = NULL; - _tmp434_ = setter; - _tmp435_ = _tmp434_->symbol; - _tmp432_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp435_, VALA_TYPE_METHOD) ? ((ValaMethod*) _tmp435_) : NULL; + ValaGirParserNode* _tmp438_ = NULL; + ValaMethod* m = NULL; + ValaMethod* _tmp441_ = NULL; + ValaMethod* _tmp442_ = NULL; + _tmp438_ = setter; + if (_tmp438_ != NULL) { + ValaGirParserNode* _tmp439_ = NULL; + ValaSymbol* _tmp440_ = NULL; + _tmp439_ = setter; + _tmp440_ = _tmp439_->symbol; + _tmp437_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp440_, VALA_TYPE_METHOD) ? ((ValaMethod*) _tmp440_) : NULL; } else { - _tmp432_ = NULL; + _tmp437_ = NULL; } - _tmp436_ = _vala_code_node_ref0 (_tmp432_); - m = _tmp436_; - _tmp437_ = m; - if (_tmp437_ != NULL) { - ValaGirParserNode* _tmp438_ = NULL; - ValaGirParser* _tmp439_ = NULL; - gboolean _tmp440_ = FALSE; - ValaMethod* _tmp441_ = NULL; - ValaDataType* _tmp442_ = NULL; - ValaDataType* _tmp443_ = NULL; - _tmp438_ = setter; - _tmp439_ = parser; - vala_gir_parser_node_process (_tmp438_, _tmp439_); - _tmp441_ = m; - _tmp442_ = vala_method_get_return_type (_tmp441_); - _tmp443_ = _tmp442_; - if (!G_TYPE_CHECK_INSTANCE_TYPE (_tmp443_, VALA_TYPE_VOID_TYPE)) { - _tmp440_ = TRUE; + _tmp441_ = _vala_code_node_ref0 (_tmp437_); + m = _tmp441_; + _tmp442_ = m; + if (_tmp442_ != NULL) { + ValaGirParserNode* _tmp443_ = NULL; + ValaGirParser* _tmp444_ = NULL; + gboolean _tmp445_ = FALSE; + ValaMethod* _tmp446_ = NULL; + ValaDataType* _tmp447_ = NULL; + ValaDataType* _tmp448_ = NULL; + _tmp443_ = setter; + _tmp444_ = parser; + vala_gir_parser_node_process (_tmp443_, _tmp444_); + _tmp446_ = m; + _tmp447_ = vala_method_get_return_type (_tmp446_); + _tmp448_ = _tmp447_; + if (!G_TYPE_CHECK_INSTANCE_TYPE (_tmp448_, VALA_TYPE_VOID_TYPE)) { + _tmp445_ = TRUE; } else { - ValaMethod* _tmp444_ = NULL; - ValaList* _tmp445_ = NULL; - ValaList* _tmp446_ = NULL; - gint _tmp447_ = 0; - gint _tmp448_ = 0; - _tmp444_ = m; - _tmp445_ = vala_method_get_parameters (_tmp444_); - _tmp446_ = _tmp445_; - _tmp447_ = vala_collection_get_size ((ValaCollection*) _tmp446_); - _tmp448_ = _tmp447_; - _tmp440_ = _tmp448_ != 1; - _vala_iterable_unref0 (_tmp446_); + ValaMethod* _tmp449_ = NULL; + ValaList* _tmp450_ = NULL; + ValaList* _tmp451_ = NULL; + gint _tmp452_ = 0; + gint _tmp453_ = 0; + _tmp449_ = m; + _tmp450_ = vala_method_get_parameters (_tmp449_); + _tmp451_ = _tmp450_; + _tmp452_ = vala_collection_get_size ((ValaCollection*) _tmp451_); + _tmp453_ = _tmp452_; + _tmp445_ = _tmp453_ != 1; + _vala_iterable_unref0 (_tmp451_); } - if (_tmp440_) { - ValaProperty* _tmp449_ = NULL; - ValaProperty* _tmp450_ = NULL; - _tmp449_ = prop; - vala_code_node_set_attribute ((ValaCodeNode*) _tmp449_, "NoAccessorMethod", TRUE, NULL); - _tmp450_ = prop; - vala_code_node_set_attribute ((ValaCodeNode*) _tmp450_, "ConcreteAccessor", FALSE, NULL); + if (_tmp445_) { + ValaProperty* _tmp454_ = NULL; + ValaProperty* _tmp455_ = NULL; + _tmp454_ = prop; + vala_code_node_set_attribute ((ValaCodeNode*) _tmp454_, "NoAccessorMethod", TRUE, NULL); + _tmp455_ = prop; + vala_code_node_set_attribute ((ValaCodeNode*) _tmp455_, "ConcreteAccessor", FALSE, NULL); } else { - ValaProperty* _tmp451_ = NULL; - ValaPropertyAccessor* _tmp452_ = NULL; - ValaPropertyAccessor* _tmp453_ = NULL; - ValaDataType* _tmp454_ = NULL; - ValaDataType* _tmp455_ = NULL; - ValaMethod* _tmp456_ = NULL; - ValaList* _tmp457_ = NULL; - ValaList* _tmp458_ = NULL; - gpointer _tmp459_ = NULL; - ValaParameter* _tmp460_ = NULL; - ValaDataType* _tmp461_ = NULL; - ValaDataType* _tmp462_ = NULL; - gboolean _tmp463_ = FALSE; - gboolean _tmp464_ = FALSE; - gboolean _tmp465_ = FALSE; - gboolean _tmp466_ = FALSE; - gboolean _tmp467_ = FALSE; - ValaProperty* _tmp468_ = NULL; - ValaAttribute* _tmp469_ = NULL; - ValaAttribute* _tmp470_ = NULL; + ValaProperty* _tmp456_ = NULL; + ValaPropertyAccessor* _tmp457_ = NULL; + ValaPropertyAccessor* _tmp458_ = NULL; + ValaDataType* _tmp459_ = NULL; + ValaDataType* _tmp460_ = NULL; + ValaMethod* _tmp461_ = NULL; + ValaList* _tmp462_ = NULL; + ValaList* _tmp463_ = NULL; + gpointer _tmp464_ = NULL; + ValaParameter* _tmp465_ = NULL; + ValaDataType* _tmp466_ = NULL; + ValaDataType* _tmp467_ = NULL; + gboolean _tmp468_ = FALSE; + gboolean _tmp469_ = FALSE; + gboolean _tmp470_ = FALSE; gboolean _tmp471_ = FALSE; - _tmp451_ = prop; - _tmp452_ = vala_property_get_set_accessor (_tmp451_); - _tmp453_ = _tmp452_; - _tmp454_ = vala_property_accessor_get_value_type (_tmp453_); - _tmp455_ = _tmp454_; - _tmp456_ = m; - _tmp457_ = vala_method_get_parameters (_tmp456_); + gboolean _tmp472_ = FALSE; + ValaProperty* _tmp473_ = NULL; + ValaAttribute* _tmp474_ = NULL; + ValaAttribute* _tmp475_ = NULL; + gboolean _tmp476_ = FALSE; + _tmp456_ = prop; + _tmp457_ = vala_property_get_set_accessor (_tmp456_); _tmp458_ = _tmp457_; - _tmp459_ = vala_list_get (_tmp458_, 0); - _tmp460_ = (ValaParameter*) _tmp459_; - _tmp461_ = vala_variable_get_variable_type ((ValaVariable*) _tmp460_); - _tmp462_ = _tmp461_; - _tmp463_ = vala_data_type_get_value_owned (_tmp462_); - _tmp464_ = _tmp463_; - vala_data_type_set_value_owned (_tmp455_, _tmp464_); - _vala_code_node_unref0 (_tmp460_); - _vala_iterable_unref0 (_tmp458_); - _tmp468_ = prop; - _tmp469_ = vala_code_node_get_attribute ((ValaCodeNode*) _tmp468_, "ConcreteAccessor"); - _tmp470_ = _tmp469_; - _tmp471_ = _tmp470_ != NULL; - _vala_code_node_unref0 (_tmp470_); - if (_tmp471_) { - ValaMethod* _tmp472_ = NULL; - gboolean _tmp473_ = FALSE; - gboolean _tmp474_ = FALSE; - _tmp472_ = m; - _tmp473_ = vala_method_get_is_abstract (_tmp472_); - _tmp474_ = _tmp473_; - _tmp467_ = !_tmp474_; + _tmp459_ = vala_property_accessor_get_value_type (_tmp458_); + _tmp460_ = _tmp459_; + _tmp461_ = m; + _tmp462_ = vala_method_get_parameters (_tmp461_); + _tmp463_ = _tmp462_; + _tmp464_ = vala_list_get (_tmp463_, 0); + _tmp465_ = (ValaParameter*) _tmp464_; + _tmp466_ = vala_variable_get_variable_type ((ValaVariable*) _tmp465_); + _tmp467_ = _tmp466_; + _tmp468_ = vala_data_type_get_value_owned (_tmp467_); + _tmp469_ = _tmp468_; + vala_data_type_set_value_owned (_tmp460_, _tmp469_); + _vala_code_node_unref0 (_tmp465_); + _vala_iterable_unref0 (_tmp463_); + _tmp473_ = prop; + _tmp474_ = vala_code_node_get_attribute ((ValaCodeNode*) _tmp473_, "ConcreteAccessor"); + _tmp475_ = _tmp474_; + _tmp476_ = _tmp475_ != NULL; + _vala_code_node_unref0 (_tmp475_); + if (_tmp476_) { + ValaMethod* _tmp477_ = NULL; + gboolean _tmp478_ = FALSE; + gboolean _tmp479_ = FALSE; + _tmp477_ = m; + _tmp478_ = vala_method_get_is_abstract (_tmp477_); + _tmp479_ = _tmp478_; + _tmp472_ = !_tmp479_; } else { - _tmp467_ = FALSE; + _tmp472_ = FALSE; } - if (_tmp467_) { - ValaMethod* _tmp475_ = NULL; - gboolean _tmp476_ = FALSE; - gboolean _tmp477_ = FALSE; - _tmp475_ = m; - _tmp476_ = vala_method_get_is_virtual (_tmp475_); - _tmp477_ = _tmp476_; - _tmp466_ = !_tmp477_; + if (_tmp472_) { + ValaMethod* _tmp480_ = NULL; + gboolean _tmp481_ = FALSE; + gboolean _tmp482_ = FALSE; + _tmp480_ = m; + _tmp481_ = vala_method_get_is_virtual (_tmp480_); + _tmp482_ = _tmp481_; + _tmp471_ = !_tmp482_; } else { - _tmp466_ = FALSE; + _tmp471_ = FALSE; } - if (_tmp466_) { - ValaProperty* _tmp478_ = NULL; - gboolean _tmp479_ = FALSE; - gboolean _tmp480_ = FALSE; - _tmp478_ = prop; - _tmp479_ = vala_property_get_is_abstract (_tmp478_); - _tmp480_ = _tmp479_; - _tmp465_ = _tmp480_; + if (_tmp471_) { + ValaProperty* _tmp483_ = NULL; + gboolean _tmp484_ = FALSE; + gboolean _tmp485_ = FALSE; + _tmp483_ = prop; + _tmp484_ = vala_property_get_is_abstract (_tmp483_); + _tmp485_ = _tmp484_; + _tmp470_ = _tmp485_; } else { - _tmp465_ = FALSE; + _tmp470_ = FALSE; } - if (_tmp465_) { - ValaProperty* _tmp481_ = NULL; - ValaProperty* _tmp482_ = NULL; - _tmp481_ = prop; - vala_code_node_set_attribute ((ValaCodeNode*) _tmp481_, "ConcreteAccessor", TRUE, NULL); - _tmp482_ = prop; - vala_code_node_set_attribute ((ValaCodeNode*) _tmp482_, "NoAccessorMethod", FALSE, NULL); + if (_tmp470_) { + ValaProperty* _tmp486_ = NULL; + ValaProperty* _tmp487_ = NULL; + _tmp486_ = prop; + vala_code_node_set_attribute ((ValaCodeNode*) _tmp486_, "ConcreteAccessor", TRUE, NULL); + _tmp487_ = prop; + vala_code_node_set_attribute ((ValaCodeNode*) _tmp487_, "NoAccessorMethod", FALSE, NULL); } } } else { - ValaProperty* _tmp483_ = NULL; - ValaProperty* _tmp484_ = NULL; - _tmp483_ = prop; - vala_code_node_set_attribute ((ValaCodeNode*) _tmp483_, "NoAccessorMethod", TRUE, NULL); - _tmp484_ = prop; - vala_code_node_set_attribute ((ValaCodeNode*) _tmp484_, "ConcreteAccessor", FALSE, NULL); + ValaProperty* _tmp488_ = NULL; + ValaProperty* _tmp489_ = NULL; + _tmp488_ = prop; + vala_code_node_set_attribute ((ValaCodeNode*) _tmp488_, "NoAccessorMethod", TRUE, NULL); + _tmp489_ = prop; + vala_code_node_set_attribute ((ValaCodeNode*) _tmp489_, "ConcreteAccessor", FALSE, NULL); } _vala_code_node_unref0 (m); } - _tmp485_ = prop; - _tmp486_ = vala_code_node_get_attribute ((ValaCodeNode*) _tmp485_, "NoAccessorMethod"); - _tmp487_ = _tmp486_; - _tmp488_ = _tmp487_ != NULL; - _vala_code_node_unref0 (_tmp487_); - if (_tmp488_) { - gboolean _tmp489_ = FALSE; - ValaProperty* _tmp490_ = NULL; - gboolean _tmp491_ = FALSE; - gboolean _tmp492_ = FALSE; - _tmp490_ = prop; - _tmp491_ = vala_property_get_overrides (_tmp490_); - _tmp492_ = _tmp491_; - if (!_tmp492_) { - ValaGirParserNode* _tmp493_ = NULL; - ValaSymbol* _tmp494_ = NULL; - _tmp493_ = self->parent; - _tmp494_ = _tmp493_->symbol; - _tmp489_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp494_, VALA_TYPE_CLASS); + _tmp490_ = prop; + _tmp491_ = vala_code_node_get_attribute ((ValaCodeNode*) _tmp490_, "NoAccessorMethod"); + _tmp492_ = _tmp491_; + _tmp493_ = _tmp492_ != NULL; + _vala_code_node_unref0 (_tmp492_); + if (_tmp493_) { + gboolean _tmp494_ = FALSE; + ValaProperty* _tmp495_ = NULL; + gboolean _tmp496_ = FALSE; + gboolean _tmp497_ = FALSE; + _tmp495_ = prop; + _tmp496_ = vala_property_get_overrides (_tmp495_); + _tmp497_ = _tmp496_; + if (!_tmp497_) { + ValaGirParserNode* _tmp498_ = NULL; + ValaSymbol* _tmp499_ = NULL; + _tmp498_ = self->parent; + _tmp499_ = _tmp498_->symbol; + _tmp494_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp499_, VALA_TYPE_CLASS); } else { - _tmp489_ = FALSE; + _tmp494_ = FALSE; } - if (_tmp489_) { + if (_tmp494_) { ValaGirParserNode* base_prop_node = NULL; - ValaGirParser* _tmp495_ = NULL; - ValaGirParserNode* _tmp496_ = NULL; - ValaGirParserNode* _tmp497_ = NULL; - _tmp495_ = parser; - _tmp496_ = vala_gir_parser_base_interface_property (_tmp495_, self); - base_prop_node = _tmp496_; - _tmp497_ = base_prop_node; - if (_tmp497_ != NULL) { - ValaGirParserNode* _tmp498_ = NULL; - ValaGirParser* _tmp499_ = NULL; + ValaGirParser* _tmp500_ = NULL; + ValaGirParserNode* _tmp501_ = NULL; + ValaGirParserNode* _tmp502_ = NULL; + _tmp500_ = parser; + _tmp501_ = vala_gir_parser_base_interface_property (_tmp500_, self); + base_prop_node = _tmp501_; + _tmp502_ = base_prop_node; + if (_tmp502_ != NULL) { + ValaGirParserNode* _tmp503_ = NULL; + ValaGirParser* _tmp504_ = NULL; ValaProperty* base_property = NULL; - ValaGirParserNode* _tmp500_ = NULL; - ValaSymbol* _tmp501_ = NULL; - ValaProperty* _tmp502_ = NULL; - ValaProperty* _tmp503_ = NULL; - ValaAttribute* _tmp504_ = NULL; - ValaAttribute* _tmp505_ = NULL; - gboolean _tmp506_ = FALSE; - _tmp498_ = base_prop_node; - _tmp499_ = parser; - vala_gir_parser_node_process (_tmp498_, _tmp499_); - _tmp500_ = base_prop_node; - _tmp501_ = _tmp500_->symbol; - _tmp502_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp501_, VALA_TYPE_PROPERTY, ValaProperty)); - base_property = _tmp502_; - _tmp503_ = base_property; - _tmp504_ = vala_code_node_get_attribute ((ValaCodeNode*) _tmp503_, "ConcreteAccessor"); - _tmp505_ = _tmp504_; - _tmp506_ = _tmp505_ != NULL; - _vala_code_node_unref0 (_tmp505_); - if (_tmp506_) { - ValaProperty* _tmp507_ = NULL; - ValaProperty* _tmp508_ = NULL; - ValaPropertyAccessor* _tmp509_ = NULL; - ValaPropertyAccessor* _tmp510_ = NULL; - ValaProperty* _tmp523_ = NULL; - ValaPropertyAccessor* _tmp524_ = NULL; - ValaPropertyAccessor* _tmp525_ = NULL; - _tmp507_ = prop; - vala_code_node_set_attribute ((ValaCodeNode*) _tmp507_, "NoAccessorMethod", FALSE, NULL); - _tmp508_ = prop; - _tmp509_ = vala_property_get_get_accessor (_tmp508_); - _tmp510_ = _tmp509_; - if (_tmp510_ != NULL) { - ValaProperty* _tmp511_ = NULL; - ValaPropertyAccessor* _tmp512_ = NULL; - ValaPropertyAccessor* _tmp513_ = NULL; - ValaDataType* _tmp514_ = NULL; - ValaDataType* _tmp515_ = NULL; + ValaGirParserNode* _tmp505_ = NULL; + ValaSymbol* _tmp506_ = NULL; + ValaProperty* _tmp507_ = NULL; + ValaProperty* _tmp508_ = NULL; + ValaAttribute* _tmp509_ = NULL; + ValaAttribute* _tmp510_ = NULL; + gboolean _tmp511_ = FALSE; + _tmp503_ = base_prop_node; + _tmp504_ = parser; + vala_gir_parser_node_process (_tmp503_, _tmp504_); + _tmp505_ = base_prop_node; + _tmp506_ = _tmp505_->symbol; + _tmp507_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp506_, VALA_TYPE_PROPERTY, ValaProperty)); + base_property = _tmp507_; + _tmp508_ = base_property; + _tmp509_ = vala_code_node_get_attribute ((ValaCodeNode*) _tmp508_, "ConcreteAccessor"); + _tmp510_ = _tmp509_; + _tmp511_ = _tmp510_ != NULL; + _vala_code_node_unref0 (_tmp510_); + if (_tmp511_) { + ValaProperty* _tmp512_ = NULL; + ValaProperty* _tmp513_ = NULL; + ValaPropertyAccessor* _tmp514_ = NULL; + ValaPropertyAccessor* _tmp515_ = NULL; + ValaProperty* _tmp528_ = NULL; + ValaPropertyAccessor* _tmp529_ = NULL; + ValaPropertyAccessor* _tmp530_ = NULL; + _tmp512_ = prop; + vala_code_node_set_attribute ((ValaCodeNode*) _tmp512_, "NoAccessorMethod", FALSE, NULL); + _tmp513_ = prop; + _tmp514_ = vala_property_get_get_accessor (_tmp513_); + _tmp515_ = _tmp514_; + if (_tmp515_ != NULL) { ValaProperty* _tmp516_ = NULL; ValaPropertyAccessor* _tmp517_ = NULL; ValaPropertyAccessor* _tmp518_ = NULL; ValaDataType* _tmp519_ = NULL; ValaDataType* _tmp520_ = NULL; - gboolean _tmp521_ = FALSE; - gboolean _tmp522_ = FALSE; - _tmp511_ = prop; - _tmp512_ = vala_property_get_get_accessor (_tmp511_); - _tmp513_ = _tmp512_; - _tmp514_ = vala_property_accessor_get_value_type (_tmp513_); - _tmp515_ = _tmp514_; - _tmp516_ = base_property; + ValaProperty* _tmp521_ = NULL; + ValaPropertyAccessor* _tmp522_ = NULL; + ValaPropertyAccessor* _tmp523_ = NULL; + ValaDataType* _tmp524_ = NULL; + ValaDataType* _tmp525_ = NULL; + gboolean _tmp526_ = FALSE; + gboolean _tmp527_ = FALSE; + _tmp516_ = prop; _tmp517_ = vala_property_get_get_accessor (_tmp516_); _tmp518_ = _tmp517_; _tmp519_ = vala_property_accessor_get_value_type (_tmp518_); _tmp520_ = _tmp519_; - _tmp521_ = vala_data_type_get_value_owned (_tmp520_); - _tmp522_ = _tmp521_; - vala_data_type_set_value_owned (_tmp515_, _tmp522_); + _tmp521_ = base_property; + _tmp522_ = vala_property_get_get_accessor (_tmp521_); + _tmp523_ = _tmp522_; + _tmp524_ = vala_property_accessor_get_value_type (_tmp523_); + _tmp525_ = _tmp524_; + _tmp526_ = vala_data_type_get_value_owned (_tmp525_); + _tmp527_ = _tmp526_; + vala_data_type_set_value_owned (_tmp520_, _tmp527_); } - _tmp523_ = prop; - _tmp524_ = vala_property_get_set_accessor (_tmp523_); - _tmp525_ = _tmp524_; - if (_tmp525_ != NULL) { - ValaProperty* _tmp526_ = NULL; - ValaPropertyAccessor* _tmp527_ = NULL; - ValaPropertyAccessor* _tmp528_ = NULL; - ValaDataType* _tmp529_ = NULL; - ValaDataType* _tmp530_ = NULL; + _tmp528_ = prop; + _tmp529_ = vala_property_get_set_accessor (_tmp528_); + _tmp530_ = _tmp529_; + if (_tmp530_ != NULL) { ValaProperty* _tmp531_ = NULL; ValaPropertyAccessor* _tmp532_ = NULL; ValaPropertyAccessor* _tmp533_ = NULL; ValaDataType* _tmp534_ = NULL; ValaDataType* _tmp535_ = NULL; - gboolean _tmp536_ = FALSE; - gboolean _tmp537_ = FALSE; - _tmp526_ = prop; - _tmp527_ = vala_property_get_set_accessor (_tmp526_); - _tmp528_ = _tmp527_; - _tmp529_ = vala_property_accessor_get_value_type (_tmp528_); - _tmp530_ = _tmp529_; - _tmp531_ = base_property; + ValaProperty* _tmp536_ = NULL; + ValaPropertyAccessor* _tmp537_ = NULL; + ValaPropertyAccessor* _tmp538_ = NULL; + ValaDataType* _tmp539_ = NULL; + ValaDataType* _tmp540_ = NULL; + gboolean _tmp541_ = FALSE; + gboolean _tmp542_ = FALSE; + _tmp531_ = prop; _tmp532_ = vala_property_get_set_accessor (_tmp531_); _tmp533_ = _tmp532_; _tmp534_ = vala_property_accessor_get_value_type (_tmp533_); _tmp535_ = _tmp534_; - _tmp536_ = vala_data_type_get_value_owned (_tmp535_); - _tmp537_ = _tmp536_; - vala_data_type_set_value_owned (_tmp530_, _tmp537_); + _tmp536_ = base_property; + _tmp537_ = vala_property_get_set_accessor (_tmp536_); + _tmp538_ = _tmp537_; + _tmp539_ = vala_property_accessor_get_value_type (_tmp538_); + _tmp540_ = _tmp539_; + _tmp541_ = vala_data_type_get_value_owned (_tmp540_); + _tmp542_ = _tmp541_; + vala_data_type_set_value_owned (_tmp535_, _tmp542_); } } _vala_code_node_unref0 (base_property); @@ -20786,49 +20800,49 @@ _vala_gir_parser_node_unref0 (base_prop_node); } } - _tmp538_ = prop; - _tmp539_ = vala_code_node_get_attribute ((ValaCodeNode*) _tmp538_, "NoAccessorMethod"); - _tmp540_ = _tmp539_; - _tmp541_ = _tmp540_ != NULL; - _vala_code_node_unref0 (_tmp540_); - if (_tmp541_) { - ValaProperty* _tmp542_ = NULL; - ValaPropertyAccessor* _tmp543_ = NULL; - ValaPropertyAccessor* _tmp544_ = NULL; - ValaProperty* _tmp550_ = NULL; - ValaPropertyAccessor* _tmp551_ = NULL; - ValaPropertyAccessor* _tmp552_ = NULL; - _tmp542_ = prop; - _tmp543_ = vala_property_get_get_accessor (_tmp542_); - _tmp544_ = _tmp543_; - if (_tmp544_ != NULL) { - ValaProperty* _tmp545_ = NULL; - ValaPropertyAccessor* _tmp546_ = NULL; - ValaPropertyAccessor* _tmp547_ = NULL; - ValaDataType* _tmp548_ = NULL; - ValaDataType* _tmp549_ = NULL; - _tmp545_ = prop; - _tmp546_ = vala_property_get_get_accessor (_tmp545_); - _tmp547_ = _tmp546_; - _tmp548_ = vala_property_accessor_get_value_type (_tmp547_); - _tmp549_ = _tmp548_; - vala_data_type_set_value_owned (_tmp549_, TRUE); - } - _tmp550_ = prop; - _tmp551_ = vala_property_get_set_accessor (_tmp550_); - _tmp552_ = _tmp551_; - if (_tmp552_ != NULL) { - ValaProperty* _tmp553_ = NULL; - ValaPropertyAccessor* _tmp554_ = NULL; - ValaPropertyAccessor* _tmp555_ = NULL; - ValaDataType* _tmp556_ = NULL; - ValaDataType* _tmp557_ = NULL; - _tmp553_ = prop; - _tmp554_ = vala_property_get_set_accessor (_tmp553_); - _tmp555_ = _tmp554_; - _tmp556_ = vala_property_accessor_get_value_type (_tmp555_); - _tmp557_ = _tmp556_; - vala_data_type_set_value_owned (_tmp557_, FALSE); + _tmp543_ = prop; + _tmp544_ = vala_code_node_get_attribute ((ValaCodeNode*) _tmp543_, "NoAccessorMethod"); + _tmp545_ = _tmp544_; + _tmp546_ = _tmp545_ != NULL; + _vala_code_node_unref0 (_tmp545_); + if (_tmp546_) { + ValaProperty* _tmp547_ = NULL; + ValaPropertyAccessor* _tmp548_ = NULL; + ValaPropertyAccessor* _tmp549_ = NULL; + ValaProperty* _tmp555_ = NULL; + ValaPropertyAccessor* _tmp556_ = NULL; + ValaPropertyAccessor* _tmp557_ = NULL; + _tmp547_ = prop; + _tmp548_ = vala_property_get_get_accessor (_tmp547_); + _tmp549_ = _tmp548_; + if (_tmp549_ != NULL) { + ValaProperty* _tmp550_ = NULL; + ValaPropertyAccessor* _tmp551_ = NULL; + ValaPropertyAccessor* _tmp552_ = NULL; + ValaDataType* _tmp553_ = NULL; + ValaDataType* _tmp554_ = NULL; + _tmp550_ = prop; + _tmp551_ = vala_property_get_get_accessor (_tmp550_); + _tmp552_ = _tmp551_; + _tmp553_ = vala_property_accessor_get_value_type (_tmp552_); + _tmp554_ = _tmp553_; + vala_data_type_set_value_owned (_tmp554_, TRUE); + } + _tmp555_ = prop; + _tmp556_ = vala_property_get_set_accessor (_tmp555_); + _tmp557_ = _tmp556_; + if (_tmp557_ != NULL) { + ValaProperty* _tmp558_ = NULL; + ValaPropertyAccessor* _tmp559_ = NULL; + ValaPropertyAccessor* _tmp560_ = NULL; + ValaDataType* _tmp561_ = NULL; + ValaDataType* _tmp562_ = NULL; + _tmp558_ = prop; + _tmp559_ = vala_property_get_set_accessor (_tmp558_); + _tmp560_ = _tmp559_; + _tmp561_ = vala_property_accessor_get_value_type (_tmp560_); + _tmp562_ = _tmp561_; + vala_data_type_set_value_owned (_tmp562_, FALSE); } } _vala_iterable_unref0 (setters); @@ -20842,284 +20856,284 @@ _vala_code_node_unref0 (prop); _vala_iterable_unref0 (colliding); } else { - ValaSymbol* _tmp558_ = NULL; - _tmp558_ = self->symbol; - if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp558_, VALA_TYPE_FIELD)) { + ValaSymbol* _tmp563_ = NULL; + _tmp563_ = self->symbol; + if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp563_, VALA_TYPE_FIELD)) { ValaField* field = NULL; - ValaSymbol* _tmp559_ = NULL; - ValaField* _tmp560_ = NULL; + ValaSymbol* _tmp564_ = NULL; + ValaField* _tmp565_ = NULL; ValaArrayList* colliding = NULL; - ValaGirParserNode* _tmp561_ = NULL; - const gchar* _tmp562_ = NULL; - ValaArrayList* _tmp563_ = NULL; - ValaArrayList* _tmp564_ = NULL; - gint _tmp565_ = 0; - gint _tmp566_ = 0; - ValaGirParserMetadata* _tmp567_ = NULL; - gboolean _tmp568_ = FALSE; + ValaGirParserNode* _tmp566_ = NULL; + const gchar* _tmp567_ = NULL; + ValaArrayList* _tmp568_ = NULL; + ValaArrayList* _tmp569_ = NULL; + gint _tmp570_ = 0; + gint _tmp571_ = 0; + ValaGirParserMetadata* _tmp572_ = NULL; gboolean _tmp573_ = FALSE; - ValaField* _tmp574_ = NULL; - ValaDataType* _tmp575_ = NULL; - ValaDataType* _tmp576_ = NULL; - _tmp559_ = self->symbol; - _tmp560_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp559_, VALA_TYPE_FIELD, ValaField)); - field = _tmp560_; - _tmp561_ = self->parent; - _tmp562_ = self->name; - _tmp563_ = vala_gir_parser_node_lookup_all (_tmp561_, _tmp562_); - colliding = _tmp563_; - _tmp564_ = colliding; - _tmp565_ = vala_collection_get_size ((ValaCollection*) _tmp564_); - _tmp566_ = _tmp565_; - if (_tmp566_ > 1) { + gboolean _tmp578_ = FALSE; + ValaField* _tmp579_ = NULL; + ValaDataType* _tmp580_ = NULL; + ValaDataType* _tmp581_ = NULL; + _tmp564_ = self->symbol; + _tmp565_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp564_, VALA_TYPE_FIELD, ValaField)); + field = _tmp565_; + _tmp566_ = self->parent; + _tmp567_ = self->name; + _tmp568_ = vala_gir_parser_node_lookup_all (_tmp566_, _tmp567_); + colliding = _tmp568_; + _tmp569_ = colliding; + _tmp570_ = vala_collection_get_size ((ValaCollection*) _tmp569_); + _tmp571_ = _tmp570_; + if (_tmp571_ > 1) { self->merged = TRUE; } - _tmp567_ = self->metadata; - _tmp568_ = vala_gir_parser_metadata_has_argument (_tmp567_, VALA_GIR_PARSER_ARGUMENT_TYPE_DELEGATE_TARGET_CNAME); - if (_tmp568_) { - ValaField* _tmp569_ = NULL; - ValaGirParserMetadata* _tmp570_ = NULL; - gchar* _tmp571_ = NULL; - gchar* _tmp572_ = NULL; - _tmp569_ = field; - _tmp570_ = self->metadata; - _tmp571_ = vala_gir_parser_metadata_get_string (_tmp570_, VALA_GIR_PARSER_ARGUMENT_TYPE_DELEGATE_TARGET_CNAME); - _tmp572_ = _tmp571_; - vala_code_node_set_attribute_string ((ValaCodeNode*) _tmp569_, "CCode", "delegate_target_cname", _tmp572_, NULL); - _g_free0 (_tmp572_); - } - _tmp574_ = field; - _tmp575_ = vala_variable_get_variable_type ((ValaVariable*) _tmp574_); - _tmp576_ = _tmp575_; - if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp576_, VALA_TYPE_DELEGATE_TYPE)) { - ValaGirParserNode* _tmp577_ = NULL; - ValaUnresolvedSymbol* _tmp578_ = NULL; - _tmp577_ = self->parent; - _tmp578_ = _tmp577_->gtype_struct_for; - _tmp573_ = _tmp578_ != NULL; + _tmp572_ = self->metadata; + _tmp573_ = vala_gir_parser_metadata_has_argument (_tmp572_, VALA_GIR_PARSER_ARGUMENT_TYPE_DELEGATE_TARGET_CNAME); + if (_tmp573_) { + ValaField* _tmp574_ = NULL; + ValaGirParserMetadata* _tmp575_ = NULL; + gchar* _tmp576_ = NULL; + gchar* _tmp577_ = NULL; + _tmp574_ = field; + _tmp575_ = self->metadata; + _tmp576_ = vala_gir_parser_metadata_get_string (_tmp575_, VALA_GIR_PARSER_ARGUMENT_TYPE_DELEGATE_TARGET_CNAME); + _tmp577_ = _tmp576_; + vala_code_node_set_attribute_string ((ValaCodeNode*) _tmp574_, "CCode", "delegate_target_cname", _tmp577_, NULL); + _g_free0 (_tmp577_); + } + _tmp579_ = field; + _tmp580_ = vala_variable_get_variable_type ((ValaVariable*) _tmp579_); + _tmp581_ = _tmp580_; + if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp581_, VALA_TYPE_DELEGATE_TYPE)) { + ValaGirParserNode* _tmp582_ = NULL; + ValaUnresolvedSymbol* _tmp583_ = NULL; + _tmp582_ = self->parent; + _tmp583_ = _tmp582_->gtype_struct_for; + _tmp578_ = _tmp583_ != NULL; } else { - _tmp573_ = FALSE; + _tmp578_ = FALSE; } - if (_tmp573_) { + if (_tmp578_) { ValaDelegate* d = NULL; - ValaField* _tmp579_ = NULL; - ValaDataType* _tmp580_ = NULL; - ValaDataType* _tmp581_ = NULL; - ValaDelegate* _tmp582_ = NULL; - ValaDelegate* _tmp583_ = NULL; - ValaDelegate* _tmp584_ = NULL; - ValaGirParser* _tmp585_ = NULL; - ValaDelegate* _tmp586_ = NULL; - ValaGirParserNode* _tmp587_ = NULL; - ValaUnresolvedSymbol* _tmp588_ = NULL; - _tmp579_ = field; - _tmp580_ = vala_variable_get_variable_type ((ValaVariable*) _tmp579_); - _tmp581_ = _tmp580_; - _tmp582_ = vala_delegate_type_get_delegate_symbol (G_TYPE_CHECK_INSTANCE_CAST (_tmp581_, VALA_TYPE_DELEGATE_TYPE, ValaDelegateType)); - _tmp583_ = _tmp582_; - _tmp584_ = _vala_code_node_ref0 (_tmp583_); - d = _tmp584_; - _tmp585_ = parser; - _tmp586_ = d; - _tmp587_ = self->parent; - _tmp588_ = _tmp587_->gtype_struct_for; - vala_gir_parser_process_virtual_method_field (_tmp585_, self, _tmp586_, _tmp588_); + ValaField* _tmp584_ = NULL; + ValaDataType* _tmp585_ = NULL; + ValaDataType* _tmp586_ = NULL; + ValaDelegate* _tmp587_ = NULL; + ValaDelegate* _tmp588_ = NULL; + ValaDelegate* _tmp589_ = NULL; + ValaGirParser* _tmp590_ = NULL; + ValaDelegate* _tmp591_ = NULL; + ValaGirParserNode* _tmp592_ = NULL; + ValaUnresolvedSymbol* _tmp593_ = NULL; + _tmp584_ = field; + _tmp585_ = vala_variable_get_variable_type ((ValaVariable*) _tmp584_); + _tmp586_ = _tmp585_; + _tmp587_ = vala_delegate_type_get_delegate_symbol (G_TYPE_CHECK_INSTANCE_CAST (_tmp586_, VALA_TYPE_DELEGATE_TYPE, ValaDelegateType)); + _tmp588_ = _tmp587_; + _tmp589_ = _vala_code_node_ref0 (_tmp588_); + d = _tmp589_; + _tmp590_ = parser; + _tmp591_ = d; + _tmp592_ = self->parent; + _tmp593_ = _tmp592_->gtype_struct_for; + vala_gir_parser_process_virtual_method_field (_tmp590_, self, _tmp591_, _tmp593_); self->merged = TRUE; _vala_code_node_unref0 (d); } else { - ValaField* _tmp589_ = NULL; - ValaDataType* _tmp590_ = NULL; - ValaDataType* _tmp591_ = NULL; - _tmp589_ = field; - _tmp590_ = vala_variable_get_variable_type ((ValaVariable*) _tmp589_); - _tmp591_ = _tmp590_; - if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp591_, VALA_TYPE_ARRAY_TYPE)) { + ValaField* _tmp594_ = NULL; + ValaDataType* _tmp595_ = NULL; + ValaDataType* _tmp596_ = NULL; + _tmp594_ = field; + _tmp595_ = vala_variable_get_variable_type ((ValaVariable*) _tmp594_); + _tmp596_ = _tmp595_; + if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp596_, VALA_TYPE_ARRAY_TYPE)) { ValaGirParserNode* array_length = NULL; - ValaGirParserMetadata* _tmp592_ = NULL; - gboolean _tmp593_ = FALSE; - gboolean _tmp633_ = FALSE; - ValaGirParserNode* _tmp634_ = NULL; - _tmp592_ = self->metadata; - _tmp593_ = vala_gir_parser_metadata_has_argument (_tmp592_, VALA_GIR_PARSER_ARGUMENT_TYPE_ARRAY_LENGTH_FIELD); - if (_tmp593_) { - ValaGirParserNode* _tmp594_ = NULL; - ValaGirParserMetadata* _tmp595_ = NULL; - gchar* _tmp596_ = NULL; - gchar* _tmp597_ = NULL; - ValaGirParserNode* _tmp598_ = NULL; - _tmp594_ = self->parent; - _tmp595_ = self->metadata; - _tmp596_ = vala_gir_parser_metadata_get_string (_tmp595_, VALA_GIR_PARSER_ARGUMENT_TYPE_ARRAY_LENGTH_FIELD); - _tmp597_ = _tmp596_; - _tmp598_ = vala_gir_parser_node_lookup (_tmp594_, _tmp597_, FALSE, NULL); + ValaGirParserMetadata* _tmp597_ = NULL; + gboolean _tmp598_ = FALSE; + gboolean _tmp638_ = FALSE; + ValaGirParserNode* _tmp639_ = NULL; + _tmp597_ = self->metadata; + _tmp598_ = vala_gir_parser_metadata_has_argument (_tmp597_, VALA_GIR_PARSER_ARGUMENT_TYPE_ARRAY_LENGTH_FIELD); + if (_tmp598_) { + ValaGirParserNode* _tmp599_ = NULL; + ValaGirParserMetadata* _tmp600_ = NULL; + gchar* _tmp601_ = NULL; + gchar* _tmp602_ = NULL; + ValaGirParserNode* _tmp603_ = NULL; + _tmp599_ = self->parent; + _tmp600_ = self->metadata; + _tmp601_ = vala_gir_parser_metadata_get_string (_tmp600_, VALA_GIR_PARSER_ARGUMENT_TYPE_ARRAY_LENGTH_FIELD); + _tmp602_ = _tmp601_; + _tmp603_ = vala_gir_parser_node_lookup (_tmp599_, _tmp602_, FALSE, NULL); _vala_gir_parser_node_unref0 (array_length); - array_length = _tmp598_; - _g_free0 (_tmp597_); + array_length = _tmp603_; + _g_free0 (_tmp602_); } else { - gboolean _tmp599_ = FALSE; - gint _tmp600_ = 0; - _tmp600_ = self->array_length_idx; - if (_tmp600_ > -1) { - ValaGirParserNode* _tmp601_ = NULL; - ValaArrayList* _tmp602_ = NULL; - gint _tmp603_ = 0; - gint _tmp604_ = 0; - gint _tmp605_ = 0; - _tmp601_ = self->parent; - _tmp602_ = _tmp601_->members; - _tmp603_ = vala_collection_get_size ((ValaCollection*) _tmp602_); - _tmp604_ = _tmp603_; - _tmp605_ = self->array_length_idx; - _tmp599_ = _tmp604_ > _tmp605_; - } else { - _tmp599_ = FALSE; - } - if (_tmp599_) { + gboolean _tmp604_ = FALSE; + gint _tmp605_ = 0; + _tmp605_ = self->array_length_idx; + if (_tmp605_ > -1) { ValaGirParserNode* _tmp606_ = NULL; ValaArrayList* _tmp607_ = NULL; gint _tmp608_ = 0; - gpointer _tmp609_ = NULL; + gint _tmp609_ = 0; + gint _tmp610_ = 0; _tmp606_ = self->parent; _tmp607_ = _tmp606_->members; - _tmp608_ = self->array_length_idx; - _tmp609_ = vala_list_get ((ValaList*) _tmp607_, _tmp608_); + _tmp608_ = vala_collection_get_size ((ValaCollection*) _tmp607_); + _tmp609_ = _tmp608_; + _tmp610_ = self->array_length_idx; + _tmp604_ = _tmp609_ > _tmp610_; + } else { + _tmp604_ = FALSE; + } + if (_tmp604_) { + ValaGirParserNode* _tmp611_ = NULL; + ValaArrayList* _tmp612_ = NULL; + gint _tmp613_ = 0; + gpointer _tmp614_ = NULL; + _tmp611_ = self->parent; + _tmp612_ = _tmp611_->members; + _tmp613_ = self->array_length_idx; + _tmp614_ = vala_list_get ((ValaList*) _tmp612_, _tmp613_); _vala_gir_parser_node_unref0 (array_length); - array_length = (ValaGirParserNode*) _tmp609_; + array_length = (ValaGirParserNode*) _tmp614_; } else { - ValaGirParserNode* _tmp610_ = NULL; - ValaField* _tmp611_ = NULL; - const gchar* _tmp612_ = NULL; - const gchar* _tmp613_ = NULL; - gchar* _tmp614_ = NULL; - gchar* _tmp615_ = NULL; - ValaGirParserNode* _tmp616_ = NULL; - ValaGirParserNode* _tmp617_ = NULL; - _tmp610_ = self->parent; - _tmp611_ = field; - _tmp612_ = vala_symbol_get_name ((ValaSymbol*) _tmp611_); - _tmp613_ = _tmp612_; - _tmp614_ = g_strdup_printf ("n_%s", _tmp613_); - _tmp615_ = _tmp614_; - _tmp616_ = vala_gir_parser_node_lookup (_tmp610_, _tmp615_, FALSE, NULL); + ValaGirParserNode* _tmp615_ = NULL; + ValaField* _tmp616_ = NULL; + const gchar* _tmp617_ = NULL; + const gchar* _tmp618_ = NULL; + gchar* _tmp619_ = NULL; + gchar* _tmp620_ = NULL; + ValaGirParserNode* _tmp621_ = NULL; + ValaGirParserNode* _tmp622_ = NULL; + _tmp615_ = self->parent; + _tmp616_ = field; + _tmp617_ = vala_symbol_get_name ((ValaSymbol*) _tmp616_); + _tmp618_ = _tmp617_; + _tmp619_ = g_strdup_printf ("n_%s", _tmp618_); + _tmp620_ = _tmp619_; + _tmp621_ = vala_gir_parser_node_lookup (_tmp615_, _tmp620_, FALSE, NULL); _vala_gir_parser_node_unref0 (array_length); - array_length = _tmp616_; - _g_free0 (_tmp615_); - _tmp617_ = array_length; - if (_tmp617_ == NULL) { - ValaGirParserNode* _tmp618_ = NULL; - ValaField* _tmp619_ = NULL; - const gchar* _tmp620_ = NULL; - const gchar* _tmp621_ = NULL; - gchar* _tmp622_ = NULL; - gchar* _tmp623_ = NULL; - ValaGirParserNode* _tmp624_ = NULL; - ValaGirParserNode* _tmp625_ = NULL; - _tmp618_ = self->parent; - _tmp619_ = field; - _tmp620_ = vala_symbol_get_name ((ValaSymbol*) _tmp619_); - _tmp621_ = _tmp620_; - _tmp622_ = g_strdup_printf ("num_%s", _tmp621_); - _tmp623_ = _tmp622_; - _tmp624_ = vala_gir_parser_node_lookup (_tmp618_, _tmp623_, FALSE, NULL); + array_length = _tmp621_; + _g_free0 (_tmp620_); + _tmp622_ = array_length; + if (_tmp622_ == NULL) { + ValaGirParserNode* _tmp623_ = NULL; + ValaField* _tmp624_ = NULL; + const gchar* _tmp625_ = NULL; + const gchar* _tmp626_ = NULL; + gchar* _tmp627_ = NULL; + gchar* _tmp628_ = NULL; + ValaGirParserNode* _tmp629_ = NULL; + ValaGirParserNode* _tmp630_ = NULL; + _tmp623_ = self->parent; + _tmp624_ = field; + _tmp625_ = vala_symbol_get_name ((ValaSymbol*) _tmp624_); + _tmp626_ = _tmp625_; + _tmp627_ = g_strdup_printf ("num_%s", _tmp626_); + _tmp628_ = _tmp627_; + _tmp629_ = vala_gir_parser_node_lookup (_tmp623_, _tmp628_, FALSE, NULL); _vala_gir_parser_node_unref0 (array_length); - array_length = _tmp624_; - _g_free0 (_tmp623_); - _tmp625_ = array_length; - if (_tmp625_ == NULL) { - ValaGirParserNode* _tmp626_ = NULL; - ValaField* _tmp627_ = NULL; - const gchar* _tmp628_ = NULL; - const gchar* _tmp629_ = NULL; - gchar* _tmp630_ = NULL; - gchar* _tmp631_ = NULL; - ValaGirParserNode* _tmp632_ = NULL; - _tmp626_ = self->parent; - _tmp627_ = field; - _tmp628_ = vala_symbol_get_name ((ValaSymbol*) _tmp627_); - _tmp629_ = _tmp628_; - _tmp630_ = g_strdup_printf ("%s_length", _tmp629_); - _tmp631_ = _tmp630_; - _tmp632_ = vala_gir_parser_node_lookup (_tmp626_, _tmp631_, FALSE, NULL); + array_length = _tmp629_; + _g_free0 (_tmp628_); + _tmp630_ = array_length; + if (_tmp630_ == NULL) { + ValaGirParserNode* _tmp631_ = NULL; + ValaField* _tmp632_ = NULL; + const gchar* _tmp633_ = NULL; + const gchar* _tmp634_ = NULL; + gchar* _tmp635_ = NULL; + gchar* _tmp636_ = NULL; + ValaGirParserNode* _tmp637_ = NULL; + _tmp631_ = self->parent; + _tmp632_ = field; + _tmp633_ = vala_symbol_get_name ((ValaSymbol*) _tmp632_); + _tmp634_ = _tmp633_; + _tmp635_ = g_strdup_printf ("%s_length", _tmp634_); + _tmp636_ = _tmp635_; + _tmp637_ = vala_gir_parser_node_lookup (_tmp631_, _tmp636_, FALSE, NULL); _vala_gir_parser_node_unref0 (array_length); - array_length = _tmp632_; - _g_free0 (_tmp631_); + array_length = _tmp637_; + _g_free0 (_tmp636_); } } } } - _tmp634_ = array_length; - if (_tmp634_ != NULL) { - ValaGirParserNode* _tmp635_ = NULL; - ValaSymbol* _tmp636_ = NULL; - _tmp635_ = array_length; - _tmp636_ = _tmp635_->symbol; - _tmp633_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp636_, VALA_TYPE_FIELD); + _tmp639_ = array_length; + if (_tmp639_ != NULL) { + ValaGirParserNode* _tmp640_ = NULL; + ValaSymbol* _tmp641_ = NULL; + _tmp640_ = array_length; + _tmp641_ = _tmp640_->symbol; + _tmp638_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp641_, VALA_TYPE_FIELD); } else { - _tmp633_ = FALSE; + _tmp638_ = FALSE; } - if (_tmp633_) { + if (_tmp638_) { ValaField* length_field = NULL; - ValaGirParserNode* _tmp637_ = NULL; - ValaSymbol* _tmp638_ = NULL; - ValaField* _tmp639_ = NULL; - ValaField* _tmp640_ = NULL; - ValaField* _tmp641_ = NULL; - const gchar* _tmp642_ = NULL; - const gchar* _tmp643_ = NULL; - gchar* length_type = NULL; + ValaGirParserNode* _tmp642_ = NULL; + ValaSymbol* _tmp643_ = NULL; ValaField* _tmp644_ = NULL; - ValaDataType* _tmp645_ = NULL; - ValaDataType* _tmp646_ = NULL; - gchar* _tmp647_ = NULL; + ValaField* _tmp645_ = NULL; + ValaField* _tmp646_ = NULL; + const gchar* _tmp647_ = NULL; const gchar* _tmp648_ = NULL; - ValaField* _tmp658_ = NULL; - ValaField* _tmp659_ = NULL; - _tmp637_ = array_length; - _tmp638_ = _tmp637_->symbol; - _tmp639_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp638_, VALA_TYPE_FIELD, ValaField)); - length_field = _tmp639_; - _tmp640_ = field; - _tmp641_ = length_field; - _tmp642_ = vala_symbol_get_name ((ValaSymbol*) _tmp641_); - _tmp643_ = _tmp642_; - vala_code_node_set_attribute_string ((ValaCodeNode*) _tmp640_, "CCode", "array_length_cname", _tmp643_, NULL); - _tmp644_ = length_field; - _tmp645_ = vala_variable_get_variable_type ((ValaVariable*) _tmp644_); - _tmp646_ = _tmp645_; - _tmp647_ = vala_data_type_to_qualified_string (_tmp646_, NULL); - length_type = _tmp647_; - _tmp648_ = length_type; - if (g_strcmp0 (_tmp648_, "int") != 0) { + gchar* length_type = NULL; + ValaField* _tmp649_ = NULL; + ValaDataType* _tmp650_ = NULL; + ValaDataType* _tmp651_ = NULL; + gchar* _tmp652_ = NULL; + const gchar* _tmp653_ = NULL; + ValaField* _tmp663_ = NULL; + ValaField* _tmp664_ = NULL; + _tmp642_ = array_length; + _tmp643_ = _tmp642_->symbol; + _tmp644_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp643_, VALA_TYPE_FIELD, ValaField)); + length_field = _tmp644_; + _tmp645_ = field; + _tmp646_ = length_field; + _tmp647_ = vala_symbol_get_name ((ValaSymbol*) _tmp646_); + _tmp648_ = _tmp647_; + vala_code_node_set_attribute_string ((ValaCodeNode*) _tmp645_, "CCode", "array_length_cname", _tmp648_, NULL); + _tmp649_ = length_field; + _tmp650_ = vala_variable_get_variable_type ((ValaVariable*) _tmp649_); + _tmp651_ = _tmp650_; + _tmp652_ = vala_data_type_to_qualified_string (_tmp651_, NULL); + length_type = _tmp652_; + _tmp653_ = length_type; + if (g_strcmp0 (_tmp653_, "int") != 0) { ValaGirParserNode* st = NULL; - ValaGirParser* _tmp649_ = NULL; - ValaGirParserNode* _tmp650_ = NULL; - const gchar* _tmp651_ = NULL; - ValaGirParserNode* _tmp652_ = NULL; - ValaGirParserNode* _tmp653_ = NULL; - _tmp649_ = parser; - _tmp650_ = _tmp649_->priv->root; - _tmp651_ = length_type; - _tmp652_ = vala_gir_parser_node_lookup (_tmp650_, _tmp651_, FALSE, NULL); - st = _tmp652_; - _tmp653_ = st; - if (_tmp653_ != NULL) { - ValaField* _tmp654_ = NULL; - ValaGirParserNode* _tmp655_ = NULL; - gchar* _tmp656_ = NULL; - gchar* _tmp657_ = NULL; - _tmp654_ = field; - _tmp655_ = st; - _tmp656_ = vala_gir_parser_node_get_cname (_tmp655_); - _tmp657_ = _tmp656_; - vala_code_node_set_attribute_string ((ValaCodeNode*) _tmp654_, "CCode", "array_length_type", _tmp657_, NULL); - _g_free0 (_tmp657_); + ValaGirParser* _tmp654_ = NULL; + ValaGirParserNode* _tmp655_ = NULL; + const gchar* _tmp656_ = NULL; + ValaGirParserNode* _tmp657_ = NULL; + ValaGirParserNode* _tmp658_ = NULL; + _tmp654_ = parser; + _tmp655_ = _tmp654_->priv->root; + _tmp656_ = length_type; + _tmp657_ = vala_gir_parser_node_lookup (_tmp655_, _tmp656_, FALSE, NULL); + st = _tmp657_; + _tmp658_ = st; + if (_tmp658_ != NULL) { + ValaField* _tmp659_ = NULL; + ValaGirParserNode* _tmp660_ = NULL; + gchar* _tmp661_ = NULL; + gchar* _tmp662_ = NULL; + _tmp659_ = field; + _tmp660_ = st; + _tmp661_ = vala_gir_parser_node_get_cname (_tmp660_); + _tmp662_ = _tmp661_; + vala_code_node_set_attribute_string ((ValaCodeNode*) _tmp659_, "CCode", "array_length_type", _tmp662_, NULL); + _g_free0 (_tmp662_); } _vala_gir_parser_node_unref0 (st); } - _tmp658_ = field; - vala_code_node_remove_attribute_argument ((ValaCodeNode*) _tmp658_, "CCode", "array_length"); - _tmp659_ = field; - vala_code_node_remove_attribute_argument ((ValaCodeNode*) _tmp659_, "CCode", "array_null_terminated"); + _tmp663_ = field; + vala_code_node_remove_attribute_argument ((ValaCodeNode*) _tmp663_, "CCode", "array_length"); + _tmp664_ = field; + vala_code_node_remove_attribute_argument ((ValaCodeNode*) _tmp664_, "CCode", "array_null_terminated"); _g_free0 (length_type); _vala_code_node_unref0 (length_field); } @@ -21129,165 +21143,165 @@ _vala_iterable_unref0 (colliding); _vala_code_node_unref0 (field); } else { - gboolean _tmp660_ = FALSE; - ValaSymbol* _tmp661_ = NULL; - _tmp661_ = self->symbol; - if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp661_, VALA_TYPE_SIGNAL)) { - _tmp660_ = TRUE; + gboolean _tmp665_ = FALSE; + ValaSymbol* _tmp666_ = NULL; + _tmp666_ = self->symbol; + if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp666_, VALA_TYPE_SIGNAL)) { + _tmp665_ = TRUE; } else { - ValaSymbol* _tmp662_ = NULL; - _tmp662_ = self->symbol; - _tmp660_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp662_, VALA_TYPE_DELEGATE); - } - if (_tmp660_) { - ValaGirParser* _tmp663_ = NULL; - _tmp663_ = parser; - vala_gir_parser_process_callable (_tmp663_, self); + ValaSymbol* _tmp667_ = NULL; + _tmp667_ = self->symbol; + _tmp665_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp667_, VALA_TYPE_DELEGATE); + } + if (_tmp665_) { + ValaGirParser* _tmp668_ = NULL; + _tmp668_ = parser; + vala_gir_parser_process_callable (_tmp668_, self); } else { - ValaSymbol* _tmp664_ = NULL; - _tmp664_ = self->symbol; - if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp664_, VALA_TYPE_INTERFACE)) { - ValaGirParser* _tmp665_ = NULL; - _tmp665_ = parser; - vala_gir_parser_process_interface (_tmp665_, self); + ValaSymbol* _tmp669_ = NULL; + _tmp669_ = self->symbol; + if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp669_, VALA_TYPE_INTERFACE)) { + ValaGirParser* _tmp670_ = NULL; + _tmp670_ = parser; + vala_gir_parser_process_interface (_tmp670_, self); } else { - ValaSymbol* _tmp666_ = NULL; - _tmp666_ = self->symbol; - if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp666_, VALA_TYPE_STRUCT)) { - gboolean _tmp667_ = FALSE; - ValaGirParserNode* _tmp668_ = NULL; - ValaSymbol* _tmp669_ = NULL; - _tmp668_ = self->parent; - _tmp669_ = _tmp668_->symbol; - if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp669_, VALA_TYPE_OBJECT_TYPE_SYMBOL)) { - _tmp667_ = TRUE; + ValaSymbol* _tmp671_ = NULL; + _tmp671_ = self->symbol; + if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp671_, VALA_TYPE_STRUCT)) { + gboolean _tmp672_ = FALSE; + ValaGirParserNode* _tmp673_ = NULL; + ValaSymbol* _tmp674_ = NULL; + _tmp673_ = self->parent; + _tmp674_ = _tmp673_->symbol; + if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp674_, VALA_TYPE_OBJECT_TYPE_SYMBOL)) { + _tmp672_ = TRUE; } else { - ValaGirParserNode* _tmp670_ = NULL; - ValaSymbol* _tmp671_ = NULL; - _tmp670_ = self->parent; - _tmp671_ = _tmp670_->symbol; - _tmp667_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp671_, VALA_TYPE_STRUCT); + ValaGirParserNode* _tmp675_ = NULL; + ValaSymbol* _tmp676_ = NULL; + _tmp675_ = self->parent; + _tmp676_ = _tmp675_->symbol; + _tmp672_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp676_, VALA_TYPE_STRUCT); } - if (_tmp667_) { + if (_tmp672_) { { ValaArrayList* _fn_list = NULL; - ValaArrayList* _tmp672_ = NULL; - ValaArrayList* _tmp673_ = NULL; + ValaArrayList* _tmp677_ = NULL; + ValaArrayList* _tmp678_ = NULL; gint _fn_size = 0; - ValaArrayList* _tmp674_ = NULL; - gint _tmp675_ = 0; - gint _tmp676_ = 0; + ValaArrayList* _tmp679_ = NULL; + gint _tmp680_ = 0; + gint _tmp681_ = 0; gint _fn_index = 0; - _tmp672_ = self->members; - _tmp673_ = _vala_iterable_ref0 (_tmp672_); - _fn_list = _tmp673_; - _tmp674_ = _fn_list; - _tmp675_ = vala_collection_get_size ((ValaCollection*) _tmp674_); - _tmp676_ = _tmp675_; - _fn_size = _tmp676_; + _tmp677_ = self->members; + _tmp678_ = _vala_iterable_ref0 (_tmp677_); + _fn_list = _tmp678_; + _tmp679_ = _fn_list; + _tmp680_ = vala_collection_get_size ((ValaCollection*) _tmp679_); + _tmp681_ = _tmp680_; + _fn_size = _tmp681_; _fn_index = -1; while (TRUE) { - gint _tmp677_ = 0; - gint _tmp678_ = 0; - gint _tmp679_ = 0; + gint _tmp682_ = 0; + gint _tmp683_ = 0; + gint _tmp684_ = 0; ValaGirParserNode* fn = NULL; - ValaArrayList* _tmp680_ = NULL; - gint _tmp681_ = 0; - gpointer _tmp682_ = NULL; + ValaArrayList* _tmp685_ = NULL; + gint _tmp686_ = 0; + gpointer _tmp687_ = NULL; ValaField* f = NULL; - ValaGirParserNode* _tmp683_ = NULL; - ValaSymbol* _tmp684_ = NULL; - ValaField* _tmp685_ = NULL; - ValaField* _tmp686_ = NULL; - _tmp677_ = _fn_index; - _fn_index = _tmp677_ + 1; - _tmp678_ = _fn_index; - _tmp679_ = _fn_size; - if (!(_tmp678_ < _tmp679_)) { + ValaGirParserNode* _tmp688_ = NULL; + ValaSymbol* _tmp689_ = NULL; + ValaField* _tmp690_ = NULL; + ValaField* _tmp691_ = NULL; + _tmp682_ = _fn_index; + _fn_index = _tmp682_ + 1; + _tmp683_ = _fn_index; + _tmp684_ = _fn_size; + if (!(_tmp683_ < _tmp684_)) { break; } - _tmp680_ = _fn_list; - _tmp681_ = _fn_index; - _tmp682_ = vala_list_get ((ValaList*) _tmp680_, _tmp681_); - fn = (ValaGirParserNode*) _tmp682_; - _tmp683_ = fn; - _tmp684_ = _tmp683_->symbol; - _tmp685_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp684_, VALA_TYPE_FIELD) ? ((ValaField*) _tmp684_) : NULL); - f = _tmp685_; - _tmp686_ = f; - if (_tmp686_ != NULL) { - ValaField* _tmp687_ = NULL; - ValaMemberBinding _tmp688_ = 0; - ValaMemberBinding _tmp689_ = 0; - ValaField* _tmp699_ = NULL; - ValaSymbol* _tmp700_ = NULL; - const gchar* _tmp701_ = NULL; - const gchar* _tmp702_ = NULL; - gchar* _tmp703_ = NULL; - gchar* _tmp704_ = NULL; - ValaField* _tmp705_ = NULL; + _tmp685_ = _fn_list; + _tmp686_ = _fn_index; + _tmp687_ = vala_list_get ((ValaList*) _tmp685_, _tmp686_); + fn = (ValaGirParserNode*) _tmp687_; + _tmp688_ = fn; + _tmp689_ = _tmp688_->symbol; + _tmp690_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp689_, VALA_TYPE_FIELD) ? ((ValaField*) _tmp689_) : NULL); + f = _tmp690_; + _tmp691_ = f; + if (_tmp691_ != NULL) { + ValaField* _tmp692_ = NULL; + ValaMemberBinding _tmp693_ = 0; + ValaMemberBinding _tmp694_ = 0; + ValaField* _tmp704_ = NULL; + ValaSymbol* _tmp705_ = NULL; const gchar* _tmp706_ = NULL; const gchar* _tmp707_ = NULL; gchar* _tmp708_ = NULL; gchar* _tmp709_ = NULL; - ValaGirParserNode* _tmp710_ = NULL; - ValaField* _tmp711_ = NULL; + ValaField* _tmp710_ = NULL; + const gchar* _tmp711_ = NULL; const gchar* _tmp712_ = NULL; - const gchar* _tmp713_ = NULL; + gchar* _tmp713_ = NULL; gchar* _tmp714_ = NULL; ValaGirParserNode* _tmp715_ = NULL; - ValaGirParserNode* _tmp716_ = NULL; - _tmp687_ = f; - _tmp688_ = vala_field_get_binding (_tmp687_); - _tmp689_ = _tmp688_; - if (_tmp689_ == VALA_MEMBER_BINDING_INSTANCE) { - ValaField* _tmp690_ = NULL; - const gchar* _tmp691_ = NULL; - gchar* _tmp692_ = NULL; - gchar* _tmp693_ = NULL; - ValaGirParserNode* _tmp694_ = NULL; - gchar* _tmp695_ = NULL; - gchar* _tmp696_ = NULL; + ValaField* _tmp716_ = NULL; + const gchar* _tmp717_ = NULL; + const gchar* _tmp718_ = NULL; + gchar* _tmp719_ = NULL; + ValaGirParserNode* _tmp720_ = NULL; + ValaGirParserNode* _tmp721_ = NULL; + _tmp692_ = f; + _tmp693_ = vala_field_get_binding (_tmp692_); + _tmp694_ = _tmp693_; + if (_tmp694_ == VALA_MEMBER_BINDING_INSTANCE) { + ValaField* _tmp695_ = NULL; + const gchar* _tmp696_ = NULL; gchar* _tmp697_ = NULL; gchar* _tmp698_ = NULL; - _tmp690_ = f; - _tmp691_ = self->name; - _tmp692_ = g_strconcat (_tmp691_, ".", NULL); - _tmp693_ = _tmp692_; - _tmp694_ = fn; - _tmp695_ = vala_gir_parser_node_get_cname (_tmp694_); - _tmp696_ = _tmp695_; - _tmp697_ = g_strconcat (_tmp693_, _tmp696_, NULL); + ValaGirParserNode* _tmp699_ = NULL; + gchar* _tmp700_ = NULL; + gchar* _tmp701_ = NULL; + gchar* _tmp702_ = NULL; + gchar* _tmp703_ = NULL; + _tmp695_ = f; + _tmp696_ = self->name; + _tmp697_ = g_strconcat (_tmp696_, ".", NULL); _tmp698_ = _tmp697_; - vala_code_node_set_attribute_string ((ValaCodeNode*) _tmp690_, "CCode", "cname", _tmp698_, NULL); + _tmp699_ = fn; + _tmp700_ = vala_gir_parser_node_get_cname (_tmp699_); + _tmp701_ = _tmp700_; + _tmp702_ = g_strconcat (_tmp698_, _tmp701_, NULL); + _tmp703_ = _tmp702_; + vala_code_node_set_attribute_string ((ValaCodeNode*) _tmp695_, "CCode", "cname", _tmp703_, NULL); + _g_free0 (_tmp703_); + _g_free0 (_tmp701_); _g_free0 (_tmp698_); - _g_free0 (_tmp696_); - _g_free0 (_tmp693_); } - _tmp699_ = f; - _tmp700_ = self->symbol; - _tmp701_ = vala_symbol_get_name (_tmp700_); - _tmp702_ = _tmp701_; - _tmp703_ = g_strconcat (_tmp702_, "_", NULL); - _tmp704_ = _tmp703_; - _tmp705_ = f; - _tmp706_ = vala_symbol_get_name ((ValaSymbol*) _tmp705_); + _tmp704_ = f; + _tmp705_ = self->symbol; + _tmp706_ = vala_symbol_get_name (_tmp705_); _tmp707_ = _tmp706_; - _tmp708_ = g_strconcat (_tmp704_, _tmp707_, NULL); + _tmp708_ = g_strconcat (_tmp707_, "_", NULL); _tmp709_ = _tmp708_; - vala_symbol_set_name ((ValaSymbol*) _tmp699_, _tmp709_); + _tmp710_ = f; + _tmp711_ = vala_symbol_get_name ((ValaSymbol*) _tmp710_); + _tmp712_ = _tmp711_; + _tmp713_ = g_strconcat (_tmp709_, _tmp712_, NULL); + _tmp714_ = _tmp713_; + vala_symbol_set_name ((ValaSymbol*) _tmp704_, _tmp714_); + _g_free0 (_tmp714_); _g_free0 (_tmp709_); - _g_free0 (_tmp704_); - _tmp710_ = fn; - _tmp711_ = f; - _tmp712_ = vala_symbol_get_name ((ValaSymbol*) _tmp711_); - _tmp713_ = _tmp712_; - _tmp714_ = g_strdup (_tmp713_); - _g_free0 (_tmp710_->name); - _tmp710_->name = _tmp714_; - _tmp715_ = self->parent; - _tmp716_ = fn; - vala_gir_parser_node_add_member (_tmp715_, _tmp716_); + _tmp715_ = fn; + _tmp716_ = f; + _tmp717_ = vala_symbol_get_name ((ValaSymbol*) _tmp716_); + _tmp718_ = _tmp717_; + _tmp719_ = g_strdup (_tmp718_); + _g_free0 (_tmp715_->name); + _tmp715_->name = _tmp719_; + _tmp720_ = self->parent; + _tmp721_ = fn; + vala_gir_parser_node_add_member (_tmp720_, _tmp721_); } _vala_code_node_unref0 (f); _vala_gir_parser_node_unref0 (fn); @@ -21297,81 +21311,81 @@ self->merged = TRUE; } else { gchar* gtype_struct_for = NULL; - ValaMap* _tmp717_ = NULL; - gpointer _tmp718_ = NULL; - const gchar* _tmp719_ = NULL; - _tmp717_ = self->girdata; - _tmp718_ = vala_map_get (_tmp717_, "glib:is-gtype-struct-for"); - gtype_struct_for = (gchar*) _tmp718_; - _tmp719_ = gtype_struct_for; - if (_tmp719_ != NULL) { + ValaMap* _tmp722_ = NULL; + gpointer _tmp723_ = NULL; + const gchar* _tmp724_ = NULL; + _tmp722_ = self->girdata; + _tmp723_ = vala_map_get (_tmp722_, "glib:is-gtype-struct-for"); + gtype_struct_for = (gchar*) _tmp723_; + _tmp724_ = gtype_struct_for; + if (_tmp724_ != NULL) { ValaGirParserNode* iface = NULL; - ValaGirParser* _tmp720_ = NULL; - ValaGirParserNode* _tmp721_ = NULL; - ValaGirParser* _tmp722_ = NULL; - const gchar* _tmp723_ = NULL; - ValaSourceReference* _tmp724_ = NULL; - ValaUnresolvedSymbol* _tmp725_ = NULL; - ValaUnresolvedSymbol* _tmp726_ = NULL; - ValaGirParserNode* _tmp727_ = NULL; - ValaGirParserNode* _tmp728_ = NULL; - gboolean _tmp729_ = FALSE; - gboolean _tmp730_ = FALSE; - ValaGirParserNode* _tmp731_ = NULL; - _tmp720_ = parser; - _tmp721_ = self->parent; - _tmp722_ = parser; - _tmp723_ = gtype_struct_for; - _tmp724_ = self->source_reference; - _tmp725_ = vala_gir_parser_parse_symbol_from_string (_tmp722_, _tmp723_, _tmp724_); - _tmp726_ = _tmp725_; - _tmp727_ = vala_gir_parser_resolve_node (_tmp720_, _tmp721_, _tmp726_, FALSE); - _tmp728_ = _tmp727_; - _vala_code_node_unref0 (_tmp726_); - iface = _tmp728_; - _tmp731_ = iface; - if (_tmp731_ != NULL) { - ValaGirParserNode* _tmp732_ = NULL; - ValaSymbol* _tmp733_ = NULL; - _tmp732_ = iface; - _tmp733_ = _tmp732_->symbol; - _tmp730_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp733_, VALA_TYPE_INTERFACE); + ValaGirParser* _tmp725_ = NULL; + ValaGirParserNode* _tmp726_ = NULL; + ValaGirParser* _tmp727_ = NULL; + const gchar* _tmp728_ = NULL; + ValaSourceReference* _tmp729_ = NULL; + ValaUnresolvedSymbol* _tmp730_ = NULL; + ValaUnresolvedSymbol* _tmp731_ = NULL; + ValaGirParserNode* _tmp732_ = NULL; + ValaGirParserNode* _tmp733_ = NULL; + gboolean _tmp734_ = FALSE; + gboolean _tmp735_ = FALSE; + ValaGirParserNode* _tmp736_ = NULL; + _tmp725_ = parser; + _tmp726_ = self->parent; + _tmp727_ = parser; + _tmp728_ = gtype_struct_for; + _tmp729_ = self->source_reference; + _tmp730_ = vala_gir_parser_parse_symbol_from_string (_tmp727_, _tmp728_, _tmp729_); + _tmp731_ = _tmp730_; + _tmp732_ = vala_gir_parser_resolve_node (_tmp725_, _tmp726_, _tmp731_, FALSE); + _tmp733_ = _tmp732_; + _vala_code_node_unref0 (_tmp731_); + iface = _tmp733_; + _tmp736_ = iface; + if (_tmp736_ != NULL) { + ValaGirParserNode* _tmp737_ = NULL; + ValaSymbol* _tmp738_ = NULL; + _tmp737_ = iface; + _tmp738_ = _tmp737_->symbol; + _tmp735_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp738_, VALA_TYPE_INTERFACE); } else { - _tmp730_ = FALSE; + _tmp735_ = FALSE; } - if (_tmp730_) { - ValaGirParserNode* _tmp734_ = NULL; - gchar* _tmp735_ = NULL; - gchar* _tmp736_ = NULL; - gchar* _tmp737_ = NULL; - gchar* _tmp738_ = NULL; - gchar* _tmp739_ = NULL; + if (_tmp735_) { + ValaGirParserNode* _tmp739_ = NULL; gchar* _tmp740_ = NULL; - _tmp734_ = iface; - _tmp735_ = vala_gir_parser_node_get_cname (_tmp734_); - _tmp736_ = _tmp735_; - _tmp737_ = g_strdup_printf ("%sIface", _tmp736_); - _tmp738_ = _tmp737_; - _tmp739_ = vala_gir_parser_node_get_cname (self); - _tmp740_ = _tmp739_; - _tmp729_ = g_strcmp0 (_tmp738_, _tmp740_) != 0; - _g_free0 (_tmp740_); - _g_free0 (_tmp738_); - _g_free0 (_tmp736_); - } else { - _tmp729_ = FALSE; - } - if (_tmp729_) { - ValaGirParserNode* _tmp741_ = NULL; - ValaSymbol* _tmp742_ = NULL; + gchar* _tmp741_ = NULL; + gchar* _tmp742_ = NULL; gchar* _tmp743_ = NULL; gchar* _tmp744_ = NULL; - _tmp741_ = iface; - _tmp742_ = _tmp741_->symbol; - _tmp743_ = vala_gir_parser_node_get_cname (self); - _tmp744_ = _tmp743_; - vala_code_node_set_attribute_string ((ValaCodeNode*) _tmp742_, "CCode", "type_cname", _tmp744_, NULL); - _g_free0 (_tmp744_); + gchar* _tmp745_ = NULL; + _tmp739_ = iface; + _tmp740_ = vala_gir_parser_node_get_cname (_tmp739_); + _tmp741_ = _tmp740_; + _tmp742_ = g_strdup_printf ("%sIface", _tmp741_); + _tmp743_ = _tmp742_; + _tmp744_ = vala_gir_parser_node_get_cname (self); + _tmp745_ = _tmp744_; + _tmp734_ = g_strcmp0 (_tmp743_, _tmp745_) != 0; + _g_free0 (_tmp745_); + _g_free0 (_tmp743_); + _g_free0 (_tmp741_); + } else { + _tmp734_ = FALSE; + } + if (_tmp734_) { + ValaGirParserNode* _tmp746_ = NULL; + ValaSymbol* _tmp747_ = NULL; + gchar* _tmp748_ = NULL; + gchar* _tmp749_ = NULL; + _tmp746_ = iface; + _tmp747_ = _tmp746_->symbol; + _tmp748_ = vala_gir_parser_node_get_cname (self); + _tmp749_ = _tmp748_; + vala_code_node_set_attribute_string ((ValaCodeNode*) _tmp747_, "CCode", "type_cname", _tmp749_, NULL); + _g_free0 (_tmp749_); } self->merged = TRUE; _vala_gir_parser_node_unref0 (iface); @@ -21384,499 +21398,499 @@ } } } - _tmp745_ = self->metadata; - _tmp746_ = vala_gir_parser_metadata_has_argument (_tmp745_, VALA_GIR_PARSER_ARGUMENT_TYPE_REPLACEMENT); - if (_tmp746_) { - ValaGirParserMetadata* _tmp747_ = NULL; - gchar* _tmp748_ = NULL; + _tmp750_ = self->metadata; + _tmp751_ = vala_gir_parser_metadata_has_argument (_tmp750_, VALA_GIR_PARSER_ARGUMENT_TYPE_REPLACEMENT); + if (_tmp751_) { + ValaGirParserMetadata* _tmp752_ = NULL; + gchar* _tmp753_ = NULL; self->deprecated = TRUE; - _tmp747_ = self->metadata; - _tmp748_ = vala_gir_parser_metadata_get_string (_tmp747_, VALA_GIR_PARSER_ARGUMENT_TYPE_REPLACEMENT); + _tmp752_ = self->metadata; + _tmp753_ = vala_gir_parser_metadata_get_string (_tmp752_, VALA_GIR_PARSER_ARGUMENT_TYPE_REPLACEMENT); _g_free0 (self->deprecated_replacement); - self->deprecated_replacement = _tmp748_; + self->deprecated_replacement = _tmp753_; } - _tmp749_ = self->metadata; - _tmp750_ = vala_gir_parser_metadata_has_argument (_tmp749_, VALA_GIR_PARSER_ARGUMENT_TYPE_DEPRECATED_SINCE); - if (_tmp750_) { - ValaGirParserMetadata* _tmp751_ = NULL; - gchar* _tmp752_ = NULL; + _tmp754_ = self->metadata; + _tmp755_ = vala_gir_parser_metadata_has_argument (_tmp754_, VALA_GIR_PARSER_ARGUMENT_TYPE_DEPRECATED_SINCE); + if (_tmp755_) { + ValaGirParserMetadata* _tmp756_ = NULL; + gchar* _tmp757_ = NULL; self->deprecated = TRUE; - _tmp751_ = self->metadata; - _tmp752_ = vala_gir_parser_metadata_get_string (_tmp751_, VALA_GIR_PARSER_ARGUMENT_TYPE_DEPRECATED_SINCE); + _tmp756_ = self->metadata; + _tmp757_ = vala_gir_parser_metadata_get_string (_tmp756_, VALA_GIR_PARSER_ARGUMENT_TYPE_DEPRECATED_SINCE); _g_free0 (self->deprecated_since); - self->deprecated_since = _tmp752_; + self->deprecated_since = _tmp757_; } else { - ValaMap* _tmp753_ = NULL; - gpointer _tmp754_ = NULL; - gchar* _tmp755_ = NULL; - gboolean _tmp756_ = FALSE; - _tmp753_ = self->girdata; - _tmp754_ = vala_map_get (_tmp753_, "deprecated-version"); - _tmp755_ = (gchar*) _tmp754_; - _tmp756_ = _tmp755_ != NULL; - _g_free0 (_tmp755_); - if (_tmp756_) { - ValaMap* _tmp757_ = NULL; - gpointer _tmp758_ = NULL; + ValaMap* _tmp758_ = NULL; + gpointer _tmp759_ = NULL; + gchar* _tmp760_ = NULL; + gboolean _tmp761_ = FALSE; + _tmp758_ = self->girdata; + _tmp759_ = vala_map_get (_tmp758_, "deprecated-version"); + _tmp760_ = (gchar*) _tmp759_; + _tmp761_ = _tmp760_ != NULL; + _g_free0 (_tmp760_); + if (_tmp761_) { + ValaMap* _tmp762_ = NULL; + gpointer _tmp763_ = NULL; self->deprecated = TRUE; - _tmp757_ = self->girdata; - _tmp758_ = vala_map_get (_tmp757_, "deprecated-version"); + _tmp762_ = self->girdata; + _tmp763_ = vala_map_get (_tmp762_, "deprecated-version"); _g_free0 (self->deprecated_since); - self->deprecated_since = (gchar*) _tmp758_; + self->deprecated_since = (gchar*) _tmp763_; } } - _tmp759_ = self->metadata; - _tmp760_ = vala_gir_parser_metadata_has_argument (_tmp759_, VALA_GIR_PARSER_ARGUMENT_TYPE_DEPRECATED); - if (_tmp760_) { - ValaGirParserMetadata* _tmp761_ = NULL; - gboolean _tmp762_ = FALSE; - gboolean _tmp763_ = FALSE; - _tmp761_ = self->metadata; - _tmp762_ = vala_gir_parser_metadata_get_bool (_tmp761_, VALA_GIR_PARSER_ARGUMENT_TYPE_DEPRECATED, TRUE); - self->deprecated = _tmp762_; - _tmp763_ = self->deprecated; - if (!_tmp763_) { + _tmp764_ = self->metadata; + _tmp765_ = vala_gir_parser_metadata_has_argument (_tmp764_, VALA_GIR_PARSER_ARGUMENT_TYPE_DEPRECATED); + if (_tmp765_) { + ValaGirParserMetadata* _tmp766_ = NULL; + gboolean _tmp767_ = FALSE; + gboolean _tmp768_ = FALSE; + _tmp766_ = self->metadata; + _tmp767_ = vala_gir_parser_metadata_get_bool (_tmp766_, VALA_GIR_PARSER_ARGUMENT_TYPE_DEPRECATED, TRUE); + self->deprecated = _tmp767_; + _tmp768_ = self->deprecated; + if (!_tmp768_) { _g_free0 (self->deprecated_since); self->deprecated_since = NULL; _g_free0 (self->deprecated_replacement); self->deprecated_replacement = NULL; } } else { - ValaMap* _tmp764_ = NULL; - gpointer _tmp765_ = NULL; - gchar* _tmp766_ = NULL; - gboolean _tmp767_ = FALSE; - _tmp764_ = self->girdata; - _tmp765_ = vala_map_get (_tmp764_, "deprecated"); - _tmp766_ = (gchar*) _tmp765_; - _tmp767_ = _tmp766_ != NULL; - _g_free0 (_tmp766_); - if (_tmp767_) { + ValaMap* _tmp769_ = NULL; + gpointer _tmp770_ = NULL; + gchar* _tmp771_ = NULL; + gboolean _tmp772_ = FALSE; + _tmp769_ = self->girdata; + _tmp770_ = vala_map_get (_tmp769_, "deprecated"); + _tmp771_ = (gchar*) _tmp770_; + _tmp772_ = _tmp771_ != NULL; + _g_free0 (_tmp771_); + if (_tmp772_) { self->deprecated = TRUE; } } - _tmp768_ = self->deprecated_since; - if (_tmp768_ != NULL) { - const gchar* _tmp769_ = NULL; - guint64 _tmp770_ = 0ULL; - _tmp769_ = self->deprecated_since; - _tmp770_ = vala_gir_parser_node_parse_version_string (_tmp769_); - self->deprecated_version = _tmp770_; - } - _tmp771_ = self->metadata; - _tmp772_ = vala_gir_parser_metadata_has_argument (_tmp771_, VALA_GIR_PARSER_ARGUMENT_TYPE_EXPERIMENTAL); - if (_tmp772_) { - ValaSymbol* _tmp773_ = NULL; - ValaGirParserMetadata* _tmp774_ = NULL; - gboolean _tmp775_ = FALSE; - _tmp773_ = self->symbol; - _tmp774_ = self->metadata; - _tmp775_ = vala_gir_parser_metadata_get_bool (_tmp774_, VALA_GIR_PARSER_ARGUMENT_TYPE_EXPERIMENTAL, FALSE); - vala_code_node_set_attribute_bool ((ValaCodeNode*) _tmp773_, "Version", "experimental", _tmp775_, NULL); + _tmp773_ = self->deprecated_since; + if (_tmp773_ != NULL) { + const gchar* _tmp774_ = NULL; + guint64 _tmp775_ = 0ULL; + _tmp774_ = self->deprecated_since; + _tmp775_ = vala_gir_parser_node_parse_version_string (_tmp774_); + self->deprecated_version = _tmp775_; } _tmp776_ = self->metadata; - _tmp777_ = vala_gir_parser_metadata_has_argument (_tmp776_, VALA_GIR_PARSER_ARGUMENT_TYPE_SINCE); + _tmp777_ = vala_gir_parser_metadata_has_argument (_tmp776_, VALA_GIR_PARSER_ARGUMENT_TYPE_EXPERIMENTAL); if (_tmp777_) { ValaSymbol* _tmp778_ = NULL; - ValaVersionAttribute* _tmp779_ = NULL; - ValaVersionAttribute* _tmp780_ = NULL; - ValaGirParserMetadata* _tmp781_ = NULL; - gchar* _tmp782_ = NULL; - gchar* _tmp783_ = NULL; + ValaGirParserMetadata* _tmp779_ = NULL; + gboolean _tmp780_ = FALSE; _tmp778_ = self->symbol; - _tmp779_ = vala_symbol_get_version (_tmp778_); - _tmp780_ = _tmp779_; - _tmp781_ = self->metadata; - _tmp782_ = vala_gir_parser_metadata_get_string (_tmp781_, VALA_GIR_PARSER_ARGUMENT_TYPE_SINCE); - _tmp783_ = _tmp782_; - vala_version_attribute_set_since (_tmp780_, _tmp783_); - _g_free0 (_tmp783_); + _tmp779_ = self->metadata; + _tmp780_ = vala_gir_parser_metadata_get_bool (_tmp779_, VALA_GIR_PARSER_ARGUMENT_TYPE_EXPERIMENTAL, FALSE); + vala_code_node_set_attribute_bool ((ValaCodeNode*) _tmp778_, "Version", "experimental", _tmp780_, NULL); + } + _tmp781_ = self->metadata; + _tmp782_ = vala_gir_parser_metadata_has_argument (_tmp781_, VALA_GIR_PARSER_ARGUMENT_TYPE_SINCE); + if (_tmp782_) { + ValaSymbol* _tmp783_ = NULL; + ValaVersionAttribute* _tmp784_ = NULL; + ValaVersionAttribute* _tmp785_ = NULL; + ValaGirParserMetadata* _tmp786_ = NULL; + gchar* _tmp787_ = NULL; + gchar* _tmp788_ = NULL; + _tmp783_ = self->symbol; + _tmp784_ = vala_symbol_get_version (_tmp783_); + _tmp785_ = _tmp784_; + _tmp786_ = self->metadata; + _tmp787_ = vala_gir_parser_metadata_get_string (_tmp786_, VALA_GIR_PARSER_ARGUMENT_TYPE_SINCE); + _tmp788_ = _tmp787_; + vala_version_attribute_set_since (_tmp785_, _tmp788_); + _g_free0 (_tmp788_); } else { - gboolean _tmp784_ = FALSE; - ValaSymbol* _tmp785_ = NULL; - _tmp785_ = self->symbol; - if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp785_, VALA_TYPE_NAMESPACE) == FALSE) { - ValaMap* _tmp786_ = NULL; - gpointer _tmp787_ = NULL; - gchar* _tmp788_ = NULL; - _tmp786_ = self->girdata; - _tmp787_ = vala_map_get (_tmp786_, "version"); - _tmp788_ = (gchar*) _tmp787_; - _tmp784_ = _tmp788_ != NULL; - _g_free0 (_tmp788_); + gboolean _tmp789_ = FALSE; + ValaSymbol* _tmp790_ = NULL; + _tmp790_ = self->symbol; + if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp790_, VALA_TYPE_NAMESPACE) == FALSE) { + ValaMap* _tmp791_ = NULL; + gpointer _tmp792_ = NULL; + gchar* _tmp793_ = NULL; + _tmp791_ = self->girdata; + _tmp792_ = vala_map_get (_tmp791_, "version"); + _tmp793_ = (gchar*) _tmp792_; + _tmp789_ = _tmp793_ != NULL; + _g_free0 (_tmp793_); } else { - _tmp784_ = FALSE; + _tmp789_ = FALSE; } - if (_tmp784_) { - ValaSymbol* _tmp789_ = NULL; - ValaVersionAttribute* _tmp790_ = NULL; - ValaVersionAttribute* _tmp791_ = NULL; - ValaMap* _tmp792_ = NULL; - gpointer _tmp793_ = NULL; - gchar* _tmp794_ = NULL; - _tmp789_ = self->symbol; - _tmp790_ = vala_symbol_get_version (_tmp789_); - _tmp791_ = _tmp790_; - _tmp792_ = self->girdata; - _tmp793_ = vala_map_get (_tmp792_, "version"); - _tmp794_ = (gchar*) _tmp793_; - vala_version_attribute_set_since (_tmp791_, _tmp794_); - _g_free0 (_tmp794_); - } - } - _tmp795_ = self->parent; - _tmp796_ = _tmp795_->symbol; - if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp796_, VALA_TYPE_NAMESPACE)) { - ValaSymbol* _tmp797_ = NULL; - gchar* _tmp798_ = NULL; - gchar* _tmp799_ = NULL; - _tmp797_ = self->symbol; - _tmp798_ = vala_gir_parser_node_get_cheader_filename (self); - _tmp799_ = _tmp798_; - vala_code_node_set_attribute_string ((ValaCodeNode*) _tmp797_, "CCode", "cheader_filename", _tmp799_, NULL); - _g_free0 (_tmp799_); + if (_tmp789_) { + ValaSymbol* _tmp794_ = NULL; + ValaVersionAttribute* _tmp795_ = NULL; + ValaVersionAttribute* _tmp796_ = NULL; + ValaMap* _tmp797_ = NULL; + gpointer _tmp798_ = NULL; + gchar* _tmp799_ = NULL; + _tmp794_ = self->symbol; + _tmp795_ = vala_symbol_get_version (_tmp794_); + _tmp796_ = _tmp795_; + _tmp797_ = self->girdata; + _tmp798_ = vala_map_get (_tmp797_, "version"); + _tmp799_ = (gchar*) _tmp798_; + vala_version_attribute_set_since (_tmp796_, _tmp799_); + _g_free0 (_tmp799_); + } + } + _tmp800_ = self->parent; + _tmp801_ = _tmp800_->symbol; + if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp801_, VALA_TYPE_NAMESPACE)) { + ValaSymbol* _tmp802_ = NULL; + gchar* _tmp803_ = NULL; + gchar* _tmp804_ = NULL; + _tmp802_ = self->symbol; + _tmp803_ = vala_gir_parser_node_get_cheader_filename (self); + _tmp804_ = _tmp803_; + vala_code_node_set_attribute_string ((ValaCodeNode*) _tmp802_, "CCode", "cheader_filename", _tmp804_, NULL); + _g_free0 (_tmp804_); } else { - ValaGirParserMetadata* _tmp800_ = NULL; - gboolean _tmp801_ = FALSE; - _tmp800_ = self->metadata; - _tmp801_ = vala_gir_parser_metadata_has_argument (_tmp800_, VALA_GIR_PARSER_ARGUMENT_TYPE_CHEADER_FILENAME); - if (_tmp801_) { - ValaSymbol* _tmp802_ = NULL; - ValaGirParserMetadata* _tmp803_ = NULL; - gchar* _tmp804_ = NULL; - gchar* _tmp805_ = NULL; - _tmp802_ = self->symbol; - _tmp803_ = self->metadata; - _tmp804_ = vala_gir_parser_metadata_get_string (_tmp803_, VALA_GIR_PARSER_ARGUMENT_TYPE_CHEADER_FILENAME); - _tmp805_ = _tmp804_; - vala_code_node_set_attribute_string ((ValaCodeNode*) _tmp802_, "CCode", "cheader_filename", _tmp805_, NULL); - _g_free0 (_tmp805_); - } - } - _tmp806_ = vala_gir_parser_node_get_cname (self); - _tmp807_ = _tmp806_; - _tmp808_ = vala_gir_parser_node_get_default_cname (self); - _tmp809_ = _tmp808_; - _tmp810_ = g_strcmp0 (_tmp807_, _tmp809_) != 0; - _g_free0 (_tmp809_); - _g_free0 (_tmp807_); - if (_tmp810_) { - ValaSymbol* _tmp811_ = NULL; - gchar* _tmp812_ = NULL; - gchar* _tmp813_ = NULL; - _tmp811_ = self->symbol; - _tmp812_ = vala_gir_parser_node_get_cname (self); - _tmp813_ = _tmp812_; - vala_code_node_set_attribute_string ((ValaCodeNode*) _tmp811_, "CCode", "cname", _tmp813_, NULL); - _g_free0 (_tmp813_); - } - _tmp814_ = vala_gir_parser_node_get_lower_case_cprefix (self); - _tmp815_ = _tmp814_; - _tmp816_ = vala_gir_parser_node_get_default_lower_case_cprefix (self); - _tmp817_ = _tmp816_; - _tmp818_ = g_strcmp0 (_tmp815_, _tmp817_) != 0; - _g_free0 (_tmp817_); - _g_free0 (_tmp815_); - if (_tmp818_) { - ValaSymbol* _tmp819_ = NULL; - gchar* _tmp820_ = NULL; - gchar* _tmp821_ = NULL; - _tmp819_ = self->symbol; - _tmp820_ = vala_gir_parser_node_get_lower_case_cprefix (self); - _tmp821_ = _tmp820_; - vala_code_node_set_attribute_string ((ValaCodeNode*) _tmp819_, "CCode", "lower_case_cprefix", _tmp821_, NULL); - _g_free0 (_tmp821_); - } - _tmp822_ = vala_gir_parser_node_get_lower_case_csuffix (self); - _tmp823_ = _tmp822_; - _tmp824_ = vala_gir_parser_node_get_default_lower_case_csuffix (self); - _tmp825_ = _tmp824_; - _tmp826_ = g_strcmp0 (_tmp823_, _tmp825_) != 0; - _g_free0 (_tmp825_); - _g_free0 (_tmp823_); - if (_tmp826_) { - ValaSymbol* _tmp827_ = NULL; - gchar* _tmp828_ = NULL; - gchar* _tmp829_ = NULL; - _tmp827_ = self->symbol; - _tmp828_ = vala_gir_parser_node_get_lower_case_csuffix (self); - _tmp829_ = _tmp828_; - vala_code_node_set_attribute_string ((ValaCodeNode*) _tmp827_, "CCode", "lower_case_csuffix", _tmp829_, NULL); - _g_free0 (_tmp829_); - } - _tmp830_ = vala_gir_parser_node_get_gir_name (self); - gir_name = _tmp830_; - _tmp831_ = vala_gir_parser_node_get_default_gir_name (self); - default_gir_name = _tmp831_; - _tmp834_ = self->symbol; - _tmp835_ = vala_gir_parser_is_container (_tmp834_); - if (_tmp835_) { - ValaSymbol* _tmp836_ = NULL; - _tmp836_ = self->symbol; - _tmp833_ = !G_TYPE_CHECK_INSTANCE_TYPE (_tmp836_, VALA_TYPE_NAMESPACE); + ValaGirParserMetadata* _tmp805_ = NULL; + gboolean _tmp806_ = FALSE; + _tmp805_ = self->metadata; + _tmp806_ = vala_gir_parser_metadata_has_argument (_tmp805_, VALA_GIR_PARSER_ARGUMENT_TYPE_CHEADER_FILENAME); + if (_tmp806_) { + ValaSymbol* _tmp807_ = NULL; + ValaGirParserMetadata* _tmp808_ = NULL; + gchar* _tmp809_ = NULL; + gchar* _tmp810_ = NULL; + _tmp807_ = self->symbol; + _tmp808_ = self->metadata; + _tmp809_ = vala_gir_parser_metadata_get_string (_tmp808_, VALA_GIR_PARSER_ARGUMENT_TYPE_CHEADER_FILENAME); + _tmp810_ = _tmp809_; + vala_code_node_set_attribute_string ((ValaCodeNode*) _tmp807_, "CCode", "cheader_filename", _tmp810_, NULL); + _g_free0 (_tmp810_); + } + } + _tmp811_ = vala_gir_parser_node_get_cname (self); + _tmp812_ = _tmp811_; + _tmp813_ = vala_gir_parser_node_get_default_cname (self); + _tmp814_ = _tmp813_; + _tmp815_ = g_strcmp0 (_tmp812_, _tmp814_) != 0; + _g_free0 (_tmp814_); + _g_free0 (_tmp812_); + if (_tmp815_) { + ValaSymbol* _tmp816_ = NULL; + gchar* _tmp817_ = NULL; + gchar* _tmp818_ = NULL; + _tmp816_ = self->symbol; + _tmp817_ = vala_gir_parser_node_get_cname (self); + _tmp818_ = _tmp817_; + vala_code_node_set_attribute_string ((ValaCodeNode*) _tmp816_, "CCode", "cname", _tmp818_, NULL); + _g_free0 (_tmp818_); + } + _tmp819_ = vala_gir_parser_node_get_lower_case_cprefix (self); + _tmp820_ = _tmp819_; + _tmp821_ = vala_gir_parser_node_get_default_lower_case_cprefix (self); + _tmp822_ = _tmp821_; + _tmp823_ = g_strcmp0 (_tmp820_, _tmp822_) != 0; + _g_free0 (_tmp822_); + _g_free0 (_tmp820_); + if (_tmp823_) { + ValaSymbol* _tmp824_ = NULL; + gchar* _tmp825_ = NULL; + gchar* _tmp826_ = NULL; + _tmp824_ = self->symbol; + _tmp825_ = vala_gir_parser_node_get_lower_case_cprefix (self); + _tmp826_ = _tmp825_; + vala_code_node_set_attribute_string ((ValaCodeNode*) _tmp824_, "CCode", "lower_case_cprefix", _tmp826_, NULL); + _g_free0 (_tmp826_); + } + _tmp827_ = vala_gir_parser_node_get_lower_case_csuffix (self); + _tmp828_ = _tmp827_; + _tmp829_ = vala_gir_parser_node_get_default_lower_case_csuffix (self); + _tmp830_ = _tmp829_; + _tmp831_ = g_strcmp0 (_tmp828_, _tmp830_) != 0; + _g_free0 (_tmp830_); + _g_free0 (_tmp828_); + if (_tmp831_) { + ValaSymbol* _tmp832_ = NULL; + gchar* _tmp833_ = NULL; + gchar* _tmp834_ = NULL; + _tmp832_ = self->symbol; + _tmp833_ = vala_gir_parser_node_get_lower_case_csuffix (self); + _tmp834_ = _tmp833_; + vala_code_node_set_attribute_string ((ValaCodeNode*) _tmp832_, "CCode", "lower_case_csuffix", _tmp834_, NULL); + _g_free0 (_tmp834_); + } + _tmp835_ = vala_gir_parser_node_get_gir_name (self); + gir_name = _tmp835_; + _tmp836_ = vala_gir_parser_node_get_default_gir_name (self); + default_gir_name = _tmp836_; + _tmp839_ = self->symbol; + _tmp840_ = vala_gir_parser_is_container (_tmp839_); + if (_tmp840_) { + ValaSymbol* _tmp841_ = NULL; + _tmp841_ = self->symbol; + _tmp838_ = !G_TYPE_CHECK_INSTANCE_TYPE (_tmp841_, VALA_TYPE_NAMESPACE); } else { - _tmp833_ = FALSE; + _tmp838_ = FALSE; } - if (_tmp833_) { - gboolean _tmp837_ = FALSE; - const gchar* _tmp838_ = NULL; - const gchar* _tmp839_ = NULL; - _tmp838_ = self->name; - _tmp839_ = gir_name; - if (g_strcmp0 (_tmp838_, _tmp839_) != 0) { - _tmp837_ = TRUE; + if (_tmp838_) { + gboolean _tmp842_ = FALSE; + const gchar* _tmp843_ = NULL; + const gchar* _tmp844_ = NULL; + _tmp843_ = self->name; + _tmp844_ = gir_name; + if (g_strcmp0 (_tmp843_, _tmp844_) != 0) { + _tmp842_ = TRUE; } else { - const gchar* _tmp840_ = NULL; - const gchar* _tmp841_ = NULL; - _tmp840_ = gir_name; - _tmp841_ = default_gir_name; - _tmp837_ = g_strcmp0 (_tmp840_, _tmp841_) != 0; + const gchar* _tmp845_ = NULL; + const gchar* _tmp846_ = NULL; + _tmp845_ = gir_name; + _tmp846_ = default_gir_name; + _tmp842_ = g_strcmp0 (_tmp845_, _tmp846_) != 0; } - _tmp832_ = _tmp837_; + _tmp837_ = _tmp842_; } else { - _tmp832_ = FALSE; + _tmp837_ = FALSE; } - if (_tmp832_) { - ValaSymbol* _tmp842_ = NULL; - const gchar* _tmp843_ = NULL; - _tmp842_ = self->symbol; - _tmp843_ = gir_name; - vala_code_node_set_attribute_string ((ValaCodeNode*) _tmp842_, "GIR", "name", _tmp843_, NULL); + if (_tmp837_) { + ValaSymbol* _tmp847_ = NULL; + const gchar* _tmp848_ = NULL; + _tmp847_ = self->symbol; + _tmp848_ = gir_name; + vala_code_node_set_attribute_string ((ValaCodeNode*) _tmp847_, "GIR", "name", _tmp848_, NULL); } _g_free0 (default_gir_name); _g_free0 (gir_name); } - _tmp846_ = self->new_symbol; - if (_tmp846_) { - gboolean _tmp847_ = FALSE; - _tmp847_ = self->merged; - _tmp845_ = _tmp847_; - } else { - _tmp845_ = FALSE; - } - if (!_tmp845_) { - ValaSymbol* _tmp848_ = NULL; - gboolean _tmp849_ = FALSE; - _tmp848_ = self->symbol; - _tmp849_ = vala_gir_parser_is_container (_tmp848_); - _tmp844_ = _tmp849_; + _tmp851_ = self->new_symbol; + if (_tmp851_) { + gboolean _tmp852_ = FALSE; + _tmp852_ = self->merged; + _tmp850_ = _tmp852_; + } else { + _tmp850_ = FALSE; + } + if (!_tmp850_) { + ValaSymbol* _tmp853_ = NULL; + gboolean _tmp854_ = FALSE; + _tmp853_ = self->symbol; + _tmp854_ = vala_gir_parser_is_container (_tmp853_); + _tmp849_ = _tmp854_; } else { - _tmp844_ = FALSE; + _tmp849_ = FALSE; } - if (_tmp844_) { + if (_tmp849_) { ValaClass* cl = NULL; - ValaSymbol* _tmp904_ = NULL; - ValaClass* _tmp905_ = NULL; - gboolean _tmp906_ = FALSE; - gboolean _tmp907_ = FALSE; - ValaClass* _tmp908_ = NULL; + ValaSymbol* _tmp909_ = NULL; + ValaClass* _tmp910_ = NULL; + gboolean _tmp911_ = FALSE; + gboolean _tmp912_ = FALSE; + ValaClass* _tmp913_ = NULL; { ValaArrayList* _node_list = NULL; - ValaArrayList* _tmp850_ = NULL; - ValaArrayList* _tmp851_ = NULL; + ValaArrayList* _tmp855_ = NULL; + ValaArrayList* _tmp856_ = NULL; gint _node_size = 0; - ValaArrayList* _tmp852_ = NULL; - gint _tmp853_ = 0; - gint _tmp854_ = 0; + ValaArrayList* _tmp857_ = NULL; + gint _tmp858_ = 0; + gint _tmp859_ = 0; gint _node_index = 0; - _tmp850_ = self->members; - _tmp851_ = _vala_iterable_ref0 (_tmp850_); - _node_list = _tmp851_; - _tmp852_ = _node_list; - _tmp853_ = vala_collection_get_size ((ValaCollection*) _tmp852_); - _tmp854_ = _tmp853_; - _node_size = _tmp854_; + _tmp855_ = self->members; + _tmp856_ = _vala_iterable_ref0 (_tmp855_); + _node_list = _tmp856_; + _tmp857_ = _node_list; + _tmp858_ = vala_collection_get_size ((ValaCollection*) _tmp857_); + _tmp859_ = _tmp858_; + _node_size = _tmp859_; _node_index = -1; while (TRUE) { - gint _tmp855_ = 0; - gint _tmp856_ = 0; - gint _tmp857_ = 0; + gint _tmp860_ = 0; + gint _tmp861_ = 0; + gint _tmp862_ = 0; ValaGirParserNode* node = NULL; - ValaArrayList* _tmp858_ = NULL; - gint _tmp859_ = 0; - gpointer _tmp860_ = NULL; - gboolean _tmp861_ = FALSE; - guint64 _tmp862_ = 0ULL; - ValaGirParserNode* _tmp871_ = NULL; - gboolean _tmp872_ = FALSE; - ValaGirParserNode* _tmp877_ = NULL; - const gchar* _tmp878_ = NULL; - ValaGirParserNode* _tmp885_ = NULL; - const gchar* _tmp886_ = NULL; - gboolean _tmp893_ = FALSE; - gboolean _tmp894_ = FALSE; - ValaGirParserNode* _tmp895_ = NULL; - gboolean _tmp896_ = FALSE; - _tmp855_ = _node_index; - _node_index = _tmp855_ + 1; - _tmp856_ = _node_index; - _tmp857_ = _node_size; - if (!(_tmp856_ < _tmp857_)) { + ValaArrayList* _tmp863_ = NULL; + gint _tmp864_ = 0; + gpointer _tmp865_ = NULL; + gboolean _tmp866_ = FALSE; + guint64 _tmp867_ = 0ULL; + ValaGirParserNode* _tmp876_ = NULL; + gboolean _tmp877_ = FALSE; + ValaGirParserNode* _tmp882_ = NULL; + const gchar* _tmp883_ = NULL; + ValaGirParserNode* _tmp890_ = NULL; + const gchar* _tmp891_ = NULL; + gboolean _tmp898_ = FALSE; + gboolean _tmp899_ = FALSE; + ValaGirParserNode* _tmp900_ = NULL; + gboolean _tmp901_ = FALSE; + _tmp860_ = _node_index; + _node_index = _tmp860_ + 1; + _tmp861_ = _node_index; + _tmp862_ = _node_size; + if (!(_tmp861_ < _tmp862_)) { break; } - _tmp858_ = _node_list; - _tmp859_ = _node_index; - _tmp860_ = vala_list_get ((ValaList*) _tmp858_, _tmp859_); - node = (ValaGirParserNode*) _tmp860_; - _tmp862_ = self->deprecated_version; - if (_tmp862_ > ((guint64) 0)) { - ValaGirParserNode* _tmp863_ = NULL; - guint64 _tmp864_ = 0ULL; - _tmp863_ = node; - _tmp864_ = _tmp863_->deprecated_version; - _tmp861_ = _tmp864_ > ((guint64) 0); + _tmp863_ = _node_list; + _tmp864_ = _node_index; + _tmp865_ = vala_list_get ((ValaList*) _tmp863_, _tmp864_); + node = (ValaGirParserNode*) _tmp865_; + _tmp867_ = self->deprecated_version; + if (_tmp867_ > ((guint64) 0)) { + ValaGirParserNode* _tmp868_ = NULL; + guint64 _tmp869_ = 0ULL; + _tmp868_ = node; + _tmp869_ = _tmp868_->deprecated_version; + _tmp866_ = _tmp869_ > ((guint64) 0); } else { - _tmp861_ = FALSE; + _tmp866_ = FALSE; } - if (_tmp861_) { - guint64 _tmp865_ = 0ULL; - ValaGirParserNode* _tmp866_ = NULL; - guint64 _tmp867_ = 0ULL; - _tmp865_ = self->deprecated_version; - _tmp866_ = node; - _tmp867_ = _tmp866_->deprecated_version; - if (_tmp865_ <= _tmp867_) { - ValaGirParserNode* _tmp868_ = NULL; - ValaGirParserNode* _tmp869_ = NULL; - ValaGirParserNode* _tmp870_ = NULL; - _tmp868_ = node; - _tmp868_->deprecated = FALSE; - _tmp869_ = node; - _g_free0 (_tmp869_->deprecated_since); - _tmp869_->deprecated_since = NULL; - _tmp870_ = node; - _g_free0 (_tmp870_->deprecated_replacement); - _tmp870_->deprecated_replacement = NULL; - } - } - _tmp871_ = node; - _tmp872_ = _tmp871_->deprecated; - if (_tmp872_) { - ValaGirParserNode* _tmp873_ = NULL; - ValaSymbol* _tmp874_ = NULL; - ValaVersionAttribute* _tmp875_ = NULL; - ValaVersionAttribute* _tmp876_ = NULL; - _tmp873_ = node; - _tmp874_ = _tmp873_->symbol; - _tmp875_ = vala_symbol_get_version (_tmp874_); - _tmp876_ = _tmp875_; - vala_version_attribute_set_deprecated (_tmp876_, TRUE); - } - _tmp877_ = node; - _tmp878_ = _tmp877_->deprecated_since; - if (_tmp878_ != NULL) { - ValaGirParserNode* _tmp879_ = NULL; - ValaSymbol* _tmp880_ = NULL; + if (_tmp866_) { + guint64 _tmp870_ = 0ULL; + ValaGirParserNode* _tmp871_ = NULL; + guint64 _tmp872_ = 0ULL; + _tmp870_ = self->deprecated_version; + _tmp871_ = node; + _tmp872_ = _tmp871_->deprecated_version; + if (_tmp870_ <= _tmp872_) { + ValaGirParserNode* _tmp873_ = NULL; + ValaGirParserNode* _tmp874_ = NULL; + ValaGirParserNode* _tmp875_ = NULL; + _tmp873_ = node; + _tmp873_->deprecated = FALSE; + _tmp874_ = node; + _g_free0 (_tmp874_->deprecated_since); + _tmp874_->deprecated_since = NULL; + _tmp875_ = node; + _g_free0 (_tmp875_->deprecated_replacement); + _tmp875_->deprecated_replacement = NULL; + } + } + _tmp876_ = node; + _tmp877_ = _tmp876_->deprecated; + if (_tmp877_) { + ValaGirParserNode* _tmp878_ = NULL; + ValaSymbol* _tmp879_ = NULL; + ValaVersionAttribute* _tmp880_ = NULL; ValaVersionAttribute* _tmp881_ = NULL; - ValaVersionAttribute* _tmp882_ = NULL; - ValaGirParserNode* _tmp883_ = NULL; - const gchar* _tmp884_ = NULL; - _tmp879_ = node; - _tmp880_ = _tmp879_->symbol; - _tmp881_ = vala_symbol_get_version (_tmp880_); - _tmp882_ = _tmp881_; - _tmp883_ = node; - _tmp884_ = _tmp883_->deprecated_since; - vala_version_attribute_set_deprecated_since (_tmp882_, _tmp884_); - } - _tmp885_ = node; - _tmp886_ = _tmp885_->deprecated_replacement; - if (_tmp886_ != NULL) { - ValaGirParserNode* _tmp887_ = NULL; - ValaSymbol* _tmp888_ = NULL; - ValaVersionAttribute* _tmp889_ = NULL; - ValaVersionAttribute* _tmp890_ = NULL; - ValaGirParserNode* _tmp891_ = NULL; - const gchar* _tmp892_ = NULL; - _tmp887_ = node; - _tmp888_ = _tmp887_->symbol; - _tmp889_ = vala_symbol_get_version (_tmp888_); - _tmp890_ = _tmp889_; - _tmp891_ = node; - _tmp892_ = _tmp891_->deprecated_replacement; - vala_version_attribute_set_replacement (_tmp890_, _tmp892_); - } - _tmp895_ = node; - _tmp896_ = _tmp895_->new_symbol; - if (_tmp896_) { - ValaGirParserNode* _tmp897_ = NULL; - gboolean _tmp898_ = FALSE; - _tmp897_ = node; - _tmp898_ = _tmp897_->merged; - _tmp894_ = !_tmp898_; + _tmp878_ = node; + _tmp879_ = _tmp878_->symbol; + _tmp880_ = vala_symbol_get_version (_tmp879_); + _tmp881_ = _tmp880_; + vala_version_attribute_set_deprecated (_tmp881_, TRUE); + } + _tmp882_ = node; + _tmp883_ = _tmp882_->deprecated_since; + if (_tmp883_ != NULL) { + ValaGirParserNode* _tmp884_ = NULL; + ValaSymbol* _tmp885_ = NULL; + ValaVersionAttribute* _tmp886_ = NULL; + ValaVersionAttribute* _tmp887_ = NULL; + ValaGirParserNode* _tmp888_ = NULL; + const gchar* _tmp889_ = NULL; + _tmp884_ = node; + _tmp885_ = _tmp884_->symbol; + _tmp886_ = vala_symbol_get_version (_tmp885_); + _tmp887_ = _tmp886_; + _tmp888_ = node; + _tmp889_ = _tmp888_->deprecated_since; + vala_version_attribute_set_deprecated_since (_tmp887_, _tmp889_); + } + _tmp890_ = node; + _tmp891_ = _tmp890_->deprecated_replacement; + if (_tmp891_ != NULL) { + ValaGirParserNode* _tmp892_ = NULL; + ValaSymbol* _tmp893_ = NULL; + ValaVersionAttribute* _tmp894_ = NULL; + ValaVersionAttribute* _tmp895_ = NULL; + ValaGirParserNode* _tmp896_ = NULL; + const gchar* _tmp897_ = NULL; + _tmp892_ = node; + _tmp893_ = _tmp892_->symbol; + _tmp894_ = vala_symbol_get_version (_tmp893_); + _tmp895_ = _tmp894_; + _tmp896_ = node; + _tmp897_ = _tmp896_->deprecated_replacement; + vala_version_attribute_set_replacement (_tmp895_, _tmp897_); + } + _tmp900_ = node; + _tmp901_ = _tmp900_->new_symbol; + if (_tmp901_) { + ValaGirParserNode* _tmp902_ = NULL; + gboolean _tmp903_ = FALSE; + _tmp902_ = node; + _tmp903_ = _tmp902_->merged; + _tmp899_ = !_tmp903_; } else { - _tmp894_ = FALSE; + _tmp899_ = FALSE; } - if (_tmp894_) { - ValaGirParserMetadata* _tmp899_ = NULL; - gboolean _tmp900_ = FALSE; - _tmp899_ = self->metadata; - _tmp900_ = vala_gir_parser_metadata_get_bool (_tmp899_, VALA_GIR_PARSER_ARGUMENT_TYPE_HIDDEN, FALSE); - _tmp893_ = !_tmp900_; + if (_tmp899_) { + ValaGirParserMetadata* _tmp904_ = NULL; + gboolean _tmp905_ = FALSE; + _tmp904_ = self->metadata; + _tmp905_ = vala_gir_parser_metadata_get_bool (_tmp904_, VALA_GIR_PARSER_ARGUMENT_TYPE_HIDDEN, FALSE); + _tmp898_ = !_tmp905_; } else { - _tmp893_ = FALSE; + _tmp898_ = FALSE; } - if (_tmp893_) { - ValaSymbol* _tmp901_ = NULL; - ValaGirParserNode* _tmp902_ = NULL; - ValaSymbol* _tmp903_ = NULL; - _tmp901_ = self->symbol; - _tmp902_ = node; - _tmp903_ = _tmp902_->symbol; - vala_gir_parser_add_symbol_to_container (_tmp901_, _tmp903_); + if (_tmp898_) { + ValaSymbol* _tmp906_ = NULL; + ValaGirParserNode* _tmp907_ = NULL; + ValaSymbol* _tmp908_ = NULL; + _tmp906_ = self->symbol; + _tmp907_ = node; + _tmp908_ = _tmp907_->symbol; + vala_gir_parser_add_symbol_to_container (_tmp906_, _tmp908_); } _vala_gir_parser_node_unref0 (node); } _vala_iterable_unref0 (_node_list); } - _tmp904_ = self->symbol; - _tmp905_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp904_, VALA_TYPE_CLASS) ? ((ValaClass*) _tmp904_) : NULL); - cl = _tmp905_; - _tmp908_ = cl; - if (_tmp908_ != NULL) { - ValaClass* _tmp909_ = NULL; - gboolean _tmp910_ = FALSE; - gboolean _tmp911_ = FALSE; - _tmp909_ = cl; - _tmp910_ = vala_class_get_is_compact (_tmp909_); - _tmp911_ = _tmp910_; - _tmp907_ = !_tmp911_; + _tmp909_ = self->symbol; + _tmp910_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp909_, VALA_TYPE_CLASS) ? ((ValaClass*) _tmp909_) : NULL); + cl = _tmp910_; + _tmp913_ = cl; + if (_tmp913_ != NULL) { + ValaClass* _tmp914_ = NULL; + gboolean _tmp915_ = FALSE; + gboolean _tmp916_ = FALSE; + _tmp914_ = cl; + _tmp915_ = vala_class_get_is_compact (_tmp914_); + _tmp916_ = _tmp915_; + _tmp912_ = !_tmp916_; } else { - _tmp907_ = FALSE; + _tmp912_ = FALSE; } - if (_tmp907_) { - ValaClass* _tmp912_ = NULL; - ValaCreationMethod* _tmp913_ = NULL; - ValaCreationMethod* _tmp914_ = NULL; - _tmp912_ = cl; - _tmp913_ = vala_class_get_default_construction_method (_tmp912_); - _tmp914_ = _tmp913_; - _tmp906_ = _tmp914_ == NULL; + if (_tmp912_) { + ValaClass* _tmp917_ = NULL; + ValaCreationMethod* _tmp918_ = NULL; + ValaCreationMethod* _tmp919_ = NULL; + _tmp917_ = cl; + _tmp918_ = vala_class_get_default_construction_method (_tmp917_); + _tmp919_ = _tmp918_; + _tmp911_ = _tmp919_ == NULL; } else { - _tmp906_ = FALSE; + _tmp911_ = FALSE; } - if (_tmp906_) { + if (_tmp911_) { ValaCreationMethod* cm = NULL; - ValaClass* _tmp915_ = NULL; - ValaSourceReference* _tmp916_ = NULL; - ValaSourceReference* _tmp917_ = NULL; - ValaCreationMethod* _tmp918_ = NULL; - ValaCreationMethod* _tmp919_ = NULL; - ValaCreationMethod* _tmp920_ = NULL; - ValaClass* _tmp921_ = NULL; - ValaCreationMethod* _tmp922_ = NULL; - _tmp915_ = cl; - _tmp916_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp915_); - _tmp917_ = _tmp916_; - _tmp918_ = vala_creation_method_new (NULL, NULL, _tmp917_, NULL); - cm = _tmp918_; - _tmp919_ = cm; - vala_method_set_has_construct_function ((ValaMethod*) _tmp919_, FALSE); - _tmp920_ = cm; - vala_symbol_set_access ((ValaSymbol*) _tmp920_, VALA_SYMBOL_ACCESSIBILITY_PROTECTED); - _tmp921_ = cl; - _tmp922_ = cm; - vala_symbol_add_method ((ValaSymbol*) _tmp921_, (ValaMethod*) _tmp922_); + ValaClass* _tmp920_ = NULL; + ValaSourceReference* _tmp921_ = NULL; + ValaSourceReference* _tmp922_ = NULL; + ValaCreationMethod* _tmp923_ = NULL; + ValaCreationMethod* _tmp924_ = NULL; + ValaCreationMethod* _tmp925_ = NULL; + ValaClass* _tmp926_ = NULL; + ValaCreationMethod* _tmp927_ = NULL; + _tmp920_ = cl; + _tmp921_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp920_); + _tmp922_ = _tmp921_; + _tmp923_ = vala_creation_method_new (NULL, NULL, _tmp922_, NULL); + cm = _tmp923_; + _tmp924_ = cm; + vala_method_set_has_construct_function ((ValaMethod*) _tmp924_, FALSE); + _tmp925_ = cm; + vala_symbol_set_access ((ValaSymbol*) _tmp925_, VALA_SYMBOL_ACCESSIBILITY_PROTECTED); + _tmp926_ = cl; + _tmp927_ = cm; + vala_symbol_add_method ((ValaSymbol*) _tmp926_, (ValaMethod*) _tmp927_); _vala_code_node_unref0 (cm); } _vala_code_node_unref0 (cl); diff -Nru vala-0.34.6/vala/valagirparser.vala vala-0.34.7/vala/valagirparser.vala --- vala-0.34.6/vala/valagirparser.vala 2017-03-07 08:23:50.000000000 +0000 +++ vala-0.34.7/vala/valagirparser.vala 2017-03-20 21:24:57.000000000 +0000 @@ -81,6 +81,7 @@ FLOATING, TYPE_ID, RETURN_VOID, + RETURNS_MODIFIED_POINTER, DELEGATE_TARGET_CNAME, FINISH_VFUNC_NAME; @@ -921,6 +922,9 @@ if (metadata.has_argument (ArgumentType.DESTROYS_INSTANCE)) { m.set_attribute ("DestroysInstance", metadata.get_bool (ArgumentType.DESTROYS_INSTANCE)); } + if (metadata.has_argument (ArgumentType.RETURNS_MODIFIED_POINTER)) { + m.set_attribute ("ReturnsModifiedPointer", metadata.get_bool (ArgumentType.RETURNS_MODIFIED_POINTER)); + } // merge custom vfunc if (metadata.has_argument (ArgumentType.VFUNC_NAME)) { var vfunc = parent.lookup (metadata.get_string (ArgumentType.VFUNC_NAME)); diff -Nru vala-0.34.6/vala/valamemberaccess.c vala-0.34.7/vala/valamemberaccess.c --- vala-0.34.6/vala/valamemberaccess.c 2017-03-07 09:39:33.000000000 +0000 +++ vala-0.34.7/vala/valamemberaccess.c 2017-03-20 21:30:43.000000000 +0000 @@ -208,6 +208,16 @@ #define VALA_TYPE_MEMBER_BINDING (vala_member_binding_get_type ()) +#define VALA_TYPE_ENUM_VALUE (vala_enum_value_get_type ()) +#define VALA_ENUM_VALUE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_ENUM_VALUE, ValaEnumValue)) +#define VALA_ENUM_VALUE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_ENUM_VALUE, ValaEnumValueClass)) +#define VALA_IS_ENUM_VALUE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_ENUM_VALUE)) +#define VALA_IS_ENUM_VALUE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_ENUM_VALUE)) +#define VALA_ENUM_VALUE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_ENUM_VALUE, ValaEnumValueClass)) + +typedef struct _ValaEnumValue ValaEnumValue; +typedef struct _ValaEnumValueClass ValaEnumValueClass; + #define VALA_TYPE_PARAMETER (vala_parameter_get_type ()) #define VALA_PARAMETER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_PARAMETER, ValaParameter)) #define VALA_PARAMETER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_PARAMETER, ValaParameterClass)) @@ -309,16 +319,6 @@ typedef struct _ValaEnum ValaEnum; typedef struct _ValaEnumClass ValaEnumClass; -#define VALA_TYPE_ENUM_VALUE (vala_enum_value_get_type ()) -#define VALA_ENUM_VALUE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_ENUM_VALUE, ValaEnumValue)) -#define VALA_ENUM_VALUE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_ENUM_VALUE, ValaEnumValueClass)) -#define VALA_IS_ENUM_VALUE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_ENUM_VALUE)) -#define VALA_IS_ENUM_VALUE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_ENUM_VALUE)) -#define VALA_ENUM_VALUE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_ENUM_VALUE, ValaEnumValueClass)) - -typedef struct _ValaEnumValue ValaEnumValue; -typedef struct _ValaEnumValueClass ValaEnumValueClass; - #define VALA_TYPE_ERROR_DOMAIN (vala_error_domain_get_type ()) #define VALA_ERROR_DOMAIN(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_ERROR_DOMAIN, ValaErrorDomain)) #define VALA_ERROR_DOMAIN_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_ERROR_DOMAIN, ValaErrorDomainClass)) @@ -1449,6 +1449,7 @@ ValaMemberBinding vala_method_get_binding (ValaMethod* self); gboolean vala_member_access_get_prototype_access (ValaMemberAccess* self); static gboolean vala_member_access_real_is_non_null (ValaExpression* base); +GType vala_enum_value_get_type (void) G_GNUC_CONST; ValaDataType* vala_constant_get_type_reference (ValaConstant* self); gboolean vala_data_type_get_nullable (ValaDataType* self); static gboolean vala_member_access_real_check (ValaCodeNode* base, ValaCodeContext* context); @@ -1475,7 +1476,6 @@ GType vala_struct_get_type (void) G_GNUC_CONST; GType vala_interface_get_type (void) G_GNUC_CONST; GType vala_enum_get_type (void) G_GNUC_CONST; -GType vala_enum_value_get_type (void) G_GNUC_CONST; GType vala_error_domain_get_type (void) G_GNUC_CONST; GType vala_error_code_get_type (void) G_GNUC_CONST; GType vala_delegate_get_type (void) G_GNUC_CONST; @@ -2190,17 +2190,25 @@ c = _tmp2_; _tmp3_ = c; if (_tmp3_ != NULL) { - ValaConstant* _tmp4_ = NULL; - ValaDataType* _tmp5_ = NULL; - ValaDataType* _tmp6_ = NULL; - gboolean _tmp7_ = FALSE; - gboolean _tmp8_ = FALSE; - _tmp4_ = c; - _tmp5_ = vala_constant_get_type_reference (_tmp4_); - _tmp6_ = _tmp5_; - _tmp7_ = vala_data_type_get_nullable (_tmp6_); - _tmp8_ = _tmp7_; - result = !_tmp8_; + gboolean _tmp4_ = FALSE; + ValaConstant* _tmp5_ = NULL; + _tmp5_ = c; + if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp5_, VALA_TYPE_ENUM_VALUE)) { + _tmp4_ = TRUE; + } else { + ValaConstant* _tmp6_ = NULL; + ValaDataType* _tmp7_ = NULL; + ValaDataType* _tmp8_ = NULL; + gboolean _tmp9_ = FALSE; + gboolean _tmp10_ = FALSE; + _tmp6_ = c; + _tmp7_ = vala_constant_get_type_reference (_tmp6_); + _tmp8_ = _tmp7_; + _tmp9_ = vala_data_type_get_nullable (_tmp8_); + _tmp10_ = _tmp9_; + _tmp4_ = !_tmp10_; + } + result = _tmp4_; _vala_code_node_unref0 (c); return result; } else { diff -Nru vala-0.34.6/vala/valamemberaccess.vala vala-0.34.7/vala/valamemberaccess.vala --- vala-0.34.6/vala/valamemberaccess.vala 2017-03-07 08:23:50.000000000 +0000 +++ vala-0.34.7/vala/valamemberaccess.vala 2017-03-20 21:24:57.000000000 +0000 @@ -183,7 +183,7 @@ public override bool is_non_null () { var c = symbol_reference as Constant; if (c != null) { - return !c.type_reference.nullable; + return (c is EnumValue || !c.type_reference.nullable); } else { return false; } diff -Nru vala-0.34.6/vapi/enchant.vapi vala-0.34.7/vapi/enchant.vapi --- vala-0.34.6/vapi/enchant.vapi 2017-03-02 09:33:15.000000000 +0000 +++ vala-0.34.7/vapi/enchant.vapi 2017-03-20 18:51:50.000000000 +0000 @@ -1,5 +1,7 @@ -[CCode (cname_prefix = "enchant_", cheader_filename = "enchant.h")] +[CCode (cheader_filename = "enchant.h")] namespace Enchant { + public unowned string get_version (); + public delegate void BrokerDescribeFn (string provider_name, string provider_desc, string provider_dll_file); public delegate void DictDescribeFn (string lang_tag, string provider_name, string provider_desc, string provider_file); @@ -22,6 +24,7 @@ [Compact] public class Dict { public int check (string word, long len = -1); + [CCode (array_length_type = "size_t")] public unowned string[] suggest (string word, long len = -1); public void free_string_list ([CCode (array_length = false)] string[] string_list); public void add_to_session (string word, long len = -1); diff -Nru vala-0.34.6/vapi/gio-2.0.vapi vala-0.34.7/vapi/gio-2.0.vapi --- vala-0.34.6/vapi/gio-2.0.vapi 2017-03-07 08:23:50.000000000 +0000 +++ vala-0.34.7/vapi/gio-2.0.vapi 2017-03-20 21:24:57.000000000 +0000 @@ -1375,6 +1375,8 @@ public const string PROXY; [CCode (cheader_filename = "gio/gio.h", cname = "G_PROXY_RESOLVER_EXTENSION_POINT_NAME")] public const string PROXY_RESOLVER; + [CCode (cheader_filename = "gio/gio.h", cname = "G_SETTINGS_BACKEND_EXTENSION_POINT_NAME")] + public const string SETTINGS_BACKEND; [CCode (cheader_filename = "gio/gio.h", cname = "G_TLS_BACKEND_EXTENSION_POINT_NAME")] public const string TLS_BACKEND; [CCode (cheader_filename = "gio/gio.h", cname = "G_VFS_EXTENSION_POINT_NAME")] @@ -2032,7 +2034,7 @@ public unowned GLib.Resource @ref (); public void unref (); } - [CCode (cheader_filename = "gio/gio.h")] + [CCode (cheader_filename = "gio/gio.h", type_id = "g_settings_get_type ()")] public class Settings : GLib.Object { [CCode (has_construct_function = false)] [Version (since = "2.26")] @@ -2153,15 +2155,57 @@ public string schema_id { owned get; construct; } [NoAccessorMethod] public GLib.SettingsSchema settings_schema { owned get; construct; } - public virtual signal bool change_event (GLib.Quark[]? keys); + public virtual signal bool change_event ([CCode (array_length_cname = "n_keys", array_length_pos = 1.1)] GLib.Quark[]? keys); public virtual signal void changed (string key); public virtual signal bool writable_change_event (uint key); public virtual signal void writable_changed (string key); } - [CCode (cheader_filename = "gio/gio.h")] - public class SettingsBackend : GLib.Object { + [CCode (cheader_filename = "gio/gio.h", type_id = "g_settings_backend_get_type ()")] + public abstract class SettingsBackend : GLib.Object { [CCode (has_construct_function = false)] protected SettingsBackend (); + [Version (since = "2.26")] + public void changed (string key, void* origin_tag); + [Version (since = "2.26")] + public void changed_tree (GLib.Tree tree, void* origin_tag); + [Version (since = "2.26")] + public static void flatten_tree (GLib.Tree tree, out string path, [CCode (array_length = false, array_null_terminated = true)] out (unowned string)[] keys, [CCode (array_length = false, array_null_terminated = true)] out (unowned GLib.Variant)[] values); + [Version (since = "2.28")] + public static GLib.SettingsBackend get_default (); + [NoWrapper] + public virtual bool get_writable (string key); + [CCode (cheader_filename = "gio/gio.h", cname = "g_keyfile_settings_backend_new")] + public static GLib.SettingsBackend keyfile_settings_backend_new (string filename, string root_path, string? root_group); + [Version (since = "2.26")] + public void keys_changed (string path, [CCode (array_length = false, array_null_terminated = true)] string[] items, void* origin_tag); + [CCode (cheader_filename = "gio/gio.h", cname = "g_memory_settings_backend_new")] + [Version (since = "2.28")] + public static GLib.SettingsBackend memory_settings_backend_new (); + [CCode (cheader_filename = "gio/gio.h", cname = "g_null_settings_backend_new")] + [Version (since = "2.28")] + public static GLib.SettingsBackend null_settings_backend_new (); + [Version (since = "2.26")] + public void path_changed (string path, void* origin_tag); + [Version (since = "2.26")] + public void path_writable_changed (string path); + [NoWrapper] + public virtual GLib.Variant read (string key, GLib.VariantType expected_type, bool default_value); + [NoWrapper] + public virtual GLib.Variant read_user_value (string key, GLib.VariantType expected_type); + [NoWrapper] + public virtual void reset (string key, void* origin_tag); + [NoWrapper] + public virtual void subscribe (string name); + [NoWrapper] + public virtual void sync (); + [NoWrapper] + public virtual void unsubscribe (string name); + [Version (since = "2.26")] + public void writable_changed (string key); + [NoWrapper] + public virtual bool write (string key, GLib.Variant value, void* origin_tag); + [NoWrapper] + public virtual bool write_tree (GLib.Tree tree, void* origin_tag); } [CCode (cheader_filename = "gio/gio.h", ref_function = "g_settings_schema_ref", type_id = "g_settings_schema_get_type ()", unref_function = "g_settings_schema_unref")] [Compact] @@ -2674,6 +2718,8 @@ [Version (since = "2.36")] public async Task (GLib.Object? source_object, GLib.Cancellable? cancellable = null); [Version (since = "2.36")] + public void attach_source (GLib.Source source, [CCode (type = "GSourceFunc")] GLib.TaskSourceFunc callback); + [Version (since = "2.36")] public unowned GLib.Cancellable get_cancellable (); [Version (since = "2.36")] public bool get_check_cancellable (); @@ -2701,6 +2747,9 @@ public void* propagate_pointer () throws GLib.Error; [Version (since = "2.36")] public static async void report_error (GLib.Object? source_object, void* source_tag, owned GLib.Error error); + [PrintfFormat] + [Version (since = "2.36")] + public static async void report_new_error (GLib.Object? source_object, void* source_tag, GLib.Quark domain, int code, string format, ...); [Version (since = "2.36")] public void return_boolean (bool result); [Version (since = "2.36")] @@ -2709,9 +2758,16 @@ public bool return_error_if_cancelled (); [Version (since = "2.36")] public void return_int (ssize_t result); + [PrintfFormat] + [Version (since = "2.36")] + public void return_new_error (GLib.Quark domain, int code, string format, ...); [Version (since = "2.36")] public void return_pointer (owned void* result, GLib.DestroyNotify? result_destroy); [Version (since = "2.36")] + public void run_in_thread (GLib.TaskThreadFunc task_func); + [Version (since = "2.36")] + public void run_in_thread_sync (GLib.TaskThreadFunc task_func); + [Version (since = "2.36")] public void set_check_cancellable (bool check_cancellable); [Version (since = "2.36")] public void set_priority (int priority); @@ -4632,6 +4688,8 @@ [CCode (cheader_filename = "gio/gio.h", instance_pos = 2.9)] [Version (since = "2.22")] public delegate bool SocketSourceFunc (GLib.Socket socket, GLib.IOCondition condition); + [CCode (cheader_filename = "gio/gio.h", cname = "GSourceFunc", has_target = false)] + public delegate bool TaskSourceFunc (GLib.Task task); [CCode (cheader_filename = "gio/gio.h", has_target = false)] [Version (since = "2.36")] public delegate void TaskThreadFunc (GLib.Task task, GLib.Object source_object, void* task_data, GLib.Cancellable? cancellable = null); diff -Nru vala-0.34.6/vapi/gstreamer-1.0.vapi vala-0.34.7/vapi/gstreamer-1.0.vapi --- vala-0.34.6/vapi/gstreamer-1.0.vapi 2017-03-07 08:23:50.000000000 +0000 +++ vala-0.34.7/vapi/gstreamer-1.0.vapi 2017-03-20 21:24:57.000000000 +0000 @@ -1674,6 +1674,7 @@ public T get_qdata (GLib.Quark quark); public bool is_writable (); public bool @lock (Gst.LockFlags flags); + [ReturnsModifiedPointer] public Gst.MiniObject make_writable (); public unowned Gst.MiniObject @ref (); public static bool replace (ref Gst.MiniObject? olddata, Gst.MiniObject? newdata); @@ -2502,6 +2503,7 @@ public bool is_writable (); [Version (since = "1.6")] public Gst.Uri join (Gst.Uri? ref_uri); + [ReturnsModifiedPointer] [Version (since = "1.6")] public Gst.Uri make_writable (); [Version (since = "1.6")] diff -Nru vala-0.34.6/vapi/gstreamer-base-1.0.vapi vala-0.34.7/vapi/gstreamer-base-1.0.vapi --- vala-0.34.6/vapi/gstreamer-base-1.0.vapi 2017-03-07 08:23:50.000000000 +0000 +++ vala-0.34.7/vapi/gstreamer-base-1.0.vapi 2017-03-20 21:24:57.000000000 +0000 @@ -26,8 +26,8 @@ public Gst.BufferList? get_buffer_list (size_t nbytes); [Version (since = "1.6")] public GLib.List? get_list (size_t nbytes); - [CCode (array_length_pos = 0.1, array_length_type = "gsize")] - public unowned uint8[]? map (); + [CCode (array_length = false)] + public unowned uint8[]? map (size_t size); public ssize_t masked_scan_uint32 (uint32 mask, uint32 pattern, size_t offset, size_t size); public ssize_t masked_scan_uint32_peek (uint32 mask, uint32 pattern, size_t offset, size_t size, out uint32 value); [Version (since = "1.10")] @@ -43,8 +43,8 @@ [Version (since = "1.10")] public Gst.ClockTime pts_at_discont (); public void push (owned Gst.Buffer buf); - [CCode (array_length_pos = 0.1, array_length_type = "gsize")] - public uint8[]? take (); + [CCode (array_length = false)] + public uint8[]? take (size_t nbytes); public Gst.Buffer? take_buffer (size_t nbytes); [Version (since = "1.2")] public Gst.Buffer? take_buffer_fast (size_t nbytes); diff -Nru vala-0.34.6/vapi/gstreamer-video-1.0.vapi vala-0.34.7/vapi/gstreamer-video-1.0.vapi --- vala-0.34.6/vapi/gstreamer-video-1.0.vapi 2017-03-07 08:23:50.000000000 +0000 +++ vala-0.34.7/vapi/gstreamer-video-1.0.vapi 2017-03-20 21:24:57.000000000 +0000 @@ -292,6 +292,7 @@ public Gst.Video.OverlayComposition copy (); public unowned Gst.Video.OverlayRectangle get_rectangle (uint n); public uint get_seqnum (); + [ReturnsModifiedPointer] public Gst.Video.OverlayComposition make_writable (); public uint n_rectangles (); } diff -Nru vala-0.34.6/vapi/gtk+-3.0.vapi vala-0.34.7/vapi/gtk+-3.0.vapi --- vala-0.34.6/vapi/gtk+-3.0.vapi 2017-03-07 08:23:50.000000000 +0000 +++ vala-0.34.7/vapi/gtk+-3.0.vapi 2017-03-20 21:24:57.000000000 +0000 @@ -6809,10 +6809,15 @@ public void modify_style (Gtk.RcStyle style); [Version (deprecated_since = "3.0", replacement = "override_color")] public void modify_text (Gtk.StateType state, Gdk.Color? color); + [Version (deprecated_since = "3.16")] public void override_background_color (Gtk.StateFlags state, Gdk.RGBA? color); + [Version (deprecated_since = "3.16")] public void override_color (Gtk.StateFlags state, Gdk.RGBA? color); + [Version (deprecated_since = "3.16")] public void override_cursor (Gdk.RGBA? cursor, Gdk.RGBA? secondary_cursor); + [Version (deprecated_since = "3.16")] public void override_font (Pango.FontDescription? font_desc); + [Version (deprecated_since = "3.16")] public void override_symbolic_color (string name, Gdk.RGBA? color); [Version (deprecated_since = "3.0", replacement = "get_path")] public void path (out uint path_length, out string path, out string path_reversed); diff -Nru vala-0.34.6/vapi/poppler-glib.vapi vala-0.34.7/vapi/poppler-glib.vapi --- vala-0.34.6/vapi/poppler-glib.vapi 2017-03-02 09:33:15.000000000 +0000 +++ vala-0.34.7/vapi/poppler-glib.vapi 2017-03-20 18:51:50.000000000 +0000 @@ -305,27 +305,43 @@ public bool is_linearized (); public bool save (string uri) throws GLib.Error; public bool save_a_copy (string uri) throws GLib.Error; - public string author { owned get; } - public int creation_date { get; } - public string creator { owned get; } + [Version (since = "0.46")] + public void set_author (string author); + [Version (since = "0.46")] + public void set_creation_date (long creation_date); + [Version (since = "0.46")] + public void set_creator (string creator); + [Version (since = "0.46")] + public void set_keywords (string keywords); + [Version (since = "0.46")] + public void set_modification_date (long modification_date); + [Version (since = "0.46")] + public void set_producer (string producer); + [Version (since = "0.46")] + public void set_subject (string subject); + [Version (since = "0.46")] + public void set_title (string title); + public string author { owned get; set; } + public int creation_date { get; set; } + public string creator { owned get; set; } [NoAccessorMethod] public string format { owned get; } [NoAccessorMethod] public uint format_major { get; } [NoAccessorMethod] public uint format_minor { get; } - public string keywords { owned get; } + public string keywords { owned get; set; } [NoAccessorMethod] public bool linearized { get; } public string metadata { owned get; } [NoAccessorMethod] - public int mod_date { get; } + public int mod_date { get; set; } public Poppler.PageLayout page_layout { get; } public Poppler.PageMode page_mode { get; } public Poppler.Permissions permissions { get; } - public string producer { owned get; } - public string subject { owned get; } - public string title { owned get; } + public string producer { owned get; set; } + public string subject { owned get; set; } + public string title { owned get; set; } [NoAccessorMethod] public Poppler.ViewerPreferences viewer_preferences { get; } } @@ -1025,13 +1041,6 @@ MULTILINE, FILE_SELECT } - [CCode (cheader_filename = "poppler.h", cprefix = "POPPLER_ORIENTATION_", type_id = "poppler_orientation_get_type ()")] - public enum Orientation { - PORTRAIT, - LANDSCAPE, - UPSIDEDOWN, - SEASCAPE - } [CCode (cheader_filename = "poppler.h", cprefix = "POPPLER_PAGE_LAYOUT_", type_id = "poppler_page_layout_get_type ()")] public enum PageLayout { UNSET, diff -Nru vala-0.34.6/.version vala-0.34.7/.version --- vala-0.34.6/.version 2017-03-07 09:39:23.000000000 +0000 +++ vala-0.34.7/.version 2017-03-20 21:30:33.000000000 +0000 @@ -1 +1 @@ -0.34.6 +0.34.7