diff -Nru vala-0.56.16/.tarball-version vala-0.56.17/.tarball-version --- vala-0.56.16/.tarball-version 2024-03-14 09:04:45.000000000 +0000 +++ vala-0.56.17/.tarball-version 2024-04-19 11:04:52.000000000 +0000 @@ -1 +1 @@ -0.56.16 +0.56.17 diff -Nru vala-0.56.16/.version vala-0.56.17/.version --- vala-0.56.16/.version 2024-03-14 09:03:13.000000000 +0000 +++ vala-0.56.17/.version 2024-04-19 11:03:16.000000000 +0000 @@ -1 +1 @@ -0.56.16 +0.56.17 diff -Nru vala-0.56.16/ChangeLog vala-0.56.17/ChangeLog --- vala-0.56.16/ChangeLog 2024-03-14 09:04:45.000000000 +0000 +++ vala-0.56.17/ChangeLog 2024-04-19 11:04:52.000000000 +0000 @@ -1,3 +1,65 @@ +2024-04-19 Rico Tzschichholz + + Release 0.56.17 + +2024-04-19 Reuben Thomas + + gnu: add binding for flock(2) and its constants + +2024-04-19 Rico Tzschichholz + + vala: Inherit important attributes for Property backing field + + codegen: Only handle null-terminated array as such if there is no length given + + codegen: Refactor and cache parameter in loop + +2024-04-15 Rico Tzschichholz + + glib-2.0: Add dev_t/gid_t/pid_t/uid_t/socklen_t types for compatibility + Cherry-picked from 935260ceb87a4d744509f5624be9035ab2299de9 + + vala: Report invalid type in property assignment attempt + Fixes https://gitlab.gnome.org/GNOME/vala/issues/1541 + + vala: Point to the invalid initializer on error + +2024-04-15 Reuben Thomas + + glib-2.0: Add SPACING_MARK, deprecate COMBINING_MARK + +2024-04-15 Zhou Qiankang + + glib-2.0: Avoid unnecessary copying operations in FileStream.read_line() + +2024-04-15 Rico Tzschichholz + + codegen: Properly pass through a null-terminated out argument + + codegen: Update array length variable passed to null-terminated ref parameter + Fixes https://gitlab.gnome.org/GNOME/vala/issues/1536 + + tests: Extend off_t/time_t test cases to increase coverage + +2024-03-19 Simon McVittie + + vala: Correctly use Path.build_path() + The first argument to Path.build_path() is a separator, and for it to be + practically useful, at least two subsequent arguments are needed. + + Also to find GIR XML in /usr/share we should make the second argument be + an absolute path. + +2024-03-19 Rico Tzschichholz + + parser: Allow declaration of static nested methods (local functions) + Fixes https://gitlab.gnome.org/GNOME/vala/issues/1533 + + tests: Add -Werror=null-dereference flag + + codegen: Add missing initializers for private fields of GSourceFuncs + Found by -Werror=missing-field-initializers + 2024-03-14 Rico Tzschichholz Release 0.56.16 diff -Nru vala-0.56.16/NEWS vala-0.56.17/NEWS --- vala-0.56.16/NEWS 2024-03-14 09:01:23.000000000 +0000 +++ vala-0.56.17/NEWS 2024-04-19 10:56:48.000000000 +0000 @@ -1,3 +1,25 @@ +Vala 0.56.17 +============ + * Various improvements and bug fixes: + - codegen: + + Add missing initializers for private fields of GSourceFuncs + + Update array length variable passed to null-terminated ref parameter [#1536] + + Properly pass through a null-terminated out argument + + Refactor and cache parameter in loop + + Only handle null-terminated array as such if there is no length given + - vala: + + Allow declaration of static nested methods (local functions) [#1533] + + Correctly use Path.build_path() + + Point to the invalid initializer on error + + Report invalid type in property assignment attempt [#1541] + + Inherit important attributes for Property backing field + + * Bindings: + - glib-2.0: Avoid unnecessary copying operations in FileStream.read_line() + - glib-2.0: Add SPACING_MARK, deprecate COMBINING_MARK + - glib-2.0: Add dev_t/gid_t/pid_t/uid_t/socklen_t types for compatibility + - gnu: add binding for flock(2) and its constants + Vala 0.56.16 ============ * Various improvements and bug fixes: diff -Nru vala-0.56.16/build-aux/ltmain.sh vala-0.56.17/build-aux/ltmain.sh --- vala-0.56.16/build-aux/ltmain.sh 2024-03-14 09:02:56.000000000 +0000 +++ vala-0.56.17/build-aux/ltmain.sh 2024-04-19 11:03:06.000000000 +0000 @@ -31,7 +31,7 @@ PROGRAM=libtool PACKAGE=libtool -VERSION="2.4.7 Debian-2.4.7-7" +VERSION="2.4.7 Debian-2.4.7-7build1" package_revision=2.4.7 @@ -2296,7 +2296,7 @@ compiler: $LTCC compiler flags: $LTCFLAGS linker: $LD (gnu? $with_gnu_ld) - version: $progname $scriptversion Debian-2.4.7-7 + version: $progname $scriptversion Debian-2.4.7-7build1 automake: `($AUTOMAKE --version) 2>/dev/null |$SED 1q` autoconf: `($AUTOCONF --version) 2>/dev/null |$SED 1q` diff -Nru vala-0.56.16/codegen/valaccodedelegatemodule.c vala-0.56.17/codegen/valaccodedelegatemodule.c --- vala-0.56.16/codegen/valaccodedelegatemodule.c 2024-03-14 09:03:36.000000000 +0000 +++ vala-0.56.17/codegen/valaccodedelegatemodule.c 2024-04-19 11:03:37.000000000 +0000 @@ -913,33 +913,33 @@ ValaMemberBinding _tmp207_; ValaMemberBinding _tmp208_; gboolean first = FALSE; - gboolean _tmp369_ = FALSE; - gboolean _tmp416_; - gboolean _tmp417_; + gboolean _tmp354_ = FALSE; + gboolean _tmp401_; + gboolean _tmp402_; ValaCCodeFunctionCall* ccall = NULL; - gchar* _tmp421_; - gchar* _tmp422_; - ValaCCodeIdentifier* _tmp423_; - ValaCCodeIdentifier* _tmp424_; - ValaCCodeFunctionCall* _tmp425_; - ValaCCodeFunctionCall* _tmp426_; - gboolean _tmp441_; - gboolean _tmp442_; - gboolean _tmp449_ = FALSE; - ValaDataType* _tmp450_; - ValaDataType* _tmp451_; - gboolean _tmp493_ = FALSE; - ValaDelegate* _tmp494_; - gboolean _tmp495_; - gboolean _tmp496_; - gboolean _tmp534_ = FALSE; - gboolean _tmp535_ = FALSE; - ValaDataType* _tmp536_; - ValaDataType* _tmp537_; - ValaCCodeFile* _tmp551_; - ValaCCodeFunction* _tmp552_; - ValaCCodeFile* _tmp553_; - ValaCCodeFunction* _tmp554_; + gchar* _tmp406_; + gchar* _tmp407_; + ValaCCodeIdentifier* _tmp408_; + ValaCCodeIdentifier* _tmp409_; + ValaCCodeFunctionCall* _tmp410_; + ValaCCodeFunctionCall* _tmp411_; + gboolean _tmp426_; + gboolean _tmp427_; + gboolean _tmp434_ = FALSE; + ValaDataType* _tmp435_; + ValaDataType* _tmp436_; + gboolean _tmp478_ = FALSE; + ValaDelegate* _tmp479_; + gboolean _tmp480_; + gboolean _tmp481_; + gboolean _tmp519_ = FALSE; + gboolean _tmp520_ = FALSE; + ValaDataType* _tmp521_; + ValaDataType* _tmp522_; + ValaCCodeFile* _tmp536_; + ValaCCodeFunction* _tmp537_; + ValaCCodeFile* _tmp538_; + ValaCCodeFunction* _tmp539_; gchar* result; g_return_val_if_fail (self != NULL, NULL); g_return_val_if_fail (m != NULL, NULL); @@ -1636,25 +1636,23 @@ gpointer _tmp251_; gboolean _tmp252_ = FALSE; gboolean _tmp253_ = FALSE; - ValaCCodeExpression* arg = NULL; + ValaParameter* d_param = NULL; ValaList* _tmp268_; gpointer _tmp269_; + ValaCCodeExpression* arg = NULL; ValaParameter* _tmp270_; gchar* _tmp271_; gchar* _tmp272_; ValaCCodeIdentifier* _tmp273_; - ValaList* _tmp274_; - gpointer _tmp275_; - ValaParameter* _tmp276_; - ValaDataType* _tmp277_; - ValaDataType* _tmp278_; - gboolean _tmp279_; - ValaHashMap* _tmp285_; + ValaParameter* _tmp274_; + ValaDataType* _tmp275_; + ValaDataType* _tmp276_; + ValaHashMap* _tmp282_; + ValaParameter* _tmp283_; + ValaCCodeExpression* _tmp284_; + gboolean _tmp285_ = FALSE; ValaParameter* _tmp286_; - ValaCCodeExpression* _tmp287_; - gboolean _tmp288_ = FALSE; - ValaParameter* _tmp289_; - gint _tmp368_; + gint _tmp353_; _param_index = _param_index + 1; _tmp248_ = _param_index; _tmp249_ = _param_size; @@ -1711,267 +1709,237 @@ } _tmp268_ = d_params; _tmp269_ = vala_list_get (_tmp268_, i); - _tmp270_ = (ValaParameter*) _tmp269_; + d_param = (ValaParameter*) _tmp269_; + _tmp270_ = d_param; _tmp271_ = vala_get_ccode_name ((ValaCodeNode*) _tmp270_); _tmp272_ = _tmp271_; _tmp273_ = vala_ccode_identifier_new (_tmp272_); _vala_ccode_node_unref0 (arg); arg = (ValaCCodeExpression*) _tmp273_; _g_free0 (_tmp272_); - _vala_code_node_unref0 (_tmp270_); - _tmp274_ = d_params; - _tmp275_ = vala_list_get (_tmp274_, i); - _tmp276_ = (ValaParameter*) _tmp275_; - _tmp277_ = vala_variable_get_variable_type ((ValaVariable*) _tmp276_); - _tmp278_ = _tmp277_; - _tmp279_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp278_, VALA_TYPE_GENERIC_TYPE); - _vala_code_node_unref0 (_tmp276_); - if (_tmp279_) { - ValaCCodeExpression* _tmp280_; - ValaParameter* _tmp281_; - ValaDataType* _tmp282_; - ValaDataType* _tmp283_; - ValaCCodeExpression* _tmp284_; - _tmp280_ = arg; - _tmp281_ = param; - _tmp282_ = vala_variable_get_variable_type ((ValaVariable*) _tmp281_); - _tmp283_ = _tmp282_; - _tmp284_ = vala_ccode_base_module_convert_from_generic_pointer ((ValaCCodeBaseModule*) self, _tmp280_, _tmp283_); + _tmp274_ = d_param; + _tmp275_ = vala_variable_get_variable_type ((ValaVariable*) _tmp274_); + _tmp276_ = _tmp275_; + if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp276_, VALA_TYPE_GENERIC_TYPE)) { + ValaCCodeExpression* _tmp277_; + ValaParameter* _tmp278_; + ValaDataType* _tmp279_; + ValaDataType* _tmp280_; + ValaCCodeExpression* _tmp281_; + _tmp277_ = arg; + _tmp278_ = param; + _tmp279_ = vala_variable_get_variable_type ((ValaVariable*) _tmp278_); + _tmp280_ = _tmp279_; + _tmp281_ = vala_ccode_base_module_convert_from_generic_pointer ((ValaCCodeBaseModule*) self, _tmp277_, _tmp280_); _vala_ccode_node_unref0 (arg); - arg = _tmp284_; + arg = _tmp281_; } - _tmp285_ = carg_map; + _tmp282_ = carg_map; + _tmp283_ = param; + _tmp284_ = arg; + vala_map_set ((ValaMap*) _tmp282_, (gpointer) ((gintptr) vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, vala_get_ccode_pos (_tmp283_), FALSE)), _tmp284_); _tmp286_ = param; - _tmp287_ = arg; - vala_map_set ((ValaMap*) _tmp285_, (gpointer) ((gintptr) vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, vala_get_ccode_pos (_tmp286_), FALSE)), _tmp287_); - _tmp289_ = param; - if (vala_get_ccode_array_length ((ValaCodeNode*) _tmp289_)) { + if (vala_get_ccode_array_length ((ValaCodeNode*) _tmp286_)) { + ValaParameter* _tmp287_; + ValaDataType* _tmp288_; + ValaDataType* _tmp289_; + _tmp287_ = param; + _tmp288_ = vala_variable_get_variable_type ((ValaVariable*) _tmp287_); + _tmp289_ = _tmp288_; + _tmp285_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp289_, VALA_TYPE_ARRAY_TYPE); + } else { + _tmp285_ = FALSE; + } + if (_tmp285_) { + ValaArrayType* array_type = NULL; ValaParameter* _tmp290_; ValaDataType* _tmp291_; ValaDataType* _tmp292_; + ValaArrayType* _tmp293_; _tmp290_ = param; _tmp291_ = vala_variable_get_variable_type ((ValaVariable*) _tmp290_); _tmp292_ = _tmp291_; - _tmp288_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp292_, VALA_TYPE_ARRAY_TYPE); - } else { - _tmp288_ = FALSE; - } - if (_tmp288_) { - ValaArrayType* array_type = NULL; - ValaParameter* _tmp293_; - ValaDataType* _tmp294_; - ValaDataType* _tmp295_; - ValaArrayType* _tmp296_; - _tmp293_ = param; - _tmp294_ = vala_variable_get_variable_type ((ValaVariable*) _tmp293_); - _tmp295_ = _tmp294_; - _tmp296_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp295_, VALA_TYPE_ARRAY_TYPE, ValaArrayType)); - array_type = _tmp296_; + _tmp293_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp292_, VALA_TYPE_ARRAY_TYPE, ValaArrayType)); + array_type = _tmp293_; { gint dim = 0; dim = 1; { - gboolean _tmp297_ = FALSE; - _tmp297_ = TRUE; + gboolean _tmp294_ = FALSE; + _tmp294_ = TRUE; while (TRUE) { - ValaArrayType* _tmp299_; - gint _tmp300_; - gint _tmp301_; + ValaArrayType* _tmp296_; + gint _tmp297_; + gint _tmp298_; ValaCCodeExpression* clength = NULL; - ValaList* _tmp302_; - gpointer _tmp303_; - ValaParameter* _tmp304_; - gboolean _tmp305_; - ValaHashMap* _tmp331_; - ValaParameter* _tmp332_; - ValaCCodeExpression* _tmp333_; - if (!_tmp297_) { - gint _tmp298_; - _tmp298_ = dim; - dim = _tmp298_ + 1; + gboolean _tmp299_ = FALSE; + ValaParameter* _tmp300_; + ValaHashMap* _tmp320_; + ValaParameter* _tmp321_; + ValaCCodeExpression* _tmp322_; + if (!_tmp294_) { + gint _tmp295_; + _tmp295_ = dim; + dim = _tmp295_ + 1; } - _tmp297_ = FALSE; - _tmp299_ = array_type; - _tmp300_ = vala_array_type_get_rank (_tmp299_); - _tmp301_ = _tmp300_; - if (!(dim <= _tmp301_)) { + _tmp294_ = FALSE; + _tmp296_ = array_type; + _tmp297_ = vala_array_type_get_rank (_tmp296_); + _tmp298_ = _tmp297_; + if (!(dim <= _tmp298_)) { break; } - _tmp302_ = d_params; - _tmp303_ = vala_list_get (_tmp302_, i); - _tmp304_ = (ValaParameter*) _tmp303_; - _tmp305_ = vala_get_ccode_array_null_terminated ((ValaCodeNode*) _tmp304_); - _vala_code_node_unref0 (_tmp304_); - if (_tmp305_) { + _tmp300_ = d_param; + if (vala_get_ccode_array_null_terminated ((ValaCodeNode*) _tmp300_)) { + ValaParameter* _tmp301_; + _tmp301_ = d_param; + _tmp299_ = !vala_get_ccode_array_length ((ValaCodeNode*) _tmp301_); + } else { + _tmp299_ = FALSE; + } + if (_tmp299_) { ValaCCodeFunctionCall* len_call = NULL; - ValaCCodeIdentifier* _tmp306_; - ValaCCodeIdentifier* _tmp307_; - ValaCCodeFunctionCall* _tmp308_; - ValaCCodeFunctionCall* _tmp309_; - ValaCCodeFunctionCall* _tmp310_; - ValaList* _tmp311_; - gpointer _tmp312_; - ValaParameter* _tmp313_; - const gchar* _tmp314_; - const gchar* _tmp315_; - ValaCCodeIdentifier* _tmp316_; - ValaCCodeIdentifier* _tmp317_; - ValaCCodeFunctionCall* _tmp318_; - ValaCCodeExpression* _tmp319_; + ValaCCodeIdentifier* _tmp302_; + ValaCCodeIdentifier* _tmp303_; + ValaCCodeFunctionCall* _tmp304_; + ValaCCodeFunctionCall* _tmp305_; + ValaCCodeFunctionCall* _tmp306_; + ValaParameter* _tmp307_; + const gchar* _tmp308_; + const gchar* _tmp309_; + ValaCCodeIdentifier* _tmp310_; + ValaCCodeIdentifier* _tmp311_; + ValaCCodeFunctionCall* _tmp312_; + ValaCCodeExpression* _tmp313_; ((ValaCCodeBaseModule*) self)->requires_array_length = TRUE; - _tmp306_ = vala_ccode_identifier_new ("_vala_array_length"); - _tmp307_ = _tmp306_; - _tmp308_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp307_); + _tmp302_ = vala_ccode_identifier_new ("_vala_array_length"); + _tmp303_ = _tmp302_; + _tmp304_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp303_); + _tmp305_ = _tmp304_; + _vala_ccode_node_unref0 (_tmp303_); + len_call = _tmp305_; + _tmp306_ = len_call; + _tmp307_ = d_param; + _tmp308_ = vala_symbol_get_name ((ValaSymbol*) _tmp307_); _tmp309_ = _tmp308_; - _vala_ccode_node_unref0 (_tmp307_); - len_call = _tmp309_; - _tmp310_ = len_call; - _tmp311_ = d_params; - _tmp312_ = vala_list_get (_tmp311_, i); - _tmp313_ = (ValaParameter*) _tmp312_; - _tmp314_ = vala_symbol_get_name ((ValaSymbol*) _tmp313_); - _tmp315_ = _tmp314_; - _tmp316_ = vala_ccode_identifier_new (_tmp315_); - _tmp317_ = _tmp316_; - vala_ccode_function_call_add_argument (_tmp310_, (ValaCCodeExpression*) _tmp317_); - _vala_ccode_node_unref0 (_tmp317_); - _vala_code_node_unref0 (_tmp313_); - _tmp318_ = len_call; - _tmp319_ = _vala_ccode_node_ref0 ((ValaCCodeExpression*) _tmp318_); + _tmp310_ = vala_ccode_identifier_new (_tmp309_); + _tmp311_ = _tmp310_; + vala_ccode_function_call_add_argument (_tmp306_, (ValaCCodeExpression*) _tmp311_); + _vala_ccode_node_unref0 (_tmp311_); + _tmp312_ = len_call; + _tmp313_ = _vala_ccode_node_ref0 ((ValaCCodeExpression*) _tmp312_); _vala_ccode_node_unref0 (clength); - clength = _tmp319_; + clength = _tmp313_; _vala_ccode_node_unref0 (len_call); } else { - ValaList* _tmp320_; - gpointer _tmp321_; - ValaParameter* _tmp322_; - gboolean _tmp323_; - _tmp320_ = d_params; - _tmp321_ = vala_list_get (_tmp320_, i); - _tmp322_ = (ValaParameter*) _tmp321_; - _tmp323_ = !vala_get_ccode_array_length ((ValaCodeNode*) _tmp322_); - _vala_code_node_unref0 (_tmp322_); - if (_tmp323_) { - ValaCCodeConstant* _tmp324_; - _tmp324_ = vala_ccode_constant_new ("-1"); + ValaParameter* _tmp314_; + _tmp314_ = d_param; + if (!vala_get_ccode_array_length ((ValaCodeNode*) _tmp314_)) { + ValaCCodeConstant* _tmp315_; + _tmp315_ = vala_ccode_constant_new ("-1"); _vala_ccode_node_unref0 (clength); - clength = (ValaCCodeExpression*) _tmp324_; + clength = (ValaCCodeExpression*) _tmp315_; } else { - ValaList* _tmp325_; - gpointer _tmp326_; - ValaParameter* _tmp327_; - gchar* _tmp328_; - gchar* _tmp329_; - ValaCCodeIdentifier* _tmp330_; - _tmp325_ = d_params; - _tmp326_ = vala_list_get (_tmp325_, i); - _tmp327_ = (ValaParameter*) _tmp326_; - _tmp328_ = vala_ccode_base_module_get_variable_array_length_cname ((ValaCCodeBaseModule*) self, (ValaVariable*) _tmp327_, dim); - _tmp329_ = _tmp328_; - _tmp330_ = vala_ccode_identifier_new (_tmp329_); + ValaParameter* _tmp316_; + gchar* _tmp317_; + gchar* _tmp318_; + ValaCCodeIdentifier* _tmp319_; + _tmp316_ = d_param; + _tmp317_ = vala_ccode_base_module_get_variable_array_length_cname ((ValaCCodeBaseModule*) self, (ValaVariable*) _tmp316_, dim); + _tmp318_ = _tmp317_; + _tmp319_ = vala_ccode_identifier_new (_tmp318_); _vala_ccode_node_unref0 (clength); - clength = (ValaCCodeExpression*) _tmp330_; - _g_free0 (_tmp329_); - _vala_code_node_unref0 (_tmp327_); + clength = (ValaCCodeExpression*) _tmp319_; + _g_free0 (_tmp318_); } } - _tmp331_ = carg_map; - _tmp332_ = param; - _tmp333_ = clength; - vala_map_set ((ValaMap*) _tmp331_, (gpointer) ((gintptr) vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, vala_get_ccode_array_length_pos ((ValaCodeNode*) _tmp332_) + (0.01 * dim), FALSE)), _tmp333_); + _tmp320_ = carg_map; + _tmp321_ = param; + _tmp322_ = clength; + vala_map_set ((ValaMap*) _tmp320_, (gpointer) ((gintptr) vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, vala_get_ccode_array_length_pos ((ValaCodeNode*) _tmp321_) + (0.01 * dim), FALSE)), _tmp322_); _vala_ccode_node_unref0 (clength); } } } _vala_code_node_unref0 (array_type); } else { - gboolean _tmp334_ = FALSE; - ValaParameter* _tmp335_; - _tmp335_ = param; - if (vala_get_ccode_delegate_target ((ValaCodeNode*) _tmp335_)) { - ValaParameter* _tmp336_; - ValaDataType* _tmp337_; - ValaDataType* _tmp338_; - _tmp336_ = param; - _tmp337_ = vala_variable_get_variable_type ((ValaVariable*) _tmp336_); - _tmp338_ = _tmp337_; - _tmp334_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp338_, VALA_TYPE_DELEGATE_TYPE); + gboolean _tmp323_ = FALSE; + ValaParameter* _tmp324_; + _tmp324_ = param; + if (vala_get_ccode_delegate_target ((ValaCodeNode*) _tmp324_)) { + ValaParameter* _tmp325_; + ValaDataType* _tmp326_; + ValaDataType* _tmp327_; + _tmp325_ = param; + _tmp326_ = vala_variable_get_variable_type ((ValaVariable*) _tmp325_); + _tmp327_ = _tmp326_; + _tmp323_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp327_, VALA_TYPE_DELEGATE_TYPE); } else { - _tmp334_ = FALSE; + _tmp323_ = FALSE; } - if (_tmp334_) { + if (_tmp323_) { ValaDelegateType* deleg_type = NULL; - ValaParameter* _tmp339_; - ValaDataType* _tmp340_; - ValaDataType* _tmp341_; - ValaDelegateType* _tmp342_; - ValaDelegateType* _tmp343_; - ValaDelegate* _tmp344_; - ValaDelegate* _tmp345_; - gboolean _tmp346_; - gboolean _tmp347_; - _tmp339_ = param; - _tmp340_ = vala_variable_get_variable_type ((ValaVariable*) _tmp339_); - _tmp341_ = _tmp340_; - _tmp342_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp341_, VALA_TYPE_DELEGATE_TYPE, ValaDelegateType)); - deleg_type = _tmp342_; - _tmp343_ = deleg_type; - _tmp344_ = vala_delegate_type_get_delegate_symbol (_tmp343_); - _tmp345_ = _tmp344_; - _tmp346_ = vala_delegate_get_has_target (_tmp345_); - _tmp347_ = _tmp346_; - if (_tmp347_) { + ValaParameter* _tmp328_; + ValaDataType* _tmp329_; + ValaDataType* _tmp330_; + ValaDelegateType* _tmp331_; + ValaDelegateType* _tmp332_; + ValaDelegate* _tmp333_; + ValaDelegate* _tmp334_; + gboolean _tmp335_; + gboolean _tmp336_; + _tmp328_ = param; + _tmp329_ = vala_variable_get_variable_type ((ValaVariable*) _tmp328_); + _tmp330_ = _tmp329_; + _tmp331_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp330_, VALA_TYPE_DELEGATE_TYPE, ValaDelegateType)); + deleg_type = _tmp331_; + _tmp332_ = deleg_type; + _tmp333_ = vala_delegate_type_get_delegate_symbol (_tmp332_); + _tmp334_ = _tmp333_; + _tmp335_ = vala_delegate_get_has_target (_tmp334_); + _tmp336_ = _tmp335_; + if (_tmp336_) { ValaCCodeIdentifier* ctarget = NULL; - ValaList* _tmp348_; - gpointer _tmp349_; - ValaParameter* _tmp350_; - gchar* _tmp351_; - gchar* _tmp352_; - ValaCCodeIdentifier* _tmp353_; - ValaCCodeIdentifier* _tmp354_; - ValaHashMap* _tmp355_; - ValaParameter* _tmp356_; - ValaCCodeIdentifier* _tmp357_; - ValaDelegateType* _tmp358_; - _tmp348_ = d_params; - _tmp349_ = vala_list_get (_tmp348_, i); - _tmp350_ = (ValaParameter*) _tmp349_; - _tmp351_ = vala_get_ccode_delegate_target_name ((ValaVariable*) _tmp350_); - _tmp352_ = _tmp351_; - _tmp353_ = vala_ccode_identifier_new (_tmp352_); - _tmp354_ = _tmp353_; - _g_free0 (_tmp352_); - _vala_code_node_unref0 (_tmp350_); - ctarget = _tmp354_; - _tmp355_ = carg_map; - _tmp356_ = param; - _tmp357_ = ctarget; - vala_map_set ((ValaMap*) _tmp355_, (gpointer) ((gintptr) vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, vala_get_ccode_delegate_target_pos ((ValaCodeNode*) _tmp356_), FALSE)), (ValaCCodeExpression*) _tmp357_); - _tmp358_ = deleg_type; - if (vala_data_type_is_disposable ((ValaDataType*) _tmp358_)) { + ValaParameter* _tmp337_; + gchar* _tmp338_; + gchar* _tmp339_; + ValaCCodeIdentifier* _tmp340_; + ValaCCodeIdentifier* _tmp341_; + ValaHashMap* _tmp342_; + ValaParameter* _tmp343_; + ValaCCodeIdentifier* _tmp344_; + ValaDelegateType* _tmp345_; + _tmp337_ = d_param; + _tmp338_ = vala_get_ccode_delegate_target_name ((ValaVariable*) _tmp337_); + _tmp339_ = _tmp338_; + _tmp340_ = vala_ccode_identifier_new (_tmp339_); + _tmp341_ = _tmp340_; + _g_free0 (_tmp339_); + ctarget = _tmp341_; + _tmp342_ = carg_map; + _tmp343_ = param; + _tmp344_ = ctarget; + vala_map_set ((ValaMap*) _tmp342_, (gpointer) ((gintptr) vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, vala_get_ccode_delegate_target_pos ((ValaCodeNode*) _tmp343_), FALSE)), (ValaCCodeExpression*) _tmp344_); + _tmp345_ = deleg_type; + if (vala_data_type_is_disposable ((ValaDataType*) _tmp345_)) { ValaCCodeIdentifier* ctarget_destroy_notify = NULL; - ValaList* _tmp359_; - gpointer _tmp360_; - ValaParameter* _tmp361_; - gchar* _tmp362_; - gchar* _tmp363_; - ValaCCodeIdentifier* _tmp364_; - ValaCCodeIdentifier* _tmp365_; - ValaHashMap* _tmp366_; - ValaCCodeIdentifier* _tmp367_; - _tmp359_ = d_params; - _tmp360_ = vala_list_get (_tmp359_, i); - _tmp361_ = (ValaParameter*) _tmp360_; - _tmp362_ = vala_get_ccode_delegate_target_destroy_notify_name ((ValaVariable*) _tmp361_); - _tmp363_ = _tmp362_; - _tmp364_ = vala_ccode_identifier_new (_tmp363_); - _tmp365_ = _tmp364_; - _g_free0 (_tmp363_); - _vala_code_node_unref0 (_tmp361_); - ctarget_destroy_notify = _tmp365_; - _tmp366_ = carg_map; - _tmp367_ = ctarget_destroy_notify; - vala_map_set ((ValaMap*) _tmp366_, (gpointer) ((gintptr) vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, vala_get_ccode_destroy_notify_pos ((ValaCodeNode*) m), FALSE)), (ValaCCodeExpression*) _tmp367_); + ValaParameter* _tmp346_; + gchar* _tmp347_; + gchar* _tmp348_; + ValaCCodeIdentifier* _tmp349_; + ValaCCodeIdentifier* _tmp350_; + ValaHashMap* _tmp351_; + ValaCCodeIdentifier* _tmp352_; + _tmp346_ = d_param; + _tmp347_ = vala_get_ccode_delegate_target_destroy_notify_name ((ValaVariable*) _tmp346_); + _tmp348_ = _tmp347_; + _tmp349_ = vala_ccode_identifier_new (_tmp348_); + _tmp350_ = _tmp349_; + _g_free0 (_tmp348_); + ctarget_destroy_notify = _tmp350_; + _tmp351_ = carg_map; + _tmp352_ = ctarget_destroy_notify; + vala_map_set ((ValaMap*) _tmp351_, (gpointer) ((gintptr) vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, vala_get_ccode_destroy_notify_pos ((ValaCodeNode*) m), FALSE)), (ValaCCodeExpression*) _tmp352_); _vala_ccode_node_unref0 (ctarget_destroy_notify); } _vala_ccode_node_unref0 (ctarget); @@ -1979,236 +1947,237 @@ _vala_code_node_unref0 (deleg_type); } } - _tmp368_ = i; - i = _tmp368_ + 1; + _tmp353_ = i; + i = _tmp353_ + 1; _vala_ccode_node_unref0 (arg); + _vala_code_node_unref0 (d_param); _vala_code_node_unref0 (param); } } if (vala_get_ccode_array_length ((ValaCodeNode*) m)) { - ValaDataType* _tmp370_; - ValaDataType* _tmp371_; - _tmp370_ = vala_callable_get_return_type ((ValaCallable*) m); - _tmp371_ = _tmp370_; - _tmp369_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp371_, VALA_TYPE_ARRAY_TYPE); + ValaDataType* _tmp355_; + ValaDataType* _tmp356_; + _tmp355_ = vala_callable_get_return_type ((ValaCallable*) m); + _tmp356_ = _tmp355_; + _tmp354_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp356_, VALA_TYPE_ARRAY_TYPE); } else { - _tmp369_ = FALSE; + _tmp354_ = FALSE; } - if (_tmp369_) { + if (_tmp354_) { ValaArrayType* array_type = NULL; - ValaDataType* _tmp372_; - ValaDataType* _tmp373_; - ValaArrayType* _tmp374_; - _tmp372_ = vala_callable_get_return_type ((ValaCallable*) m); - _tmp373_ = _tmp372_; - _tmp374_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp373_, VALA_TYPE_ARRAY_TYPE, ValaArrayType)); - array_type = _tmp374_; + ValaDataType* _tmp357_; + ValaDataType* _tmp358_; + ValaArrayType* _tmp359_; + _tmp357_ = vala_callable_get_return_type ((ValaCallable*) m); + _tmp358_ = _tmp357_; + _tmp359_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp358_, VALA_TYPE_ARRAY_TYPE, ValaArrayType)); + array_type = _tmp359_; { gint dim = 0; dim = 1; { - gboolean _tmp375_ = FALSE; - _tmp375_ = TRUE; + gboolean _tmp360_ = FALSE; + _tmp360_ = TRUE; while (TRUE) { - ValaArrayType* _tmp377_; - gint _tmp378_; - gint _tmp379_; + ValaArrayType* _tmp362_; + gint _tmp363_; + gint _tmp364_; ValaCCodeExpression* clength = NULL; - ValaDelegate* _tmp380_; - ValaHashMap* _tmp385_; - ValaCCodeExpression* _tmp386_; - if (!_tmp375_) { - gint _tmp376_; - _tmp376_ = dim; - dim = _tmp376_ + 1; + ValaDelegate* _tmp365_; + ValaHashMap* _tmp370_; + ValaCCodeExpression* _tmp371_; + if (!_tmp360_) { + gint _tmp361_; + _tmp361_ = dim; + dim = _tmp361_ + 1; } - _tmp375_ = FALSE; - _tmp377_ = array_type; - _tmp378_ = vala_array_type_get_rank (_tmp377_); - _tmp379_ = _tmp378_; - if (!(dim <= _tmp379_)) { + _tmp360_ = FALSE; + _tmp362_ = array_type; + _tmp363_ = vala_array_type_get_rank (_tmp362_); + _tmp364_ = _tmp363_; + if (!(dim <= _tmp364_)) { break; } - _tmp380_ = d; - if (!vala_get_ccode_array_length ((ValaCodeNode*) _tmp380_)) { - ValaCCodeConstant* _tmp381_; - _tmp381_ = vala_ccode_constant_new ("NULL"); + _tmp365_ = d; + if (!vala_get_ccode_array_length ((ValaCodeNode*) _tmp365_)) { + ValaCCodeConstant* _tmp366_; + _tmp366_ = vala_ccode_constant_new ("NULL"); _vala_ccode_node_unref0 (clength); - clength = (ValaCCodeExpression*) _tmp381_; + clength = (ValaCCodeExpression*) _tmp366_; } else { - gchar* _tmp382_; - gchar* _tmp383_; - ValaCCodeIdentifier* _tmp384_; - _tmp382_ = vala_ccode_base_module_get_array_length_cname ((ValaCCodeBaseModule*) self, "result", dim); - _tmp383_ = _tmp382_; - _tmp384_ = vala_ccode_identifier_new (_tmp383_); + gchar* _tmp367_; + gchar* _tmp368_; + ValaCCodeIdentifier* _tmp369_; + _tmp367_ = vala_ccode_base_module_get_array_length_cname ((ValaCCodeBaseModule*) self, "result", dim); + _tmp368_ = _tmp367_; + _tmp369_ = vala_ccode_identifier_new (_tmp368_); _vala_ccode_node_unref0 (clength); - clength = (ValaCCodeExpression*) _tmp384_; - _g_free0 (_tmp383_); + clength = (ValaCCodeExpression*) _tmp369_; + _g_free0 (_tmp368_); } - _tmp385_ = carg_map; - _tmp386_ = clength; - vala_map_set ((ValaMap*) _tmp385_, (gpointer) ((gintptr) vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, vala_get_ccode_array_length_pos ((ValaCodeNode*) m) + (0.01 * dim), FALSE)), _tmp386_); + _tmp370_ = carg_map; + _tmp371_ = clength; + vala_map_set ((ValaMap*) _tmp370_, (gpointer) ((gintptr) vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, vala_get_ccode_array_length_pos ((ValaCodeNode*) m) + (0.01 * dim), FALSE)), _tmp371_); _vala_ccode_node_unref0 (clength); } } } _vala_code_node_unref0 (array_type); } else { - gboolean _tmp387_ = FALSE; + gboolean _tmp372_ = FALSE; if (vala_get_ccode_delegate_target ((ValaCodeNode*) m)) { - ValaDataType* _tmp388_; - ValaDataType* _tmp389_; - _tmp388_ = vala_callable_get_return_type ((ValaCallable*) m); - _tmp389_ = _tmp388_; - _tmp387_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp389_, VALA_TYPE_DELEGATE_TYPE); + ValaDataType* _tmp373_; + ValaDataType* _tmp374_; + _tmp373_ = vala_callable_get_return_type ((ValaCallable*) m); + _tmp374_ = _tmp373_; + _tmp372_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp374_, VALA_TYPE_DELEGATE_TYPE); } else { - _tmp387_ = FALSE; + _tmp372_ = FALSE; } - if (_tmp387_) { + if (_tmp372_) { ValaDelegateType* deleg_type = NULL; - ValaDataType* _tmp390_; - ValaDataType* _tmp391_; - ValaDelegateType* _tmp392_; - ValaDelegateType* _tmp393_; - ValaDelegate* _tmp394_; - ValaDelegate* _tmp395_; - gboolean _tmp396_; - gboolean _tmp397_; - _tmp390_ = vala_callable_get_return_type ((ValaCallable*) m); - _tmp391_ = _tmp390_; - _tmp392_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp391_, VALA_TYPE_DELEGATE_TYPE, ValaDelegateType)); - deleg_type = _tmp392_; - _tmp393_ = deleg_type; - _tmp394_ = vala_delegate_type_get_delegate_symbol (_tmp393_); - _tmp395_ = _tmp394_; - _tmp396_ = vala_delegate_get_has_target (_tmp395_); - _tmp397_ = _tmp396_; - if (_tmp397_) { + ValaDataType* _tmp375_; + ValaDataType* _tmp376_; + ValaDelegateType* _tmp377_; + ValaDelegateType* _tmp378_; + ValaDelegate* _tmp379_; + ValaDelegate* _tmp380_; + gboolean _tmp381_; + gboolean _tmp382_; + _tmp375_ = vala_callable_get_return_type ((ValaCallable*) m); + _tmp376_ = _tmp375_; + _tmp377_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp376_, VALA_TYPE_DELEGATE_TYPE, ValaDelegateType)); + deleg_type = _tmp377_; + _tmp378_ = deleg_type; + _tmp379_ = vala_delegate_type_get_delegate_symbol (_tmp378_); + _tmp380_ = _tmp379_; + _tmp381_ = vala_delegate_get_has_target (_tmp380_); + _tmp382_ = _tmp381_; + if (_tmp382_) { ValaCCodeIdentifier* ctarget = NULL; - gchar* _tmp398_; - gchar* _tmp399_; - ValaCCodeIdentifier* _tmp400_; - ValaCCodeIdentifier* _tmp401_; - ValaHashMap* _tmp402_; - ValaCCodeIdentifier* _tmp403_; - ValaDelegateType* _tmp404_; - _tmp398_ = vala_ccode_base_module_get_delegate_target_cname ((ValaCCodeBaseModule*) self, "result"); - _tmp399_ = _tmp398_; - _tmp400_ = vala_ccode_identifier_new (_tmp399_); - _tmp401_ = _tmp400_; - _g_free0 (_tmp399_); - ctarget = _tmp401_; - _tmp402_ = carg_map; - _tmp403_ = ctarget; - vala_map_set ((ValaMap*) _tmp402_, (gpointer) ((gintptr) vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, vala_get_ccode_delegate_target_pos ((ValaCodeNode*) m), FALSE)), (ValaCCodeExpression*) _tmp403_); - _tmp404_ = deleg_type; - if (vala_data_type_is_disposable ((ValaDataType*) _tmp404_)) { + gchar* _tmp383_; + gchar* _tmp384_; + ValaCCodeIdentifier* _tmp385_; + ValaCCodeIdentifier* _tmp386_; + ValaHashMap* _tmp387_; + ValaCCodeIdentifier* _tmp388_; + ValaDelegateType* _tmp389_; + _tmp383_ = vala_ccode_base_module_get_delegate_target_cname ((ValaCCodeBaseModule*) self, "result"); + _tmp384_ = _tmp383_; + _tmp385_ = vala_ccode_identifier_new (_tmp384_); + _tmp386_ = _tmp385_; + _g_free0 (_tmp384_); + ctarget = _tmp386_; + _tmp387_ = carg_map; + _tmp388_ = ctarget; + vala_map_set ((ValaMap*) _tmp387_, (gpointer) ((gintptr) vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, vala_get_ccode_delegate_target_pos ((ValaCodeNode*) m), FALSE)), (ValaCCodeExpression*) _tmp388_); + _tmp389_ = deleg_type; + if (vala_data_type_is_disposable ((ValaDataType*) _tmp389_)) { ValaCCodeIdentifier* ctarget_destroy_notify = NULL; - gchar* _tmp405_; - gchar* _tmp406_; - ValaCCodeIdentifier* _tmp407_; - ValaCCodeIdentifier* _tmp408_; - ValaHashMap* _tmp409_; - ValaCCodeIdentifier* _tmp410_; - _tmp405_ = vala_ccode_base_module_get_delegate_target_destroy_notify_cname ((ValaCCodeBaseModule*) self, "result"); - _tmp406_ = _tmp405_; - _tmp407_ = vala_ccode_identifier_new (_tmp406_); - _tmp408_ = _tmp407_; - _g_free0 (_tmp406_); - ctarget_destroy_notify = _tmp408_; - _tmp409_ = carg_map; - _tmp410_ = ctarget_destroy_notify; - vala_map_set ((ValaMap*) _tmp409_, (gpointer) ((gintptr) vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, vala_get_ccode_destroy_notify_pos ((ValaCodeNode*) m), FALSE)), (ValaCCodeExpression*) _tmp410_); + gchar* _tmp390_; + gchar* _tmp391_; + ValaCCodeIdentifier* _tmp392_; + ValaCCodeIdentifier* _tmp393_; + ValaHashMap* _tmp394_; + ValaCCodeIdentifier* _tmp395_; + _tmp390_ = vala_ccode_base_module_get_delegate_target_destroy_notify_cname ((ValaCCodeBaseModule*) self, "result"); + _tmp391_ = _tmp390_; + _tmp392_ = vala_ccode_identifier_new (_tmp391_); + _tmp393_ = _tmp392_; + _g_free0 (_tmp391_); + ctarget_destroy_notify = _tmp393_; + _tmp394_ = carg_map; + _tmp395_ = ctarget_destroy_notify; + vala_map_set ((ValaMap*) _tmp394_, (gpointer) ((gintptr) vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, vala_get_ccode_destroy_notify_pos ((ValaCodeNode*) m), FALSE)), (ValaCCodeExpression*) _tmp395_); _vala_ccode_node_unref0 (ctarget_destroy_notify); } _vala_ccode_node_unref0 (ctarget); } _vala_code_node_unref0 (deleg_type); } else { - ValaDataType* _tmp411_; - ValaDataType* _tmp412_; - _tmp411_ = vala_callable_get_return_type ((ValaCallable*) m); - _tmp412_ = _tmp411_; - if (vala_data_type_is_real_non_null_struct_type (_tmp412_)) { - ValaHashMap* _tmp413_; - ValaCCodeIdentifier* _tmp414_; - ValaCCodeIdentifier* _tmp415_; - _tmp413_ = carg_map; - _tmp414_ = vala_ccode_identifier_new ("result"); - _tmp415_ = _tmp414_; - vala_map_set ((ValaMap*) _tmp413_, (gpointer) ((gintptr) vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, (gdouble) -3, FALSE)), (ValaCCodeExpression*) _tmp415_); - _vala_ccode_node_unref0 (_tmp415_); + ValaDataType* _tmp396_; + ValaDataType* _tmp397_; + _tmp396_ = vala_callable_get_return_type ((ValaCallable*) m); + _tmp397_ = _tmp396_; + if (vala_data_type_is_real_non_null_struct_type (_tmp397_)) { + ValaHashMap* _tmp398_; + ValaCCodeIdentifier* _tmp399_; + ValaCCodeIdentifier* _tmp400_; + _tmp398_ = carg_map; + _tmp399_ = vala_ccode_identifier_new ("result"); + _tmp400_ = _tmp399_; + vala_map_set ((ValaMap*) _tmp398_, (gpointer) ((gintptr) vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, (gdouble) -3, FALSE)), (ValaCCodeExpression*) _tmp400_); + _vala_ccode_node_unref0 (_tmp400_); } } } - _tmp416_ = vala_code_node_get_tree_can_fail ((ValaCodeNode*) m); - _tmp417_ = _tmp416_; - if (_tmp417_) { - ValaHashMap* _tmp418_; - ValaCCodeIdentifier* _tmp419_; - ValaCCodeIdentifier* _tmp420_; - _tmp418_ = carg_map; - _tmp419_ = vala_ccode_identifier_new ("error"); - _tmp420_ = _tmp419_; - vala_map_set ((ValaMap*) _tmp418_, (gpointer) ((gintptr) vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, vala_get_ccode_error_pos ((ValaCallable*) m), FALSE)), (ValaCCodeExpression*) _tmp420_); - _vala_ccode_node_unref0 (_tmp420_); - } - _tmp421_ = vala_get_ccode_name ((ValaCodeNode*) m); - _tmp422_ = _tmp421_; - _tmp423_ = vala_ccode_identifier_new (_tmp422_); - _tmp424_ = _tmp423_; - _tmp425_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp424_); - _tmp426_ = _tmp425_; - _vala_ccode_node_unref0 (_tmp424_); - _g_free0 (_tmp422_); - ccall = _tmp426_; + _tmp401_ = vala_code_node_get_tree_can_fail ((ValaCodeNode*) m); + _tmp402_ = _tmp401_; + if (_tmp402_) { + ValaHashMap* _tmp403_; + ValaCCodeIdentifier* _tmp404_; + ValaCCodeIdentifier* _tmp405_; + _tmp403_ = carg_map; + _tmp404_ = vala_ccode_identifier_new ("error"); + _tmp405_ = _tmp404_; + vala_map_set ((ValaMap*) _tmp403_, (gpointer) ((gintptr) vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, vala_get_ccode_error_pos ((ValaCallable*) m), FALSE)), (ValaCCodeExpression*) _tmp405_); + _vala_ccode_node_unref0 (_tmp405_); + } + _tmp406_ = vala_get_ccode_name ((ValaCodeNode*) m); + _tmp407_ = _tmp406_; + _tmp408_ = vala_ccode_identifier_new (_tmp407_); + _tmp409_ = _tmp408_; + _tmp410_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp409_); + _tmp411_ = _tmp410_; + _vala_ccode_node_unref0 (_tmp409_); + _g_free0 (_tmp407_); + ccall = _tmp411_; last_pos = -1; while (TRUE) { - ValaCCodeFunctionCall* _tmp437_; - ValaHashMap* _tmp438_; - gpointer _tmp439_; - ValaCCodeExpression* _tmp440_; + ValaCCodeFunctionCall* _tmp422_; + ValaHashMap* _tmp423_; + gpointer _tmp424_; + ValaCCodeExpression* _tmp425_; min_pos = -1; { ValaIterator* _pos_it = NULL; - ValaHashMap* _tmp427_; - ValaSet* _tmp428_; - ValaSet* _tmp429_; - ValaIterator* _tmp430_; - ValaIterator* _tmp431_; - _tmp427_ = carg_map; - _tmp428_ = vala_map_get_keys ((ValaMap*) _tmp427_); - _tmp429_ = _tmp428_; - _tmp430_ = vala_iterable_iterator ((ValaIterable*) _tmp429_); - _tmp431_ = _tmp430_; - _vala_iterable_unref0 (_tmp429_); - _pos_it = _tmp431_; + ValaHashMap* _tmp412_; + ValaSet* _tmp413_; + ValaSet* _tmp414_; + ValaIterator* _tmp415_; + ValaIterator* _tmp416_; + _tmp412_ = carg_map; + _tmp413_ = vala_map_get_keys ((ValaMap*) _tmp412_); + _tmp414_ = _tmp413_; + _tmp415_ = vala_iterable_iterator ((ValaIterable*) _tmp414_); + _tmp416_ = _tmp415_; + _vala_iterable_unref0 (_tmp414_); + _pos_it = _tmp416_; while (TRUE) { - ValaIterator* _tmp432_; + ValaIterator* _tmp417_; gint pos = 0; - ValaIterator* _tmp433_; - gpointer _tmp434_; - gboolean _tmp435_ = FALSE; - _tmp432_ = _pos_it; - if (!vala_iterator_next (_tmp432_)) { + ValaIterator* _tmp418_; + gpointer _tmp419_; + gboolean _tmp420_ = FALSE; + _tmp417_ = _pos_it; + if (!vala_iterator_next (_tmp417_)) { break; } - _tmp433_ = _pos_it; - _tmp434_ = vala_iterator_get (_tmp433_); - pos = (gint) ((gintptr) _tmp434_); + _tmp418_ = _pos_it; + _tmp419_ = vala_iterator_get (_tmp418_); + pos = (gint) ((gintptr) _tmp419_); if (pos > last_pos) { - gboolean _tmp436_ = FALSE; + gboolean _tmp421_ = FALSE; if (min_pos == -1) { - _tmp436_ = TRUE; + _tmp421_ = TRUE; } else { - _tmp436_ = pos < min_pos; + _tmp421_ = pos < min_pos; } - _tmp435_ = _tmp436_; + _tmp420_ = _tmp421_; } else { - _tmp435_ = FALSE; + _tmp420_ = FALSE; } - if (_tmp435_) { + if (_tmp420_) { min_pos = pos; } } @@ -2217,319 +2186,319 @@ if (min_pos == -1) { break; } - _tmp437_ = ccall; - _tmp438_ = carg_map; - _tmp439_ = vala_map_get ((ValaMap*) _tmp438_, (gpointer) ((gintptr) min_pos)); - _tmp440_ = (ValaCCodeExpression*) _tmp439_; - vala_ccode_function_call_add_argument (_tmp437_, _tmp440_); - _vala_ccode_node_unref0 (_tmp440_); + _tmp422_ = ccall; + _tmp423_ = carg_map; + _tmp424_ = vala_map_get ((ValaMap*) _tmp423_, (gpointer) ((gintptr) min_pos)); + _tmp425_ = (ValaCCodeExpression*) _tmp424_; + vala_ccode_function_call_add_argument (_tmp422_, _tmp425_); + _vala_ccode_node_unref0 (_tmp425_); last_pos = min_pos; } - _tmp441_ = vala_method_get_coroutine (m); - _tmp442_ = _tmp441_; - if (_tmp442_) { - ValaCCodeFunctionCall* _tmp443_; - ValaCCodeConstant* _tmp444_; - ValaCCodeConstant* _tmp445_; - ValaCCodeFunctionCall* _tmp446_; - ValaCCodeConstant* _tmp447_; - ValaCCodeConstant* _tmp448_; - _tmp443_ = ccall; - _tmp444_ = vala_ccode_constant_new ("NULL"); - _tmp445_ = _tmp444_; - vala_ccode_function_call_add_argument (_tmp443_, (ValaCCodeExpression*) _tmp445_); - _vala_ccode_node_unref0 (_tmp445_); - _tmp446_ = ccall; - _tmp447_ = vala_ccode_constant_new ("NULL"); - _tmp448_ = _tmp447_; - vala_ccode_function_call_add_argument (_tmp446_, (ValaCCodeExpression*) _tmp448_); - _vala_ccode_node_unref0 (_tmp448_); - } - _tmp450_ = vala_callable_get_return_type ((ValaCallable*) m); - _tmp451_ = _tmp450_; - if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp451_, VALA_TYPE_VOID_TYPE)) { - _tmp449_ = TRUE; + _tmp426_ = vala_method_get_coroutine (m); + _tmp427_ = _tmp426_; + if (_tmp427_) { + ValaCCodeFunctionCall* _tmp428_; + ValaCCodeConstant* _tmp429_; + ValaCCodeConstant* _tmp430_; + ValaCCodeFunctionCall* _tmp431_; + ValaCCodeConstant* _tmp432_; + ValaCCodeConstant* _tmp433_; + _tmp428_ = ccall; + _tmp429_ = vala_ccode_constant_new ("NULL"); + _tmp430_ = _tmp429_; + vala_ccode_function_call_add_argument (_tmp428_, (ValaCCodeExpression*) _tmp430_); + _vala_ccode_node_unref0 (_tmp430_); + _tmp431_ = ccall; + _tmp432_ = vala_ccode_constant_new ("NULL"); + _tmp433_ = _tmp432_; + vala_ccode_function_call_add_argument (_tmp431_, (ValaCCodeExpression*) _tmp433_); + _vala_ccode_node_unref0 (_tmp433_); + } + _tmp435_ = vala_callable_get_return_type ((ValaCallable*) m); + _tmp436_ = _tmp435_; + if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp436_, VALA_TYPE_VOID_TYPE)) { + _tmp434_ = TRUE; } else { - ValaDataType* _tmp452_; - ValaDataType* _tmp453_; - _tmp452_ = vala_callable_get_return_type ((ValaCallable*) m); - _tmp453_ = _tmp452_; - _tmp449_ = vala_data_type_is_real_non_null_struct_type (_tmp453_); - } - if (_tmp449_) { - ValaCCodeFunction* _tmp454_; - ValaCCodeFunction* _tmp455_; - ValaCCodeFunctionCall* _tmp456_; - gboolean _tmp457_ = FALSE; - ValaDelegate* _tmp458_; - ValaDataType* _tmp459_; - ValaDataType* _tmp460_; - _tmp454_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); - _tmp455_ = _tmp454_; - _tmp456_ = ccall; - vala_ccode_function_add_expression (_tmp455_, (ValaCCodeExpression*) _tmp456_); - _tmp458_ = d; - _tmp459_ = vala_callable_get_return_type ((ValaCallable*) _tmp458_); - _tmp460_ = _tmp459_; - if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp460_, VALA_TYPE_VOID_TYPE)) { - _tmp457_ = TRUE; + ValaDataType* _tmp437_; + ValaDataType* _tmp438_; + _tmp437_ = vala_callable_get_return_type ((ValaCallable*) m); + _tmp438_ = _tmp437_; + _tmp434_ = vala_data_type_is_real_non_null_struct_type (_tmp438_); + } + if (_tmp434_) { + ValaCCodeFunction* _tmp439_; + ValaCCodeFunction* _tmp440_; + ValaCCodeFunctionCall* _tmp441_; + gboolean _tmp442_ = FALSE; + ValaDelegate* _tmp443_; + ValaDataType* _tmp444_; + ValaDataType* _tmp445_; + _tmp439_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp440_ = _tmp439_; + _tmp441_ = ccall; + vala_ccode_function_add_expression (_tmp440_, (ValaCCodeExpression*) _tmp441_); + _tmp443_ = d; + _tmp444_ = vala_callable_get_return_type ((ValaCallable*) _tmp443_); + _tmp445_ = _tmp444_; + if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp445_, VALA_TYPE_VOID_TYPE)) { + _tmp442_ = TRUE; } else { - ValaDelegate* _tmp461_; - ValaDataType* _tmp462_; - ValaDataType* _tmp463_; - _tmp461_ = d; - _tmp462_ = vala_callable_get_return_type ((ValaCallable*) _tmp461_); - _tmp463_ = _tmp462_; - _tmp457_ = vala_data_type_is_real_non_null_struct_type (_tmp463_); + ValaDelegate* _tmp446_; + ValaDataType* _tmp447_; + ValaDataType* _tmp448_; + _tmp446_ = d; + _tmp447_ = vala_callable_get_return_type ((ValaCallable*) _tmp446_); + _tmp448_ = _tmp447_; + _tmp442_ = vala_data_type_is_real_non_null_struct_type (_tmp448_); } - if (!_tmp457_) { - ValaCCodeFunction* _tmp464_; - ValaCCodeFunction* _tmp465_; - ValaDataType* _tmp466_; - gchar* _tmp467_; - gchar* _tmp468_; - ValaDelegate* _tmp469_; - ValaDataType* _tmp470_; - ValaDataType* _tmp471_; - ValaCCodeExpression* _tmp472_; - ValaCCodeExpression* _tmp473_; - ValaCCodeVariableDeclarator* _tmp474_; - ValaCCodeVariableDeclarator* _tmp475_; - _tmp464_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); - _tmp465_ = _tmp464_; - _tmp466_ = creturn_type; - _tmp467_ = vala_get_ccode_name ((ValaCodeNode*) _tmp466_); - _tmp468_ = _tmp467_; - _tmp469_ = d; - _tmp470_ = vala_callable_get_return_type ((ValaCallable*) _tmp469_); - _tmp471_ = _tmp470_; - _tmp472_ = vala_ccode_base_module_default_value_for_type ((ValaCCodeBaseModule*) self, _tmp471_, TRUE, FALSE); - _tmp473_ = _tmp472_; - _tmp474_ = vala_ccode_variable_declarator_new ("result", _tmp473_, NULL); - _tmp475_ = _tmp474_; - vala_ccode_function_add_declaration (_tmp465_, _tmp468_, (ValaCCodeDeclarator*) _tmp475_, 0); - _vala_ccode_node_unref0 (_tmp475_); - _vala_ccode_node_unref0 (_tmp473_); - _g_free0 (_tmp468_); + if (!_tmp442_) { + ValaCCodeFunction* _tmp449_; + ValaCCodeFunction* _tmp450_; + ValaDataType* _tmp451_; + gchar* _tmp452_; + gchar* _tmp453_; + ValaDelegate* _tmp454_; + ValaDataType* _tmp455_; + ValaDataType* _tmp456_; + ValaCCodeExpression* _tmp457_; + ValaCCodeExpression* _tmp458_; + ValaCCodeVariableDeclarator* _tmp459_; + ValaCCodeVariableDeclarator* _tmp460_; + _tmp449_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp450_ = _tmp449_; + _tmp451_ = creturn_type; + _tmp452_ = vala_get_ccode_name ((ValaCodeNode*) _tmp451_); + _tmp453_ = _tmp452_; + _tmp454_ = d; + _tmp455_ = vala_callable_get_return_type ((ValaCallable*) _tmp454_); + _tmp456_ = _tmp455_; + _tmp457_ = vala_ccode_base_module_default_value_for_type ((ValaCCodeBaseModule*) self, _tmp456_, TRUE, FALSE); + _tmp458_ = _tmp457_; + _tmp459_ = vala_ccode_variable_declarator_new ("result", _tmp458_, NULL); + _tmp460_ = _tmp459_; + vala_ccode_function_add_declaration (_tmp450_, _tmp453_, (ValaCCodeDeclarator*) _tmp460_, 0); + _vala_ccode_node_unref0 (_tmp460_); + _vala_ccode_node_unref0 (_tmp458_); + _g_free0 (_tmp453_); } } else { ValaCCodeExpression* _result_ = NULL; - ValaCCodeFunctionCall* _tmp476_; - ValaCCodeExpression* _tmp477_; - ValaDelegate* _tmp478_; - ValaDataType* _tmp479_; - ValaDataType* _tmp480_; - ValaCCodeFunction* _tmp485_; - ValaCCodeFunction* _tmp486_; - ValaDataType* _tmp487_; - gchar* _tmp488_; - gchar* _tmp489_; - ValaCCodeExpression* _tmp490_; - ValaCCodeVariableDeclarator* _tmp491_; - ValaCCodeVariableDeclarator* _tmp492_; - _tmp476_ = ccall; - _tmp477_ = _vala_ccode_node_ref0 ((ValaCCodeExpression*) _tmp476_); - _result_ = _tmp477_; - _tmp478_ = d; - _tmp479_ = vala_callable_get_return_type ((ValaCallable*) _tmp478_); - _tmp480_ = _tmp479_; - if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp480_, VALA_TYPE_GENERIC_TYPE)) { - ValaCCodeExpression* _tmp481_; - ValaDataType* _tmp482_; - ValaDataType* _tmp483_; - ValaCCodeExpression* _tmp484_; - _tmp481_ = _result_; - _tmp482_ = vala_callable_get_return_type ((ValaCallable*) m); - _tmp483_ = _tmp482_; - _tmp484_ = vala_ccode_base_module_convert_to_generic_pointer ((ValaCCodeBaseModule*) self, _tmp481_, _tmp483_); + ValaCCodeFunctionCall* _tmp461_; + ValaCCodeExpression* _tmp462_; + ValaDelegate* _tmp463_; + ValaDataType* _tmp464_; + ValaDataType* _tmp465_; + ValaCCodeFunction* _tmp470_; + ValaCCodeFunction* _tmp471_; + ValaDataType* _tmp472_; + gchar* _tmp473_; + gchar* _tmp474_; + ValaCCodeExpression* _tmp475_; + ValaCCodeVariableDeclarator* _tmp476_; + ValaCCodeVariableDeclarator* _tmp477_; + _tmp461_ = ccall; + _tmp462_ = _vala_ccode_node_ref0 ((ValaCCodeExpression*) _tmp461_); + _result_ = _tmp462_; + _tmp463_ = d; + _tmp464_ = vala_callable_get_return_type ((ValaCallable*) _tmp463_); + _tmp465_ = _tmp464_; + if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp465_, VALA_TYPE_GENERIC_TYPE)) { + ValaCCodeExpression* _tmp466_; + ValaDataType* _tmp467_; + ValaDataType* _tmp468_; + ValaCCodeExpression* _tmp469_; + _tmp466_ = _result_; + _tmp467_ = vala_callable_get_return_type ((ValaCallable*) m); + _tmp468_ = _tmp467_; + _tmp469_ = vala_ccode_base_module_convert_to_generic_pointer ((ValaCCodeBaseModule*) self, _tmp466_, _tmp468_); _vala_ccode_node_unref0 (_result_); - _result_ = _tmp484_; + _result_ = _tmp469_; } - _tmp485_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); - _tmp486_ = _tmp485_; - _tmp487_ = creturn_type; - _tmp488_ = vala_get_ccode_name ((ValaCodeNode*) _tmp487_); - _tmp489_ = _tmp488_; - _tmp490_ = _result_; - _tmp491_ = vala_ccode_variable_declarator_new ("result", _tmp490_, NULL); - _tmp492_ = _tmp491_; - vala_ccode_function_add_declaration (_tmp486_, _tmp489_, (ValaCCodeDeclarator*) _tmp492_, 0); - _vala_ccode_node_unref0 (_tmp492_); - _g_free0 (_tmp489_); + _tmp470_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp471_ = _tmp470_; + _tmp472_ = creturn_type; + _tmp473_ = vala_get_ccode_name ((ValaCodeNode*) _tmp472_); + _tmp474_ = _tmp473_; + _tmp475_ = _result_; + _tmp476_ = vala_ccode_variable_declarator_new ("result", _tmp475_, NULL); + _tmp477_ = _tmp476_; + vala_ccode_function_add_declaration (_tmp471_, _tmp474_, (ValaCCodeDeclarator*) _tmp477_, 0); + _vala_ccode_node_unref0 (_tmp477_); + _g_free0 (_tmp474_); _vala_ccode_node_unref0 (_result_); } - _tmp494_ = d; - _tmp495_ = vala_delegate_get_has_target (_tmp494_); - _tmp496_ = _tmp495_; - if (_tmp496_) { - gboolean _tmp497_; - gboolean _tmp498_; - _tmp497_ = vala_delegate_type_get_is_called_once (dt); - _tmp498_ = _tmp497_; - _tmp493_ = _tmp498_; + _tmp479_ = d; + _tmp480_ = vala_delegate_get_has_target (_tmp479_); + _tmp481_ = _tmp480_; + if (_tmp481_) { + gboolean _tmp482_; + gboolean _tmp483_; + _tmp482_ = vala_delegate_type_get_is_called_once (dt); + _tmp483_ = _tmp482_; + _tmp478_ = _tmp483_; } else { - _tmp493_ = FALSE; + _tmp478_ = FALSE; } - if (_tmp493_) { + if (_tmp478_) { ValaCCodeExpression* destroy_notify = NULL; - gboolean _tmp499_; - gboolean _tmp500_; - ValaCCodeExpression* _tmp525_; + gboolean _tmp484_; + gboolean _tmp485_; + ValaCCodeExpression* _tmp510_; destroy_notify = NULL; - _tmp499_ = vala_method_get_closure (m); - _tmp500_ = _tmp499_; - if (_tmp500_) { + _tmp484_ = vala_method_get_closure (m); + _tmp485_ = _tmp484_; + if (_tmp485_) { gint block_id = 0; - ValaBlock* _tmp501_; - ValaBlock* _tmp502_; - gchar* _tmp503_; - gchar* _tmp504_; - ValaCCodeIdentifier* _tmp505_; - _tmp501_ = vala_ccode_base_module_get_current_closure_block ((ValaCCodeBaseModule*) self); - _tmp502_ = _tmp501_; - block_id = vala_ccode_base_module_get_block_id ((ValaCCodeBaseModule*) self, _tmp502_); - _tmp503_ = g_strdup_printf ("block%d_data_unref", block_id); - _tmp504_ = _tmp503_; - _tmp505_ = vala_ccode_identifier_new (_tmp504_); + ValaBlock* _tmp486_; + ValaBlock* _tmp487_; + gchar* _tmp488_; + gchar* _tmp489_; + ValaCCodeIdentifier* _tmp490_; + _tmp486_ = vala_ccode_base_module_get_current_closure_block ((ValaCCodeBaseModule*) self); + _tmp487_ = _tmp486_; + block_id = vala_ccode_base_module_get_block_id ((ValaCCodeBaseModule*) self, _tmp487_); + _tmp488_ = g_strdup_printf ("block%d_data_unref", block_id); + _tmp489_ = _tmp488_; + _tmp490_ = vala_ccode_identifier_new (_tmp489_); _vala_ccode_node_unref0 (destroy_notify); - destroy_notify = (ValaCCodeExpression*) _tmp505_; - _g_free0 (_tmp504_); + destroy_notify = (ValaCCodeExpression*) _tmp490_; + _g_free0 (_tmp489_); } else { - gboolean _tmp506_ = FALSE; - gboolean _tmp507_ = FALSE; - gboolean _tmp508_ = FALSE; - ValaDataType* _tmp509_; - _tmp509_ = vala_ccode_base_module_get_this_type ((ValaCCodeBaseModule*) self); - if (_tmp509_ != NULL) { - ValaMemberBinding _tmp510_; - ValaMemberBinding _tmp511_; - _tmp510_ = vala_method_get_binding (m); - _tmp511_ = _tmp510_; - _tmp508_ = _tmp511_ != VALA_MEMBER_BINDING_STATIC; + gboolean _tmp491_ = FALSE; + gboolean _tmp492_ = FALSE; + gboolean _tmp493_ = FALSE; + ValaDataType* _tmp494_; + _tmp494_ = vala_ccode_base_module_get_this_type ((ValaCCodeBaseModule*) self); + if (_tmp494_ != NULL) { + ValaMemberBinding _tmp495_; + ValaMemberBinding _tmp496_; + _tmp495_ = vala_method_get_binding (m); + _tmp496_ = _tmp495_; + _tmp493_ = _tmp496_ != VALA_MEMBER_BINDING_STATIC; } else { - _tmp508_ = FALSE; + _tmp493_ = FALSE; } - if (_tmp508_) { - gboolean _tmp512_; - gboolean _tmp513_; - _tmp512_ = vala_method_get_is_async_callback (m); - _tmp513_ = _tmp512_; - _tmp507_ = !_tmp513_; + if (_tmp493_) { + gboolean _tmp497_; + gboolean _tmp498_; + _tmp497_ = vala_method_get_is_async_callback (m); + _tmp498_ = _tmp497_; + _tmp492_ = !_tmp498_; } else { - _tmp507_ = FALSE; + _tmp492_ = FALSE; } - if (_tmp507_) { - ValaParameter* _tmp514_; - ValaParameter* _tmp515_; - ValaDataType* _tmp516_; - ValaDataType* _tmp517_; - ValaTypeSymbol* _tmp518_; - ValaTypeSymbol* _tmp519_; - _tmp514_ = vala_method_get_this_parameter (m); - _tmp515_ = _tmp514_; - _tmp516_ = vala_variable_get_variable_type ((ValaVariable*) _tmp515_); - _tmp517_ = _tmp516_; - _tmp518_ = vala_data_type_get_type_symbol (_tmp517_); - _tmp519_ = _tmp518_; - _tmp506_ = vala_is_reference_counting (_tmp519_); + if (_tmp492_) { + ValaParameter* _tmp499_; + ValaParameter* _tmp500_; + ValaDataType* _tmp501_; + ValaDataType* _tmp502_; + ValaTypeSymbol* _tmp503_; + ValaTypeSymbol* _tmp504_; + _tmp499_ = vala_method_get_this_parameter (m); + _tmp500_ = _tmp499_; + _tmp501_ = vala_variable_get_variable_type ((ValaVariable*) _tmp500_); + _tmp502_ = _tmp501_; + _tmp503_ = vala_data_type_get_type_symbol (_tmp502_); + _tmp504_ = _tmp503_; + _tmp491_ = vala_is_reference_counting (_tmp504_); } else { - _tmp506_ = FALSE; + _tmp491_ = FALSE; } - if (_tmp506_) { - ValaParameter* _tmp520_; - ValaParameter* _tmp521_; - ValaDataType* _tmp522_; - ValaDataType* _tmp523_; - ValaCCodeExpression* _tmp524_; - _tmp520_ = vala_method_get_this_parameter (m); - _tmp521_ = _tmp520_; - _tmp522_ = vala_variable_get_variable_type ((ValaVariable*) _tmp521_); - _tmp523_ = _tmp522_; - _tmp524_ = vala_ccode_base_module_get_destroy_func_expression ((ValaCCodeBaseModule*) self, _tmp523_, FALSE); + if (_tmp491_) { + ValaParameter* _tmp505_; + ValaParameter* _tmp506_; + ValaDataType* _tmp507_; + ValaDataType* _tmp508_; + ValaCCodeExpression* _tmp509_; + _tmp505_ = vala_method_get_this_parameter (m); + _tmp506_ = _tmp505_; + _tmp507_ = vala_variable_get_variable_type ((ValaVariable*) _tmp506_); + _tmp508_ = _tmp507_; + _tmp509_ = vala_ccode_base_module_get_destroy_func_expression ((ValaCCodeBaseModule*) self, _tmp508_, FALSE); _vala_ccode_node_unref0 (destroy_notify); - destroy_notify = _tmp524_; + destroy_notify = _tmp509_; } } - _tmp525_ = destroy_notify; - if (_tmp525_ != NULL) { + _tmp510_ = destroy_notify; + if (_tmp510_ != NULL) { ValaCCodeFunctionCall* unref_call = NULL; - ValaCCodeExpression* _tmp526_; - ValaCCodeFunctionCall* _tmp527_; - ValaCCodeFunctionCall* _tmp528_; - ValaCCodeIdentifier* _tmp529_; - ValaCCodeIdentifier* _tmp530_; - ValaCCodeFunction* _tmp531_; - ValaCCodeFunction* _tmp532_; - ValaCCodeFunctionCall* _tmp533_; - _tmp526_ = destroy_notify; - _tmp527_ = vala_ccode_function_call_new (_tmp526_); - unref_call = _tmp527_; - _tmp528_ = unref_call; - _tmp529_ = vala_ccode_identifier_new ("self"); - _tmp530_ = _tmp529_; - vala_ccode_function_call_add_argument (_tmp528_, (ValaCCodeExpression*) _tmp530_); - _vala_ccode_node_unref0 (_tmp530_); - _tmp531_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); - _tmp532_ = _tmp531_; - _tmp533_ = unref_call; - vala_ccode_function_add_expression (_tmp532_, (ValaCCodeExpression*) _tmp533_); + ValaCCodeExpression* _tmp511_; + ValaCCodeFunctionCall* _tmp512_; + ValaCCodeFunctionCall* _tmp513_; + ValaCCodeIdentifier* _tmp514_; + ValaCCodeIdentifier* _tmp515_; + ValaCCodeFunction* _tmp516_; + ValaCCodeFunction* _tmp517_; + ValaCCodeFunctionCall* _tmp518_; + _tmp511_ = destroy_notify; + _tmp512_ = vala_ccode_function_call_new (_tmp511_); + unref_call = _tmp512_; + _tmp513_ = unref_call; + _tmp514_ = vala_ccode_identifier_new ("self"); + _tmp515_ = _tmp514_; + vala_ccode_function_call_add_argument (_tmp513_, (ValaCCodeExpression*) _tmp515_); + _vala_ccode_node_unref0 (_tmp515_); + _tmp516_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp517_ = _tmp516_; + _tmp518_ = unref_call; + vala_ccode_function_add_expression (_tmp517_, (ValaCCodeExpression*) _tmp518_); _vala_ccode_node_unref0 (unref_call); } _vala_ccode_node_unref0 (destroy_notify); } - _tmp536_ = vala_callable_get_return_type ((ValaCallable*) m); - _tmp537_ = _tmp536_; - if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp537_, VALA_TYPE_VOID_TYPE)) { - _tmp535_ = TRUE; + _tmp521_ = vala_callable_get_return_type ((ValaCallable*) m); + _tmp522_ = _tmp521_; + if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp522_, VALA_TYPE_VOID_TYPE)) { + _tmp520_ = TRUE; } else { - ValaDataType* _tmp538_; - ValaDataType* _tmp539_; - _tmp538_ = vala_callable_get_return_type ((ValaCallable*) m); - _tmp539_ = _tmp538_; - _tmp535_ = vala_data_type_is_real_non_null_struct_type (_tmp539_); + ValaDataType* _tmp523_; + ValaDataType* _tmp524_; + _tmp523_ = vala_callable_get_return_type ((ValaCallable*) m); + _tmp524_ = _tmp523_; + _tmp520_ = vala_data_type_is_real_non_null_struct_type (_tmp524_); } - if (!_tmp535_) { - _tmp534_ = TRUE; + if (!_tmp520_) { + _tmp519_ = TRUE; } else { - gboolean _tmp540_ = FALSE; - ValaDelegate* _tmp541_; - ValaDataType* _tmp542_; - ValaDataType* _tmp543_; - _tmp541_ = d; - _tmp542_ = vala_callable_get_return_type ((ValaCallable*) _tmp541_); - _tmp543_ = _tmp542_; - if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp543_, VALA_TYPE_VOID_TYPE)) { - _tmp540_ = TRUE; + gboolean _tmp525_ = FALSE; + ValaDelegate* _tmp526_; + ValaDataType* _tmp527_; + ValaDataType* _tmp528_; + _tmp526_ = d; + _tmp527_ = vala_callable_get_return_type ((ValaCallable*) _tmp526_); + _tmp528_ = _tmp527_; + if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp528_, VALA_TYPE_VOID_TYPE)) { + _tmp525_ = TRUE; } else { - ValaDelegate* _tmp544_; - ValaDataType* _tmp545_; - ValaDataType* _tmp546_; - _tmp544_ = d; - _tmp545_ = vala_callable_get_return_type ((ValaCallable*) _tmp544_); - _tmp546_ = _tmp545_; - _tmp540_ = vala_data_type_is_real_non_null_struct_type (_tmp546_); + ValaDelegate* _tmp529_; + ValaDataType* _tmp530_; + ValaDataType* _tmp531_; + _tmp529_ = d; + _tmp530_ = vala_callable_get_return_type ((ValaCallable*) _tmp529_); + _tmp531_ = _tmp530_; + _tmp525_ = vala_data_type_is_real_non_null_struct_type (_tmp531_); } - _tmp534_ = !_tmp540_; + _tmp519_ = !_tmp525_; } - if (_tmp534_) { - ValaCCodeFunction* _tmp547_; - ValaCCodeFunction* _tmp548_; - ValaCCodeIdentifier* _tmp549_; - ValaCCodeIdentifier* _tmp550_; - _tmp547_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); - _tmp548_ = _tmp547_; - _tmp549_ = vala_ccode_identifier_new ("result"); - _tmp550_ = _tmp549_; - vala_ccode_function_add_return (_tmp548_, (ValaCCodeExpression*) _tmp550_); - _vala_ccode_node_unref0 (_tmp550_); + if (_tmp519_) { + ValaCCodeFunction* _tmp532_; + ValaCCodeFunction* _tmp533_; + ValaCCodeIdentifier* _tmp534_; + ValaCCodeIdentifier* _tmp535_; + _tmp532_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp533_ = _tmp532_; + _tmp534_ = vala_ccode_identifier_new ("result"); + _tmp535_ = _tmp534_; + vala_ccode_function_add_return (_tmp533_, (ValaCCodeExpression*) _tmp535_); + _vala_ccode_node_unref0 (_tmp535_); } vala_ccode_base_module_pop_function ((ValaCCodeBaseModule*) self); - _tmp551_ = ((ValaCCodeBaseModule*) self)->cfile; - _tmp552_ = function; - vala_ccode_file_add_function_declaration (_tmp551_, _tmp552_); - _tmp553_ = ((ValaCCodeBaseModule*) self)->cfile; - _tmp554_ = function; - vala_ccode_file_add_function (_tmp553_, _tmp554_); + _tmp536_ = ((ValaCCodeBaseModule*) self)->cfile; + _tmp537_ = function; + vala_ccode_file_add_function_declaration (_tmp536_, _tmp537_); + _tmp538_ = ((ValaCCodeBaseModule*) self)->cfile; + _tmp539_ = function; + vala_ccode_file_add_function (_tmp538_, _tmp539_); result = wrapper_name; _vala_ccode_node_unref0 (ccall); _vala_map_unref0 (carg_map); diff -Nru vala-0.56.16/codegen/valaccodedelegatemodule.vala vala-0.56.17/codegen/valaccodedelegatemodule.vala --- vala-0.56.16/codegen/valaccodedelegatemodule.vala 2023-12-13 07:24:35.000000000 +0000 +++ vala-0.56.17/codegen/valaccodedelegatemodule.vala 2024-04-19 10:23:32.000000000 +0000 @@ -315,9 +315,10 @@ continue; } + var d_param = d_params.get (i); CCodeExpression arg; - arg = new CCodeIdentifier (get_ccode_name (d_params.get (i))); - if (d_params.get (i).variable_type is GenericType) { + arg = new CCodeIdentifier (get_ccode_name (d_param)); + if (d_param.variable_type is GenericType) { arg = convert_from_generic_pointer (arg, param.variable_type); } carg_map.set (get_param_pos (get_ccode_pos (param)), arg); @@ -327,15 +328,15 @@ var array_type = (ArrayType) param.variable_type; for (int dim = 1; dim <= array_type.rank; dim++) { CCodeExpression clength; - if (get_ccode_array_null_terminated (d_params.get (i))) { + if (get_ccode_array_null_terminated (d_param) && !get_ccode_array_length (d_param)) { requires_array_length = true; var len_call = new CCodeFunctionCall (new CCodeIdentifier ("_vala_array_length")); - len_call.add_argument (new CCodeIdentifier (d_params.get (i).name)); + len_call.add_argument (new CCodeIdentifier (d_param.name)); clength = len_call; - } else if (!get_ccode_array_length (d_params.get (i))) { + } else if (!get_ccode_array_length (d_param)) { clength = new CCodeConstant ("-1"); } else { - clength = new CCodeIdentifier (get_variable_array_length_cname (d_params.get (i), dim)); + clength = new CCodeIdentifier (get_variable_array_length_cname (d_param, dim)); } carg_map.set (get_param_pos (get_ccode_array_length_pos (param) + 0.01 * dim), clength); } @@ -343,10 +344,10 @@ var deleg_type = (DelegateType) param.variable_type; if (deleg_type.delegate_symbol.has_target) { - var ctarget = new CCodeIdentifier (get_ccode_delegate_target_name (d_params.get (i))); + var ctarget = new CCodeIdentifier (get_ccode_delegate_target_name (d_param)); carg_map.set (get_param_pos (get_ccode_delegate_target_pos (param)), ctarget); if (deleg_type.is_disposable ()) { - var ctarget_destroy_notify = new CCodeIdentifier (get_ccode_delegate_target_destroy_notify_name (d_params.get (i))); + var ctarget_destroy_notify = new CCodeIdentifier (get_ccode_delegate_target_destroy_notify_name (d_param)); carg_map.set (get_param_pos (get_ccode_destroy_notify_pos (m)), ctarget_destroy_notify); } } diff -Nru vala-0.56.16/codegen/valaccodememberaccessmodule.c vala-0.56.17/codegen/valaccodememberaccessmodule.c --- vala-0.56.16/codegen/valaccodememberaccessmodule.c 2024-03-14 09:03:36.000000000 +0000 +++ vala-0.56.17/codegen/valaccodememberaccessmodule.c 2024-04-19 11:03:37.000000000 +0000 @@ -114,8 +114,8 @@ ValaDelegateType* _tmp11_; ValaSymbol* _tmp12_; ValaSymbol* _tmp13_; - ValaSymbol* _tmp964_; - ValaSymbol* _tmp965_; + ValaSymbol* _tmp968_; + ValaSymbol* _tmp969_; self = (ValaCCodeMemberAccessModule*) base; g_return_if_fail (expr != NULL); pub_inst = NULL; @@ -1363,15 +1363,15 @@ gboolean _tmp488_ = FALSE; ValaExpression* _tmp489_; ValaExpression* _tmp490_; - ValaProperty* _tmp871_; - ValaPropertyAccessor* _tmp872_; - ValaPropertyAccessor* _tmp873_; - ValaDataType* _tmp874_; - ValaDataType* _tmp875_; - ValaTargetValue* _tmp891_; - ValaTargetValue* _tmp892_; - ValaTargetValue* _tmp893_; - ValaTargetValue* _tmp894_; + ValaProperty* _tmp875_; + ValaPropertyAccessor* _tmp876_; + ValaPropertyAccessor* _tmp877_; + ValaDataType* _tmp878_; + ValaDataType* _tmp879_; + ValaTargetValue* _tmp895_; + ValaTargetValue* _tmp896_; + ValaTargetValue* _tmp897_; + ValaTargetValue* _tmp898_; _tmp445_ = vala_expression_get_symbol_reference ((ValaExpression*) expr); _tmp446_ = _tmp445_; _tmp447_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp446_, VALA_TYPE_PROPERTY, ValaProperty)); @@ -2044,307 +2044,315 @@ array_type = _tmp692_; _tmp693_ = array_type; if (_tmp693_ != NULL) { - ValaProperty* _tmp694_; - _tmp694_ = prop; - if (vala_get_ccode_array_null_terminated ((ValaCodeNode*) _tmp694_)) { + gboolean _tmp694_ = FALSE; + ValaProperty* _tmp695_; + _tmp695_ = prop; + if (vala_get_ccode_array_null_terminated ((ValaCodeNode*) _tmp695_)) { + ValaProperty* _tmp696_; + _tmp696_ = prop; + _tmp694_ = !vala_get_ccode_array_length ((ValaCodeNode*) _tmp696_); + } else { + _tmp694_ = FALSE; + } + if (_tmp694_) { ValaCCodeFunctionCall* len_call = NULL; - ValaCCodeIdentifier* _tmp695_; - ValaCCodeIdentifier* _tmp696_; - ValaCCodeFunctionCall* _tmp697_; - ValaCCodeFunctionCall* _tmp698_; + ValaCCodeIdentifier* _tmp697_; + ValaCCodeIdentifier* _tmp698_; ValaCCodeFunctionCall* _tmp699_; - ValaCCodeExpression* _tmp700_; - ValaCCodeFunction* _tmp701_; - ValaCCodeFunction* _tmp702_; - ValaCCodeExpression* _tmp703_; - ValaCCodeFunctionCall* _tmp704_; - ValaCCodeFunction* _tmp705_; - ValaCCodeFunction* _tmp706_; - ValaGLibValue* _tmp707_; - ValaList* _tmp708_; - gpointer _tmp709_; - ValaCCodeExpression* _tmp710_; - ValaCCodeFunctionCall* _tmp711_; + ValaCCodeFunctionCall* _tmp700_; + ValaCCodeFunctionCall* _tmp701_; + ValaCCodeExpression* _tmp702_; + ValaCCodeFunction* _tmp703_; + ValaCCodeFunction* _tmp704_; + ValaCCodeExpression* _tmp705_; + ValaCCodeFunctionCall* _tmp706_; + ValaCCodeFunction* _tmp707_; + ValaCCodeFunction* _tmp708_; + ValaGLibValue* _tmp709_; + ValaList* _tmp710_; + gpointer _tmp711_; + ValaCCodeExpression* _tmp712_; + ValaCCodeFunctionCall* _tmp713_; ((ValaCCodeBaseModule*) self)->requires_array_length = TRUE; - _tmp695_ = vala_ccode_identifier_new ("_vala_array_length"); - _tmp696_ = _tmp695_; - _tmp697_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp696_); + _tmp697_ = vala_ccode_identifier_new ("_vala_array_length"); _tmp698_ = _tmp697_; - _vala_ccode_node_unref0 (_tmp696_); - len_call = _tmp698_; - _tmp699_ = len_call; - _tmp700_ = ctemp; - vala_ccode_function_call_add_argument (_tmp699_, _tmp700_); - _tmp701_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); - _tmp702_ = _tmp701_; - _tmp703_ = ctemp; - _tmp704_ = ccall; - vala_ccode_function_add_assignment (_tmp702_, _tmp703_, (ValaCCodeExpression*) _tmp704_); - _tmp705_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); - _tmp706_ = _tmp705_; - _tmp707_ = temp_value; - _tmp708_ = _tmp707_->array_length_cvalues; - _tmp709_ = vala_list_get (_tmp708_, 0); - _tmp710_ = (ValaCCodeExpression*) _tmp709_; - _tmp711_ = len_call; - vala_ccode_function_add_assignment (_tmp706_, _tmp710_, (ValaCCodeExpression*) _tmp711_); - _vala_ccode_node_unref0 (_tmp710_); + _tmp699_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp698_); + _tmp700_ = _tmp699_; + _vala_ccode_node_unref0 (_tmp698_); + len_call = _tmp700_; + _tmp701_ = len_call; + _tmp702_ = ctemp; + vala_ccode_function_call_add_argument (_tmp701_, _tmp702_); + _tmp703_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp704_ = _tmp703_; + _tmp705_ = ctemp; + _tmp706_ = ccall; + vala_ccode_function_add_assignment (_tmp704_, _tmp705_, (ValaCCodeExpression*) _tmp706_); + _tmp707_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp708_ = _tmp707_; + _tmp709_ = temp_value; + _tmp710_ = _tmp709_->array_length_cvalues; + _tmp711_ = vala_list_get (_tmp710_, 0); + _tmp712_ = (ValaCCodeExpression*) _tmp711_; + _tmp713_ = len_call; + vala_ccode_function_add_assignment (_tmp708_, _tmp712_, (ValaCCodeExpression*) _tmp713_); + _vala_ccode_node_unref0 (_tmp712_); _vala_ccode_node_unref0 (len_call); } else { - ValaProperty* _tmp712_; - _tmp712_ = prop; - if (vala_get_ccode_array_length ((ValaCodeNode*) _tmp712_)) { + ValaProperty* _tmp714_; + _tmp714_ = prop; + if (vala_get_ccode_array_length ((ValaCodeNode*) _tmp714_)) { ValaArrayList* temp_refs = NULL; - GEqualFunc _tmp713_; - ValaArrayList* _tmp714_; - ValaCCodeFunction* _tmp738_; - ValaCCodeFunction* _tmp739_; - ValaCCodeExpression* _tmp740_; - ValaCCodeFunctionCall* _tmp741_; - _tmp713_ = g_direct_equal; - _tmp714_ = vala_array_list_new (VALA_TYPE_CCODE_EXPRESSION, (GBoxedCopyFunc) vala_ccode_node_ref, (GDestroyNotify) vala_ccode_node_unref, _tmp713_); - temp_refs = _tmp714_; + GEqualFunc _tmp715_; + ValaArrayList* _tmp716_; + ValaCCodeFunction* _tmp740_; + ValaCCodeFunction* _tmp741_; + ValaCCodeExpression* _tmp742_; + ValaCCodeFunctionCall* _tmp743_; + _tmp715_ = g_direct_equal; + _tmp716_ = vala_array_list_new (VALA_TYPE_CCODE_EXPRESSION, (GBoxedCopyFunc) vala_ccode_node_ref, (GDestroyNotify) vala_ccode_node_unref, _tmp715_); + temp_refs = _tmp716_; { gint dim = 0; dim = 1; { - gboolean _tmp715_ = FALSE; - _tmp715_ = TRUE; + gboolean _tmp717_ = FALSE; + _tmp717_ = TRUE; while (TRUE) { - ValaArrayType* _tmp717_; - gint _tmp718_; - gint _tmp719_; + ValaArrayType* _tmp719_; + gint _tmp720_; + gint _tmp721_; gchar* length_ctype = NULL; - ValaProperty* _tmp720_; - gchar* _tmp721_; + ValaProperty* _tmp722_; + gchar* _tmp723_; ValaLocalVariable* temp_var = NULL; - const gchar* _tmp722_; - ValaCType* _tmp723_; - ValaCType* _tmp724_; - ValaLocalVariable* _tmp725_; - ValaLocalVariable* _tmp726_; - ValaCCodeExpression* temp_ref = NULL; + const gchar* _tmp724_; + ValaCType* _tmp725_; + ValaCType* _tmp726_; ValaLocalVariable* _tmp727_; - const gchar* _tmp728_; - const gchar* _tmp729_; - ValaCCodeExpression* _tmp730_; - ValaLocalVariable* _tmp731_; - ValaCCodeFunctionCall* _tmp732_; - ValaCCodeExpression* _tmp733_; - ValaCCodeUnaryExpression* _tmp734_; - ValaCCodeUnaryExpression* _tmp735_; - ValaArrayList* _tmp736_; - ValaCCodeExpression* _tmp737_; - if (!_tmp715_) { - gint _tmp716_; - _tmp716_ = dim; - dim = _tmp716_ + 1; + ValaLocalVariable* _tmp728_; + ValaCCodeExpression* temp_ref = NULL; + ValaLocalVariable* _tmp729_; + const gchar* _tmp730_; + const gchar* _tmp731_; + ValaCCodeExpression* _tmp732_; + ValaLocalVariable* _tmp733_; + ValaCCodeFunctionCall* _tmp734_; + ValaCCodeExpression* _tmp735_; + ValaCCodeUnaryExpression* _tmp736_; + ValaCCodeUnaryExpression* _tmp737_; + ValaArrayList* _tmp738_; + ValaCCodeExpression* _tmp739_; + if (!_tmp717_) { + gint _tmp718_; + _tmp718_ = dim; + dim = _tmp718_ + 1; } - _tmp715_ = FALSE; - _tmp717_ = array_type; - _tmp718_ = vala_array_type_get_rank (_tmp717_); - _tmp719_ = _tmp718_; - if (!(dim <= _tmp719_)) { + _tmp717_ = FALSE; + _tmp719_ = array_type; + _tmp720_ = vala_array_type_get_rank (_tmp719_); + _tmp721_ = _tmp720_; + if (!(dim <= _tmp721_)) { break; } - _tmp720_ = prop; - _tmp721_ = vala_get_ccode_array_length_type ((ValaCodeNode*) _tmp720_); - length_ctype = _tmp721_; - _tmp722_ = length_ctype; - _tmp723_ = vala_ctype_new (_tmp722_, "0"); - _tmp724_ = _tmp723_; - _tmp725_ = vala_ccode_base_module_get_temp_variable ((ValaCCodeBaseModule*) self, (ValaDataType*) _tmp724_, TRUE, NULL, TRUE); + _tmp722_ = prop; + _tmp723_ = vala_get_ccode_array_length_type ((ValaCodeNode*) _tmp722_); + length_ctype = _tmp723_; + _tmp724_ = length_ctype; + _tmp725_ = vala_ctype_new (_tmp724_, "0"); _tmp726_ = _tmp725_; - _vala_code_node_unref0 (_tmp724_); - temp_var = _tmp726_; - _tmp727_ = temp_var; - _tmp728_ = vala_symbol_get_name ((ValaSymbol*) _tmp727_); - _tmp729_ = _tmp728_; - _tmp730_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, _tmp729_); - temp_ref = _tmp730_; - _tmp731_ = temp_var; - vala_ccode_base_module_emit_temp_var ((ValaCCodeBaseModule*) self, _tmp731_, FALSE); - _tmp732_ = ccall; - _tmp733_ = temp_ref; - _tmp734_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, _tmp733_); - _tmp735_ = _tmp734_; - vala_ccode_function_call_add_argument (_tmp732_, (ValaCCodeExpression*) _tmp735_); - _vala_ccode_node_unref0 (_tmp735_); - _tmp736_ = temp_refs; - _tmp737_ = temp_ref; - vala_collection_add ((ValaCollection*) _tmp736_, _tmp737_); + _tmp727_ = vala_ccode_base_module_get_temp_variable ((ValaCCodeBaseModule*) self, (ValaDataType*) _tmp726_, TRUE, NULL, TRUE); + _tmp728_ = _tmp727_; + _vala_code_node_unref0 (_tmp726_); + temp_var = _tmp728_; + _tmp729_ = temp_var; + _tmp730_ = vala_symbol_get_name ((ValaSymbol*) _tmp729_); + _tmp731_ = _tmp730_; + _tmp732_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, _tmp731_); + temp_ref = _tmp732_; + _tmp733_ = temp_var; + vala_ccode_base_module_emit_temp_var ((ValaCCodeBaseModule*) self, _tmp733_, FALSE); + _tmp734_ = ccall; + _tmp735_ = temp_ref; + _tmp736_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, _tmp735_); + _tmp737_ = _tmp736_; + vala_ccode_function_call_add_argument (_tmp734_, (ValaCCodeExpression*) _tmp737_); + _vala_ccode_node_unref0 (_tmp737_); + _tmp738_ = temp_refs; + _tmp739_ = temp_ref; + vala_collection_add ((ValaCollection*) _tmp738_, _tmp739_); _vala_ccode_node_unref0 (temp_ref); _vala_code_node_unref0 (temp_var); _g_free0 (length_ctype); } } } - _tmp738_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); - _tmp739_ = _tmp738_; - _tmp740_ = ctemp; - _tmp741_ = ccall; - vala_ccode_function_add_assignment (_tmp739_, _tmp740_, (ValaCCodeExpression*) _tmp741_); + _tmp740_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp741_ = _tmp740_; + _tmp742_ = ctemp; + _tmp743_ = ccall; + vala_ccode_function_add_assignment (_tmp741_, _tmp742_, (ValaCCodeExpression*) _tmp743_); { gint dim = 0; dim = 1; { - gboolean _tmp742_ = FALSE; - _tmp742_ = TRUE; + gboolean _tmp744_ = FALSE; + _tmp744_ = TRUE; while (TRUE) { - ValaArrayType* _tmp744_; - gint _tmp745_; - gint _tmp746_; - ValaCCodeFunction* _tmp747_; - ValaCCodeFunction* _tmp748_; - ValaGLibValue* _tmp749_; - ValaList* _tmp750_; - gpointer _tmp751_; - ValaCCodeExpression* _tmp752_; - ValaArrayList* _tmp753_; - gpointer _tmp754_; - ValaCCodeExpression* _tmp755_; - if (!_tmp742_) { - gint _tmp743_; - _tmp743_ = dim; - dim = _tmp743_ + 1; + ValaArrayType* _tmp746_; + gint _tmp747_; + gint _tmp748_; + ValaCCodeFunction* _tmp749_; + ValaCCodeFunction* _tmp750_; + ValaGLibValue* _tmp751_; + ValaList* _tmp752_; + gpointer _tmp753_; + ValaCCodeExpression* _tmp754_; + ValaArrayList* _tmp755_; + gpointer _tmp756_; + ValaCCodeExpression* _tmp757_; + if (!_tmp744_) { + gint _tmp745_; + _tmp745_ = dim; + dim = _tmp745_ + 1; } - _tmp742_ = FALSE; - _tmp744_ = array_type; - _tmp745_ = vala_array_type_get_rank (_tmp744_); - _tmp746_ = _tmp745_; - if (!(dim <= _tmp746_)) { + _tmp744_ = FALSE; + _tmp746_ = array_type; + _tmp747_ = vala_array_type_get_rank (_tmp746_); + _tmp748_ = _tmp747_; + if (!(dim <= _tmp748_)) { break; } - _tmp747_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); - _tmp748_ = _tmp747_; - _tmp749_ = temp_value; - _tmp750_ = _tmp749_->array_length_cvalues; - _tmp751_ = vala_list_get (_tmp750_, dim - 1); - _tmp752_ = (ValaCCodeExpression*) _tmp751_; - _tmp753_ = temp_refs; - _tmp754_ = vala_list_get ((ValaList*) _tmp753_, dim - 1); - _tmp755_ = (ValaCCodeExpression*) _tmp754_; - vala_ccode_function_add_assignment (_tmp748_, _tmp752_, _tmp755_); - _vala_ccode_node_unref0 (_tmp755_); - _vala_ccode_node_unref0 (_tmp752_); + _tmp749_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp750_ = _tmp749_; + _tmp751_ = temp_value; + _tmp752_ = _tmp751_->array_length_cvalues; + _tmp753_ = vala_list_get (_tmp752_, dim - 1); + _tmp754_ = (ValaCCodeExpression*) _tmp753_; + _tmp755_ = temp_refs; + _tmp756_ = vala_list_get ((ValaList*) _tmp755_, dim - 1); + _tmp757_ = (ValaCCodeExpression*) _tmp756_; + vala_ccode_function_add_assignment (_tmp750_, _tmp754_, _tmp757_); + _vala_ccode_node_unref0 (_tmp757_); + _vala_ccode_node_unref0 (_tmp754_); } } } _vala_iterable_unref0 (temp_refs); } else { - ValaCCodeFunction* _tmp756_; - ValaCCodeFunction* _tmp757_; - ValaCCodeExpression* _tmp758_; - ValaCCodeFunctionCall* _tmp759_; - _tmp756_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); - _tmp757_ = _tmp756_; - _tmp758_ = ctemp; - _tmp759_ = ccall; - vala_ccode_function_add_assignment (_tmp757_, _tmp758_, (ValaCCodeExpression*) _tmp759_); + ValaCCodeFunction* _tmp758_; + ValaCCodeFunction* _tmp759_; + ValaCCodeExpression* _tmp760_; + ValaCCodeFunctionCall* _tmp761_; + _tmp758_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp759_ = _tmp758_; + _tmp760_ = ctemp; + _tmp761_ = ccall; + vala_ccode_function_add_assignment (_tmp759_, _tmp760_, (ValaCCodeExpression*) _tmp761_); } } } else { - ValaCCodeFunction* _tmp760_; - ValaCCodeFunction* _tmp761_; - ValaCCodeExpression* _tmp762_; - ValaCCodeFunctionCall* _tmp763_; - ValaProperty* _tmp764_; - ValaDataType* _tmp765_; - ValaDataType* _tmp766_; - ValaDelegateType* _tmp767_; - gboolean _tmp768_ = FALSE; - gboolean _tmp769_ = FALSE; - ValaDelegateType* _tmp770_; - _tmp760_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); - _tmp761_ = _tmp760_; - _tmp762_ = ctemp; - _tmp763_ = ccall; - vala_ccode_function_add_assignment (_tmp761_, _tmp762_, (ValaCCodeExpression*) _tmp763_); - _tmp764_ = prop; - _tmp765_ = vala_property_get_property_type (_tmp764_); - _tmp766_ = _tmp765_; - _tmp767_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp766_, VALA_TYPE_DELEGATE_TYPE) ? ((ValaDelegateType*) _tmp766_) : NULL); + ValaCCodeFunction* _tmp762_; + ValaCCodeFunction* _tmp763_; + ValaCCodeExpression* _tmp764_; + ValaCCodeFunctionCall* _tmp765_; + ValaProperty* _tmp766_; + ValaDataType* _tmp767_; + ValaDataType* _tmp768_; + ValaDelegateType* _tmp769_; + gboolean _tmp770_ = FALSE; + gboolean _tmp771_ = FALSE; + ValaDelegateType* _tmp772_; + _tmp762_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp763_ = _tmp762_; + _tmp764_ = ctemp; + _tmp765_ = ccall; + vala_ccode_function_add_assignment (_tmp763_, _tmp764_, (ValaCCodeExpression*) _tmp765_); + _tmp766_ = prop; + _tmp767_ = vala_property_get_property_type (_tmp766_); + _tmp768_ = _tmp767_; + _tmp769_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp768_, VALA_TYPE_DELEGATE_TYPE) ? ((ValaDelegateType*) _tmp768_) : NULL); _vala_code_node_unref0 (delegate_type); - delegate_type = _tmp767_; - _tmp770_ = delegate_type; - if (_tmp770_ != NULL) { - ValaProperty* _tmp771_; - _tmp771_ = prop; - _tmp769_ = vala_get_ccode_delegate_target ((ValaCodeNode*) _tmp771_); + delegate_type = _tmp769_; + _tmp772_ = delegate_type; + if (_tmp772_ != NULL) { + ValaProperty* _tmp773_; + _tmp773_ = prop; + _tmp771_ = vala_get_ccode_delegate_target ((ValaCodeNode*) _tmp773_); } else { - _tmp769_ = FALSE; + _tmp771_ = FALSE; } - if (_tmp769_) { - ValaDelegateType* _tmp772_; - ValaDelegate* _tmp773_; - ValaDelegate* _tmp774_; - gboolean _tmp775_; - gboolean _tmp776_; - _tmp772_ = delegate_type; - _tmp773_ = vala_delegate_type_get_delegate_symbol (_tmp772_); - _tmp774_ = _tmp773_; - _tmp775_ = vala_delegate_get_has_target (_tmp774_); + if (_tmp771_) { + ValaDelegateType* _tmp774_; + ValaDelegate* _tmp775_; + ValaDelegate* _tmp776_; + gboolean _tmp777_; + gboolean _tmp778_; + _tmp774_ = delegate_type; + _tmp775_ = vala_delegate_type_get_delegate_symbol (_tmp774_); _tmp776_ = _tmp775_; - _tmp768_ = _tmp776_; + _tmp777_ = vala_delegate_get_has_target (_tmp776_); + _tmp778_ = _tmp777_; + _tmp770_ = _tmp778_; } else { - _tmp768_ = FALSE; + _tmp770_ = FALSE; } - if (_tmp768_) { - ValaCCodeFunctionCall* _tmp777_; - ValaGLibValue* _tmp778_; - ValaCCodeExpression* _tmp779_; - ValaCCodeExpression* _tmp780_; - ValaCCodeUnaryExpression* _tmp781_; - ValaCCodeUnaryExpression* _tmp782_; - _tmp777_ = ccall; - _tmp778_ = temp_value; - _tmp779_ = vala_ccode_base_module_get_delegate_target_cvalue ((ValaCCodeBaseModule*) self, (ValaTargetValue*) _tmp778_); - _tmp780_ = _tmp779_; - _tmp781_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, _tmp780_); + if (_tmp770_) { + ValaCCodeFunctionCall* _tmp779_; + ValaGLibValue* _tmp780_; + ValaCCodeExpression* _tmp781_; + ValaCCodeExpression* _tmp782_; + ValaCCodeUnaryExpression* _tmp783_; + ValaCCodeUnaryExpression* _tmp784_; + _tmp779_ = ccall; + _tmp780_ = temp_value; + _tmp781_ = vala_ccode_base_module_get_delegate_target_cvalue ((ValaCCodeBaseModule*) self, (ValaTargetValue*) _tmp780_); _tmp782_ = _tmp781_; - vala_ccode_function_call_add_argument (_tmp777_, (ValaCCodeExpression*) _tmp782_); + _tmp783_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, _tmp782_); + _tmp784_ = _tmp783_; + vala_ccode_function_call_add_argument (_tmp779_, (ValaCCodeExpression*) _tmp784_); + _vala_ccode_node_unref0 (_tmp784_); _vala_ccode_node_unref0 (_tmp782_); - _vala_ccode_node_unref0 (_tmp780_); } else { - ValaGLibValue* _tmp783_; - ValaCCodeExpression* _tmp784_; - ValaGLibValue* _tmp791_; - ValaCCodeExpression* _tmp792_; - _tmp783_ = temp_value; - _tmp784_ = _tmp783_->delegate_target_cvalue; - if (_tmp784_ != NULL) { - ValaCCodeFunction* _tmp785_; - ValaCCodeFunction* _tmp786_; - ValaGLibValue* _tmp787_; - ValaCCodeExpression* _tmp788_; - ValaCCodeConstant* _tmp789_; - ValaCCodeConstant* _tmp790_; - _tmp785_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); - _tmp786_ = _tmp785_; - _tmp787_ = temp_value; - _tmp788_ = _tmp787_->delegate_target_cvalue; - _tmp789_ = vala_ccode_constant_new ("NULL"); - _tmp790_ = _tmp789_; - vala_ccode_function_add_assignment (_tmp786_, _tmp788_, (ValaCCodeExpression*) _tmp790_); - _vala_ccode_node_unref0 (_tmp790_); + ValaGLibValue* _tmp785_; + ValaCCodeExpression* _tmp786_; + ValaGLibValue* _tmp793_; + ValaCCodeExpression* _tmp794_; + _tmp785_ = temp_value; + _tmp786_ = _tmp785_->delegate_target_cvalue; + if (_tmp786_ != NULL) { + ValaCCodeFunction* _tmp787_; + ValaCCodeFunction* _tmp788_; + ValaGLibValue* _tmp789_; + ValaCCodeExpression* _tmp790_; + ValaCCodeConstant* _tmp791_; + ValaCCodeConstant* _tmp792_; + _tmp787_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp788_ = _tmp787_; + _tmp789_ = temp_value; + _tmp790_ = _tmp789_->delegate_target_cvalue; + _tmp791_ = vala_ccode_constant_new ("NULL"); + _tmp792_ = _tmp791_; + vala_ccode_function_add_assignment (_tmp788_, _tmp790_, (ValaCCodeExpression*) _tmp792_); + _vala_ccode_node_unref0 (_tmp792_); } - _tmp791_ = temp_value; - _tmp792_ = _tmp791_->delegate_target_destroy_notify_cvalue; - if (_tmp792_ != NULL) { - ValaCCodeFunction* _tmp793_; - ValaCCodeFunction* _tmp794_; - ValaGLibValue* _tmp795_; - ValaCCodeExpression* _tmp796_; - ValaCCodeConstant* _tmp797_; - ValaCCodeConstant* _tmp798_; - _tmp793_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); - _tmp794_ = _tmp793_; - _tmp795_ = temp_value; - _tmp796_ = _tmp795_->delegate_target_destroy_notify_cvalue; - _tmp797_ = vala_ccode_constant_new ("NULL"); - _tmp798_ = _tmp797_; - vala_ccode_function_add_assignment (_tmp794_, _tmp796_, (ValaCCodeExpression*) _tmp798_); - _vala_ccode_node_unref0 (_tmp798_); + _tmp793_ = temp_value; + _tmp794_ = _tmp793_->delegate_target_destroy_notify_cvalue; + if (_tmp794_ != NULL) { + ValaCCodeFunction* _tmp795_; + ValaCCodeFunction* _tmp796_; + ValaGLibValue* _tmp797_; + ValaCCodeExpression* _tmp798_; + ValaCCodeConstant* _tmp799_; + ValaCCodeConstant* _tmp800_; + _tmp795_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp796_ = _tmp795_; + _tmp797_ = temp_value; + _tmp798_ = _tmp797_->delegate_target_destroy_notify_cvalue; + _tmp799_ = vala_ccode_constant_new ("NULL"); + _tmp800_ = _tmp799_; + vala_ccode_function_add_assignment (_tmp796_, _tmp798_, (ValaCCodeExpression*) _tmp800_); + _vala_ccode_node_unref0 (_tmp800_); } } } @@ -2354,196 +2362,204 @@ _vala_ccode_node_unref0 (ccall); } else { ValaCCodeFunctionCall* ccall = NULL; - ValaCCodeIdentifier* _tmp799_; - ValaCCodeIdentifier* _tmp800_; - ValaCCodeFunctionCall* _tmp801_; - ValaCCodeFunctionCall* _tmp802_; + ValaCCodeIdentifier* _tmp801_; + ValaCCodeIdentifier* _tmp802_; ValaCCodeFunctionCall* _tmp803_; - ValaCCodeExpression* _tmp804_; + ValaCCodeFunctionCall* _tmp804_; ValaCCodeFunctionCall* _tmp805_; - ValaProperty* _tmp806_; - ValaCCodeConstant* _tmp807_; - ValaCCodeConstant* _tmp808_; - gboolean _tmp809_ = FALSE; - ValaProperty* _tmp810_; - ValaDataType* _tmp834_; - ValaDataType* _tmp835_; + ValaCCodeExpression* _tmp806_; + ValaCCodeFunctionCall* _tmp807_; + ValaProperty* _tmp808_; + ValaCCodeConstant* _tmp809_; + ValaCCodeConstant* _tmp810_; + gboolean _tmp811_ = FALSE; + ValaProperty* _tmp812_; + ValaDataType* _tmp836_; + ValaDataType* _tmp837_; ValaLocalVariable* temp_var = NULL; - ValaDataType* _tmp838_; - ValaDataType* _tmp839_; - ValaLocalVariable* _tmp840_; + ValaDataType* _tmp840_; + ValaDataType* _tmp841_; + ValaLocalVariable* _tmp842_; ValaCCodeExpression* ctemp = NULL; - ValaLocalVariable* _tmp841_; - const gchar* _tmp842_; - const gchar* _tmp843_; - ValaCCodeExpression* _tmp844_; - ValaLocalVariable* _tmp845_; - ValaCCodeFunctionCall* _tmp846_; - ValaCCodeExpression* _tmp847_; - ValaCCodeUnaryExpression* _tmp848_; - ValaCCodeUnaryExpression* _tmp849_; - ValaCCodeFunctionCall* _tmp850_; - ValaCCodeConstant* _tmp851_; - ValaCCodeConstant* _tmp852_; - ValaCCodeFunction* _tmp853_; - ValaCCodeFunction* _tmp854_; - ValaCCodeFunctionCall* _tmp855_; - ValaCCodeExpression* _tmp856_; - ValaProperty* _tmp857_; - _tmp799_ = vala_ccode_identifier_new ("g_object_get"); - _tmp800_ = _tmp799_; - _tmp801_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp800_); + ValaLocalVariable* _tmp843_; + const gchar* _tmp844_; + const gchar* _tmp845_; + ValaCCodeExpression* _tmp846_; + ValaLocalVariable* _tmp847_; + ValaCCodeFunctionCall* _tmp848_; + ValaCCodeExpression* _tmp849_; + ValaCCodeUnaryExpression* _tmp850_; + ValaCCodeUnaryExpression* _tmp851_; + ValaCCodeFunctionCall* _tmp852_; + ValaCCodeConstant* _tmp853_; + ValaCCodeConstant* _tmp854_; + ValaCCodeFunction* _tmp855_; + ValaCCodeFunction* _tmp856_; + ValaCCodeFunctionCall* _tmp857_; + ValaCCodeExpression* _tmp858_; + gboolean _tmp859_ = FALSE; + ValaProperty* _tmp860_; + _tmp801_ = vala_ccode_identifier_new ("g_object_get"); _tmp802_ = _tmp801_; - _vala_ccode_node_unref0 (_tmp800_); - ccall = _tmp802_; - _tmp803_ = ccall; - _tmp804_ = pub_inst; - vala_ccode_function_call_add_argument (_tmp803_, _tmp804_); + _tmp803_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp802_); + _tmp804_ = _tmp803_; + _vala_ccode_node_unref0 (_tmp802_); + ccall = _tmp804_; _tmp805_ = ccall; - _tmp806_ = prop; - _tmp807_ = vala_ccode_base_module_get_property_canonical_cconstant ((ValaCCodeBaseModule*) self, _tmp806_); - _tmp808_ = _tmp807_; - vala_ccode_function_call_add_argument (_tmp805_, (ValaCCodeExpression*) _tmp808_); - _vala_ccode_node_unref0 (_tmp808_); - _tmp810_ = prop; - if (!G_TYPE_CHECK_INSTANCE_TYPE (_tmp810_, VALA_TYPE_DYNAMIC_PROPERTY)) { - ValaProperty* _tmp811_; - ValaPropertyAccessor* _tmp812_; - ValaPropertyAccessor* _tmp813_; - ValaDataType* _tmp814_; - ValaDataType* _tmp815_; - gboolean _tmp816_; - gboolean _tmp817_; - _tmp811_ = prop; - _tmp812_ = vala_property_get_get_accessor (_tmp811_); - _tmp813_ = _tmp812_; - _tmp814_ = vala_property_accessor_get_value_type (_tmp813_); + _tmp806_ = pub_inst; + vala_ccode_function_call_add_argument (_tmp805_, _tmp806_); + _tmp807_ = ccall; + _tmp808_ = prop; + _tmp809_ = vala_ccode_base_module_get_property_canonical_cconstant ((ValaCCodeBaseModule*) self, _tmp808_); + _tmp810_ = _tmp809_; + vala_ccode_function_call_add_argument (_tmp807_, (ValaCCodeExpression*) _tmp810_); + _vala_ccode_node_unref0 (_tmp810_); + _tmp812_ = prop; + if (!G_TYPE_CHECK_INSTANCE_TYPE (_tmp812_, VALA_TYPE_DYNAMIC_PROPERTY)) { + ValaProperty* _tmp813_; + ValaPropertyAccessor* _tmp814_; + ValaPropertyAccessor* _tmp815_; + ValaDataType* _tmp816_; + ValaDataType* _tmp817_; + gboolean _tmp818_; + gboolean _tmp819_; + _tmp813_ = prop; + _tmp814_ = vala_property_get_get_accessor (_tmp813_); _tmp815_ = _tmp814_; - _tmp816_ = vala_data_type_get_value_owned (_tmp815_); + _tmp816_ = vala_property_accessor_get_value_type (_tmp815_); _tmp817_ = _tmp816_; - _tmp809_ = !_tmp817_; + _tmp818_ = vala_data_type_get_value_owned (_tmp817_); + _tmp819_ = _tmp818_; + _tmp811_ = !_tmp819_; } else { - _tmp809_ = FALSE; + _tmp811_ = FALSE; } - if (_tmp809_) { + if (_tmp811_) { ValaDataType* owned_value_type = NULL; - ValaProperty* _tmp818_; - ValaPropertyAccessor* _tmp819_; - ValaPropertyAccessor* _tmp820_; - ValaDataType* _tmp821_; - ValaDataType* _tmp822_; + ValaProperty* _tmp820_; + ValaPropertyAccessor* _tmp821_; + ValaPropertyAccessor* _tmp822_; ValaDataType* _tmp823_; ValaDataType* _tmp824_; ValaDataType* _tmp825_; - _tmp818_ = prop; - _tmp819_ = vala_property_get_get_accessor (_tmp818_); - _tmp820_ = _tmp819_; - _tmp821_ = vala_property_accessor_get_value_type (_tmp820_); + ValaDataType* _tmp826_; + ValaDataType* _tmp827_; + _tmp820_ = prop; + _tmp821_ = vala_property_get_get_accessor (_tmp820_); _tmp822_ = _tmp821_; - _tmp823_ = vala_data_type_copy (_tmp822_); - owned_value_type = _tmp823_; - _tmp824_ = owned_value_type; - vala_data_type_set_value_owned (_tmp824_, TRUE); - _tmp825_ = owned_value_type; - if (vala_ccode_base_module_requires_copy (_tmp825_)) { - ValaProperty* _tmp826_; - ValaPropertyAccessor* _tmp827_; - ValaPropertyAccessor* _tmp828_; - ValaSourceReference* _tmp829_; - ValaSourceReference* _tmp830_; - ValaProperty* _tmp831_; - gchar* _tmp832_; - gchar* _tmp833_; - _tmp826_ = prop; - _tmp827_ = vala_property_get_get_accessor (_tmp826_); - _tmp828_ = _tmp827_; - _tmp829_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp828_); + _tmp823_ = vala_property_accessor_get_value_type (_tmp822_); + _tmp824_ = _tmp823_; + _tmp825_ = vala_data_type_copy (_tmp824_); + owned_value_type = _tmp825_; + _tmp826_ = owned_value_type; + vala_data_type_set_value_owned (_tmp826_, TRUE); + _tmp827_ = owned_value_type; + if (vala_ccode_base_module_requires_copy (_tmp827_)) { + ValaProperty* _tmp828_; + ValaPropertyAccessor* _tmp829_; + ValaPropertyAccessor* _tmp830_; + ValaSourceReference* _tmp831_; + ValaSourceReference* _tmp832_; + ValaProperty* _tmp833_; + gchar* _tmp834_; + gchar* _tmp835_; + _tmp828_ = prop; + _tmp829_ = vala_property_get_get_accessor (_tmp828_); _tmp830_ = _tmp829_; - _tmp831_ = prop; - _tmp832_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp831_); - _tmp833_ = _tmp832_; - vala_report_error (_tmp830_, "unowned return value for getter of property `%s' not supported without" \ -" accessor", _tmp833_); - _g_free0 (_tmp833_); + _tmp831_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp830_); + _tmp832_ = _tmp831_; + _tmp833_ = prop; + _tmp834_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp833_); + _tmp835_ = _tmp834_; + vala_report_error (_tmp832_, "unowned return value for getter of property `%s' not supported without" \ +" accessor", _tmp835_); + _g_free0 (_tmp835_); } _vala_code_node_unref0 (owned_value_type); } - _tmp834_ = vala_expression_get_value_type ((ValaExpression*) expr); - _tmp835_ = _tmp834_; - if (vala_data_type_is_real_struct_type (_tmp835_)) { - ValaDataType* _tmp836_; - ValaDataType* _tmp837_; - _tmp836_ = vala_expression_get_value_type ((ValaExpression*) expr); - _tmp837_ = _tmp836_; - vala_data_type_set_nullable (_tmp837_, TRUE); + _tmp836_ = vala_expression_get_value_type ((ValaExpression*) expr); + _tmp837_ = _tmp836_; + if (vala_data_type_is_real_struct_type (_tmp837_)) { + ValaDataType* _tmp838_; + ValaDataType* _tmp839_; + _tmp838_ = vala_expression_get_value_type ((ValaExpression*) expr); + _tmp839_ = _tmp838_; + vala_data_type_set_nullable (_tmp839_, TRUE); } - _tmp838_ = vala_expression_get_value_type ((ValaExpression*) expr); - _tmp839_ = _tmp838_; - _tmp840_ = vala_ccode_base_module_get_temp_variable ((ValaCCodeBaseModule*) self, _tmp839_, TRUE, NULL, FALSE); - temp_var = _tmp840_; - _tmp841_ = temp_var; - _tmp842_ = vala_symbol_get_name ((ValaSymbol*) _tmp841_); - _tmp843_ = _tmp842_; - _tmp844_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, _tmp843_); - ctemp = _tmp844_; - _tmp845_ = temp_var; - vala_ccode_base_module_emit_temp_var ((ValaCCodeBaseModule*) self, _tmp845_, FALSE); - _tmp846_ = ccall; - _tmp847_ = ctemp; - _tmp848_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, _tmp847_); - _tmp849_ = _tmp848_; - vala_ccode_function_call_add_argument (_tmp846_, (ValaCCodeExpression*) _tmp849_); - _vala_ccode_node_unref0 (_tmp849_); - _tmp850_ = ccall; - _tmp851_ = vala_ccode_constant_new ("NULL"); - _tmp852_ = _tmp851_; - vala_ccode_function_call_add_argument (_tmp850_, (ValaCCodeExpression*) _tmp852_); - _vala_ccode_node_unref0 (_tmp852_); - _tmp853_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp840_ = vala_expression_get_value_type ((ValaExpression*) expr); + _tmp841_ = _tmp840_; + _tmp842_ = vala_ccode_base_module_get_temp_variable ((ValaCCodeBaseModule*) self, _tmp841_, TRUE, NULL, FALSE); + temp_var = _tmp842_; + _tmp843_ = temp_var; + _tmp844_ = vala_symbol_get_name ((ValaSymbol*) _tmp843_); + _tmp845_ = _tmp844_; + _tmp846_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, _tmp845_); + ctemp = _tmp846_; + _tmp847_ = temp_var; + vala_ccode_base_module_emit_temp_var ((ValaCCodeBaseModule*) self, _tmp847_, FALSE); + _tmp848_ = ccall; + _tmp849_ = ctemp; + _tmp850_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, _tmp849_); + _tmp851_ = _tmp850_; + vala_ccode_function_call_add_argument (_tmp848_, (ValaCCodeExpression*) _tmp851_); + _vala_ccode_node_unref0 (_tmp851_); + _tmp852_ = ccall; + _tmp853_ = vala_ccode_constant_new ("NULL"); _tmp854_ = _tmp853_; - _tmp855_ = ccall; - vala_ccode_function_add_expression (_tmp854_, (ValaCCodeExpression*) _tmp855_); - _tmp856_ = ctemp; - vala_set_cvalue ((ValaExpression*) expr, _tmp856_); - _tmp857_ = prop; - if (vala_get_ccode_array_null_terminated ((ValaCodeNode*) _tmp857_)) { + vala_ccode_function_call_add_argument (_tmp852_, (ValaCCodeExpression*) _tmp854_); + _vala_ccode_node_unref0 (_tmp854_); + _tmp855_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp856_ = _tmp855_; + _tmp857_ = ccall; + vala_ccode_function_add_expression (_tmp856_, (ValaCCodeExpression*) _tmp857_); + _tmp858_ = ctemp; + vala_set_cvalue ((ValaExpression*) expr, _tmp858_); + _tmp860_ = prop; + if (vala_get_ccode_array_null_terminated ((ValaCodeNode*) _tmp860_)) { + ValaProperty* _tmp861_; + _tmp861_ = prop; + _tmp859_ = !vala_get_ccode_array_length ((ValaCodeNode*) _tmp861_); + } else { + _tmp859_ = FALSE; + } + if (_tmp859_) { ValaCCodeFunctionCall* len_call = NULL; - ValaCCodeIdentifier* _tmp858_; - ValaCCodeIdentifier* _tmp859_; - ValaCCodeFunctionCall* _tmp860_; - ValaCCodeFunctionCall* _tmp861_; - ValaCCodeFunctionCall* _tmp862_; - ValaCCodeExpression* _tmp863_; + ValaCCodeIdentifier* _tmp862_; + ValaCCodeIdentifier* _tmp863_; + ValaCCodeFunctionCall* _tmp864_; + ValaCCodeFunctionCall* _tmp865_; + ValaCCodeFunctionCall* _tmp866_; + ValaCCodeExpression* _tmp867_; ValaGLibValue* glib_value = NULL; - ValaTargetValue* _tmp864_; - ValaTargetValue* _tmp865_; - ValaGLibValue* _tmp866_; - ValaGLibValue* _tmp867_; - ValaGLibValue* _tmp868_; - ValaCCodeFunctionCall* _tmp869_; + ValaTargetValue* _tmp868_; + ValaTargetValue* _tmp869_; ValaGLibValue* _tmp870_; + ValaGLibValue* _tmp871_; + ValaGLibValue* _tmp872_; + ValaCCodeFunctionCall* _tmp873_; + ValaGLibValue* _tmp874_; ((ValaCCodeBaseModule*) self)->requires_array_length = TRUE; - _tmp858_ = vala_ccode_identifier_new ("_vala_array_length"); - _tmp859_ = _tmp858_; - _tmp860_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp859_); - _tmp861_ = _tmp860_; - _vala_ccode_node_unref0 (_tmp859_); - len_call = _tmp861_; - _tmp862_ = len_call; - _tmp863_ = ctemp; - vala_ccode_function_call_add_argument (_tmp862_, _tmp863_); - _tmp864_ = vala_expression_get_target_value ((ValaExpression*) expr); + _tmp862_ = vala_ccode_identifier_new ("_vala_array_length"); + _tmp863_ = _tmp862_; + _tmp864_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp863_); _tmp865_ = _tmp864_; - _tmp866_ = _vala_target_value_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp865_, VALA_TYPE_GLIB_VALUE, ValaGLibValue)); - glib_value = _tmp866_; - _tmp867_ = glib_value; - _vala_iterable_unref0 (_tmp867_->array_length_cvalues); - _tmp867_->array_length_cvalues = NULL; - _tmp868_ = glib_value; - _tmp869_ = len_call; - vala_glib_value_append_array_length_cvalue (_tmp868_, (ValaCCodeExpression*) _tmp869_); - _tmp870_ = glib_value; - _tmp870_->lvalue = FALSE; + _vala_ccode_node_unref0 (_tmp863_); + len_call = _tmp865_; + _tmp866_ = len_call; + _tmp867_ = ctemp; + vala_ccode_function_call_add_argument (_tmp866_, _tmp867_); + _tmp868_ = vala_expression_get_target_value ((ValaExpression*) expr); + _tmp869_ = _tmp868_; + _tmp870_ = _vala_target_value_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp869_, VALA_TYPE_GLIB_VALUE, ValaGLibValue)); + glib_value = _tmp870_; + _tmp871_ = glib_value; + _vala_iterable_unref0 (_tmp871_->array_length_cvalues); + _tmp871_->array_length_cvalues = NULL; + _tmp872_ = glib_value; + _tmp873_ = len_call; + vala_glib_value_append_array_length_cvalue (_tmp872_, (ValaCCodeExpression*) _tmp873_); + _tmp874_ = glib_value; + _tmp874_->lvalue = FALSE; _vala_target_value_unref0 (glib_value); _vala_ccode_node_unref0 (len_call); } @@ -2553,256 +2569,256 @@ } } } - _tmp871_ = prop; - _tmp872_ = vala_property_get_get_accessor (_tmp871_); - _tmp873_ = _tmp872_; - _tmp874_ = vala_property_accessor_get_value_type (_tmp873_); - _tmp875_ = _tmp874_; - if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp875_, VALA_TYPE_GENERIC_TYPE)) { - ValaTargetValue* _tmp876_; - ValaTargetValue* _tmp877_; - ValaProperty* _tmp878_; - ValaPropertyAccessor* _tmp879_; - ValaPropertyAccessor* _tmp880_; - ValaDataType* _tmp881_; - ValaDataType* _tmp882_; - ValaDataType* _tmp883_; - ValaDataType* _tmp884_; - _tmp876_ = vala_expression_get_target_value ((ValaExpression*) expr); - _tmp877_ = _tmp876_; - _tmp878_ = prop; - _tmp879_ = vala_property_get_get_accessor (_tmp878_); - _tmp880_ = _tmp879_; - _tmp881_ = vala_property_accessor_get_value_type (_tmp880_); - _tmp882_ = _tmp881_; - _tmp883_ = vala_data_type_copy (_tmp882_); - _tmp884_ = _tmp883_; - vala_target_value_set_value_type (_tmp877_, _tmp884_); - _vala_code_node_unref0 (_tmp884_); - } else { - ValaTargetValue* _tmp885_; - ValaTargetValue* _tmp886_; + _tmp875_ = prop; + _tmp876_ = vala_property_get_get_accessor (_tmp875_); + _tmp877_ = _tmp876_; + _tmp878_ = vala_property_accessor_get_value_type (_tmp877_); + _tmp879_ = _tmp878_; + if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp879_, VALA_TYPE_GENERIC_TYPE)) { + ValaTargetValue* _tmp880_; + ValaTargetValue* _tmp881_; + ValaProperty* _tmp882_; + ValaPropertyAccessor* _tmp883_; + ValaPropertyAccessor* _tmp884_; + ValaDataType* _tmp885_; + ValaDataType* _tmp886_; ValaDataType* _tmp887_; ValaDataType* _tmp888_; - ValaDataType* _tmp889_; - ValaDataType* _tmp890_; - _tmp885_ = vala_expression_get_target_value ((ValaExpression*) expr); + _tmp880_ = vala_expression_get_target_value ((ValaExpression*) expr); + _tmp881_ = _tmp880_; + _tmp882_ = prop; + _tmp883_ = vala_property_get_get_accessor (_tmp882_); + _tmp884_ = _tmp883_; + _tmp885_ = vala_property_accessor_get_value_type (_tmp884_); _tmp886_ = _tmp885_; - _tmp887_ = vala_expression_get_value_type ((ValaExpression*) expr); + _tmp887_ = vala_data_type_copy (_tmp886_); _tmp888_ = _tmp887_; - _tmp889_ = vala_data_type_copy (_tmp888_); + vala_target_value_set_value_type (_tmp881_, _tmp888_); + _vala_code_node_unref0 (_tmp888_); + } else { + ValaTargetValue* _tmp889_; + ValaTargetValue* _tmp890_; + ValaDataType* _tmp891_; + ValaDataType* _tmp892_; + ValaDataType* _tmp893_; + ValaDataType* _tmp894_; + _tmp889_ = vala_expression_get_target_value ((ValaExpression*) expr); _tmp890_ = _tmp889_; - vala_target_value_set_value_type (_tmp886_, _tmp890_); - _vala_code_node_unref0 (_tmp890_); + _tmp891_ = vala_expression_get_value_type ((ValaExpression*) expr); + _tmp892_ = _tmp891_; + _tmp893_ = vala_data_type_copy (_tmp892_); + _tmp894_ = _tmp893_; + vala_target_value_set_value_type (_tmp890_, _tmp894_); + _vala_code_node_unref0 (_tmp894_); } - _tmp891_ = vala_expression_get_target_value ((ValaExpression*) expr); - _tmp892_ = _tmp891_; - _tmp893_ = vala_ccode_base_module_store_temp_value ((ValaCCodeBaseModule*) self, _tmp892_, (ValaCodeNode*) expr, NULL); - _tmp894_ = _tmp893_; - vala_expression_set_target_value ((ValaExpression*) expr, _tmp894_); - _vala_target_value_unref0 (_tmp894_); + _tmp895_ = vala_expression_get_target_value ((ValaExpression*) expr); + _tmp896_ = _tmp895_; + _tmp897_ = vala_ccode_base_module_store_temp_value ((ValaCCodeBaseModule*) self, _tmp896_, (ValaCodeNode*) expr, NULL); + _tmp898_ = _tmp897_; + vala_expression_set_target_value ((ValaExpression*) expr, _tmp898_); + _vala_target_value_unref0 (_tmp898_); _vala_code_node_unref0 (prop); } else { - ValaSymbol* _tmp895_; - ValaSymbol* _tmp896_; - _tmp895_ = vala_expression_get_symbol_reference ((ValaExpression*) expr); - _tmp896_ = _tmp895_; - if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp896_, VALA_TYPE_LOCAL_VARIABLE)) { + ValaSymbol* _tmp899_; + ValaSymbol* _tmp900_; + _tmp899_ = vala_expression_get_symbol_reference ((ValaExpression*) expr); + _tmp900_ = _tmp899_; + if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp900_, VALA_TYPE_LOCAL_VARIABLE)) { ValaLocalVariable* local = NULL; - ValaSymbol* _tmp897_; - ValaSymbol* _tmp898_; - ValaLocalVariable* _tmp899_; - gboolean _tmp900_ = FALSE; - gboolean _tmp901_ = FALSE; - gboolean _tmp902_ = FALSE; - gboolean _tmp903_ = FALSE; + ValaSymbol* _tmp901_; + ValaSymbol* _tmp902_; + ValaLocalVariable* _tmp903_; gboolean _tmp904_ = FALSE; - ValaCodeNode* _tmp905_; - ValaCodeNode* _tmp906_; - _tmp897_ = vala_expression_get_symbol_reference ((ValaExpression*) expr); - _tmp898_ = _tmp897_; - _tmp899_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp898_, VALA_TYPE_LOCAL_VARIABLE, ValaLocalVariable)); - local = _tmp899_; - _tmp905_ = vala_code_node_get_parent_node ((ValaCodeNode*) expr); - _tmp906_ = _tmp905_; - if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp906_, VALA_TYPE_RETURN_STATEMENT)) { - ValaDataType* _tmp907_; - ValaDataType* _tmp908_; - gboolean _tmp909_; - gboolean _tmp910_; - _tmp907_ = vala_ccode_base_module_get_current_return_type ((ValaCCodeBaseModule*) self); - _tmp908_ = _tmp907_; - _tmp909_ = vala_data_type_get_value_owned (_tmp908_); - _tmp910_ = _tmp909_; - _tmp904_ = _tmp910_; - } else { - _tmp904_ = FALSE; - } - if (_tmp904_) { - ValaLocalVariable* _tmp911_; + gboolean _tmp905_ = FALSE; + gboolean _tmp906_ = FALSE; + gboolean _tmp907_ = FALSE; + gboolean _tmp908_ = FALSE; + ValaCodeNode* _tmp909_; + ValaCodeNode* _tmp910_; + _tmp901_ = vala_expression_get_symbol_reference ((ValaExpression*) expr); + _tmp902_ = _tmp901_; + _tmp903_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp902_, VALA_TYPE_LOCAL_VARIABLE, ValaLocalVariable)); + local = _tmp903_; + _tmp909_ = vala_code_node_get_parent_node ((ValaCodeNode*) expr); + _tmp910_ = _tmp909_; + if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp910_, VALA_TYPE_RETURN_STATEMENT)) { + ValaDataType* _tmp911_; ValaDataType* _tmp912_; - ValaDataType* _tmp913_; + gboolean _tmp913_; gboolean _tmp914_; - gboolean _tmp915_; - _tmp911_ = local; - _tmp912_ = vala_variable_get_variable_type ((ValaVariable*) _tmp911_); - _tmp913_ = _tmp912_; - _tmp914_ = vala_data_type_get_value_owned (_tmp913_); - _tmp915_ = _tmp914_; - _tmp903_ = _tmp915_; + _tmp911_ = vala_ccode_base_module_get_current_return_type ((ValaCCodeBaseModule*) self); + _tmp912_ = _tmp911_; + _tmp913_ = vala_data_type_get_value_owned (_tmp912_); + _tmp914_ = _tmp913_; + _tmp908_ = _tmp914_; } else { - _tmp903_ = FALSE; + _tmp908_ = FALSE; } - if (_tmp903_) { - ValaLocalVariable* _tmp916_; - gboolean _tmp917_; + if (_tmp908_) { + ValaLocalVariable* _tmp915_; + ValaDataType* _tmp916_; + ValaDataType* _tmp917_; gboolean _tmp918_; - _tmp916_ = local; - _tmp917_ = vala_local_variable_get_captured (_tmp916_); - _tmp918_ = _tmp917_; - _tmp902_ = !_tmp918_; + gboolean _tmp919_; + _tmp915_ = local; + _tmp916_ = vala_variable_get_variable_type ((ValaVariable*) _tmp915_); + _tmp917_ = _tmp916_; + _tmp918_ = vala_data_type_get_value_owned (_tmp917_); + _tmp919_ = _tmp918_; + _tmp907_ = _tmp919_; + } else { + _tmp907_ = FALSE; + } + if (_tmp907_) { + ValaLocalVariable* _tmp920_; + gboolean _tmp921_; + gboolean _tmp922_; + _tmp920_ = local; + _tmp921_ = vala_local_variable_get_captured (_tmp920_); + _tmp922_ = _tmp921_; + _tmp906_ = !_tmp922_; } else { - _tmp902_ = FALSE; + _tmp906_ = FALSE; } - if (_tmp902_) { - ValaLocalVariable* _tmp919_; - _tmp919_ = local; - _tmp901_ = !vala_ccode_base_module_variable_accessible_in_finally ((ValaCCodeBaseModule*) self, _tmp919_); + if (_tmp906_) { + ValaLocalVariable* _tmp923_; + _tmp923_ = local; + _tmp905_ = !vala_ccode_base_module_variable_accessible_in_finally ((ValaCCodeBaseModule*) self, _tmp923_); } else { - _tmp901_ = FALSE; + _tmp905_ = FALSE; } - if (_tmp901_) { - gboolean _tmp920_ = FALSE; - ValaLocalVariable* _tmp921_; - ValaDataType* _tmp922_; - ValaDataType* _tmp923_; - _tmp921_ = local; - _tmp922_ = vala_variable_get_variable_type ((ValaVariable*) _tmp921_); - _tmp923_ = _tmp922_; - if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp923_, VALA_TYPE_ARRAY_TYPE)) { - ValaLocalVariable* _tmp924_; - ValaDataType* _tmp925_; - ValaDataType* _tmp926_; - gboolean _tmp927_; - gboolean _tmp928_; - _tmp924_ = local; - _tmp925_ = vala_variable_get_variable_type ((ValaVariable*) _tmp924_); - _tmp926_ = _tmp925_; - _tmp927_ = vala_array_type_get_inline_allocated (G_TYPE_CHECK_INSTANCE_CAST (_tmp926_, VALA_TYPE_ARRAY_TYPE, ValaArrayType)); - _tmp928_ = _tmp927_; - _tmp920_ = _tmp928_; + if (_tmp905_) { + gboolean _tmp924_ = FALSE; + ValaLocalVariable* _tmp925_; + ValaDataType* _tmp926_; + ValaDataType* _tmp927_; + _tmp925_ = local; + _tmp926_ = vala_variable_get_variable_type ((ValaVariable*) _tmp925_); + _tmp927_ = _tmp926_; + if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp927_, VALA_TYPE_ARRAY_TYPE)) { + ValaLocalVariable* _tmp928_; + ValaDataType* _tmp929_; + ValaDataType* _tmp930_; + gboolean _tmp931_; + gboolean _tmp932_; + _tmp928_ = local; + _tmp929_ = vala_variable_get_variable_type ((ValaVariable*) _tmp928_); + _tmp930_ = _tmp929_; + _tmp931_ = vala_array_type_get_inline_allocated (G_TYPE_CHECK_INSTANCE_CAST (_tmp930_, VALA_TYPE_ARRAY_TYPE, ValaArrayType)); + _tmp932_ = _tmp931_; + _tmp924_ = _tmp932_; } else { - _tmp920_ = FALSE; + _tmp924_ = FALSE; } - _tmp900_ = !_tmp920_; + _tmp904_ = !_tmp924_; } else { - _tmp900_ = FALSE; + _tmp904_ = FALSE; } - if (_tmp900_) { - ValaDataType* _tmp929_; - ValaDataType* _tmp930_; - ValaLocalVariable* _tmp931_; + if (_tmp904_) { + ValaDataType* _tmp933_; + ValaDataType* _tmp934_; + ValaLocalVariable* _tmp935_; ValaGLibValue* glib_value = NULL; - ValaLocalVariable* _tmp932_; - ValaTargetValue* _tmp933_; - ValaGLibValue* _tmp934_; - ValaGLibValue* _tmp935_; - ValaCCodeExpression* _tmp936_; + ValaLocalVariable* _tmp936_; + ValaTargetValue* _tmp937_; + ValaGLibValue* _tmp938_; ValaGLibValue* _tmp939_; ValaCCodeExpression* _tmp940_; - _tmp929_ = vala_expression_get_value_type ((ValaExpression*) expr); - _tmp930_ = _tmp929_; - vala_data_type_set_value_owned (_tmp930_, TRUE); - _tmp931_ = local; - vala_symbol_set_active ((ValaSymbol*) _tmp931_, FALSE); - _tmp932_ = local; - _tmp933_ = vala_ccode_base_module_get_local_cvalue ((ValaCCodeBaseModule*) self, _tmp932_); - glib_value = G_TYPE_CHECK_INSTANCE_CAST (_tmp933_, VALA_TYPE_GLIB_VALUE, ValaGLibValue); - _tmp934_ = glib_value; - vala_expression_set_target_value ((ValaExpression*) expr, (ValaTargetValue*) _tmp934_); - _tmp935_ = glib_value; - _tmp936_ = _tmp935_->delegate_target_cvalue; - if (_tmp936_ == NULL) { - ValaGLibValue* _tmp937_; - ValaCCodeConstant* _tmp938_; - _tmp937_ = glib_value; - _tmp938_ = vala_ccode_constant_new ("NULL"); - _vala_ccode_node_unref0 (_tmp937_->delegate_target_cvalue); - _tmp937_->delegate_target_cvalue = (ValaCCodeExpression*) _tmp938_; - } + ValaGLibValue* _tmp943_; + ValaCCodeExpression* _tmp944_; + _tmp933_ = vala_expression_get_value_type ((ValaExpression*) expr); + _tmp934_ = _tmp933_; + vala_data_type_set_value_owned (_tmp934_, TRUE); + _tmp935_ = local; + vala_symbol_set_active ((ValaSymbol*) _tmp935_, FALSE); + _tmp936_ = local; + _tmp937_ = vala_ccode_base_module_get_local_cvalue ((ValaCCodeBaseModule*) self, _tmp936_); + glib_value = G_TYPE_CHECK_INSTANCE_CAST (_tmp937_, VALA_TYPE_GLIB_VALUE, ValaGLibValue); + _tmp938_ = glib_value; + vala_expression_set_target_value ((ValaExpression*) expr, (ValaTargetValue*) _tmp938_); _tmp939_ = glib_value; - _tmp940_ = _tmp939_->delegate_target_destroy_notify_cvalue; + _tmp940_ = _tmp939_->delegate_target_cvalue; if (_tmp940_ == NULL) { ValaGLibValue* _tmp941_; ValaCCodeConstant* _tmp942_; _tmp941_ = glib_value; _tmp942_ = vala_ccode_constant_new ("NULL"); - _vala_ccode_node_unref0 (_tmp941_->delegate_target_destroy_notify_cvalue); - _tmp941_->delegate_target_destroy_notify_cvalue = (ValaCCodeExpression*) _tmp942_; + _vala_ccode_node_unref0 (_tmp941_->delegate_target_cvalue); + _tmp941_->delegate_target_cvalue = (ValaCCodeExpression*) _tmp942_; + } + _tmp943_ = glib_value; + _tmp944_ = _tmp943_->delegate_target_destroy_notify_cvalue; + if (_tmp944_ == NULL) { + ValaGLibValue* _tmp945_; + ValaCCodeConstant* _tmp946_; + _tmp945_ = glib_value; + _tmp946_ = vala_ccode_constant_new ("NULL"); + _vala_ccode_node_unref0 (_tmp945_->delegate_target_destroy_notify_cvalue); + _tmp945_->delegate_target_destroy_notify_cvalue = (ValaCCodeExpression*) _tmp946_; } _vala_target_value_unref0 (glib_value); } else { - gboolean _tmp943_; - gboolean _tmp944_; - _tmp943_ = vala_expression_get_lvalue ((ValaExpression*) expr); - _tmp944_ = _tmp943_; - if (_tmp944_) { - ValaLocalVariable* _tmp945_; - ValaTargetValue* _tmp946_; - ValaTargetValue* _tmp947_; - _tmp945_ = local; - _tmp946_ = vala_ccode_base_module_get_local_cvalue ((ValaCCodeBaseModule*) self, _tmp945_); - _tmp947_ = _tmp946_; - vala_expression_set_target_value ((ValaExpression*) expr, _tmp947_); - _vala_target_value_unref0 (_tmp947_); - } else { - ValaLocalVariable* _tmp948_; - ValaTargetValue* _tmp949_; + gboolean _tmp947_; + gboolean _tmp948_; + _tmp947_ = vala_expression_get_lvalue ((ValaExpression*) expr); + _tmp948_ = _tmp947_; + if (_tmp948_) { + ValaLocalVariable* _tmp949_; ValaTargetValue* _tmp950_; - _tmp948_ = local; - _tmp949_ = vala_code_generator_load_local ((ValaCodeGenerator*) self, _tmp948_, (ValaExpression*) expr); - _tmp950_ = _tmp949_; - vala_expression_set_target_value ((ValaExpression*) expr, _tmp950_); - _vala_target_value_unref0 (_tmp950_); + ValaTargetValue* _tmp951_; + _tmp949_ = local; + _tmp950_ = vala_ccode_base_module_get_local_cvalue ((ValaCCodeBaseModule*) self, _tmp949_); + _tmp951_ = _tmp950_; + vala_expression_set_target_value ((ValaExpression*) expr, _tmp951_); + _vala_target_value_unref0 (_tmp951_); + } else { + ValaLocalVariable* _tmp952_; + ValaTargetValue* _tmp953_; + ValaTargetValue* _tmp954_; + _tmp952_ = local; + _tmp953_ = vala_code_generator_load_local ((ValaCodeGenerator*) self, _tmp952_, (ValaExpression*) expr); + _tmp954_ = _tmp953_; + vala_expression_set_target_value ((ValaExpression*) expr, _tmp954_); + _vala_target_value_unref0 (_tmp954_); } } _vala_code_node_unref0 (local); } else { - ValaSymbol* _tmp951_; - ValaSymbol* _tmp952_; - _tmp951_ = vala_expression_get_symbol_reference ((ValaExpression*) expr); - _tmp952_ = _tmp951_; - if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp952_, VALA_TYPE_PARAMETER)) { + ValaSymbol* _tmp955_; + ValaSymbol* _tmp956_; + _tmp955_ = vala_expression_get_symbol_reference ((ValaExpression*) expr); + _tmp956_ = _tmp955_; + if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp956_, VALA_TYPE_PARAMETER)) { ValaParameter* param = NULL; - ValaSymbol* _tmp953_; - ValaSymbol* _tmp954_; - ValaParameter* _tmp955_; - gboolean _tmp956_; - gboolean _tmp957_; - _tmp953_ = vala_expression_get_symbol_reference ((ValaExpression*) expr); - _tmp954_ = _tmp953_; - _tmp955_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp954_, VALA_TYPE_PARAMETER, ValaParameter)); - param = _tmp955_; - _tmp956_ = vala_expression_get_lvalue ((ValaExpression*) expr); - _tmp957_ = _tmp956_; - if (_tmp957_) { - ValaParameter* _tmp958_; - ValaTargetValue* _tmp959_; - ValaTargetValue* _tmp960_; - _tmp958_ = param; - _tmp959_ = vala_ccode_base_module_get_parameter_cvalue ((ValaCCodeBaseModule*) self, _tmp958_); - _tmp960_ = _tmp959_; - vala_expression_set_target_value ((ValaExpression*) expr, _tmp960_); - _vala_target_value_unref0 (_tmp960_); - } else { - ValaParameter* _tmp961_; - ValaTargetValue* _tmp962_; + ValaSymbol* _tmp957_; + ValaSymbol* _tmp958_; + ValaParameter* _tmp959_; + gboolean _tmp960_; + gboolean _tmp961_; + _tmp957_ = vala_expression_get_symbol_reference ((ValaExpression*) expr); + _tmp958_ = _tmp957_; + _tmp959_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp958_, VALA_TYPE_PARAMETER, ValaParameter)); + param = _tmp959_; + _tmp960_ = vala_expression_get_lvalue ((ValaExpression*) expr); + _tmp961_ = _tmp960_; + if (_tmp961_) { + ValaParameter* _tmp962_; ValaTargetValue* _tmp963_; - _tmp961_ = param; - _tmp962_ = vala_code_generator_load_parameter ((ValaCodeGenerator*) self, _tmp961_, (ValaExpression*) expr); - _tmp963_ = _tmp962_; - vala_expression_set_target_value ((ValaExpression*) expr, _tmp963_); - _vala_target_value_unref0 (_tmp963_); + ValaTargetValue* _tmp964_; + _tmp962_ = param; + _tmp963_ = vala_ccode_base_module_get_parameter_cvalue ((ValaCCodeBaseModule*) self, _tmp962_); + _tmp964_ = _tmp963_; + vala_expression_set_target_value ((ValaExpression*) expr, _tmp964_); + _vala_target_value_unref0 (_tmp964_); + } else { + ValaParameter* _tmp965_; + ValaTargetValue* _tmp966_; + ValaTargetValue* _tmp967_; + _tmp965_ = param; + _tmp966_ = vala_code_generator_load_parameter ((ValaCodeGenerator*) self, _tmp965_, (ValaExpression*) expr); + _tmp967_ = _tmp966_; + vala_expression_set_target_value ((ValaExpression*) expr, _tmp967_); + _vala_target_value_unref0 (_tmp967_); } _vala_code_node_unref0 (param); } @@ -2817,81 +2833,81 @@ } } } - _tmp964_ = vala_expression_get_symbol_reference ((ValaExpression*) expr); - _tmp965_ = _tmp964_; - if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp965_, VALA_TYPE_VARIABLE)) { + _tmp968_ = vala_expression_get_symbol_reference ((ValaExpression*) expr); + _tmp969_ = _tmp968_; + if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp969_, VALA_TYPE_VARIABLE)) { ValaGLibValue* cvalue = NULL; - ValaTargetValue* _tmp966_; - ValaTargetValue* _tmp967_; - gboolean _tmp968_ = FALSE; - gboolean _tmp969_ = FALSE; - ValaGLibValue* _tmp970_; - ValaDataType* _tmp971_; - ValaDataType* _tmp972_; - _tmp966_ = vala_expression_get_target_value ((ValaExpression*) expr); - _tmp967_ = _tmp966_; - cvalue = G_TYPE_CHECK_INSTANCE_CAST (_tmp967_, VALA_TYPE_GLIB_VALUE, ValaGLibValue); - _tmp970_ = cvalue; - _tmp971_ = vala_target_value_get_value_type ((ValaTargetValue*) _tmp970_); - _tmp972_ = _tmp971_; - if (!G_TYPE_CHECK_INSTANCE_TYPE (_tmp972_, VALA_TYPE_GENERIC_TYPE)) { - ValaGLibValue* _tmp973_; - ValaDataType* _tmp974_; - ValaDataType* _tmp975_; - ValaTypeSymbol* _tmp976_; - ValaTypeSymbol* _tmp977_; - _tmp973_ = cvalue; - _tmp974_ = vala_target_value_get_value_type ((ValaTargetValue*) _tmp973_); - _tmp975_ = _tmp974_; - _tmp976_ = vala_data_type_get_type_symbol (_tmp975_); - _tmp977_ = _tmp976_; - _tmp969_ = _tmp977_ != NULL; - } else { - _tmp969_ = FALSE; - } - if (_tmp969_) { - ValaGLibValue* _tmp978_; + ValaTargetValue* _tmp970_; + ValaTargetValue* _tmp971_; + gboolean _tmp972_ = FALSE; + gboolean _tmp973_ = FALSE; + ValaGLibValue* _tmp974_; + ValaDataType* _tmp975_; + ValaDataType* _tmp976_; + _tmp970_ = vala_expression_get_target_value ((ValaExpression*) expr); + _tmp971_ = _tmp970_; + cvalue = G_TYPE_CHECK_INSTANCE_CAST (_tmp971_, VALA_TYPE_GLIB_VALUE, ValaGLibValue); + _tmp974_ = cvalue; + _tmp975_ = vala_target_value_get_value_type ((ValaTargetValue*) _tmp974_); + _tmp976_ = _tmp975_; + if (!G_TYPE_CHECK_INSTANCE_TYPE (_tmp976_, VALA_TYPE_GENERIC_TYPE)) { + ValaGLibValue* _tmp977_; + ValaDataType* _tmp978_; ValaDataType* _tmp979_; - ValaDataType* _tmp980_; + ValaTypeSymbol* _tmp980_; ValaTypeSymbol* _tmp981_; - ValaTypeSymbol* _tmp982_; + _tmp977_ = cvalue; + _tmp978_ = vala_target_value_get_value_type ((ValaTargetValue*) _tmp977_); + _tmp979_ = _tmp978_; + _tmp980_ = vala_data_type_get_type_symbol (_tmp979_); + _tmp981_ = _tmp980_; + _tmp973_ = _tmp981_ != NULL; + } else { + _tmp973_ = FALSE; + } + if (_tmp973_) { + ValaGLibValue* _tmp982_; ValaDataType* _tmp983_; ValaDataType* _tmp984_; ValaTypeSymbol* _tmp985_; ValaTypeSymbol* _tmp986_; - _tmp978_ = cvalue; - _tmp979_ = vala_target_value_get_value_type ((ValaTargetValue*) _tmp978_); - _tmp980_ = _tmp979_; - _tmp981_ = vala_data_type_get_type_symbol (_tmp980_); - _tmp982_ = _tmp981_; - _tmp983_ = vala_expression_get_value_type ((ValaExpression*) expr); + ValaDataType* _tmp987_; + ValaDataType* _tmp988_; + ValaTypeSymbol* _tmp989_; + ValaTypeSymbol* _tmp990_; + _tmp982_ = cvalue; + _tmp983_ = vala_target_value_get_value_type ((ValaTargetValue*) _tmp982_); _tmp984_ = _tmp983_; _tmp985_ = vala_data_type_get_type_symbol (_tmp984_); _tmp986_ = _tmp985_; - _tmp968_ = _tmp982_ != _tmp986_; + _tmp987_ = vala_expression_get_value_type ((ValaExpression*) expr); + _tmp988_ = _tmp987_; + _tmp989_ = vala_data_type_get_type_symbol (_tmp988_); + _tmp990_ = _tmp989_; + _tmp972_ = _tmp986_ != _tmp990_; } else { - _tmp968_ = FALSE; + _tmp972_ = FALSE; } - if (_tmp968_) { - ValaGLibValue* _tmp987_; - ValaGLibValue* _tmp988_; - ValaCCodeExpression* _tmp989_; - ValaDataType* _tmp990_; - ValaDataType* _tmp991_; - gchar* _tmp992_; - gchar* _tmp993_; - ValaCCodeCastExpression* _tmp994_; - _tmp987_ = cvalue; - _tmp988_ = cvalue; - _tmp989_ = _tmp988_->cvalue; - _tmp990_ = vala_expression_get_value_type ((ValaExpression*) expr); - _tmp991_ = _tmp990_; - _tmp992_ = vala_get_ccode_name ((ValaCodeNode*) _tmp991_); - _tmp993_ = _tmp992_; - _tmp994_ = vala_ccode_cast_expression_new (_tmp989_, _tmp993_); - _vala_ccode_node_unref0 (_tmp987_->cvalue); - _tmp987_->cvalue = (ValaCCodeExpression*) _tmp994_; - _g_free0 (_tmp993_); + if (_tmp972_) { + ValaGLibValue* _tmp991_; + ValaGLibValue* _tmp992_; + ValaCCodeExpression* _tmp993_; + ValaDataType* _tmp994_; + ValaDataType* _tmp995_; + gchar* _tmp996_; + gchar* _tmp997_; + ValaCCodeCastExpression* _tmp998_; + _tmp991_ = cvalue; + _tmp992_ = cvalue; + _tmp993_ = _tmp992_->cvalue; + _tmp994_ = vala_expression_get_value_type ((ValaExpression*) expr); + _tmp995_ = _tmp994_; + _tmp996_ = vala_get_ccode_name ((ValaCodeNode*) _tmp995_); + _tmp997_ = _tmp996_; + _tmp998_ = vala_ccode_cast_expression_new (_tmp993_, _tmp997_); + _vala_ccode_node_unref0 (_tmp991_->cvalue); + _tmp991_->cvalue = (ValaCCodeExpression*) _tmp998_; + _g_free0 (_tmp997_); } } _vala_code_node_unref0 (delegate_type); @@ -4938,24 +4954,24 @@ ValaDataType* _tmp7_; ValaDelegateType* _tmp8_; ValaArrayType* _tmp9_; - ValaGLibValue* _tmp89_; - ValaDataType* _tmp90_; + ValaGLibValue* _tmp90_; ValaDataType* _tmp91_; + ValaDataType* _tmp92_; gboolean use_temp = FALSE; - ValaGLibValue* _tmp92_; - ValaDataType* _tmp93_; + ValaGLibValue* _tmp93_; ValaDataType* _tmp94_; - gboolean _tmp105_ = FALSE; - gboolean _tmp106_; + ValaDataType* _tmp95_; + gboolean _tmp106_ = FALSE; gboolean _tmp107_; - ValaGLibValue* _tmp111_; - ValaDataType* _tmp112_; + gboolean _tmp108_; + ValaGLibValue* _tmp112_; ValaDataType* _tmp113_; - gboolean _tmp114_ = FALSE; + ValaDataType* _tmp114_; + gboolean _tmp115_ = FALSE; ValaLocalVariable* local = NULL; - ValaLocalVariable* _tmp117_; - gboolean _tmp118_ = FALSE; - ValaLocalVariable* _tmp119_; + ValaLocalVariable* _tmp118_; + gboolean _tmp119_ = FALSE; + ValaLocalVariable* _tmp120_; ValaTargetValue* result; self = (ValaCCodeMemberAccessModule*) base; g_return_val_if_fail (variable != NULL, NULL); @@ -4977,11 +4993,11 @@ ValaArrayType* _tmp10_; gboolean _tmp11_; gboolean _tmp12_; - ValaGLibValue* _tmp78_; ValaGLibValue* _tmp79_; - ValaArrayType* _tmp80_; - gboolean _tmp81_; + ValaGLibValue* _tmp80_; + ValaArrayType* _tmp81_; gboolean _tmp82_; + gboolean _tmp83_; _tmp10_ = array_type; _tmp11_ = vala_array_type_get_fixed_length (_tmp10_); _tmp12_ = _tmp11_; @@ -5008,329 +5024,335 @@ _tmp20_ = _result_; _tmp20_->lvalue = FALSE; } else { + gboolean _tmp21_ = FALSE; if (vala_get_ccode_array_null_terminated ((ValaCodeNode*) variable)) { + _tmp21_ = !vala_get_ccode_array_length ((ValaCodeNode*) variable); + } else { + _tmp21_ = FALSE; + } + if (_tmp21_) { ValaCCodeFunctionCall* len_call = NULL; - ValaCCodeIdentifier* _tmp21_; ValaCCodeIdentifier* _tmp22_; - ValaCCodeFunctionCall* _tmp23_; + ValaCCodeIdentifier* _tmp23_; ValaCCodeFunctionCall* _tmp24_; ValaCCodeFunctionCall* _tmp25_; - ValaGLibValue* _tmp26_; - ValaCCodeExpression* _tmp27_; - ValaGLibValue* _tmp28_; + ValaCCodeFunctionCall* _tmp26_; + ValaGLibValue* _tmp27_; + ValaCCodeExpression* _tmp28_; ValaGLibValue* _tmp29_; - ValaCCodeFunctionCall* _tmp30_; - ValaGLibValue* _tmp31_; + ValaGLibValue* _tmp30_; + ValaCCodeFunctionCall* _tmp31_; + ValaGLibValue* _tmp32_; ((ValaCCodeBaseModule*) self)->requires_array_length = TRUE; - _tmp21_ = vala_ccode_identifier_new ("_vala_array_length"); - _tmp22_ = _tmp21_; - _tmp23_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp22_); - _tmp24_ = _tmp23_; - _vala_ccode_node_unref0 (_tmp22_); - len_call = _tmp24_; - _tmp25_ = len_call; - _tmp26_ = _result_; - _tmp27_ = _tmp26_->cvalue; - vala_ccode_function_call_add_argument (_tmp25_, _tmp27_); - _tmp28_ = _result_; - _vala_iterable_unref0 (_tmp28_->array_length_cvalues); - _tmp28_->array_length_cvalues = NULL; + _tmp22_ = vala_ccode_identifier_new ("_vala_array_length"); + _tmp23_ = _tmp22_; + _tmp24_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp23_); + _tmp25_ = _tmp24_; + _vala_ccode_node_unref0 (_tmp23_); + len_call = _tmp25_; + _tmp26_ = len_call; + _tmp27_ = _result_; + _tmp28_ = _tmp27_->cvalue; + vala_ccode_function_call_add_argument (_tmp26_, _tmp28_); _tmp29_ = _result_; - _tmp30_ = len_call; - vala_glib_value_append_array_length_cvalue (_tmp29_, (ValaCCodeExpression*) _tmp30_); - _tmp31_ = _result_; - _tmp31_->lvalue = FALSE; + _vala_iterable_unref0 (_tmp29_->array_length_cvalues); + _tmp29_->array_length_cvalues = NULL; + _tmp30_ = _result_; + _tmp31_ = len_call; + vala_glib_value_append_array_length_cvalue (_tmp30_, (ValaCCodeExpression*) _tmp31_); + _tmp32_ = _result_; + _tmp32_->lvalue = FALSE; _vala_ccode_node_unref0 (len_call); } else { - gchar* _tmp32_; gchar* _tmp33_; - gboolean _tmp34_; - _tmp32_ = vala_get_ccode_array_length_expr ((ValaCodeNode*) variable); - _tmp33_ = _tmp32_; - _tmp34_ = _tmp33_ != NULL; - _g_free0 (_tmp33_); - if (_tmp34_) { + gchar* _tmp34_; + gboolean _tmp35_; + _tmp33_ = vala_get_ccode_array_length_expr ((ValaCodeNode*) variable); + _tmp34_ = _tmp33_; + _tmp35_ = _tmp34_ != NULL; + _g_free0 (_tmp34_); + if (_tmp35_) { ValaCCodeConstant* length_expr = NULL; - gchar* _tmp35_; gchar* _tmp36_; - ValaCCodeConstant* _tmp37_; + gchar* _tmp37_; ValaCCodeConstant* _tmp38_; - ValaGLibValue* _tmp39_; + ValaCCodeConstant* _tmp39_; ValaGLibValue* _tmp40_; - ValaCCodeConstant* _tmp41_; - ValaGLibValue* _tmp42_; - _tmp35_ = vala_get_ccode_array_length_expr ((ValaCodeNode*) variable); - _tmp36_ = _tmp35_; - _tmp37_ = vala_ccode_constant_new (_tmp36_); - _tmp38_ = _tmp37_; - _g_free0 (_tmp36_); - length_expr = _tmp38_; - _tmp39_ = _result_; - _vala_iterable_unref0 (_tmp39_->array_length_cvalues); - _tmp39_->array_length_cvalues = NULL; + ValaGLibValue* _tmp41_; + ValaCCodeConstant* _tmp42_; + ValaGLibValue* _tmp43_; + _tmp36_ = vala_get_ccode_array_length_expr ((ValaCodeNode*) variable); + _tmp37_ = _tmp36_; + _tmp38_ = vala_ccode_constant_new (_tmp37_); + _tmp39_ = _tmp38_; + _g_free0 (_tmp37_); + length_expr = _tmp39_; _tmp40_ = _result_; - _tmp41_ = length_expr; - vala_glib_value_append_array_length_cvalue (_tmp40_, (ValaCCodeExpression*) _tmp41_); - _tmp42_ = _result_; - _tmp42_->lvalue = FALSE; + _vala_iterable_unref0 (_tmp40_->array_length_cvalues); + _tmp40_->array_length_cvalues = NULL; + _tmp41_ = _result_; + _tmp42_ = length_expr; + vala_glib_value_append_array_length_cvalue (_tmp41_, (ValaCCodeExpression*) _tmp42_); + _tmp43_ = _result_; + _tmp43_->lvalue = FALSE; _vala_ccode_node_unref0 (length_expr); } else { if (!vala_get_ccode_array_length ((ValaCodeNode*) variable)) { - ValaGLibValue* _tmp43_; - ValaGLibValue* _tmp52_; - _tmp43_ = _result_; - _vala_iterable_unref0 (_tmp43_->array_length_cvalues); - _tmp43_->array_length_cvalues = NULL; + ValaGLibValue* _tmp44_; + ValaGLibValue* _tmp53_; + _tmp44_ = _result_; + _vala_iterable_unref0 (_tmp44_->array_length_cvalues); + _tmp44_->array_length_cvalues = NULL; { gint dim = 0; dim = 1; { - gboolean _tmp44_ = FALSE; - _tmp44_ = TRUE; + gboolean _tmp45_ = FALSE; + _tmp45_ = TRUE; while (TRUE) { - ValaArrayType* _tmp46_; - gint _tmp47_; + ValaArrayType* _tmp47_; gint _tmp48_; - ValaGLibValue* _tmp49_; - ValaCCodeConstant* _tmp50_; + gint _tmp49_; + ValaGLibValue* _tmp50_; ValaCCodeConstant* _tmp51_; - if (!_tmp44_) { - gint _tmp45_; - _tmp45_ = dim; - dim = _tmp45_ + 1; + ValaCCodeConstant* _tmp52_; + if (!_tmp45_) { + gint _tmp46_; + _tmp46_ = dim; + dim = _tmp46_ + 1; } - _tmp44_ = FALSE; - _tmp46_ = array_type; - _tmp47_ = vala_array_type_get_rank (_tmp46_); - _tmp48_ = _tmp47_; - if (!(dim <= _tmp48_)) { + _tmp45_ = FALSE; + _tmp47_ = array_type; + _tmp48_ = vala_array_type_get_rank (_tmp47_); + _tmp49_ = _tmp48_; + if (!(dim <= _tmp49_)) { break; } - _tmp49_ = _result_; - _tmp50_ = vala_ccode_constant_new ("-1"); - _tmp51_ = _tmp50_; - vala_glib_value_append_array_length_cvalue (_tmp49_, (ValaCCodeExpression*) _tmp51_); - _vala_ccode_node_unref0 (_tmp51_); + _tmp50_ = _result_; + _tmp51_ = vala_ccode_constant_new ("-1"); + _tmp52_ = _tmp51_; + vala_glib_value_append_array_length_cvalue (_tmp50_, (ValaCCodeExpression*) _tmp52_); + _vala_ccode_node_unref0 (_tmp52_); } } } - _tmp52_ = _result_; - _tmp52_->lvalue = FALSE; + _tmp53_ = _result_; + _tmp53_->lvalue = FALSE; } else { - ValaDataType* _tmp53_; ValaDataType* _tmp54_; - gchar* _tmp55_; + ValaDataType* _tmp55_; gchar* _tmp56_; - ValaArrayType* _tmp57_; - gchar* _tmp58_; + gchar* _tmp57_; + ValaArrayType* _tmp58_; gchar* _tmp59_; - gboolean _tmp60_; - _tmp53_ = vala_variable_get_variable_type (variable); - _tmp54_ = _tmp53_; - _tmp55_ = vala_get_ccode_array_length_type ((ValaCodeNode*) _tmp54_); - _tmp56_ = _tmp55_; - _tmp57_ = array_type; - _tmp58_ = vala_get_ccode_array_length_type ((ValaCodeNode*) _tmp57_); - _tmp59_ = _tmp58_; - _tmp60_ = g_strcmp0 (_tmp56_, _tmp59_) != 0; - _g_free0 (_tmp59_); - _g_free0 (_tmp56_); - if (_tmp60_) { - ValaGLibValue* _tmp77_; + gchar* _tmp60_; + gboolean _tmp61_; + _tmp54_ = vala_variable_get_variable_type (variable); + _tmp55_ = _tmp54_; + _tmp56_ = vala_get_ccode_array_length_type ((ValaCodeNode*) _tmp55_); + _tmp57_ = _tmp56_; + _tmp58_ = array_type; + _tmp59_ = vala_get_ccode_array_length_type ((ValaCodeNode*) _tmp58_); + _tmp60_ = _tmp59_; + _tmp61_ = g_strcmp0 (_tmp57_, _tmp60_) != 0; + _g_free0 (_tmp60_); + _g_free0 (_tmp57_); + if (_tmp61_) { + ValaGLibValue* _tmp78_; { gint dim = 0; dim = 1; { - gboolean _tmp61_ = FALSE; - _tmp61_ = TRUE; + gboolean _tmp62_ = FALSE; + _tmp62_ = TRUE; while (TRUE) { - ValaArrayType* _tmp63_; - gint _tmp64_; + ValaArrayType* _tmp64_; gint _tmp65_; - ValaGLibValue* _tmp66_; - ValaList* _tmp67_; - ValaGLibValue* _tmp68_; - ValaList* _tmp69_; - gpointer _tmp70_; - ValaCCodeExpression* _tmp71_; - ValaArrayType* _tmp72_; - gchar* _tmp73_; + gint _tmp66_; + ValaGLibValue* _tmp67_; + ValaList* _tmp68_; + ValaGLibValue* _tmp69_; + ValaList* _tmp70_; + gpointer _tmp71_; + ValaCCodeExpression* _tmp72_; + ValaArrayType* _tmp73_; gchar* _tmp74_; - ValaCCodeCastExpression* _tmp75_; + gchar* _tmp75_; ValaCCodeCastExpression* _tmp76_; - if (!_tmp61_) { - gint _tmp62_; - _tmp62_ = dim; - dim = _tmp62_ + 1; + ValaCCodeCastExpression* _tmp77_; + if (!_tmp62_) { + gint _tmp63_; + _tmp63_ = dim; + dim = _tmp63_ + 1; } - _tmp61_ = FALSE; - _tmp63_ = array_type; - _tmp64_ = vala_array_type_get_rank (_tmp63_); - _tmp65_ = _tmp64_; - if (!(dim <= _tmp65_)) { + _tmp62_ = FALSE; + _tmp64_ = array_type; + _tmp65_ = vala_array_type_get_rank (_tmp64_); + _tmp66_ = _tmp65_; + if (!(dim <= _tmp66_)) { break; } - _tmp66_ = _result_; - _tmp67_ = _tmp66_->array_length_cvalues; - _tmp68_ = _result_; - _tmp69_ = _tmp68_->array_length_cvalues; - _tmp70_ = vala_list_get (_tmp69_, dim - 1); - _tmp71_ = (ValaCCodeExpression*) _tmp70_; - _tmp72_ = array_type; - _tmp73_ = vala_get_ccode_array_length_type ((ValaCodeNode*) _tmp72_); - _tmp74_ = _tmp73_; - _tmp75_ = vala_ccode_cast_expression_new (_tmp71_, _tmp74_); - _tmp76_ = _tmp75_; - vala_list_set (_tmp67_, dim - 1, (ValaCCodeExpression*) _tmp76_); - _vala_ccode_node_unref0 (_tmp76_); - _g_free0 (_tmp74_); - _vala_ccode_node_unref0 (_tmp71_); + _tmp67_ = _result_; + _tmp68_ = _tmp67_->array_length_cvalues; + _tmp69_ = _result_; + _tmp70_ = _tmp69_->array_length_cvalues; + _tmp71_ = vala_list_get (_tmp70_, dim - 1); + _tmp72_ = (ValaCCodeExpression*) _tmp71_; + _tmp73_ = array_type; + _tmp74_ = vala_get_ccode_array_length_type ((ValaCodeNode*) _tmp73_); + _tmp75_ = _tmp74_; + _tmp76_ = vala_ccode_cast_expression_new (_tmp72_, _tmp75_); + _tmp77_ = _tmp76_; + vala_list_set (_tmp68_, dim - 1, (ValaCCodeExpression*) _tmp77_); + _vala_ccode_node_unref0 (_tmp77_); + _g_free0 (_tmp75_); + _vala_ccode_node_unref0 (_tmp72_); } } } - _tmp77_ = _result_; - _tmp77_->lvalue = FALSE; + _tmp78_ = _result_; + _tmp78_->lvalue = FALSE; } } } } } - _tmp78_ = _result_; - _vala_ccode_node_unref0 (_tmp78_->array_size_cvalue); - _tmp78_->array_size_cvalue = NULL; _tmp79_ = _result_; - _tmp80_ = array_type; - _tmp81_ = vala_array_type_get_inline_allocated (_tmp80_); - _tmp82_ = _tmp81_; - _tmp79_->non_null = _tmp82_; + _vala_ccode_node_unref0 (_tmp79_->array_size_cvalue); + _tmp79_->array_size_cvalue = NULL; + _tmp80_ = _result_; + _tmp81_ = array_type; + _tmp82_ = vala_array_type_get_inline_allocated (_tmp81_); + _tmp83_ = _tmp82_; + _tmp80_->non_null = _tmp83_; } else { - ValaDelegateType* _tmp83_; - _tmp83_ = delegate_type; - if (_tmp83_ != NULL) { - ValaGLibValue* _tmp88_; + ValaDelegateType* _tmp84_; + _tmp84_ = delegate_type; + if (_tmp84_ != NULL) { + ValaGLibValue* _tmp89_; if (!vala_get_ccode_delegate_target ((ValaCodeNode*) variable)) { - ValaGLibValue* _tmp84_; - ValaCCodeConstant* _tmp85_; - ValaGLibValue* _tmp86_; - ValaCCodeConstant* _tmp87_; - _tmp84_ = _result_; - _tmp85_ = vala_ccode_constant_new ("NULL"); - _vala_ccode_node_unref0 (_tmp84_->delegate_target_cvalue); - _tmp84_->delegate_target_cvalue = (ValaCCodeExpression*) _tmp85_; - _tmp86_ = _result_; - _tmp87_ = vala_ccode_constant_new ("NULL"); - _vala_ccode_node_unref0 (_tmp86_->delegate_target_destroy_notify_cvalue); - _tmp86_->delegate_target_destroy_notify_cvalue = (ValaCCodeExpression*) _tmp87_; + ValaGLibValue* _tmp85_; + ValaCCodeConstant* _tmp86_; + ValaGLibValue* _tmp87_; + ValaCCodeConstant* _tmp88_; + _tmp85_ = _result_; + _tmp86_ = vala_ccode_constant_new ("NULL"); + _vala_ccode_node_unref0 (_tmp85_->delegate_target_cvalue); + _tmp85_->delegate_target_cvalue = (ValaCCodeExpression*) _tmp86_; + _tmp87_ = _result_; + _tmp88_ = vala_ccode_constant_new ("NULL"); + _vala_ccode_node_unref0 (_tmp87_->delegate_target_destroy_notify_cvalue); + _tmp87_->delegate_target_destroy_notify_cvalue = (ValaCCodeExpression*) _tmp88_; } - _tmp88_ = _result_; - _tmp88_->lvalue = FALSE; + _tmp89_ = _result_; + _tmp89_->lvalue = FALSE; } } - _tmp89_ = _result_; - _tmp90_ = vala_target_value_get_value_type ((ValaTargetValue*) _tmp89_); - _tmp91_ = _tmp90_; - vala_data_type_set_value_owned (_tmp91_, FALSE); + _tmp90_ = _result_; + _tmp91_ = vala_target_value_get_value_type ((ValaTargetValue*) _tmp90_); + _tmp92_ = _tmp91_; + vala_data_type_set_value_owned (_tmp92_, FALSE); use_temp = TRUE; - _tmp92_ = _result_; - _tmp93_ = vala_target_value_get_value_type ((ValaTargetValue*) _tmp92_); - _tmp94_ = _tmp93_; - if (!vala_ccode_base_module_is_lvalue_access_allowed ((ValaCCodeBaseModule*) self, _tmp94_)) { + _tmp93_ = _result_; + _tmp94_ = vala_target_value_get_value_type ((ValaTargetValue*) _tmp93_); + _tmp95_ = _tmp94_; + if (!vala_ccode_base_module_is_lvalue_access_allowed ((ValaCCodeBaseModule*) self, _tmp95_)) { use_temp = FALSE; } if (G_TYPE_CHECK_INSTANCE_TYPE (variable, VALA_TYPE_PARAMETER)) { ValaParameter* param = NULL; - ValaParameter* _tmp95_; - const gchar* _tmp96_; + ValaParameter* _tmp96_; const gchar* _tmp97_; - _tmp95_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (variable, VALA_TYPE_PARAMETER, ValaParameter)); - param = _tmp95_; - _tmp96_ = vala_symbol_get_name ((ValaSymbol*) variable); - _tmp97_ = _tmp96_; - if (g_strcmp0 (_tmp97_, "this") == 0) { + const gchar* _tmp98_; + _tmp96_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (variable, VALA_TYPE_PARAMETER, ValaParameter)); + param = _tmp96_; + _tmp97_ = vala_symbol_get_name ((ValaSymbol*) variable); + _tmp98_ = _tmp97_; + if (g_strcmp0 (_tmp98_, "this") == 0) { use_temp = FALSE; } else { - gboolean _tmp98_ = FALSE; - ValaParameter* _tmp99_; - ValaParameterDirection _tmp100_; + gboolean _tmp99_ = FALSE; + ValaParameter* _tmp100_; ValaParameterDirection _tmp101_; - _tmp99_ = param; - _tmp100_ = vala_parameter_get_direction (_tmp99_); - _tmp101_ = _tmp100_; - if (_tmp101_ != VALA_PARAMETER_DIRECTION_OUT) { - ValaParameter* _tmp102_; - ValaDataType* _tmp103_; + ValaParameterDirection _tmp102_; + _tmp100_ = param; + _tmp101_ = vala_parameter_get_direction (_tmp100_); + _tmp102_ = _tmp101_; + if (_tmp102_ != VALA_PARAMETER_DIRECTION_OUT) { + ValaParameter* _tmp103_; ValaDataType* _tmp104_; - _tmp102_ = param; - _tmp103_ = vala_variable_get_variable_type ((ValaVariable*) _tmp102_); - _tmp104_ = _tmp103_; - _tmp98_ = !vala_data_type_is_real_non_null_struct_type (_tmp104_); + ValaDataType* _tmp105_; + _tmp103_ = param; + _tmp104_ = vala_variable_get_variable_type ((ValaVariable*) _tmp103_); + _tmp105_ = _tmp104_; + _tmp99_ = !vala_data_type_is_real_non_null_struct_type (_tmp105_); } else { - _tmp98_ = FALSE; + _tmp99_ = FALSE; } - if (_tmp98_) { + if (_tmp99_) { use_temp = FALSE; } } _vala_code_node_unref0 (param); } - _tmp106_ = vala_variable_get_single_assignment (variable); - _tmp107_ = _tmp106_; - if (_tmp107_) { - ValaGLibValue* _tmp108_; - ValaDataType* _tmp109_; + _tmp107_ = vala_variable_get_single_assignment (variable); + _tmp108_ = _tmp107_; + if (_tmp108_) { + ValaGLibValue* _tmp109_; ValaDataType* _tmp110_; - _tmp108_ = _result_; - _tmp109_ = vala_target_value_get_value_type ((ValaTargetValue*) _tmp108_); - _tmp110_ = _tmp109_; - _tmp105_ = !vala_data_type_is_real_non_null_struct_type (_tmp110_); + ValaDataType* _tmp111_; + _tmp109_ = _result_; + _tmp110_ = vala_target_value_get_value_type ((ValaTargetValue*) _tmp109_); + _tmp111_ = _tmp110_; + _tmp106_ = !vala_data_type_is_real_non_null_struct_type (_tmp111_); } else { - _tmp105_ = FALSE; + _tmp106_ = FALSE; } - if (_tmp105_) { + if (_tmp106_) { use_temp = FALSE; } - _tmp111_ = _result_; - _tmp112_ = vala_target_value_get_value_type ((ValaTargetValue*) _tmp111_); - _tmp113_ = _tmp112_; - if (vala_data_type_is_non_null_simple_type (_tmp113_)) { + _tmp112_ = _result_; + _tmp113_ = vala_target_value_get_value_type ((ValaTargetValue*) _tmp112_); + _tmp114_ = _tmp113_; + if (vala_data_type_is_non_null_simple_type (_tmp114_)) { use_temp = FALSE; } if (G_TYPE_CHECK_INSTANCE_TYPE (expr, VALA_TYPE_MEMBER_ACCESS)) { - gboolean _tmp115_; gboolean _tmp116_; - _tmp115_ = vala_member_access_get_tainted_access (G_TYPE_CHECK_INSTANCE_CAST (expr, VALA_TYPE_MEMBER_ACCESS, ValaMemberAccess)); - _tmp116_ = _tmp115_; - _tmp114_ = _tmp116_; + gboolean _tmp117_; + _tmp116_ = vala_member_access_get_tainted_access (G_TYPE_CHECK_INSTANCE_CAST (expr, VALA_TYPE_MEMBER_ACCESS, ValaMemberAccess)); + _tmp117_ = _tmp116_; + _tmp115_ = _tmp117_; } else { - _tmp114_ = FALSE; + _tmp115_ = FALSE; } - if (_tmp114_) { + if (_tmp115_) { use_temp = TRUE; } - _tmp117_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (variable, VALA_TYPE_LOCAL_VARIABLE) ? ((ValaLocalVariable*) variable) : NULL); - local = _tmp117_; - _tmp119_ = local; - if (_tmp119_ != NULL) { - ValaLocalVariable* _tmp120_; - const gchar* _tmp121_; + _tmp118_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (variable, VALA_TYPE_LOCAL_VARIABLE) ? ((ValaLocalVariable*) variable) : NULL); + local = _tmp118_; + _tmp120_ = local; + if (_tmp120_ != NULL) { + ValaLocalVariable* _tmp121_; const gchar* _tmp122_; - _tmp120_ = local; - _tmp121_ = vala_symbol_get_name ((ValaSymbol*) _tmp120_); - _tmp122_ = _tmp121_; - _tmp118_ = string_get (_tmp122_, (glong) 0) == '.'; + const gchar* _tmp123_; + _tmp121_ = local; + _tmp122_ = vala_symbol_get_name ((ValaSymbol*) _tmp121_); + _tmp123_ = _tmp122_; + _tmp119_ = string_get (_tmp123_, (glong) 0) == '.'; } else { - _tmp118_ = FALSE; + _tmp119_ = FALSE; } - if (_tmp118_) { + if (_tmp119_) { use_temp = FALSE; } if (use_temp) { - ValaGLibValue* _tmp123_; - ValaTargetValue* _tmp124_; - _tmp123_ = _result_; - _tmp124_ = vala_ccode_base_module_store_temp_value ((ValaCCodeBaseModule*) self, (ValaTargetValue*) _tmp123_, (ValaCodeNode*) variable, NULL); + ValaGLibValue* _tmp124_; + ValaTargetValue* _tmp125_; + _tmp124_ = _result_; + _tmp125_ = vala_ccode_base_module_store_temp_value ((ValaCCodeBaseModule*) self, (ValaTargetValue*) _tmp124_, (ValaCodeNode*) variable, NULL); _vala_target_value_unref0 (_result_); - _result_ = G_TYPE_CHECK_INSTANCE_CAST (_tmp124_, VALA_TYPE_GLIB_VALUE, ValaGLibValue); + _result_ = G_TYPE_CHECK_INSTANCE_CAST (_tmp125_, VALA_TYPE_GLIB_VALUE, ValaGLibValue); } result = (ValaTargetValue*) _result_; _vala_code_node_unref0 (local); diff -Nru vala-0.56.16/codegen/valaccodememberaccessmodule.vala vala-0.56.17/codegen/valaccodememberaccessmodule.vala --- vala-0.56.16/codegen/valaccodememberaccessmodule.vala 2024-01-30 14:30:23.000000000 +0000 +++ vala-0.56.17/codegen/valaccodememberaccessmodule.vala 2024-04-19 10:23:32.000000000 +0000 @@ -282,7 +282,7 @@ } else { array_type = prop.property_type as ArrayType; if (array_type != null) { - if (get_ccode_array_null_terminated (prop)) { + if (get_ccode_array_null_terminated (prop) && !get_ccode_array_length (prop)) { requires_array_length = true; var len_call = new CCodeFunctionCall (new CCodeIdentifier ("_vala_array_length")); len_call.add_argument (ctemp); @@ -357,7 +357,7 @@ set_cvalue (expr, ctemp); - if (get_ccode_array_null_terminated (prop)) { + if (get_ccode_array_null_terminated (prop) && !get_ccode_array_length (prop)) { requires_array_length = true; var len_call = new CCodeFunctionCall (new CCodeIdentifier ("_vala_array_length")); len_call.add_argument (ctemp); @@ -735,7 +735,7 @@ result.array_length_cvalues = null; result.append_array_length_cvalue (get_ccodenode (array_type.length)); result.lvalue = false; - } else if (get_ccode_array_null_terminated (variable)) { + } else if (get_ccode_array_null_terminated (variable) && !get_ccode_array_length (variable)) { requires_array_length = true; var len_call = new CCodeFunctionCall (new CCodeIdentifier ("_vala_array_length")); len_call.add_argument (result.cvalue); diff -Nru vala-0.56.16/codegen/valaccodemethodcallmodule.c vala-0.56.17/codegen/valaccodemethodcallmodule.c --- vala-0.56.16/codegen/valaccodemethodcallmodule.c 2024-03-14 09:03:36.000000000 +0000 +++ vala-0.56.17/codegen/valaccodemethodcallmodule.c 2024-04-19 11:03:37.000000000 +0000 @@ -478,59 +478,59 @@ gboolean _tmp1503_ = FALSE; gboolean _tmp1504_ = FALSE; ValaMethod* _tmp1505_; - gboolean _tmp1626_ = FALSE; - ValaDelegate* _tmp1627_; - gboolean _tmp1723_ = FALSE; - ValaMethod* _tmp1724_; - gboolean _tmp1740_; - gboolean _tmp1741_; - gboolean _tmp1785_ = FALSE; - ValaDelegate* _tmp1786_; + gboolean _tmp1628_ = FALSE; + ValaDelegate* _tmp1629_; + gboolean _tmp1727_ = FALSE; + ValaMethod* _tmp1728_; + gboolean _tmp1744_; + gboolean _tmp1745_; + gboolean _tmp1789_ = FALSE; + ValaDelegate* _tmp1790_; gboolean return_result_via_out_param = FALSE; - ValaDataType* _tmp1804_; - ValaDataType* _tmp1805_; - gboolean _tmp1806_ = FALSE; - ValaDataType* _tmp1807_; - ValaCCodeFunctionCall* _tmp1835_; - ValaCCodeFunctionCall* _tmp1836_; + ValaDataType* _tmp1808_; + ValaDataType* _tmp1809_; + gboolean _tmp1810_ = FALSE; + ValaDataType* _tmp1811_; + ValaCCodeFunctionCall* _tmp1839_; + ValaCCodeFunctionCall* _tmp1840_; ValaCCodeExpression* out_param_ref = NULL; gint last_pos = 0; gint min_pos = 0; - ValaCCodeFunctionCall* _tmp1849_; - ValaCCodeFunctionCall* _tmp1850_; - ValaCCodeFunctionCall* _tmp1865_; - gboolean _tmp1880_; - gboolean _tmp1881_; - gboolean _tmp1903_; - gboolean _tmp1904_; + ValaCCodeFunctionCall* _tmp1853_; + ValaCCodeFunctionCall* _tmp1854_; + ValaCCodeFunctionCall* _tmp1869_; + gboolean _tmp1884_; + gboolean _tmp1885_; + gboolean _tmp1907_; + gboolean _tmp1908_; ValaDataType* collection_type = NULL; - gboolean _tmp1934_ = FALSE; - ValaMemberAccess* _tmp1935_; - gboolean _tmp1944_ = FALSE; - gboolean _tmp1945_ = FALSE; - gboolean _tmp1946_ = FALSE; - ValaDataType* _tmp1947_; - gboolean _tmp2007_ = FALSE; - gboolean _tmp2008_ = FALSE; - ValaMethod* _tmp2009_; - gboolean _tmp2047_ = FALSE; - gboolean _tmp2048_ = FALSE; - gboolean _tmp2049_ = FALSE; - gboolean _tmp2050_ = FALSE; + gboolean _tmp1938_ = FALSE; + ValaMemberAccess* _tmp1939_; + gboolean _tmp1948_ = FALSE; + gboolean _tmp1949_ = FALSE; + gboolean _tmp1950_ = FALSE; + ValaDataType* _tmp1951_; + gboolean _tmp2011_ = FALSE; + gboolean _tmp2012_ = FALSE; + ValaMethod* _tmp2013_; gboolean _tmp2051_ = FALSE; - ValaMethod* _tmp2052_; - gboolean _tmp2069_ = FALSE; - gboolean _tmp2070_ = FALSE; - ValaMethod* _tmp2071_; - ValaMethod* _tmp2090_; - gboolean _tmp2202_ = FALSE; - ValaCodeNode* _tmp2203_; - ValaCodeNode* _tmp2204_; - ValaList* _tmp2304_; - ValaIterator* _tmp2305_; - gboolean _tmp2458_ = FALSE; - gboolean _tmp2459_ = FALSE; - ValaMethod* _tmp2460_; + gboolean _tmp2052_ = FALSE; + gboolean _tmp2053_ = FALSE; + gboolean _tmp2054_ = FALSE; + gboolean _tmp2055_ = FALSE; + ValaMethod* _tmp2056_; + gboolean _tmp2073_ = FALSE; + gboolean _tmp2074_ = FALSE; + ValaMethod* _tmp2075_; + ValaMethod* _tmp2094_; + gboolean _tmp2206_ = FALSE; + ValaCodeNode* _tmp2207_; + ValaCodeNode* _tmp2208_; + ValaList* _tmp2308_; + ValaIterator* _tmp2309_; + gboolean _tmp2539_ = FALSE; + gboolean _tmp2540_ = FALSE; + ValaMethod* _tmp2541_; self = (ValaCCodeMethodCallModule*) base; g_return_if_fail (expr != NULL); _tmp0_ = vala_callable_expression_get_call ((ValaCallableExpression*) expr); @@ -2089,7 +2089,7 @@ _tmp551_ = check_func; _tmp552_ = class_prefix; _tmp553_ = class_prefix; - _tmp554_ = g_strdup_printf ("{ %s, %s, %s_real_dispatch, %s_finalize}", _tmp550_, _tmp551_, _tmp552_, _tmp553_); + _tmp554_ = g_strdup_printf ("{ %s, %s, %s_real_dispatch, %s_finalize, NULL, NULL}", _tmp550_, _tmp551_, _tmp552_, _tmp553_); _tmp555_ = _tmp554_; _tmp556_ = vala_ccode_constant_new (_tmp555_); _tmp557_ = _tmp556_; @@ -4846,7 +4846,8 @@ ValaArrayType* _tmp1517_; gint _tmp1518_; gint _tmp1519_; - ValaMethod* _tmp1520_; + gboolean _tmp1520_ = FALSE; + ValaMethod* _tmp1521_; if (!_tmp1515_) { gint _tmp1516_; _tmp1516_ = dim; @@ -4859,145 +4860,152 @@ if (!(dim <= _tmp1519_)) { break; } - _tmp1520_ = m; - if (vala_get_ccode_array_null_terminated ((ValaCodeNode*) _tmp1520_)) { + _tmp1521_ = m; + if (vala_get_ccode_array_null_terminated ((ValaCodeNode*) _tmp1521_)) { + ValaMethod* _tmp1522_; + _tmp1522_ = m; + _tmp1520_ = !vala_get_ccode_array_length ((ValaCodeNode*) _tmp1522_); + } else { + _tmp1520_ = FALSE; + } + if (_tmp1520_) { ValaLocalVariable* temp_var = NULL; - ValaDataType* _tmp1521_; - ValaDataType* _tmp1522_; - ValaLocalVariable* _tmp1523_; + ValaDataType* _tmp1523_; + ValaDataType* _tmp1524_; + ValaLocalVariable* _tmp1525_; ValaCCodeExpression* temp_ref = NULL; - ValaLocalVariable* _tmp1524_; - const gchar* _tmp1525_; - const gchar* _tmp1526_; - ValaCCodeExpression* _tmp1527_; - ValaLocalVariable* _tmp1528_; + ValaLocalVariable* _tmp1526_; + const gchar* _tmp1527_; + const gchar* _tmp1528_; ValaCCodeExpression* _tmp1529_; - ValaCCodeExpression* _tmp1530_; - ValaCCodeAssignment* _tmp1531_; + ValaLocalVariable* _tmp1530_; + ValaCCodeExpression* _tmp1531_; + ValaCCodeExpression* _tmp1532_; + ValaCCodeAssignment* _tmp1533_; ValaCCodeFunctionCall* len_call = NULL; - ValaCCodeIdentifier* _tmp1532_; - ValaCCodeIdentifier* _tmp1533_; - ValaCCodeFunctionCall* _tmp1534_; - ValaCCodeFunctionCall* _tmp1535_; + ValaCCodeIdentifier* _tmp1534_; + ValaCCodeIdentifier* _tmp1535_; ValaCCodeFunctionCall* _tmp1536_; - ValaCCodeExpression* _tmp1537_; + ValaCCodeFunctionCall* _tmp1537_; ValaCCodeFunctionCall* _tmp1538_; - _tmp1521_ = itype; - _tmp1522_ = vala_data_type_get_return_type (_tmp1521_); - _tmp1523_ = vala_ccode_base_module_get_temp_variable ((ValaCCodeBaseModule*) self, _tmp1522_, TRUE, NULL, FALSE); - temp_var = _tmp1523_; - _tmp1524_ = temp_var; - _tmp1525_ = vala_symbol_get_name ((ValaSymbol*) _tmp1524_); - _tmp1526_ = _tmp1525_; - _tmp1527_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, _tmp1526_); - temp_ref = _tmp1527_; - _tmp1528_ = temp_var; - vala_ccode_base_module_emit_temp_var ((ValaCCodeBaseModule*) self, _tmp1528_, FALSE); - _tmp1529_ = temp_ref; - _tmp1530_ = ccall_expr; - _tmp1531_ = vala_ccode_assignment_new (_tmp1529_, _tmp1530_, VALA_CCODE_ASSIGNMENT_OPERATOR_SIMPLE); + ValaCCodeExpression* _tmp1539_; + ValaCCodeFunctionCall* _tmp1540_; + _tmp1523_ = itype; + _tmp1524_ = vala_data_type_get_return_type (_tmp1523_); + _tmp1525_ = vala_ccode_base_module_get_temp_variable ((ValaCCodeBaseModule*) self, _tmp1524_, TRUE, NULL, FALSE); + temp_var = _tmp1525_; + _tmp1526_ = temp_var; + _tmp1527_ = vala_symbol_get_name ((ValaSymbol*) _tmp1526_); + _tmp1528_ = _tmp1527_; + _tmp1529_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, _tmp1528_); + temp_ref = _tmp1529_; + _tmp1530_ = temp_var; + vala_ccode_base_module_emit_temp_var ((ValaCCodeBaseModule*) self, _tmp1530_, FALSE); + _tmp1531_ = temp_ref; + _tmp1532_ = ccall_expr; + _tmp1533_ = vala_ccode_assignment_new (_tmp1531_, _tmp1532_, VALA_CCODE_ASSIGNMENT_OPERATOR_SIMPLE); _vala_ccode_node_unref0 (ccall_expr); - ccall_expr = (ValaCCodeExpression*) _tmp1531_; + ccall_expr = (ValaCCodeExpression*) _tmp1533_; ((ValaCCodeBaseModule*) self)->requires_array_length = TRUE; - _tmp1532_ = vala_ccode_identifier_new ("_vala_array_length"); - _tmp1533_ = _tmp1532_; - _tmp1534_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp1533_); + _tmp1534_ = vala_ccode_identifier_new ("_vala_array_length"); _tmp1535_ = _tmp1534_; - _vala_ccode_node_unref0 (_tmp1533_); - len_call = _tmp1535_; - _tmp1536_ = len_call; - _tmp1537_ = temp_ref; - vala_ccode_function_call_add_argument (_tmp1536_, _tmp1537_); + _tmp1536_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp1535_); + _tmp1537_ = _tmp1536_; + _vala_ccode_node_unref0 (_tmp1535_); + len_call = _tmp1537_; _tmp1538_ = len_call; - vala_append_array_length ((ValaExpression*) expr, (ValaCCodeExpression*) _tmp1538_); + _tmp1539_ = temp_ref; + vala_ccode_function_call_add_argument (_tmp1538_, _tmp1539_); + _tmp1540_ = len_call; + vala_append_array_length ((ValaExpression*) expr, (ValaCCodeExpression*) _tmp1540_); _vala_ccode_node_unref0 (len_call); _vala_ccode_node_unref0 (temp_ref); _vala_code_node_unref0 (temp_var); } else { - ValaMethod* _tmp1539_; - _tmp1539_ = m; - if (vala_get_ccode_array_length ((ValaCodeNode*) _tmp1539_)) { + ValaMethod* _tmp1541_; + _tmp1541_ = m; + if (vala_get_ccode_array_length ((ValaCodeNode*) _tmp1541_)) { gchar* length_ctype = NULL; - ValaMethod* _tmp1540_; - gchar* _tmp1541_; + ValaMethod* _tmp1542_; + gchar* _tmp1543_; ValaLocalVariable* temp_var = NULL; - const gchar* _tmp1542_; - ValaCType* _tmp1543_; - ValaCType* _tmp1544_; - ValaLocalVariable* _tmp1545_; - ValaLocalVariable* _tmp1546_; - ValaCCodeExpression* temp_ref = NULL; + const gchar* _tmp1544_; + ValaCType* _tmp1545_; + ValaCType* _tmp1546_; ValaLocalVariable* _tmp1547_; - const gchar* _tmp1548_; - const gchar* _tmp1549_; - ValaCCodeExpression* _tmp1550_; - ValaLocalVariable* _tmp1551_; - ValaHashMap* _tmp1552_; - ValaMethod* _tmp1553_; - ValaCCodeExpression* _tmp1554_; - ValaCCodeUnaryExpression* _tmp1555_; - ValaCCodeUnaryExpression* _tmp1556_; - ValaCCodeExpression* _tmp1557_; - _tmp1540_ = m; - _tmp1541_ = vala_get_ccode_array_length_type ((ValaCodeNode*) _tmp1540_); - length_ctype = _tmp1541_; - _tmp1542_ = length_ctype; - _tmp1543_ = vala_ctype_new (_tmp1542_, "0"); - _tmp1544_ = _tmp1543_; - _tmp1545_ = vala_ccode_base_module_get_temp_variable ((ValaCCodeBaseModule*) self, (ValaDataType*) _tmp1544_, TRUE, NULL, TRUE); + ValaLocalVariable* _tmp1548_; + ValaCCodeExpression* temp_ref = NULL; + ValaLocalVariable* _tmp1549_; + const gchar* _tmp1550_; + const gchar* _tmp1551_; + ValaCCodeExpression* _tmp1552_; + ValaLocalVariable* _tmp1553_; + ValaHashMap* _tmp1554_; + ValaMethod* _tmp1555_; + ValaCCodeExpression* _tmp1556_; + ValaCCodeUnaryExpression* _tmp1557_; + ValaCCodeUnaryExpression* _tmp1558_; + ValaCCodeExpression* _tmp1559_; + _tmp1542_ = m; + _tmp1543_ = vala_get_ccode_array_length_type ((ValaCodeNode*) _tmp1542_); + length_ctype = _tmp1543_; + _tmp1544_ = length_ctype; + _tmp1545_ = vala_ctype_new (_tmp1544_, "0"); _tmp1546_ = _tmp1545_; - _vala_code_node_unref0 (_tmp1544_); - temp_var = _tmp1546_; - _tmp1547_ = temp_var; - _tmp1548_ = vala_symbol_get_name ((ValaSymbol*) _tmp1547_); - _tmp1549_ = _tmp1548_; - _tmp1550_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, _tmp1549_); - temp_ref = _tmp1550_; - _tmp1551_ = temp_var; - vala_ccode_base_module_emit_temp_var ((ValaCCodeBaseModule*) self, _tmp1551_, FALSE); - _tmp1552_ = out_arg_map; - _tmp1553_ = m; - _tmp1554_ = temp_ref; - _tmp1555_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, _tmp1554_); - _tmp1556_ = _tmp1555_; - vala_map_set ((ValaMap*) _tmp1552_, (gpointer) ((gintptr) vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, vala_get_ccode_array_length_pos ((ValaCodeNode*) _tmp1553_) + (0.01 * dim), FALSE)), (ValaCCodeExpression*) _tmp1556_); - _vala_ccode_node_unref0 (_tmp1556_); - _tmp1557_ = temp_ref; - vala_append_array_length ((ValaExpression*) expr, _tmp1557_); + _tmp1547_ = vala_ccode_base_module_get_temp_variable ((ValaCCodeBaseModule*) self, (ValaDataType*) _tmp1546_, TRUE, NULL, TRUE); + _tmp1548_ = _tmp1547_; + _vala_code_node_unref0 (_tmp1546_); + temp_var = _tmp1548_; + _tmp1549_ = temp_var; + _tmp1550_ = vala_symbol_get_name ((ValaSymbol*) _tmp1549_); + _tmp1551_ = _tmp1550_; + _tmp1552_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, _tmp1551_); + temp_ref = _tmp1552_; + _tmp1553_ = temp_var; + vala_ccode_base_module_emit_temp_var ((ValaCCodeBaseModule*) self, _tmp1553_, FALSE); + _tmp1554_ = out_arg_map; + _tmp1555_ = m; + _tmp1556_ = temp_ref; + _tmp1557_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, _tmp1556_); + _tmp1558_ = _tmp1557_; + vala_map_set ((ValaMap*) _tmp1554_, (gpointer) ((gintptr) vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, vala_get_ccode_array_length_pos ((ValaCodeNode*) _tmp1555_) + (0.01 * dim), FALSE)), (ValaCCodeExpression*) _tmp1558_); + _vala_ccode_node_unref0 (_tmp1558_); + _tmp1559_ = temp_ref; + vala_append_array_length ((ValaExpression*) expr, _tmp1559_); _vala_ccode_node_unref0 (temp_ref); _vala_code_node_unref0 (temp_var); _g_free0 (length_ctype); } else { - ValaMethod* _tmp1558_; - gchar* _tmp1559_; - gchar* _tmp1560_; - gboolean _tmp1561_; - _tmp1558_ = m; - _tmp1559_ = vala_get_ccode_array_length_expr ((ValaCodeNode*) _tmp1558_); - _tmp1560_ = _tmp1559_; - _tmp1561_ = _tmp1560_ != NULL; - _g_free0 (_tmp1560_); - if (_tmp1561_) { - ValaMethod* _tmp1562_; - gchar* _tmp1563_; - gchar* _tmp1564_; - ValaCCodeConstant* _tmp1565_; - ValaCCodeConstant* _tmp1566_; - _tmp1562_ = m; - _tmp1563_ = vala_get_ccode_array_length_expr ((ValaCodeNode*) _tmp1562_); - _tmp1564_ = _tmp1563_; - _tmp1565_ = vala_ccode_constant_new (_tmp1564_); - _tmp1566_ = _tmp1565_; - vala_append_array_length ((ValaExpression*) expr, (ValaCCodeExpression*) _tmp1566_); - _vala_ccode_node_unref0 (_tmp1566_); - _g_free0 (_tmp1564_); - } else { + ValaMethod* _tmp1560_; + gchar* _tmp1561_; + gchar* _tmp1562_; + gboolean _tmp1563_; + _tmp1560_ = m; + _tmp1561_ = vala_get_ccode_array_length_expr ((ValaCodeNode*) _tmp1560_); + _tmp1562_ = _tmp1561_; + _tmp1563_ = _tmp1562_ != NULL; + _g_free0 (_tmp1562_); + if (_tmp1563_) { + ValaMethod* _tmp1564_; + gchar* _tmp1565_; + gchar* _tmp1566_; ValaCCodeConstant* _tmp1567_; ValaCCodeConstant* _tmp1568_; - _tmp1567_ = vala_ccode_constant_new ("-1"); + _tmp1564_ = m; + _tmp1565_ = vala_get_ccode_array_length_expr ((ValaCodeNode*) _tmp1564_); + _tmp1566_ = _tmp1565_; + _tmp1567_ = vala_ccode_constant_new (_tmp1566_); _tmp1568_ = _tmp1567_; vala_append_array_length ((ValaExpression*) expr, (ValaCCodeExpression*) _tmp1568_); _vala_ccode_node_unref0 (_tmp1568_); + _g_free0 (_tmp1566_); + } else { + ValaCCodeConstant* _tmp1569_; + ValaCCodeConstant* _tmp1570_; + _tmp1569_ = vala_ccode_constant_new ("-1"); + _tmp1570_ = _tmp1569_; + vala_append_array_length ((ValaExpression*) expr, (ValaCCodeExpression*) _tmp1570_); + _vala_ccode_node_unref0 (_tmp1570_); } } } @@ -5006,331 +5014,339 @@ } _vala_code_node_unref0 (array_type); } else { - gboolean _tmp1569_ = FALSE; - gboolean _tmp1570_ = FALSE; - ValaMethod* _tmp1571_; - _tmp1571_ = m; - if (_tmp1571_ != NULL) { - ValaMethod* _tmp1572_; - ValaDataType* _tmp1573_; - ValaDataType* _tmp1574_; - _tmp1572_ = m; - _tmp1573_ = vala_callable_get_return_type ((ValaCallable*) _tmp1572_); - _tmp1574_ = _tmp1573_; - _tmp1570_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp1574_, VALA_TYPE_DELEGATE_TYPE); - } else { - _tmp1570_ = FALSE; - } - if (_tmp1570_) { - ValaCCodeFunctionCall* _tmp1575_; - ValaCCodeFunctionCall* _tmp1576_; - _tmp1575_ = async_call; - _tmp1576_ = ccall; - _tmp1569_ = _tmp1575_ != _tmp1576_; + gboolean _tmp1571_ = FALSE; + gboolean _tmp1572_ = FALSE; + ValaMethod* _tmp1573_; + _tmp1573_ = m; + if (_tmp1573_ != NULL) { + ValaMethod* _tmp1574_; + ValaDataType* _tmp1575_; + ValaDataType* _tmp1576_; + _tmp1574_ = m; + _tmp1575_ = vala_callable_get_return_type ((ValaCallable*) _tmp1574_); + _tmp1576_ = _tmp1575_; + _tmp1572_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp1576_, VALA_TYPE_DELEGATE_TYPE); + } else { + _tmp1572_ = FALSE; + } + if (_tmp1572_) { + ValaCCodeFunctionCall* _tmp1577_; + ValaCCodeFunctionCall* _tmp1578_; + _tmp1577_ = async_call; + _tmp1578_ = ccall; + _tmp1571_ = _tmp1577_ != _tmp1578_; } else { - _tmp1569_ = FALSE; + _tmp1571_ = FALSE; } - if (_tmp1569_) { + if (_tmp1571_) { ValaDelegateType* deleg_type = NULL; - ValaMethod* _tmp1577_; - ValaDataType* _tmp1578_; - ValaDataType* _tmp1579_; - ValaDelegateType* _tmp1580_; - gboolean _tmp1581_ = FALSE; - ValaMethod* _tmp1582_; - _tmp1577_ = m; - _tmp1578_ = vala_callable_get_return_type ((ValaCallable*) _tmp1577_); - _tmp1579_ = _tmp1578_; - _tmp1580_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp1579_, VALA_TYPE_DELEGATE_TYPE, ValaDelegateType)); - deleg_type = _tmp1580_; - _tmp1582_ = m; - if (vala_get_ccode_delegate_target ((ValaCodeNode*) _tmp1582_)) { - ValaDelegateType* _tmp1583_; - ValaDelegate* _tmp1584_; - ValaDelegate* _tmp1585_; - gboolean _tmp1586_; - gboolean _tmp1587_; - _tmp1583_ = deleg_type; - _tmp1584_ = vala_delegate_type_get_delegate_symbol (_tmp1583_); - _tmp1585_ = _tmp1584_; - _tmp1586_ = vala_delegate_get_has_target (_tmp1585_); + ValaMethod* _tmp1579_; + ValaDataType* _tmp1580_; + ValaDataType* _tmp1581_; + ValaDelegateType* _tmp1582_; + gboolean _tmp1583_ = FALSE; + ValaMethod* _tmp1584_; + _tmp1579_ = m; + _tmp1580_ = vala_callable_get_return_type ((ValaCallable*) _tmp1579_); + _tmp1581_ = _tmp1580_; + _tmp1582_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp1581_, VALA_TYPE_DELEGATE_TYPE, ValaDelegateType)); + deleg_type = _tmp1582_; + _tmp1584_ = m; + if (vala_get_ccode_delegate_target ((ValaCodeNode*) _tmp1584_)) { + ValaDelegateType* _tmp1585_; + ValaDelegate* _tmp1586_; + ValaDelegate* _tmp1587_; + gboolean _tmp1588_; + gboolean _tmp1589_; + _tmp1585_ = deleg_type; + _tmp1586_ = vala_delegate_type_get_delegate_symbol (_tmp1585_); _tmp1587_ = _tmp1586_; - _tmp1581_ = _tmp1587_; + _tmp1588_ = vala_delegate_get_has_target (_tmp1587_); + _tmp1589_ = _tmp1588_; + _tmp1583_ = _tmp1589_; } else { - _tmp1581_ = FALSE; + _tmp1583_ = FALSE; } - if (_tmp1581_) { + if (_tmp1583_) { ValaLocalVariable* temp_var = NULL; - ValaDataType* _tmp1588_; - ValaLocalVariable* _tmp1589_; + ValaDataType* _tmp1590_; + ValaLocalVariable* _tmp1591_; ValaCCodeExpression* temp_ref = NULL; - ValaLocalVariable* _tmp1590_; - const gchar* _tmp1591_; - const gchar* _tmp1592_; - ValaCCodeExpression* _tmp1593_; - ValaLocalVariable* _tmp1594_; - ValaHashMap* _tmp1595_; - ValaMethod* _tmp1596_; - ValaCCodeExpression* _tmp1597_; - ValaCCodeUnaryExpression* _tmp1598_; - ValaCCodeUnaryExpression* _tmp1599_; - ValaCCodeExpression* _tmp1600_; - ValaDelegateType* _tmp1601_; - _tmp1588_ = ((ValaCCodeBaseModule*) self)->delegate_target_type; - _tmp1589_ = vala_ccode_base_module_get_temp_variable ((ValaCCodeBaseModule*) self, _tmp1588_, TRUE, NULL, TRUE); - temp_var = _tmp1589_; - _tmp1590_ = temp_var; - _tmp1591_ = vala_symbol_get_name ((ValaSymbol*) _tmp1590_); - _tmp1592_ = _tmp1591_; - _tmp1593_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, _tmp1592_); - temp_ref = _tmp1593_; - _tmp1594_ = temp_var; - vala_ccode_base_module_emit_temp_var ((ValaCCodeBaseModule*) self, _tmp1594_, FALSE); - _tmp1595_ = out_arg_map; - _tmp1596_ = m; - _tmp1597_ = temp_ref; - _tmp1598_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, _tmp1597_); - _tmp1599_ = _tmp1598_; - vala_map_set ((ValaMap*) _tmp1595_, (gpointer) ((gintptr) vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, vala_get_ccode_delegate_target_pos ((ValaCodeNode*) _tmp1596_), FALSE)), (ValaCCodeExpression*) _tmp1599_); - _vala_ccode_node_unref0 (_tmp1599_); - _tmp1600_ = temp_ref; - vala_set_delegate_target ((ValaExpression*) expr, _tmp1600_); - _tmp1601_ = deleg_type; - if (vala_data_type_is_disposable ((ValaDataType*) _tmp1601_)) { - ValaDelegateType* _tmp1602_; - ValaLocalVariable* _tmp1603_; - ValaLocalVariable* _tmp1604_; - const gchar* _tmp1605_; - const gchar* _tmp1606_; - ValaCCodeExpression* _tmp1607_; - ValaLocalVariable* _tmp1608_; - ValaHashMap* _tmp1609_; - ValaMethod* _tmp1610_; - ValaCCodeExpression* _tmp1611_; - ValaCCodeUnaryExpression* _tmp1612_; - ValaCCodeUnaryExpression* _tmp1613_; - ValaCCodeExpression* _tmp1614_; - _tmp1602_ = ((ValaCCodeBaseModule*) self)->delegate_target_destroy_type; - _tmp1603_ = vala_ccode_base_module_get_temp_variable ((ValaCCodeBaseModule*) self, (ValaDataType*) _tmp1602_, TRUE, NULL, TRUE); + ValaLocalVariable* _tmp1592_; + const gchar* _tmp1593_; + const gchar* _tmp1594_; + ValaCCodeExpression* _tmp1595_; + ValaLocalVariable* _tmp1596_; + ValaHashMap* _tmp1597_; + ValaMethod* _tmp1598_; + ValaCCodeExpression* _tmp1599_; + ValaCCodeUnaryExpression* _tmp1600_; + ValaCCodeUnaryExpression* _tmp1601_; + ValaCCodeExpression* _tmp1602_; + ValaDelegateType* _tmp1603_; + _tmp1590_ = ((ValaCCodeBaseModule*) self)->delegate_target_type; + _tmp1591_ = vala_ccode_base_module_get_temp_variable ((ValaCCodeBaseModule*) self, _tmp1590_, TRUE, NULL, TRUE); + temp_var = _tmp1591_; + _tmp1592_ = temp_var; + _tmp1593_ = vala_symbol_get_name ((ValaSymbol*) _tmp1592_); + _tmp1594_ = _tmp1593_; + _tmp1595_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, _tmp1594_); + temp_ref = _tmp1595_; + _tmp1596_ = temp_var; + vala_ccode_base_module_emit_temp_var ((ValaCCodeBaseModule*) self, _tmp1596_, FALSE); + _tmp1597_ = out_arg_map; + _tmp1598_ = m; + _tmp1599_ = temp_ref; + _tmp1600_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, _tmp1599_); + _tmp1601_ = _tmp1600_; + vala_map_set ((ValaMap*) _tmp1597_, (gpointer) ((gintptr) vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, vala_get_ccode_delegate_target_pos ((ValaCodeNode*) _tmp1598_), FALSE)), (ValaCCodeExpression*) _tmp1601_); + _vala_ccode_node_unref0 (_tmp1601_); + _tmp1602_ = temp_ref; + vala_set_delegate_target ((ValaExpression*) expr, _tmp1602_); + _tmp1603_ = deleg_type; + if (vala_data_type_is_disposable ((ValaDataType*) _tmp1603_)) { + ValaDelegateType* _tmp1604_; + ValaLocalVariable* _tmp1605_; + ValaLocalVariable* _tmp1606_; + const gchar* _tmp1607_; + const gchar* _tmp1608_; + ValaCCodeExpression* _tmp1609_; + ValaLocalVariable* _tmp1610_; + ValaHashMap* _tmp1611_; + ValaMethod* _tmp1612_; + ValaCCodeExpression* _tmp1613_; + ValaCCodeUnaryExpression* _tmp1614_; + ValaCCodeUnaryExpression* _tmp1615_; + ValaCCodeExpression* _tmp1616_; + _tmp1604_ = ((ValaCCodeBaseModule*) self)->delegate_target_destroy_type; + _tmp1605_ = vala_ccode_base_module_get_temp_variable ((ValaCCodeBaseModule*) self, (ValaDataType*) _tmp1604_, TRUE, NULL, TRUE); _vala_code_node_unref0 (temp_var); - temp_var = _tmp1603_; - _tmp1604_ = temp_var; - _tmp1605_ = vala_symbol_get_name ((ValaSymbol*) _tmp1604_); - _tmp1606_ = _tmp1605_; - _tmp1607_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, _tmp1606_); + temp_var = _tmp1605_; + _tmp1606_ = temp_var; + _tmp1607_ = vala_symbol_get_name ((ValaSymbol*) _tmp1606_); + _tmp1608_ = _tmp1607_; + _tmp1609_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, _tmp1608_); _vala_ccode_node_unref0 (temp_ref); - temp_ref = _tmp1607_; - _tmp1608_ = temp_var; - vala_ccode_base_module_emit_temp_var ((ValaCCodeBaseModule*) self, _tmp1608_, FALSE); - _tmp1609_ = out_arg_map; - _tmp1610_ = m; - _tmp1611_ = temp_ref; - _tmp1612_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, _tmp1611_); - _tmp1613_ = _tmp1612_; - vala_map_set ((ValaMap*) _tmp1609_, (gpointer) ((gintptr) vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, vala_get_ccode_destroy_notify_pos ((ValaCodeNode*) _tmp1610_), FALSE)), (ValaCCodeExpression*) _tmp1613_); - _vala_ccode_node_unref0 (_tmp1613_); - _tmp1614_ = temp_ref; - vala_set_delegate_target_destroy_notify ((ValaExpression*) expr, _tmp1614_); + temp_ref = _tmp1609_; + _tmp1610_ = temp_var; + vala_ccode_base_module_emit_temp_var ((ValaCCodeBaseModule*) self, _tmp1610_, FALSE); + _tmp1611_ = out_arg_map; + _tmp1612_ = m; + _tmp1613_ = temp_ref; + _tmp1614_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, _tmp1613_); + _tmp1615_ = _tmp1614_; + vala_map_set ((ValaMap*) _tmp1611_, (gpointer) ((gintptr) vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, vala_get_ccode_destroy_notify_pos ((ValaCodeNode*) _tmp1612_), FALSE)), (ValaCCodeExpression*) _tmp1615_); + _vala_ccode_node_unref0 (_tmp1615_); + _tmp1616_ = temp_ref; + vala_set_delegate_target_destroy_notify ((ValaExpression*) expr, _tmp1616_); } else { - ValaCCodeConstant* _tmp1615_; - ValaCCodeConstant* _tmp1616_; - _tmp1615_ = vala_ccode_constant_new ("NULL"); - _tmp1616_ = _tmp1615_; - vala_set_delegate_target_destroy_notify ((ValaExpression*) expr, (ValaCCodeExpression*) _tmp1616_); - _vala_ccode_node_unref0 (_tmp1616_); + ValaCCodeConstant* _tmp1617_; + ValaCCodeConstant* _tmp1618_; + _tmp1617_ = vala_ccode_constant_new ("NULL"); + _tmp1618_ = _tmp1617_; + vala_set_delegate_target_destroy_notify ((ValaExpression*) expr, (ValaCCodeExpression*) _tmp1618_); + _vala_ccode_node_unref0 (_tmp1618_); } _vala_ccode_node_unref0 (temp_ref); _vala_code_node_unref0 (temp_var); } else { - ValaCCodeConstant* _tmp1617_; - ValaCCodeConstant* _tmp1618_; - ValaDelegateType* _tmp1619_; - ValaDelegate* _tmp1620_; - ValaDelegate* _tmp1621_; - gboolean _tmp1622_; - gboolean _tmp1623_; - _tmp1617_ = vala_ccode_constant_new ("NULL"); - _tmp1618_ = _tmp1617_; - vala_set_delegate_target ((ValaExpression*) expr, (ValaCCodeExpression*) _tmp1618_); - _vala_ccode_node_unref0 (_tmp1618_); - _tmp1619_ = deleg_type; - _tmp1620_ = vala_delegate_type_get_delegate_symbol (_tmp1619_); - _tmp1621_ = _tmp1620_; - _tmp1622_ = vala_delegate_get_has_target (_tmp1621_); + ValaCCodeConstant* _tmp1619_; + ValaCCodeConstant* _tmp1620_; + ValaDelegateType* _tmp1621_; + ValaDelegate* _tmp1622_; + ValaDelegate* _tmp1623_; + gboolean _tmp1624_; + gboolean _tmp1625_; + _tmp1619_ = vala_ccode_constant_new ("NULL"); + _tmp1620_ = _tmp1619_; + vala_set_delegate_target ((ValaExpression*) expr, (ValaCCodeExpression*) _tmp1620_); + _vala_ccode_node_unref0 (_tmp1620_); + _tmp1621_ = deleg_type; + _tmp1622_ = vala_delegate_type_get_delegate_symbol (_tmp1621_); _tmp1623_ = _tmp1622_; - if (_tmp1623_) { - ValaCCodeConstant* _tmp1624_; - ValaCCodeConstant* _tmp1625_; - _tmp1624_ = vala_ccode_constant_new ("NULL"); - _tmp1625_ = _tmp1624_; - vala_set_delegate_target_destroy_notify ((ValaExpression*) expr, (ValaCCodeExpression*) _tmp1625_); - _vala_ccode_node_unref0 (_tmp1625_); + _tmp1624_ = vala_delegate_get_has_target (_tmp1623_); + _tmp1625_ = _tmp1624_; + if (_tmp1625_) { + ValaCCodeConstant* _tmp1626_; + ValaCCodeConstant* _tmp1627_; + _tmp1626_ = vala_ccode_constant_new ("NULL"); + _tmp1627_ = _tmp1626_; + vala_set_delegate_target_destroy_notify ((ValaExpression*) expr, (ValaCCodeExpression*) _tmp1627_); + _vala_ccode_node_unref0 (_tmp1627_); } } _vala_code_node_unref0 (deleg_type); } } - _tmp1627_ = deleg; - if (_tmp1627_ != NULL) { - ValaDelegate* _tmp1628_; - ValaDataType* _tmp1629_; - ValaDataType* _tmp1630_; - _tmp1628_ = deleg; - _tmp1629_ = vala_callable_get_return_type ((ValaCallable*) _tmp1628_); - _tmp1630_ = _tmp1629_; - _tmp1626_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp1630_, VALA_TYPE_ARRAY_TYPE); + _tmp1629_ = deleg; + if (_tmp1629_ != NULL) { + ValaDelegate* _tmp1630_; + ValaDataType* _tmp1631_; + ValaDataType* _tmp1632_; + _tmp1630_ = deleg; + _tmp1631_ = vala_callable_get_return_type ((ValaCallable*) _tmp1630_); + _tmp1632_ = _tmp1631_; + _tmp1628_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp1632_, VALA_TYPE_ARRAY_TYPE); } else { - _tmp1626_ = FALSE; + _tmp1628_ = FALSE; } - if (_tmp1626_) { + if (_tmp1628_) { ValaArrayType* array_type = NULL; - ValaDelegate* _tmp1631_; - ValaDataType* _tmp1632_; - ValaDataType* _tmp1633_; - ValaArrayType* _tmp1634_; - _tmp1631_ = deleg; - _tmp1632_ = vala_callable_get_return_type ((ValaCallable*) _tmp1631_); - _tmp1633_ = _tmp1632_; - _tmp1634_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp1633_, VALA_TYPE_ARRAY_TYPE, ValaArrayType)); - array_type = _tmp1634_; + ValaDelegate* _tmp1633_; + ValaDataType* _tmp1634_; + ValaDataType* _tmp1635_; + ValaArrayType* _tmp1636_; + _tmp1633_ = deleg; + _tmp1634_ = vala_callable_get_return_type ((ValaCallable*) _tmp1633_); + _tmp1635_ = _tmp1634_; + _tmp1636_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp1635_, VALA_TYPE_ARRAY_TYPE, ValaArrayType)); + array_type = _tmp1636_; { gint dim = 0; dim = 1; { - gboolean _tmp1635_ = FALSE; - _tmp1635_ = TRUE; + gboolean _tmp1637_ = FALSE; + _tmp1637_ = TRUE; while (TRUE) { - ValaArrayType* _tmp1637_; - gint _tmp1638_; - gint _tmp1639_; - ValaDelegate* _tmp1640_; - if (!_tmp1635_) { - gint _tmp1636_; - _tmp1636_ = dim; - dim = _tmp1636_ + 1; - } - _tmp1635_ = FALSE; - _tmp1637_ = array_type; - _tmp1638_ = vala_array_type_get_rank (_tmp1637_); - _tmp1639_ = _tmp1638_; - if (!(dim <= _tmp1639_)) { + ValaArrayType* _tmp1639_; + gint _tmp1640_; + gint _tmp1641_; + gboolean _tmp1642_ = FALSE; + ValaDelegate* _tmp1643_; + if (!_tmp1637_) { + gint _tmp1638_; + _tmp1638_ = dim; + dim = _tmp1638_ + 1; + } + _tmp1637_ = FALSE; + _tmp1639_ = array_type; + _tmp1640_ = vala_array_type_get_rank (_tmp1639_); + _tmp1641_ = _tmp1640_; + if (!(dim <= _tmp1641_)) { break; } - _tmp1640_ = deleg; - if (vala_get_ccode_array_null_terminated ((ValaCodeNode*) _tmp1640_)) { + _tmp1643_ = deleg; + if (vala_get_ccode_array_null_terminated ((ValaCodeNode*) _tmp1643_)) { + ValaDelegate* _tmp1644_; + _tmp1644_ = deleg; + _tmp1642_ = !vala_get_ccode_array_length ((ValaCodeNode*) _tmp1644_); + } else { + _tmp1642_ = FALSE; + } + if (_tmp1642_) { ValaLocalVariable* temp_var = NULL; - ValaDataType* _tmp1641_; - ValaDataType* _tmp1642_; - ValaLocalVariable* _tmp1643_; + ValaDataType* _tmp1645_; + ValaDataType* _tmp1646_; + ValaLocalVariable* _tmp1647_; ValaCCodeExpression* temp_ref = NULL; - ValaLocalVariable* _tmp1644_; - const gchar* _tmp1645_; - const gchar* _tmp1646_; - ValaCCodeExpression* _tmp1647_; ValaLocalVariable* _tmp1648_; - ValaCCodeExpression* _tmp1649_; - ValaCCodeExpression* _tmp1650_; - ValaCCodeAssignment* _tmp1651_; + const gchar* _tmp1649_; + const gchar* _tmp1650_; + ValaCCodeExpression* _tmp1651_; + ValaLocalVariable* _tmp1652_; + ValaCCodeExpression* _tmp1653_; + ValaCCodeExpression* _tmp1654_; + ValaCCodeAssignment* _tmp1655_; ValaCCodeFunctionCall* len_call = NULL; - ValaCCodeIdentifier* _tmp1652_; - ValaCCodeIdentifier* _tmp1653_; - ValaCCodeFunctionCall* _tmp1654_; - ValaCCodeFunctionCall* _tmp1655_; - ValaCCodeFunctionCall* _tmp1656_; - ValaCCodeExpression* _tmp1657_; + ValaCCodeIdentifier* _tmp1656_; + ValaCCodeIdentifier* _tmp1657_; ValaCCodeFunctionCall* _tmp1658_; - _tmp1641_ = itype; - _tmp1642_ = vala_data_type_get_return_type (_tmp1641_); - _tmp1643_ = vala_ccode_base_module_get_temp_variable ((ValaCCodeBaseModule*) self, _tmp1642_, TRUE, NULL, FALSE); - temp_var = _tmp1643_; - _tmp1644_ = temp_var; - _tmp1645_ = vala_symbol_get_name ((ValaSymbol*) _tmp1644_); - _tmp1646_ = _tmp1645_; - _tmp1647_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, _tmp1646_); - temp_ref = _tmp1647_; + ValaCCodeFunctionCall* _tmp1659_; + ValaCCodeFunctionCall* _tmp1660_; + ValaCCodeExpression* _tmp1661_; + ValaCCodeFunctionCall* _tmp1662_; + _tmp1645_ = itype; + _tmp1646_ = vala_data_type_get_return_type (_tmp1645_); + _tmp1647_ = vala_ccode_base_module_get_temp_variable ((ValaCCodeBaseModule*) self, _tmp1646_, TRUE, NULL, FALSE); + temp_var = _tmp1647_; _tmp1648_ = temp_var; - vala_ccode_base_module_emit_temp_var ((ValaCCodeBaseModule*) self, _tmp1648_, FALSE); - _tmp1649_ = temp_ref; - _tmp1650_ = ccall_expr; - _tmp1651_ = vala_ccode_assignment_new (_tmp1649_, _tmp1650_, VALA_CCODE_ASSIGNMENT_OPERATOR_SIMPLE); + _tmp1649_ = vala_symbol_get_name ((ValaSymbol*) _tmp1648_); + _tmp1650_ = _tmp1649_; + _tmp1651_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, _tmp1650_); + temp_ref = _tmp1651_; + _tmp1652_ = temp_var; + vala_ccode_base_module_emit_temp_var ((ValaCCodeBaseModule*) self, _tmp1652_, FALSE); + _tmp1653_ = temp_ref; + _tmp1654_ = ccall_expr; + _tmp1655_ = vala_ccode_assignment_new (_tmp1653_, _tmp1654_, VALA_CCODE_ASSIGNMENT_OPERATOR_SIMPLE); _vala_ccode_node_unref0 (ccall_expr); - ccall_expr = (ValaCCodeExpression*) _tmp1651_; + ccall_expr = (ValaCCodeExpression*) _tmp1655_; ((ValaCCodeBaseModule*) self)->requires_array_length = TRUE; - _tmp1652_ = vala_ccode_identifier_new ("_vala_array_length"); - _tmp1653_ = _tmp1652_; - _tmp1654_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp1653_); - _tmp1655_ = _tmp1654_; - _vala_ccode_node_unref0 (_tmp1653_); - len_call = _tmp1655_; - _tmp1656_ = len_call; - _tmp1657_ = temp_ref; - vala_ccode_function_call_add_argument (_tmp1656_, _tmp1657_); - _tmp1658_ = len_call; - vala_append_array_length ((ValaExpression*) expr, (ValaCCodeExpression*) _tmp1658_); + _tmp1656_ = vala_ccode_identifier_new ("_vala_array_length"); + _tmp1657_ = _tmp1656_; + _tmp1658_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp1657_); + _tmp1659_ = _tmp1658_; + _vala_ccode_node_unref0 (_tmp1657_); + len_call = _tmp1659_; + _tmp1660_ = len_call; + _tmp1661_ = temp_ref; + vala_ccode_function_call_add_argument (_tmp1660_, _tmp1661_); + _tmp1662_ = len_call; + vala_append_array_length ((ValaExpression*) expr, (ValaCCodeExpression*) _tmp1662_); _vala_ccode_node_unref0 (len_call); _vala_ccode_node_unref0 (temp_ref); _vala_code_node_unref0 (temp_var); } else { - ValaDelegate* _tmp1659_; - _tmp1659_ = deleg; - if (vala_get_ccode_array_length ((ValaCodeNode*) _tmp1659_)) { + ValaDelegate* _tmp1663_; + _tmp1663_ = deleg; + if (vala_get_ccode_array_length ((ValaCodeNode*) _tmp1663_)) { gchar* length_ctype = NULL; - ValaDelegate* _tmp1660_; - gchar* _tmp1661_; + ValaDelegate* _tmp1664_; + gchar* _tmp1665_; ValaLocalVariable* temp_var = NULL; - const gchar* _tmp1662_; - ValaCType* _tmp1663_; - ValaCType* _tmp1664_; - ValaLocalVariable* _tmp1665_; - ValaLocalVariable* _tmp1666_; + const gchar* _tmp1666_; + ValaCType* _tmp1667_; + ValaCType* _tmp1668_; + ValaLocalVariable* _tmp1669_; + ValaLocalVariable* _tmp1670_; ValaCCodeExpression* temp_ref = NULL; - ValaLocalVariable* _tmp1667_; - const gchar* _tmp1668_; - const gchar* _tmp1669_; - ValaCCodeExpression* _tmp1670_; ValaLocalVariable* _tmp1671_; - ValaHashMap* _tmp1672_; - ValaDelegate* _tmp1673_; + const gchar* _tmp1672_; + const gchar* _tmp1673_; ValaCCodeExpression* _tmp1674_; - ValaCCodeUnaryExpression* _tmp1675_; - ValaCCodeUnaryExpression* _tmp1676_; - ValaCCodeExpression* _tmp1677_; - _tmp1660_ = deleg; - _tmp1661_ = vala_get_ccode_array_length_type ((ValaCodeNode*) _tmp1660_); - length_ctype = _tmp1661_; - _tmp1662_ = length_ctype; - _tmp1663_ = vala_ctype_new (_tmp1662_, "0"); - _tmp1664_ = _tmp1663_; - _tmp1665_ = vala_ccode_base_module_get_temp_variable ((ValaCCodeBaseModule*) self, (ValaDataType*) _tmp1664_, TRUE, NULL, TRUE); - _tmp1666_ = _tmp1665_; - _vala_code_node_unref0 (_tmp1664_); - temp_var = _tmp1666_; - _tmp1667_ = temp_var; - _tmp1668_ = vala_symbol_get_name ((ValaSymbol*) _tmp1667_); - _tmp1669_ = _tmp1668_; - _tmp1670_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, _tmp1669_); - temp_ref = _tmp1670_; + ValaLocalVariable* _tmp1675_; + ValaHashMap* _tmp1676_; + ValaDelegate* _tmp1677_; + ValaCCodeExpression* _tmp1678_; + ValaCCodeUnaryExpression* _tmp1679_; + ValaCCodeUnaryExpression* _tmp1680_; + ValaCCodeExpression* _tmp1681_; + _tmp1664_ = deleg; + _tmp1665_ = vala_get_ccode_array_length_type ((ValaCodeNode*) _tmp1664_); + length_ctype = _tmp1665_; + _tmp1666_ = length_ctype; + _tmp1667_ = vala_ctype_new (_tmp1666_, "0"); + _tmp1668_ = _tmp1667_; + _tmp1669_ = vala_ccode_base_module_get_temp_variable ((ValaCCodeBaseModule*) self, (ValaDataType*) _tmp1668_, TRUE, NULL, TRUE); + _tmp1670_ = _tmp1669_; + _vala_code_node_unref0 (_tmp1668_); + temp_var = _tmp1670_; _tmp1671_ = temp_var; - vala_ccode_base_module_emit_temp_var ((ValaCCodeBaseModule*) self, _tmp1671_, FALSE); - _tmp1672_ = out_arg_map; - _tmp1673_ = deleg; - _tmp1674_ = temp_ref; - _tmp1675_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, _tmp1674_); - _tmp1676_ = _tmp1675_; - vala_map_set ((ValaMap*) _tmp1672_, (gpointer) ((gintptr) vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, vala_get_ccode_array_length_pos ((ValaCodeNode*) _tmp1673_) + (0.01 * dim), FALSE)), (ValaCCodeExpression*) _tmp1676_); - _vala_ccode_node_unref0 (_tmp1676_); - _tmp1677_ = temp_ref; - vala_append_array_length ((ValaExpression*) expr, _tmp1677_); + _tmp1672_ = vala_symbol_get_name ((ValaSymbol*) _tmp1671_); + _tmp1673_ = _tmp1672_; + _tmp1674_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, _tmp1673_); + temp_ref = _tmp1674_; + _tmp1675_ = temp_var; + vala_ccode_base_module_emit_temp_var ((ValaCCodeBaseModule*) self, _tmp1675_, FALSE); + _tmp1676_ = out_arg_map; + _tmp1677_ = deleg; + _tmp1678_ = temp_ref; + _tmp1679_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, _tmp1678_); + _tmp1680_ = _tmp1679_; + vala_map_set ((ValaMap*) _tmp1676_, (gpointer) ((gintptr) vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, vala_get_ccode_array_length_pos ((ValaCodeNode*) _tmp1677_) + (0.01 * dim), FALSE)), (ValaCCodeExpression*) _tmp1680_); + _vala_ccode_node_unref0 (_tmp1680_); + _tmp1681_ = temp_ref; + vala_append_array_length ((ValaExpression*) expr, _tmp1681_); _vala_ccode_node_unref0 (temp_ref); _vala_code_node_unref0 (temp_var); _g_free0 (length_ctype); } else { - ValaCCodeConstant* _tmp1678_; - ValaCCodeConstant* _tmp1679_; - _tmp1678_ = vala_ccode_constant_new ("-1"); - _tmp1679_ = _tmp1678_; - vala_append_array_length ((ValaExpression*) expr, (ValaCCodeExpression*) _tmp1679_); - _vala_ccode_node_unref0 (_tmp1679_); + ValaCCodeConstant* _tmp1682_; + ValaCCodeConstant* _tmp1683_; + _tmp1682_ = vala_ccode_constant_new ("-1"); + _tmp1683_ = _tmp1682_; + vala_append_array_length ((ValaExpression*) expr, (ValaCCodeExpression*) _tmp1683_); + _vala_ccode_node_unref0 (_tmp1683_); } } } @@ -5338,121 +5354,121 @@ } _vala_code_node_unref0 (array_type); } else { - gboolean _tmp1680_ = FALSE; - gboolean _tmp1681_ = FALSE; - ValaDelegate* _tmp1682_; - _tmp1682_ = deleg; - if (_tmp1682_ != NULL) { - ValaDelegate* _tmp1683_; - ValaDataType* _tmp1684_; - ValaDataType* _tmp1685_; - _tmp1683_ = deleg; - _tmp1684_ = vala_callable_get_return_type ((ValaCallable*) _tmp1683_); - _tmp1685_ = _tmp1684_; - _tmp1681_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp1685_, VALA_TYPE_DELEGATE_TYPE); - } else { - _tmp1681_ = FALSE; - } - if (_tmp1681_) { - ValaDelegate* _tmp1686_; - _tmp1686_ = deleg; - _tmp1680_ = vala_get_ccode_delegate_target ((ValaCodeNode*) _tmp1686_); - } else { - _tmp1680_ = FALSE; - } - if (_tmp1680_) { - ValaDelegateType* deleg_type = NULL; + gboolean _tmp1684_ = FALSE; + gboolean _tmp1685_ = FALSE; + ValaDelegate* _tmp1686_; + _tmp1686_ = deleg; + if (_tmp1686_ != NULL) { ValaDelegate* _tmp1687_; ValaDataType* _tmp1688_; ValaDataType* _tmp1689_; - ValaDelegateType* _tmp1690_; - ValaDelegateType* _tmp1691_; - ValaDelegate* _tmp1692_; - ValaDelegate* _tmp1693_; - gboolean _tmp1694_; - gboolean _tmp1695_; _tmp1687_ = deleg; _tmp1688_ = vala_callable_get_return_type ((ValaCallable*) _tmp1687_); _tmp1689_ = _tmp1688_; - _tmp1690_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp1689_, VALA_TYPE_DELEGATE_TYPE, ValaDelegateType)); - deleg_type = _tmp1690_; - _tmp1691_ = deleg_type; - _tmp1692_ = vala_delegate_type_get_delegate_symbol (_tmp1691_); + _tmp1685_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp1689_, VALA_TYPE_DELEGATE_TYPE); + } else { + _tmp1685_ = FALSE; + } + if (_tmp1685_) { + ValaDelegate* _tmp1690_; + _tmp1690_ = deleg; + _tmp1684_ = vala_get_ccode_delegate_target ((ValaCodeNode*) _tmp1690_); + } else { + _tmp1684_ = FALSE; + } + if (_tmp1684_) { + ValaDelegateType* deleg_type = NULL; + ValaDelegate* _tmp1691_; + ValaDataType* _tmp1692_; + ValaDataType* _tmp1693_; + ValaDelegateType* _tmp1694_; + ValaDelegateType* _tmp1695_; + ValaDelegate* _tmp1696_; + ValaDelegate* _tmp1697_; + gboolean _tmp1698_; + gboolean _tmp1699_; + _tmp1691_ = deleg; + _tmp1692_ = vala_callable_get_return_type ((ValaCallable*) _tmp1691_); _tmp1693_ = _tmp1692_; - _tmp1694_ = vala_delegate_get_has_target (_tmp1693_); - _tmp1695_ = _tmp1694_; - if (_tmp1695_) { + _tmp1694_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp1693_, VALA_TYPE_DELEGATE_TYPE, ValaDelegateType)); + deleg_type = _tmp1694_; + _tmp1695_ = deleg_type; + _tmp1696_ = vala_delegate_type_get_delegate_symbol (_tmp1695_); + _tmp1697_ = _tmp1696_; + _tmp1698_ = vala_delegate_get_has_target (_tmp1697_); + _tmp1699_ = _tmp1698_; + if (_tmp1699_) { ValaLocalVariable* temp_var = NULL; - ValaDataType* _tmp1696_; - ValaLocalVariable* _tmp1697_; + ValaDataType* _tmp1700_; + ValaLocalVariable* _tmp1701_; ValaCCodeExpression* temp_ref = NULL; - ValaLocalVariable* _tmp1698_; - const gchar* _tmp1699_; - const gchar* _tmp1700_; - ValaCCodeExpression* _tmp1701_; ValaLocalVariable* _tmp1702_; - ValaHashMap* _tmp1703_; - ValaDelegate* _tmp1704_; + const gchar* _tmp1703_; + const gchar* _tmp1704_; ValaCCodeExpression* _tmp1705_; - ValaCCodeUnaryExpression* _tmp1706_; - ValaCCodeUnaryExpression* _tmp1707_; - ValaCCodeExpression* _tmp1708_; - ValaDelegateType* _tmp1709_; - _tmp1696_ = ((ValaCCodeBaseModule*) self)->delegate_target_type; - _tmp1697_ = vala_ccode_base_module_get_temp_variable ((ValaCCodeBaseModule*) self, _tmp1696_, TRUE, NULL, TRUE); - temp_var = _tmp1697_; - _tmp1698_ = temp_var; - _tmp1699_ = vala_symbol_get_name ((ValaSymbol*) _tmp1698_); - _tmp1700_ = _tmp1699_; - _tmp1701_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, _tmp1700_); - temp_ref = _tmp1701_; + ValaLocalVariable* _tmp1706_; + ValaHashMap* _tmp1707_; + ValaDelegate* _tmp1708_; + ValaCCodeExpression* _tmp1709_; + ValaCCodeUnaryExpression* _tmp1710_; + ValaCCodeUnaryExpression* _tmp1711_; + ValaCCodeExpression* _tmp1712_; + ValaDelegateType* _tmp1713_; + _tmp1700_ = ((ValaCCodeBaseModule*) self)->delegate_target_type; + _tmp1701_ = vala_ccode_base_module_get_temp_variable ((ValaCCodeBaseModule*) self, _tmp1700_, TRUE, NULL, TRUE); + temp_var = _tmp1701_; _tmp1702_ = temp_var; - vala_ccode_base_module_emit_temp_var ((ValaCCodeBaseModule*) self, _tmp1702_, FALSE); - _tmp1703_ = out_arg_map; - _tmp1704_ = deleg; - _tmp1705_ = temp_ref; - _tmp1706_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, _tmp1705_); - _tmp1707_ = _tmp1706_; - vala_map_set ((ValaMap*) _tmp1703_, (gpointer) ((gintptr) vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, vala_get_ccode_delegate_target_pos ((ValaCodeNode*) _tmp1704_), FALSE)), (ValaCCodeExpression*) _tmp1707_); - _vala_ccode_node_unref0 (_tmp1707_); - _tmp1708_ = temp_ref; - vala_set_delegate_target ((ValaExpression*) expr, _tmp1708_); - _tmp1709_ = deleg_type; - if (vala_data_type_is_disposable ((ValaDataType*) _tmp1709_)) { - ValaDelegateType* _tmp1710_; - ValaLocalVariable* _tmp1711_; - ValaLocalVariable* _tmp1712_; - const gchar* _tmp1713_; - const gchar* _tmp1714_; - ValaCCodeExpression* _tmp1715_; + _tmp1703_ = vala_symbol_get_name ((ValaSymbol*) _tmp1702_); + _tmp1704_ = _tmp1703_; + _tmp1705_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, _tmp1704_); + temp_ref = _tmp1705_; + _tmp1706_ = temp_var; + vala_ccode_base_module_emit_temp_var ((ValaCCodeBaseModule*) self, _tmp1706_, FALSE); + _tmp1707_ = out_arg_map; + _tmp1708_ = deleg; + _tmp1709_ = temp_ref; + _tmp1710_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, _tmp1709_); + _tmp1711_ = _tmp1710_; + vala_map_set ((ValaMap*) _tmp1707_, (gpointer) ((gintptr) vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, vala_get_ccode_delegate_target_pos ((ValaCodeNode*) _tmp1708_), FALSE)), (ValaCCodeExpression*) _tmp1711_); + _vala_ccode_node_unref0 (_tmp1711_); + _tmp1712_ = temp_ref; + vala_set_delegate_target ((ValaExpression*) expr, _tmp1712_); + _tmp1713_ = deleg_type; + if (vala_data_type_is_disposable ((ValaDataType*) _tmp1713_)) { + ValaDelegateType* _tmp1714_; + ValaLocalVariable* _tmp1715_; ValaLocalVariable* _tmp1716_; - ValaHashMap* _tmp1717_; - ValaDelegate* _tmp1718_; + const gchar* _tmp1717_; + const gchar* _tmp1718_; ValaCCodeExpression* _tmp1719_; - ValaCCodeUnaryExpression* _tmp1720_; - ValaCCodeUnaryExpression* _tmp1721_; - ValaCCodeExpression* _tmp1722_; - _tmp1710_ = ((ValaCCodeBaseModule*) self)->delegate_target_destroy_type; - _tmp1711_ = vala_ccode_base_module_get_temp_variable ((ValaCCodeBaseModule*) self, (ValaDataType*) _tmp1710_, TRUE, NULL, TRUE); + ValaLocalVariable* _tmp1720_; + ValaHashMap* _tmp1721_; + ValaDelegate* _tmp1722_; + ValaCCodeExpression* _tmp1723_; + ValaCCodeUnaryExpression* _tmp1724_; + ValaCCodeUnaryExpression* _tmp1725_; + ValaCCodeExpression* _tmp1726_; + _tmp1714_ = ((ValaCCodeBaseModule*) self)->delegate_target_destroy_type; + _tmp1715_ = vala_ccode_base_module_get_temp_variable ((ValaCCodeBaseModule*) self, (ValaDataType*) _tmp1714_, TRUE, NULL, TRUE); _vala_code_node_unref0 (temp_var); - temp_var = _tmp1711_; - _tmp1712_ = temp_var; - _tmp1713_ = vala_symbol_get_name ((ValaSymbol*) _tmp1712_); - _tmp1714_ = _tmp1713_; - _tmp1715_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, _tmp1714_); - _vala_ccode_node_unref0 (temp_ref); - temp_ref = _tmp1715_; + temp_var = _tmp1715_; _tmp1716_ = temp_var; - vala_ccode_base_module_emit_temp_var ((ValaCCodeBaseModule*) self, _tmp1716_, FALSE); - _tmp1717_ = out_arg_map; - _tmp1718_ = deleg; - _tmp1719_ = temp_ref; - _tmp1720_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, _tmp1719_); - _tmp1721_ = _tmp1720_; - vala_map_set ((ValaMap*) _tmp1717_, (gpointer) ((gintptr) vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, vala_get_ccode_destroy_notify_pos ((ValaCodeNode*) _tmp1718_), FALSE)), (ValaCCodeExpression*) _tmp1721_); - _vala_ccode_node_unref0 (_tmp1721_); - _tmp1722_ = temp_ref; - vala_set_delegate_target_destroy_notify ((ValaExpression*) expr, _tmp1722_); + _tmp1717_ = vala_symbol_get_name ((ValaSymbol*) _tmp1716_); + _tmp1718_ = _tmp1717_; + _tmp1719_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, _tmp1718_); + _vala_ccode_node_unref0 (temp_ref); + temp_ref = _tmp1719_; + _tmp1720_ = temp_var; + vala_ccode_base_module_emit_temp_var ((ValaCCodeBaseModule*) self, _tmp1720_, FALSE); + _tmp1721_ = out_arg_map; + _tmp1722_ = deleg; + _tmp1723_ = temp_ref; + _tmp1724_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, _tmp1723_); + _tmp1725_ = _tmp1724_; + vala_map_set ((ValaMap*) _tmp1721_, (gpointer) ((gintptr) vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, vala_get_ccode_destroy_notify_pos ((ValaCodeNode*) _tmp1722_), FALSE)), (ValaCCodeExpression*) _tmp1725_); + _vala_ccode_node_unref0 (_tmp1725_); + _tmp1726_ = temp_ref; + vala_set_delegate_target_destroy_notify ((ValaExpression*) expr, _tmp1726_); } _vala_ccode_node_unref0 (temp_ref); _vala_code_node_unref0 (temp_var); @@ -5460,414 +5476,414 @@ _vala_code_node_unref0 (deleg_type); } } - _tmp1724_ = m; - if (_tmp1724_ != NULL) { - ValaMethod* _tmp1725_; - gboolean _tmp1726_; - gboolean _tmp1727_; - _tmp1725_ = m; - _tmp1726_ = vala_method_get_coroutine (_tmp1725_); - _tmp1727_ = _tmp1726_; - _tmp1723_ = _tmp1727_; + _tmp1728_ = m; + if (_tmp1728_ != NULL) { + ValaMethod* _tmp1729_; + gboolean _tmp1730_; + gboolean _tmp1731_; + _tmp1729_ = m; + _tmp1730_ = vala_method_get_coroutine (_tmp1729_); + _tmp1731_ = _tmp1730_; + _tmp1727_ = _tmp1731_; } else { - _tmp1723_ = FALSE; + _tmp1727_ = FALSE; } - if (_tmp1723_) { - gboolean _tmp1728_; - gboolean _tmp1729_; - _tmp1728_ = vala_callable_expression_get_is_yield_expression ((ValaCallableExpression*) expr); - _tmp1729_ = _tmp1728_; - if (_tmp1729_) { - ValaHashMap* _tmp1730_; - ValaMethod* _tmp1731_; - ValaMethod* _tmp1732_; - gchar* _tmp1733_; - gchar* _tmp1734_; - ValaCCodeIdentifier* _tmp1735_; - ValaCCodeIdentifier* _tmp1736_; - ValaHashMap* _tmp1737_; - ValaCCodeIdentifier* _tmp1738_; + if (_tmp1727_) { + gboolean _tmp1732_; + gboolean _tmp1733_; + _tmp1732_ = vala_callable_expression_get_is_yield_expression ((ValaCallableExpression*) expr); + _tmp1733_ = _tmp1732_; + if (_tmp1733_) { + ValaHashMap* _tmp1734_; + ValaMethod* _tmp1735_; + ValaMethod* _tmp1736_; + gchar* _tmp1737_; + gchar* _tmp1738_; ValaCCodeIdentifier* _tmp1739_; - _tmp1730_ = in_arg_map; - _tmp1731_ = vala_ccode_base_module_get_current_method ((ValaCCodeBaseModule*) self); - _tmp1732_ = _tmp1731_; - _tmp1733_ = vala_ccode_base_module_generate_ready_function ((ValaCCodeBaseModule*) self, _tmp1732_); - _tmp1734_ = _tmp1733_; - _tmp1735_ = vala_ccode_identifier_new (_tmp1734_); + ValaCCodeIdentifier* _tmp1740_; + ValaHashMap* _tmp1741_; + ValaCCodeIdentifier* _tmp1742_; + ValaCCodeIdentifier* _tmp1743_; + _tmp1734_ = in_arg_map; + _tmp1735_ = vala_ccode_base_module_get_current_method ((ValaCCodeBaseModule*) self); _tmp1736_ = _tmp1735_; - vala_map_set ((ValaMap*) _tmp1730_, (gpointer) ((gintptr) vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, (gdouble) -1, FALSE)), (ValaCCodeExpression*) _tmp1736_); - _vala_ccode_node_unref0 (_tmp1736_); - _g_free0 (_tmp1734_); - _tmp1737_ = in_arg_map; - _tmp1738_ = vala_ccode_identifier_new ("_data_"); - _tmp1739_ = _tmp1738_; - vala_map_set ((ValaMap*) _tmp1737_, (gpointer) ((gintptr) vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, -0.9, FALSE)), (ValaCCodeExpression*) _tmp1739_); - _vala_ccode_node_unref0 (_tmp1739_); - } - } - _tmp1740_ = vala_code_node_get_tree_can_fail ((ValaCodeNode*) expr); - _tmp1741_ = _tmp1740_; - if (_tmp1741_) { - ValaCallable* _tmp1742_ = NULL; - ValaMethod* _tmp1743_; - ValaHashMap* _tmp1745_; - ValaCCodeExpression* _tmp1746_; - ValaCCodeExpression* _tmp1747_; - ValaCCodeUnaryExpression* _tmp1748_; - ValaCCodeUnaryExpression* _tmp1749_; + _tmp1737_ = vala_ccode_base_module_generate_ready_function ((ValaCCodeBaseModule*) self, _tmp1736_); + _tmp1738_ = _tmp1737_; + _tmp1739_ = vala_ccode_identifier_new (_tmp1738_); + _tmp1740_ = _tmp1739_; + vala_map_set ((ValaMap*) _tmp1734_, (gpointer) ((gintptr) vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, (gdouble) -1, FALSE)), (ValaCCodeExpression*) _tmp1740_); + _vala_ccode_node_unref0 (_tmp1740_); + _g_free0 (_tmp1738_); + _tmp1741_ = in_arg_map; + _tmp1742_ = vala_ccode_identifier_new ("_data_"); + _tmp1743_ = _tmp1742_; + vala_map_set ((ValaMap*) _tmp1741_, (gpointer) ((gintptr) vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, -0.9, FALSE)), (ValaCCodeExpression*) _tmp1743_); + _vala_ccode_node_unref0 (_tmp1743_); + } + } + _tmp1744_ = vala_code_node_get_tree_can_fail ((ValaCodeNode*) expr); + _tmp1745_ = _tmp1744_; + if (_tmp1745_) { + ValaCallable* _tmp1746_ = NULL; + ValaMethod* _tmp1747_; + ValaHashMap* _tmp1749_; + ValaCCodeExpression* _tmp1750_; + ValaCCodeExpression* _tmp1751_; + ValaCCodeUnaryExpression* _tmp1752_; + ValaCCodeUnaryExpression* _tmp1753_; vala_ccode_base_module_set_current_method_inner_error ((ValaCCodeBaseModule*) self, TRUE); - _tmp1743_ = m; - _tmp1742_ = G_TYPE_CHECK_INSTANCE_CAST (_tmp1743_, VALA_TYPE_CALLABLE, ValaCallable); - if (_tmp1742_ == NULL) { - ValaDelegate* _tmp1744_; - _tmp1744_ = deleg; - _tmp1742_ = (ValaCallable*) _tmp1744_; - } - _tmp1745_ = out_arg_map; - _tmp1746_ = vala_ccode_base_module_get_inner_error_cexpression ((ValaCCodeBaseModule*) self); - _tmp1747_ = _tmp1746_; - _tmp1748_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, _tmp1747_); - _tmp1749_ = _tmp1748_; - vala_map_set ((ValaMap*) _tmp1745_, (gpointer) ((gintptr) vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, vala_get_ccode_error_pos (_tmp1742_), FALSE)), (ValaCCodeExpression*) _tmp1749_); - _vala_ccode_node_unref0 (_tmp1749_); - _vala_ccode_node_unref0 (_tmp1747_); + _tmp1747_ = m; + _tmp1746_ = G_TYPE_CHECK_INSTANCE_CAST (_tmp1747_, VALA_TYPE_CALLABLE, ValaCallable); + if (_tmp1746_ == NULL) { + ValaDelegate* _tmp1748_; + _tmp1748_ = deleg; + _tmp1746_ = (ValaCallable*) _tmp1748_; + } + _tmp1749_ = out_arg_map; + _tmp1750_ = vala_ccode_base_module_get_inner_error_cexpression ((ValaCCodeBaseModule*) self); + _tmp1751_ = _tmp1750_; + _tmp1752_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, _tmp1751_); + _tmp1753_ = _tmp1752_; + vala_map_set ((ValaMap*) _tmp1749_, (gpointer) ((gintptr) vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, vala_get_ccode_error_pos (_tmp1746_), FALSE)), (ValaCCodeExpression*) _tmp1753_); + _vala_ccode_node_unref0 (_tmp1753_); + _vala_ccode_node_unref0 (_tmp1751_); } else { - gboolean _tmp1750_ = FALSE; - gboolean _tmp1751_ = FALSE; - ValaMethod* _tmp1752_; - _tmp1752_ = m; - if (_tmp1752_ != NULL) { - ValaMethod* _tmp1753_; - _tmp1753_ = m; - _tmp1751_ = vala_method_has_error_type_parameter (_tmp1753_); - } else { - _tmp1751_ = FALSE; - } - if (_tmp1751_) { - ValaCCodeFunctionCall* _tmp1754_; - ValaCCodeFunctionCall* _tmp1755_; - _tmp1754_ = async_call; - _tmp1755_ = ccall; - _tmp1750_ = _tmp1754_ != _tmp1755_; - } else { - _tmp1750_ = FALSE; - } - if (_tmp1750_) { - ValaHashMap* _tmp1756_; + gboolean _tmp1754_ = FALSE; + gboolean _tmp1755_ = FALSE; + ValaMethod* _tmp1756_; + _tmp1756_ = m; + if (_tmp1756_ != NULL) { ValaMethod* _tmp1757_; - ValaCCodeConstant* _tmp1758_; - ValaCCodeConstant* _tmp1759_; - _tmp1756_ = out_arg_map; _tmp1757_ = m; - _tmp1758_ = vala_ccode_constant_new ("NULL"); - _tmp1759_ = _tmp1758_; - vala_map_set ((ValaMap*) _tmp1756_, (gpointer) ((gintptr) vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, vala_get_ccode_error_pos ((ValaCallable*) _tmp1757_), FALSE)), (ValaCCodeExpression*) _tmp1759_); - _vala_ccode_node_unref0 (_tmp1759_); + _tmp1755_ = vala_method_has_error_type_parameter (_tmp1757_); + } else { + _tmp1755_ = FALSE; } - } - if (ellipsis) { - ValaDataType* _tmp1760_; - _tmp1760_ = itype; - if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp1760_, VALA_TYPE_SIGNAL_TYPE)) { + if (_tmp1755_) { + ValaCCodeFunctionCall* _tmp1758_; + ValaCCodeFunctionCall* _tmp1759_; + _tmp1758_ = async_call; + _tmp1759_ = ccall; + _tmp1754_ = _tmp1758_ != _tmp1759_; } else { + _tmp1754_ = FALSE; + } + if (_tmp1754_) { + ValaHashMap* _tmp1760_; ValaMethod* _tmp1761_; + ValaCCodeConstant* _tmp1762_; + ValaCCodeConstant* _tmp1763_; + _tmp1760_ = out_arg_map; _tmp1761_ = m; - if (_tmp1761_ == NULL) { - ValaHashMap* _tmp1762_; - ValaCCodeConstant* _tmp1763_; - ValaCCodeConstant* _tmp1764_; - _tmp1762_ = in_arg_map; - _tmp1763_ = vala_ccode_constant_new ("NULL"); - _tmp1764_ = _tmp1763_; - vala_map_set ((ValaMap*) _tmp1762_, (gpointer) ((gintptr) vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, (gdouble) -1, TRUE)), (ValaCCodeExpression*) _tmp1764_); - _vala_ccode_node_unref0 (_tmp1764_); - } else { - gboolean _tmp1765_ = FALSE; - gboolean _tmp1766_ = FALSE; - gboolean _tmp1767_ = FALSE; - ValaMethod* _tmp1768_; - gboolean _tmp1769_; - gboolean _tmp1770_; - _tmp1768_ = m; - _tmp1769_ = vala_method_get_printf_format (_tmp1768_); - _tmp1770_ = _tmp1769_; - if (!_tmp1770_) { - ValaMethod* _tmp1771_; - gboolean _tmp1772_; - gboolean _tmp1773_; - _tmp1771_ = m; - _tmp1772_ = vala_method_get_scanf_format (_tmp1771_); - _tmp1773_ = _tmp1772_; - _tmp1767_ = !_tmp1773_; + _tmp1762_ = vala_ccode_constant_new ("NULL"); + _tmp1763_ = _tmp1762_; + vala_map_set ((ValaMap*) _tmp1760_, (gpointer) ((gintptr) vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, vala_get_ccode_error_pos ((ValaCallable*) _tmp1761_), FALSE)), (ValaCCodeExpression*) _tmp1763_); + _vala_ccode_node_unref0 (_tmp1763_); + } + } + if (ellipsis) { + ValaDataType* _tmp1764_; + _tmp1764_ = itype; + if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp1764_, VALA_TYPE_SIGNAL_TYPE)) { + } else { + ValaMethod* _tmp1765_; + _tmp1765_ = m; + if (_tmp1765_ == NULL) { + ValaHashMap* _tmp1766_; + ValaCCodeConstant* _tmp1767_; + ValaCCodeConstant* _tmp1768_; + _tmp1766_ = in_arg_map; + _tmp1767_ = vala_ccode_constant_new ("NULL"); + _tmp1768_ = _tmp1767_; + vala_map_set ((ValaMap*) _tmp1766_, (gpointer) ((gintptr) vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, (gdouble) -1, TRUE)), (ValaCCodeExpression*) _tmp1768_); + _vala_ccode_node_unref0 (_tmp1768_); + } else { + gboolean _tmp1769_ = FALSE; + gboolean _tmp1770_ = FALSE; + gboolean _tmp1771_ = FALSE; + ValaMethod* _tmp1772_; + gboolean _tmp1773_; + gboolean _tmp1774_; + _tmp1772_ = m; + _tmp1773_ = vala_method_get_printf_format (_tmp1772_); + _tmp1774_ = _tmp1773_; + if (!_tmp1774_) { + ValaMethod* _tmp1775_; + gboolean _tmp1776_; + gboolean _tmp1777_; + _tmp1775_ = m; + _tmp1776_ = vala_method_get_scanf_format (_tmp1775_); + _tmp1777_ = _tmp1776_; + _tmp1771_ = !_tmp1777_; } else { - _tmp1767_ = FALSE; + _tmp1771_ = FALSE; } - if (_tmp1767_) { - ValaMethod* _tmp1774_; - gchar* _tmp1775_; - gchar* _tmp1776_; - _tmp1774_ = m; - _tmp1775_ = vala_get_ccode_sentinel (_tmp1774_); - _tmp1776_ = _tmp1775_; - _tmp1766_ = g_strcmp0 (_tmp1776_, "") != 0; - _g_free0 (_tmp1776_); + if (_tmp1771_) { + ValaMethod* _tmp1778_; + gchar* _tmp1779_; + gchar* _tmp1780_; + _tmp1778_ = m; + _tmp1779_ = vala_get_ccode_sentinel (_tmp1778_); + _tmp1780_ = _tmp1779_; + _tmp1770_ = g_strcmp0 (_tmp1780_, "") != 0; + _g_free0 (_tmp1780_); } else { - _tmp1766_ = FALSE; + _tmp1770_ = FALSE; } - if (_tmp1766_) { - gboolean _tmp1777_; - gboolean _tmp1778_; - _tmp1777_ = vala_method_call_get_is_constructv_chainup (expr); - _tmp1778_ = _tmp1777_; - _tmp1765_ = !_tmp1778_; + if (_tmp1770_) { + gboolean _tmp1781_; + gboolean _tmp1782_; + _tmp1781_ = vala_method_call_get_is_constructv_chainup (expr); + _tmp1782_ = _tmp1781_; + _tmp1769_ = !_tmp1782_; } else { - _tmp1765_ = FALSE; + _tmp1769_ = FALSE; } - if (_tmp1765_) { - ValaHashMap* _tmp1779_; - ValaMethod* _tmp1780_; - gchar* _tmp1781_; - gchar* _tmp1782_; - ValaCCodeConstant* _tmp1783_; - ValaCCodeConstant* _tmp1784_; - _tmp1779_ = in_arg_map; - _tmp1780_ = m; - _tmp1781_ = vala_get_ccode_sentinel (_tmp1780_); - _tmp1782_ = _tmp1781_; - _tmp1783_ = vala_ccode_constant_new (_tmp1782_); - _tmp1784_ = _tmp1783_; - vala_map_set ((ValaMap*) _tmp1779_, (gpointer) ((gintptr) vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, (gdouble) -1, TRUE)), (ValaCCodeExpression*) _tmp1784_); - _vala_ccode_node_unref0 (_tmp1784_); - _g_free0 (_tmp1782_); + if (_tmp1769_) { + ValaHashMap* _tmp1783_; + ValaMethod* _tmp1784_; + gchar* _tmp1785_; + gchar* _tmp1786_; + ValaCCodeConstant* _tmp1787_; + ValaCCodeConstant* _tmp1788_; + _tmp1783_ = in_arg_map; + _tmp1784_ = m; + _tmp1785_ = vala_get_ccode_sentinel (_tmp1784_); + _tmp1786_ = _tmp1785_; + _tmp1787_ = vala_ccode_constant_new (_tmp1786_); + _tmp1788_ = _tmp1787_; + vala_map_set ((ValaMap*) _tmp1783_, (gpointer) ((gintptr) vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, (gdouble) -1, TRUE)), (ValaCCodeExpression*) _tmp1788_); + _vala_ccode_node_unref0 (_tmp1788_); + _g_free0 (_tmp1786_); } } } } - _tmp1786_ = deleg; - if (_tmp1786_ != NULL) { - ValaDelegate* _tmp1787_; - gboolean _tmp1788_; - gboolean _tmp1789_; - _tmp1787_ = deleg; - _tmp1788_ = vala_delegate_get_has_target (_tmp1787_); - _tmp1789_ = _tmp1788_; - _tmp1785_ = _tmp1789_; - } else { - _tmp1785_ = FALSE; - } - if (_tmp1785_) { - ValaCCodeExpression* delegate_target_destroy_notify = NULL; - ValaHashMap* _tmp1790_; + _tmp1790_ = deleg; + if (_tmp1790_ != NULL) { ValaDelegate* _tmp1791_; - ValaExpression* _tmp1792_; - ValaExpression* _tmp1793_; - ValaCCodeExpression* _tmp1794_ = NULL; - ValaCCodeExpression* _tmp1795_; - ValaCCodeExpression* _tmp1796_; - ValaHashMap* _tmp1797_; - ValaDelegate* _tmp1798_; - ValaExpression* _tmp1799_; - ValaExpression* _tmp1800_; - ValaCCodeExpression* _tmp1801_ = NULL; - ValaCCodeExpression* _tmp1802_; - ValaCCodeExpression* _tmp1803_; - _tmp1790_ = in_arg_map; + gboolean _tmp1792_; + gboolean _tmp1793_; _tmp1791_ = deleg; - _tmp1792_ = vala_callable_expression_get_call ((ValaCallableExpression*) expr); + _tmp1792_ = vala_delegate_get_has_target (_tmp1791_); _tmp1793_ = _tmp1792_; - _tmp1795_ = vala_ccode_base_module_get_delegate_target_cexpression ((ValaCCodeBaseModule*) self, _tmp1793_, &_tmp1794_); + _tmp1789_ = _tmp1793_; + } else { + _tmp1789_ = FALSE; + } + if (_tmp1789_) { + ValaCCodeExpression* delegate_target_destroy_notify = NULL; + ValaHashMap* _tmp1794_; + ValaDelegate* _tmp1795_; + ValaExpression* _tmp1796_; + ValaExpression* _tmp1797_; + ValaCCodeExpression* _tmp1798_ = NULL; + ValaCCodeExpression* _tmp1799_; + ValaCCodeExpression* _tmp1800_; + ValaHashMap* _tmp1801_; + ValaDelegate* _tmp1802_; + ValaExpression* _tmp1803_; + ValaExpression* _tmp1804_; + ValaCCodeExpression* _tmp1805_ = NULL; + ValaCCodeExpression* _tmp1806_; + ValaCCodeExpression* _tmp1807_; + _tmp1794_ = in_arg_map; + _tmp1795_ = deleg; + _tmp1796_ = vala_callable_expression_get_call ((ValaCallableExpression*) expr); + _tmp1797_ = _tmp1796_; + _tmp1799_ = vala_ccode_base_module_get_delegate_target_cexpression ((ValaCCodeBaseModule*) self, _tmp1797_, &_tmp1798_); _vala_ccode_node_unref0 (delegate_target_destroy_notify); - delegate_target_destroy_notify = _tmp1794_; - _tmp1796_ = _tmp1795_; - vala_map_set ((ValaMap*) _tmp1790_, (gpointer) ((gintptr) vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, vala_get_ccode_instance_pos ((ValaCodeNode*) _tmp1791_), FALSE)), _tmp1796_); - _vala_ccode_node_unref0 (_tmp1796_); - _tmp1797_ = out_arg_map; - _tmp1798_ = deleg; - _tmp1799_ = vala_callable_expression_get_call ((ValaCallableExpression*) expr); + delegate_target_destroy_notify = _tmp1798_; _tmp1800_ = _tmp1799_; - _tmp1802_ = vala_ccode_base_module_get_delegate_target_cexpression ((ValaCCodeBaseModule*) self, _tmp1800_, &_tmp1801_); + vala_map_set ((ValaMap*) _tmp1794_, (gpointer) ((gintptr) vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, vala_get_ccode_instance_pos ((ValaCodeNode*) _tmp1795_), FALSE)), _tmp1800_); + _vala_ccode_node_unref0 (_tmp1800_); + _tmp1801_ = out_arg_map; + _tmp1802_ = deleg; + _tmp1803_ = vala_callable_expression_get_call ((ValaCallableExpression*) expr); + _tmp1804_ = _tmp1803_; + _tmp1806_ = vala_ccode_base_module_get_delegate_target_cexpression ((ValaCCodeBaseModule*) self, _tmp1804_, &_tmp1805_); _vala_ccode_node_unref0 (delegate_target_destroy_notify); - delegate_target_destroy_notify = _tmp1801_; - _tmp1803_ = _tmp1802_; - vala_map_set ((ValaMap*) _tmp1797_, (gpointer) ((gintptr) vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, vala_get_ccode_instance_pos ((ValaCodeNode*) _tmp1798_), FALSE)), _tmp1803_); - _vala_ccode_node_unref0 (_tmp1803_); + delegate_target_destroy_notify = _tmp1805_; + _tmp1807_ = _tmp1806_; + vala_map_set ((ValaMap*) _tmp1801_, (gpointer) ((gintptr) vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, vala_get_ccode_instance_pos ((ValaCodeNode*) _tmp1802_), FALSE)), _tmp1807_); + _vala_ccode_node_unref0 (_tmp1807_); _vala_ccode_node_unref0 (delegate_target_destroy_notify); } - _tmp1804_ = itype; - _tmp1805_ = vala_data_type_get_return_type (_tmp1804_); - return_result_via_out_param = vala_data_type_is_real_non_null_struct_type (_tmp1805_); - _tmp1807_ = itype; - if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp1807_, VALA_TYPE_SIGNAL_TYPE)) { - ValaDataType* _tmp1808_; - ValaDataType* _tmp1809_; - _tmp1808_ = itype; - _tmp1809_ = vala_data_type_get_return_type (_tmp1808_); - _tmp1806_ = !G_TYPE_CHECK_INSTANCE_TYPE (_tmp1809_, VALA_TYPE_VOID_TYPE); + _tmp1808_ = itype; + _tmp1809_ = vala_data_type_get_return_type (_tmp1808_); + return_result_via_out_param = vala_data_type_is_real_non_null_struct_type (_tmp1809_); + _tmp1811_ = itype; + if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp1811_, VALA_TYPE_SIGNAL_TYPE)) { + ValaDataType* _tmp1812_; + ValaDataType* _tmp1813_; + _tmp1812_ = itype; + _tmp1813_ = vala_data_type_get_return_type (_tmp1812_); + _tmp1810_ = !G_TYPE_CHECK_INSTANCE_TYPE (_tmp1813_, VALA_TYPE_VOID_TYPE); } else { - _tmp1806_ = FALSE; + _tmp1810_ = FALSE; } - if (_tmp1806_) { + if (_tmp1810_) { ValaSignal* sig = NULL; - ValaDataType* _tmp1810_; - ValaSignal* _tmp1811_; - ValaSignal* _tmp1812_; - ValaSignal* _tmp1813_; - gboolean _tmp1814_ = FALSE; - gboolean _tmp1815_ = FALSE; - ValaMemberAccess* _tmp1816_; - _tmp1810_ = itype; - _tmp1811_ = vala_signal_type_get_signal_symbol (G_TYPE_CHECK_INSTANCE_CAST (_tmp1810_, VALA_TYPE_SIGNAL_TYPE, ValaSignalType)); - _tmp1812_ = _tmp1811_; - _tmp1813_ = _vala_code_node_ref0 (_tmp1812_); - sig = _tmp1813_; - _tmp1816_ = ma; - if (_tmp1816_ != NULL) { - ValaMemberAccess* _tmp1817_; - ValaExpression* _tmp1818_; - ValaExpression* _tmp1819_; - _tmp1817_ = ma; - _tmp1818_ = vala_member_access_get_inner (_tmp1817_); - _tmp1819_ = _tmp1818_; - _tmp1815_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp1819_, VALA_TYPE_BASE_ACCESS); - } else { - _tmp1815_ = FALSE; - } - if (_tmp1815_) { - ValaSignal* _tmp1820_; - gboolean _tmp1821_; - gboolean _tmp1822_; - _tmp1820_ = sig; - _tmp1821_ = vala_signal_get_is_virtual (_tmp1820_); - _tmp1822_ = _tmp1821_; - _tmp1814_ = _tmp1822_; + ValaDataType* _tmp1814_; + ValaSignal* _tmp1815_; + ValaSignal* _tmp1816_; + ValaSignal* _tmp1817_; + gboolean _tmp1818_ = FALSE; + gboolean _tmp1819_ = FALSE; + ValaMemberAccess* _tmp1820_; + _tmp1814_ = itype; + _tmp1815_ = vala_signal_type_get_signal_symbol (G_TYPE_CHECK_INSTANCE_CAST (_tmp1814_, VALA_TYPE_SIGNAL_TYPE, ValaSignalType)); + _tmp1816_ = _tmp1815_; + _tmp1817_ = _vala_code_node_ref0 (_tmp1816_); + sig = _tmp1817_; + _tmp1820_ = ma; + if (_tmp1820_ != NULL) { + ValaMemberAccess* _tmp1821_; + ValaExpression* _tmp1822_; + ValaExpression* _tmp1823_; + _tmp1821_ = ma; + _tmp1822_ = vala_member_access_get_inner (_tmp1821_); + _tmp1823_ = _tmp1822_; + _tmp1819_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp1823_, VALA_TYPE_BASE_ACCESS); } else { - _tmp1814_ = FALSE; + _tmp1819_ = FALSE; } - if (_tmp1814_) { - } else { - gboolean _tmp1823_ = FALSE; + if (_tmp1819_) { ValaSignal* _tmp1824_; + gboolean _tmp1825_; + gboolean _tmp1826_; _tmp1824_ = sig; - if (!vala_get_ccode_has_emitter (_tmp1824_)) { - _tmp1823_ = TRUE; + _tmp1825_ = vala_signal_get_is_virtual (_tmp1824_); + _tmp1826_ = _tmp1825_; + _tmp1818_ = _tmp1826_; + } else { + _tmp1818_ = FALSE; + } + if (_tmp1818_) { + } else { + gboolean _tmp1827_ = FALSE; + ValaSignal* _tmp1828_; + _tmp1828_ = sig; + if (!vala_get_ccode_has_emitter (_tmp1828_)) { + _tmp1827_ = TRUE; } else { - ValaMemberAccess* _tmp1825_; - ValaSourceReference* _tmp1826_; - ValaSourceReference* _tmp1827_; - ValaSourceFile* _tmp1828_; - ValaSourceFile* _tmp1829_; - ValaSignal* _tmp1830_; + ValaMemberAccess* _tmp1829_; + ValaSourceReference* _tmp1830_; ValaSourceReference* _tmp1831_; - ValaSourceReference* _tmp1832_; + ValaSourceFile* _tmp1832_; ValaSourceFile* _tmp1833_; - ValaSourceFile* _tmp1834_; - _tmp1825_ = ma; - _tmp1826_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp1825_); - _tmp1827_ = _tmp1826_; - _tmp1828_ = vala_source_reference_get_file (_tmp1827_); - _tmp1829_ = _tmp1828_; - _tmp1830_ = sig; - _tmp1831_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp1830_); - _tmp1832_ = _tmp1831_; - _tmp1833_ = vala_source_reference_get_file (_tmp1832_); - _tmp1834_ = _tmp1833_; - _tmp1823_ = _tmp1829_ == _tmp1834_; + ValaSignal* _tmp1834_; + ValaSourceReference* _tmp1835_; + ValaSourceReference* _tmp1836_; + ValaSourceFile* _tmp1837_; + ValaSourceFile* _tmp1838_; + _tmp1829_ = ma; + _tmp1830_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp1829_); + _tmp1831_ = _tmp1830_; + _tmp1832_ = vala_source_reference_get_file (_tmp1831_); + _tmp1833_ = _tmp1832_; + _tmp1834_ = sig; + _tmp1835_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp1834_); + _tmp1836_ = _tmp1835_; + _tmp1837_ = vala_source_reference_get_file (_tmp1836_); + _tmp1838_ = _tmp1837_; + _tmp1827_ = _tmp1833_ == _tmp1838_; } - if (_tmp1823_) { + if (_tmp1827_) { return_result_via_out_param = TRUE; } } _vala_code_node_unref0 (sig); } - _tmp1835_ = async_call; - _tmp1836_ = ccall; - if (_tmp1835_ == _tmp1836_) { + _tmp1839_ = async_call; + _tmp1840_ = ccall; + if (_tmp1839_ == _tmp1840_) { return_result_via_out_param = FALSE; } out_param_ref = NULL; if (return_result_via_out_param) { ValaLocalVariable* out_param_var = NULL; - ValaDataType* _tmp1837_; - ValaDataType* _tmp1838_; - ValaLocalVariable* _tmp1839_; - ValaLocalVariable* _tmp1840_; - const gchar* _tmp1841_; - const gchar* _tmp1842_; - ValaCCodeExpression* _tmp1843_; + ValaDataType* _tmp1841_; + ValaDataType* _tmp1842_; + ValaLocalVariable* _tmp1843_; ValaLocalVariable* _tmp1844_; - ValaHashMap* _tmp1845_; - ValaCCodeExpression* _tmp1846_; - ValaCCodeUnaryExpression* _tmp1847_; - ValaCCodeUnaryExpression* _tmp1848_; - _tmp1837_ = itype; - _tmp1838_ = vala_data_type_get_return_type (_tmp1837_); - _tmp1839_ = vala_ccode_base_module_get_temp_variable ((ValaCCodeBaseModule*) self, _tmp1838_, TRUE, NULL, TRUE); - out_param_var = _tmp1839_; - _tmp1840_ = out_param_var; - _tmp1841_ = vala_symbol_get_name ((ValaSymbol*) _tmp1840_); - _tmp1842_ = _tmp1841_; - _tmp1843_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, _tmp1842_); - _vala_ccode_node_unref0 (out_param_ref); - out_param_ref = _tmp1843_; + const gchar* _tmp1845_; + const gchar* _tmp1846_; + ValaCCodeExpression* _tmp1847_; + ValaLocalVariable* _tmp1848_; + ValaHashMap* _tmp1849_; + ValaCCodeExpression* _tmp1850_; + ValaCCodeUnaryExpression* _tmp1851_; + ValaCCodeUnaryExpression* _tmp1852_; + _tmp1841_ = itype; + _tmp1842_ = vala_data_type_get_return_type (_tmp1841_); + _tmp1843_ = vala_ccode_base_module_get_temp_variable ((ValaCCodeBaseModule*) self, _tmp1842_, TRUE, NULL, TRUE); + out_param_var = _tmp1843_; _tmp1844_ = out_param_var; - vala_ccode_base_module_emit_temp_var ((ValaCCodeBaseModule*) self, _tmp1844_, FALSE); - _tmp1845_ = out_arg_map; - _tmp1846_ = out_param_ref; - _tmp1847_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, _tmp1846_); - _tmp1848_ = _tmp1847_; - vala_map_set ((ValaMap*) _tmp1845_, (gpointer) ((gintptr) vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, (gdouble) -3, FALSE)), (ValaCCodeExpression*) _tmp1848_); - _vala_ccode_node_unref0 (_tmp1848_); + _tmp1845_ = vala_symbol_get_name ((ValaSymbol*) _tmp1844_); + _tmp1846_ = _tmp1845_; + _tmp1847_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, _tmp1846_); + _vala_ccode_node_unref0 (out_param_ref); + out_param_ref = _tmp1847_; + _tmp1848_ = out_param_var; + vala_ccode_base_module_emit_temp_var ((ValaCCodeBaseModule*) self, _tmp1848_, FALSE); + _tmp1849_ = out_arg_map; + _tmp1850_ = out_param_ref; + _tmp1851_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, _tmp1850_); + _tmp1852_ = _tmp1851_; + vala_map_set ((ValaMap*) _tmp1849_, (gpointer) ((gintptr) vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, (gdouble) -3, FALSE)), (ValaCCodeExpression*) _tmp1852_); + _vala_ccode_node_unref0 (_tmp1852_); _vala_code_node_unref0 (out_param_var); } - _tmp1849_ = async_call; - _tmp1850_ = ccall; - if (_tmp1849_ != _tmp1850_) { + _tmp1853_ = async_call; + _tmp1854_ = ccall; + if (_tmp1853_ != _tmp1854_) { last_pos = -1; while (TRUE) { - ValaCCodeFunctionCall* _tmp1861_; - ValaHashMap* _tmp1862_; - gpointer _tmp1863_; - ValaCCodeExpression* _tmp1864_; + ValaCCodeFunctionCall* _tmp1865_; + ValaHashMap* _tmp1866_; + gpointer _tmp1867_; + ValaCCodeExpression* _tmp1868_; min_pos = -1; { ValaIterator* _pos_it = NULL; - ValaHashMap* _tmp1851_; - ValaSet* _tmp1852_; - ValaSet* _tmp1853_; - ValaIterator* _tmp1854_; - ValaIterator* _tmp1855_; - _tmp1851_ = out_arg_map; - _tmp1852_ = vala_map_get_keys ((ValaMap*) _tmp1851_); - _tmp1853_ = _tmp1852_; - _tmp1854_ = vala_iterable_iterator ((ValaIterable*) _tmp1853_); - _tmp1855_ = _tmp1854_; - _vala_iterable_unref0 (_tmp1853_); - _pos_it = _tmp1855_; + ValaHashMap* _tmp1855_; + ValaSet* _tmp1856_; + ValaSet* _tmp1857_; + ValaIterator* _tmp1858_; + ValaIterator* _tmp1859_; + _tmp1855_ = out_arg_map; + _tmp1856_ = vala_map_get_keys ((ValaMap*) _tmp1855_); + _tmp1857_ = _tmp1856_; + _tmp1858_ = vala_iterable_iterator ((ValaIterable*) _tmp1857_); + _tmp1859_ = _tmp1858_; + _vala_iterable_unref0 (_tmp1857_); + _pos_it = _tmp1859_; while (TRUE) { - ValaIterator* _tmp1856_; + ValaIterator* _tmp1860_; gint pos = 0; - ValaIterator* _tmp1857_; - gpointer _tmp1858_; - gboolean _tmp1859_ = FALSE; - _tmp1856_ = _pos_it; - if (!vala_iterator_next (_tmp1856_)) { + ValaIterator* _tmp1861_; + gpointer _tmp1862_; + gboolean _tmp1863_ = FALSE; + _tmp1860_ = _pos_it; + if (!vala_iterator_next (_tmp1860_)) { break; } - _tmp1857_ = _pos_it; - _tmp1858_ = vala_iterator_get (_tmp1857_); - pos = (gint) ((gintptr) _tmp1858_); + _tmp1861_ = _pos_it; + _tmp1862_ = vala_iterator_get (_tmp1861_); + pos = (gint) ((gintptr) _tmp1862_); if (pos > last_pos) { - gboolean _tmp1860_ = FALSE; + gboolean _tmp1864_ = FALSE; if (min_pos == -1) { - _tmp1860_ = TRUE; + _tmp1864_ = TRUE; } else { - _tmp1860_ = pos < min_pos; + _tmp1864_ = pos < min_pos; } - _tmp1859_ = _tmp1860_; + _tmp1863_ = _tmp1864_; } else { - _tmp1859_ = FALSE; + _tmp1863_ = FALSE; } - if (_tmp1859_) { + if (_tmp1863_) { min_pos = pos; } } @@ -5876,63 +5892,63 @@ if (min_pos == -1) { break; } - _tmp1861_ = ccall; - _tmp1862_ = out_arg_map; - _tmp1863_ = vala_map_get ((ValaMap*) _tmp1862_, (gpointer) ((gintptr) min_pos)); - _tmp1864_ = (ValaCCodeExpression*) _tmp1863_; - vala_ccode_function_call_add_argument (_tmp1861_, _tmp1864_); - _vala_ccode_node_unref0 (_tmp1864_); + _tmp1865_ = ccall; + _tmp1866_ = out_arg_map; + _tmp1867_ = vala_map_get ((ValaMap*) _tmp1866_, (gpointer) ((gintptr) min_pos)); + _tmp1868_ = (ValaCCodeExpression*) _tmp1867_; + vala_ccode_function_call_add_argument (_tmp1865_, _tmp1868_); + _vala_ccode_node_unref0 (_tmp1868_); last_pos = min_pos; } } - _tmp1865_ = async_call; - if (_tmp1865_ != NULL) { + _tmp1869_ = async_call; + if (_tmp1869_ != NULL) { last_pos = -1; while (TRUE) { - ValaCCodeFunctionCall* _tmp1876_; - ValaHashMap* _tmp1877_; - gpointer _tmp1878_; - ValaCCodeExpression* _tmp1879_; + ValaCCodeFunctionCall* _tmp1880_; + ValaHashMap* _tmp1881_; + gpointer _tmp1882_; + ValaCCodeExpression* _tmp1883_; min_pos = -1; { ValaIterator* _pos_it = NULL; - ValaHashMap* _tmp1866_; - ValaSet* _tmp1867_; - ValaSet* _tmp1868_; - ValaIterator* _tmp1869_; - ValaIterator* _tmp1870_; - _tmp1866_ = in_arg_map; - _tmp1867_ = vala_map_get_keys ((ValaMap*) _tmp1866_); - _tmp1868_ = _tmp1867_; - _tmp1869_ = vala_iterable_iterator ((ValaIterable*) _tmp1868_); - _tmp1870_ = _tmp1869_; - _vala_iterable_unref0 (_tmp1868_); - _pos_it = _tmp1870_; + ValaHashMap* _tmp1870_; + ValaSet* _tmp1871_; + ValaSet* _tmp1872_; + ValaIterator* _tmp1873_; + ValaIterator* _tmp1874_; + _tmp1870_ = in_arg_map; + _tmp1871_ = vala_map_get_keys ((ValaMap*) _tmp1870_); + _tmp1872_ = _tmp1871_; + _tmp1873_ = vala_iterable_iterator ((ValaIterable*) _tmp1872_); + _tmp1874_ = _tmp1873_; + _vala_iterable_unref0 (_tmp1872_); + _pos_it = _tmp1874_; while (TRUE) { - ValaIterator* _tmp1871_; + ValaIterator* _tmp1875_; gint pos = 0; - ValaIterator* _tmp1872_; - gpointer _tmp1873_; - gboolean _tmp1874_ = FALSE; - _tmp1871_ = _pos_it; - if (!vala_iterator_next (_tmp1871_)) { + ValaIterator* _tmp1876_; + gpointer _tmp1877_; + gboolean _tmp1878_ = FALSE; + _tmp1875_ = _pos_it; + if (!vala_iterator_next (_tmp1875_)) { break; } - _tmp1872_ = _pos_it; - _tmp1873_ = vala_iterator_get (_tmp1872_); - pos = (gint) ((gintptr) _tmp1873_); + _tmp1876_ = _pos_it; + _tmp1877_ = vala_iterator_get (_tmp1876_); + pos = (gint) ((gintptr) _tmp1877_); if (pos > last_pos) { - gboolean _tmp1875_ = FALSE; + gboolean _tmp1879_ = FALSE; if (min_pos == -1) { - _tmp1875_ = TRUE; + _tmp1879_ = TRUE; } else { - _tmp1875_ = pos < min_pos; + _tmp1879_ = pos < min_pos; } - _tmp1874_ = _tmp1875_; + _tmp1878_ = _tmp1879_; } else { - _tmp1874_ = FALSE; + _tmp1878_ = FALSE; } - if (_tmp1874_) { + if (_tmp1878_) { min_pos = pos; } } @@ -5941,199 +5957,186 @@ if (min_pos == -1) { break; } - _tmp1876_ = async_call; - _tmp1877_ = in_arg_map; - _tmp1878_ = vala_map_get ((ValaMap*) _tmp1877_, (gpointer) ((gintptr) min_pos)); - _tmp1879_ = (ValaCCodeExpression*) _tmp1878_; - vala_ccode_function_call_add_argument (_tmp1876_, _tmp1879_); - _vala_ccode_node_unref0 (_tmp1879_); + _tmp1880_ = async_call; + _tmp1881_ = in_arg_map; + _tmp1882_ = vala_map_get ((ValaMap*) _tmp1881_, (gpointer) ((gintptr) min_pos)); + _tmp1883_ = (ValaCCodeExpression*) _tmp1882_; + vala_ccode_function_call_add_argument (_tmp1880_, _tmp1883_); + _vala_ccode_node_unref0 (_tmp1883_); last_pos = min_pos; } } - _tmp1880_ = vala_callable_expression_get_is_yield_expression ((ValaCallableExpression*) expr); - _tmp1881_ = _tmp1880_; - if (_tmp1881_) { + _tmp1884_ = vala_callable_expression_get_is_yield_expression ((ValaCallableExpression*) expr); + _tmp1885_ = _tmp1884_; + if (_tmp1885_) { gint state = 0; - ValaCCodeBaseModuleEmitContext* _tmp1882_; - gint _tmp1883_; - ValaCCodeFunction* _tmp1884_; - ValaCCodeFunction* _tmp1885_; - ValaCCodeExpression* _tmp1886_; - ValaCCodeExpression* _tmp1887_; - gchar* _tmp1888_; - gchar* _tmp1889_; - ValaCCodeConstant* _tmp1890_; - ValaCCodeConstant* _tmp1891_; - ValaCCodeFunction* _tmp1892_; - ValaCCodeFunction* _tmp1893_; - ValaCCodeFunctionCall* _tmp1894_; - ValaCCodeFunction* _tmp1895_; + ValaCCodeBaseModuleEmitContext* _tmp1886_; + gint _tmp1887_; + ValaCCodeFunction* _tmp1888_; + ValaCCodeFunction* _tmp1889_; + ValaCCodeExpression* _tmp1890_; + ValaCCodeExpression* _tmp1891_; + gchar* _tmp1892_; + gchar* _tmp1893_; + ValaCCodeConstant* _tmp1894_; + ValaCCodeConstant* _tmp1895_; ValaCCodeFunction* _tmp1896_; - ValaCCodeConstant* _tmp1897_; - ValaCCodeConstant* _tmp1898_; + ValaCCodeFunction* _tmp1897_; + ValaCCodeFunctionCall* _tmp1898_; ValaCCodeFunction* _tmp1899_; ValaCCodeFunction* _tmp1900_; - gchar* _tmp1901_; - gchar* _tmp1902_; - _tmp1882_ = ((ValaCCodeBaseModule*) self)->emit_context; - _tmp1883_ = _tmp1882_->next_coroutine_state; - _tmp1882_->next_coroutine_state = _tmp1883_ + 1; - state = _tmp1883_; - _tmp1884_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); - _tmp1885_ = _tmp1884_; - _tmp1886_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, "_state_"); - _tmp1887_ = _tmp1886_; - _tmp1888_ = g_strdup_printf ("%i", state); + ValaCCodeConstant* _tmp1901_; + ValaCCodeConstant* _tmp1902_; + ValaCCodeFunction* _tmp1903_; + ValaCCodeFunction* _tmp1904_; + gchar* _tmp1905_; + gchar* _tmp1906_; + _tmp1886_ = ((ValaCCodeBaseModule*) self)->emit_context; + _tmp1887_ = _tmp1886_->next_coroutine_state; + _tmp1886_->next_coroutine_state = _tmp1887_ + 1; + state = _tmp1887_; + _tmp1888_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); _tmp1889_ = _tmp1888_; - _tmp1890_ = vala_ccode_constant_new (_tmp1889_); + _tmp1890_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, "_state_"); _tmp1891_ = _tmp1890_; - vala_ccode_function_add_assignment (_tmp1885_, _tmp1887_, (ValaCCodeExpression*) _tmp1891_); - _vala_ccode_node_unref0 (_tmp1891_); - _g_free0 (_tmp1889_); - _vala_ccode_node_unref0 (_tmp1887_); - _tmp1892_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp1892_ = g_strdup_printf ("%i", state); _tmp1893_ = _tmp1892_; - _tmp1894_ = async_call; - vala_ccode_function_add_expression (_tmp1893_, (ValaCCodeExpression*) _tmp1894_); - _tmp1895_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); - _tmp1896_ = _tmp1895_; - _tmp1897_ = vala_ccode_constant_new ("FALSE"); - _tmp1898_ = _tmp1897_; - vala_ccode_function_add_return (_tmp1896_, (ValaCCodeExpression*) _tmp1898_); - _vala_ccode_node_unref0 (_tmp1898_); + _tmp1894_ = vala_ccode_constant_new (_tmp1893_); + _tmp1895_ = _tmp1894_; + vala_ccode_function_add_assignment (_tmp1889_, _tmp1891_, (ValaCCodeExpression*) _tmp1895_); + _vala_ccode_node_unref0 (_tmp1895_); + _g_free0 (_tmp1893_); + _vala_ccode_node_unref0 (_tmp1891_); + _tmp1896_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp1897_ = _tmp1896_; + _tmp1898_ = async_call; + vala_ccode_function_add_expression (_tmp1897_, (ValaCCodeExpression*) _tmp1898_); _tmp1899_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); _tmp1900_ = _tmp1899_; - _tmp1901_ = g_strdup_printf ("_state_%d", state); + _tmp1901_ = vala_ccode_constant_new ("FALSE"); _tmp1902_ = _tmp1901_; - vala_ccode_function_add_label (_tmp1900_, _tmp1902_); - _g_free0 (_tmp1902_); + vala_ccode_function_add_return (_tmp1900_, (ValaCCodeExpression*) _tmp1902_); + _vala_ccode_node_unref0 (_tmp1902_); + _tmp1903_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp1904_ = _tmp1903_; + _tmp1905_ = g_strdup_printf ("_state_%d", state); + _tmp1906_ = _tmp1905_; + vala_ccode_function_add_label (_tmp1904_, _tmp1906_); + _g_free0 (_tmp1906_); } - _tmp1903_ = vala_method_call_get_is_assert (expr); - _tmp1904_ = _tmp1903_; - if (_tmp1904_) { + _tmp1907_ = vala_method_call_get_is_assert (expr); + _tmp1908_ = _tmp1907_; + if (_tmp1908_) { gchar* message = NULL; - ValaSourceReference* _tmp1905_; - ValaSourceReference* _tmp1906_; - ValaSourceLocation _tmp1907_ = {0}; - ValaSourceLocation _tmp1908_; - gchar* _tmp1909_; + ValaSourceReference* _tmp1909_; ValaSourceReference* _tmp1910_; - ValaSourceReference* _tmp1911_; - ValaSourceLocation _tmp1912_ = {0}; - ValaSourceLocation _tmp1913_; - gchar* _tmp1914_; + ValaSourceLocation _tmp1911_ = {0}; + ValaSourceLocation _tmp1912_; + gchar* _tmp1913_; + ValaSourceReference* _tmp1914_; ValaSourceReference* _tmp1915_; - ValaSourceReference* _tmp1916_; - ValaSourceLocation _tmp1917_ = {0}; - ValaSourceLocation _tmp1918_; - gchar* _tmp1919_; - gchar* _tmp1920_; - ValaCCodeFunctionCall* _tmp1921_; - ValaCCodeIdentifier* _tmp1922_; - ValaCCodeIdentifier* _tmp1923_; - ValaCCodeFunctionCall* _tmp1924_; - const gchar* _tmp1925_; - gchar* _tmp1926_; - gchar* _tmp1927_; - gchar* _tmp1928_; - gchar* _tmp1929_; + ValaSourceLocation _tmp1916_ = {0}; + ValaSourceLocation _tmp1917_; + gchar* _tmp1918_; + ValaSourceReference* _tmp1919_; + ValaSourceReference* _tmp1920_; + ValaSourceLocation _tmp1921_ = {0}; + ValaSourceLocation _tmp1922_; + gchar* _tmp1923_; + gchar* _tmp1924_; + ValaCCodeFunctionCall* _tmp1925_; + ValaCCodeIdentifier* _tmp1926_; + ValaCCodeIdentifier* _tmp1927_; + ValaCCodeFunctionCall* _tmp1928_; + const gchar* _tmp1929_; gchar* _tmp1930_; gchar* _tmp1931_; - ValaCCodeConstant* _tmp1932_; - ValaCCodeConstant* _tmp1933_; - _tmp1905_ = vala_code_node_get_source_reference ((ValaCodeNode*) expr); - _tmp1906_ = _tmp1905_; - vala_source_reference_get_begin (_tmp1906_, &_tmp1907_); - _tmp1908_ = _tmp1907_; - _tmp1909_ = _tmp1908_.pos; - _tmp1910_ = vala_code_node_get_source_reference ((ValaCodeNode*) expr); - _tmp1911_ = _tmp1910_; - vala_source_reference_get_end (_tmp1911_, &_tmp1912_); - _tmp1913_ = _tmp1912_; - _tmp1914_ = _tmp1913_.pos; - _tmp1915_ = vala_code_node_get_source_reference ((ValaCodeNode*) expr); - _tmp1916_ = _tmp1915_; - vala_source_reference_get_begin (_tmp1916_, &_tmp1917_); - _tmp1918_ = _tmp1917_; - _tmp1919_ = _tmp1918_.pos; - _tmp1920_ = string_substring ((const gchar*) _tmp1909_, (glong) 0, (glong) ((gint) (_tmp1914_ - _tmp1919_))); - message = _tmp1920_; - _tmp1921_ = ccall; - _tmp1922_ = vala_ccode_identifier_new ("_vala_assert"); - _tmp1923_ = _tmp1922_; - vala_ccode_function_call_set_call (_tmp1921_, (ValaCCodeExpression*) _tmp1923_); - _vala_ccode_node_unref0 (_tmp1923_); - _tmp1924_ = ccall; - _tmp1925_ = message; - _tmp1926_ = string_replace (_tmp1925_, "\n", " "); + gchar* _tmp1932_; + gchar* _tmp1933_; + gchar* _tmp1934_; + gchar* _tmp1935_; + ValaCCodeConstant* _tmp1936_; + ValaCCodeConstant* _tmp1937_; + _tmp1909_ = vala_code_node_get_source_reference ((ValaCodeNode*) expr); + _tmp1910_ = _tmp1909_; + vala_source_reference_get_begin (_tmp1910_, &_tmp1911_); + _tmp1912_ = _tmp1911_; + _tmp1913_ = _tmp1912_.pos; + _tmp1914_ = vala_code_node_get_source_reference ((ValaCodeNode*) expr); + _tmp1915_ = _tmp1914_; + vala_source_reference_get_end (_tmp1915_, &_tmp1916_); + _tmp1917_ = _tmp1916_; + _tmp1918_ = _tmp1917_.pos; + _tmp1919_ = vala_code_node_get_source_reference ((ValaCodeNode*) expr); + _tmp1920_ = _tmp1919_; + vala_source_reference_get_begin (_tmp1920_, &_tmp1921_); + _tmp1922_ = _tmp1921_; + _tmp1923_ = _tmp1922_.pos; + _tmp1924_ = string_substring ((const gchar*) _tmp1913_, (glong) 0, (glong) ((gint) (_tmp1918_ - _tmp1923_))); + message = _tmp1924_; + _tmp1925_ = ccall; + _tmp1926_ = vala_ccode_identifier_new ("_vala_assert"); _tmp1927_ = _tmp1926_; - _tmp1928_ = g_strescape (_tmp1927_, ""); - _tmp1929_ = _tmp1928_; - _tmp1930_ = g_strdup_printf ("\"%s\"", _tmp1929_); + vala_ccode_function_call_set_call (_tmp1925_, (ValaCCodeExpression*) _tmp1927_); + _vala_ccode_node_unref0 (_tmp1927_); + _tmp1928_ = ccall; + _tmp1929_ = message; + _tmp1930_ = string_replace (_tmp1929_, "\n", " "); _tmp1931_ = _tmp1930_; - _tmp1932_ = vala_ccode_constant_new (_tmp1931_); + _tmp1932_ = g_strescape (_tmp1931_, ""); _tmp1933_ = _tmp1932_; - vala_ccode_function_call_add_argument (_tmp1924_, (ValaCCodeExpression*) _tmp1933_); - _vala_ccode_node_unref0 (_tmp1933_); + _tmp1934_ = g_strdup_printf ("\"%s\"", _tmp1933_); + _tmp1935_ = _tmp1934_; + _tmp1936_ = vala_ccode_constant_new (_tmp1935_); + _tmp1937_ = _tmp1936_; + vala_ccode_function_call_add_argument (_tmp1928_, (ValaCCodeExpression*) _tmp1937_); + _vala_ccode_node_unref0 (_tmp1937_); + _g_free0 (_tmp1935_); + _g_free0 (_tmp1933_); _g_free0 (_tmp1931_); - _g_free0 (_tmp1929_); - _g_free0 (_tmp1927_); ((ValaCCodeBaseModule*) self)->requires_assert = TRUE; _g_free0 (message); } collection_type = NULL; - _tmp1935_ = ma; - if (_tmp1935_ != NULL) { - ValaMemberAccess* _tmp1936_; - ValaExpression* _tmp1937_; - ValaExpression* _tmp1938_; - _tmp1936_ = ma; - _tmp1937_ = vala_member_access_get_inner (_tmp1936_); - _tmp1938_ = _tmp1937_; - _tmp1934_ = _tmp1938_ != NULL; + _tmp1939_ = ma; + if (_tmp1939_ != NULL) { + ValaMemberAccess* _tmp1940_; + ValaExpression* _tmp1941_; + ValaExpression* _tmp1942_; + _tmp1940_ = ma; + _tmp1941_ = vala_member_access_get_inner (_tmp1940_); + _tmp1942_ = _tmp1941_; + _tmp1938_ = _tmp1942_ != NULL; } else { - _tmp1934_ = FALSE; + _tmp1938_ = FALSE; } - if (_tmp1934_) { - ValaMemberAccess* _tmp1939_; - ValaExpression* _tmp1940_; - ValaExpression* _tmp1941_; - ValaDataType* _tmp1942_; - ValaDataType* _tmp1943_; - _tmp1939_ = ma; - _tmp1940_ = vala_member_access_get_inner (_tmp1939_); - _tmp1941_ = _tmp1940_; - _tmp1942_ = vala_expression_get_value_type (_tmp1941_); - _tmp1943_ = _tmp1942_; - collection_type = _tmp1943_; - } - _tmp1947_ = collection_type; - if (_tmp1947_ != NULL) { - gboolean _tmp1948_ = FALSE; - gboolean _tmp1949_ = FALSE; - ValaDataType* _tmp1950_; - ValaTypeSymbol* _tmp1951_; - ValaTypeSymbol* _tmp1952_; - ValaClass* _tmp1953_; - _tmp1950_ = collection_type; - _tmp1951_ = vala_data_type_get_type_symbol (_tmp1950_); - _tmp1952_ = _tmp1951_; - _tmp1953_ = ((ValaCCodeBaseModule*) self)->glist_type; - if (_tmp1952_ == G_TYPE_CHECK_INSTANCE_CAST (_tmp1953_, VALA_TYPE_TYPESYMBOL, ValaTypeSymbol)) { - _tmp1949_ = TRUE; - } else { - ValaDataType* _tmp1954_; - ValaTypeSymbol* _tmp1955_; - ValaTypeSymbol* _tmp1956_; - ValaClass* _tmp1957_; - _tmp1954_ = collection_type; - _tmp1955_ = vala_data_type_get_type_symbol (_tmp1954_); - _tmp1956_ = _tmp1955_; - _tmp1957_ = ((ValaCCodeBaseModule*) self)->gslist_type; - _tmp1949_ = _tmp1956_ == G_TYPE_CHECK_INSTANCE_CAST (_tmp1957_, VALA_TYPE_TYPESYMBOL, ValaTypeSymbol); - } - if (_tmp1949_) { - _tmp1948_ = TRUE; + if (_tmp1938_) { + ValaMemberAccess* _tmp1943_; + ValaExpression* _tmp1944_; + ValaExpression* _tmp1945_; + ValaDataType* _tmp1946_; + ValaDataType* _tmp1947_; + _tmp1943_ = ma; + _tmp1944_ = vala_member_access_get_inner (_tmp1943_); + _tmp1945_ = _tmp1944_; + _tmp1946_ = vala_expression_get_value_type (_tmp1945_); + _tmp1947_ = _tmp1946_; + collection_type = _tmp1947_; + } + _tmp1951_ = collection_type; + if (_tmp1951_ != NULL) { + gboolean _tmp1952_ = FALSE; + gboolean _tmp1953_ = FALSE; + ValaDataType* _tmp1954_; + ValaTypeSymbol* _tmp1955_; + ValaTypeSymbol* _tmp1956_; + ValaClass* _tmp1957_; + _tmp1954_ = collection_type; + _tmp1955_ = vala_data_type_get_type_symbol (_tmp1954_); + _tmp1956_ = _tmp1955_; + _tmp1957_ = ((ValaCCodeBaseModule*) self)->glist_type; + if (_tmp1956_ == G_TYPE_CHECK_INSTANCE_CAST (_tmp1957_, VALA_TYPE_TYPESYMBOL, ValaTypeSymbol)) { + _tmp1953_ = TRUE; } else { ValaDataType* _tmp1958_; ValaTypeSymbol* _tmp1959_; @@ -6142,652 +6145,665 @@ _tmp1958_ = collection_type; _tmp1959_ = vala_data_type_get_type_symbol (_tmp1958_); _tmp1960_ = _tmp1959_; - _tmp1961_ = ((ValaCCodeBaseModule*) self)->gqueue_type; - _tmp1948_ = _tmp1960_ == G_TYPE_CHECK_INSTANCE_CAST (_tmp1961_, VALA_TYPE_TYPESYMBOL, ValaTypeSymbol); + _tmp1961_ = ((ValaCCodeBaseModule*) self)->gslist_type; + _tmp1953_ = _tmp1960_ == G_TYPE_CHECK_INSTANCE_CAST (_tmp1961_, VALA_TYPE_TYPESYMBOL, ValaTypeSymbol); + } + if (_tmp1953_) { + _tmp1952_ = TRUE; + } else { + ValaDataType* _tmp1962_; + ValaTypeSymbol* _tmp1963_; + ValaTypeSymbol* _tmp1964_; + ValaClass* _tmp1965_; + _tmp1962_ = collection_type; + _tmp1963_ = vala_data_type_get_type_symbol (_tmp1962_); + _tmp1964_ = _tmp1963_; + _tmp1965_ = ((ValaCCodeBaseModule*) self)->gqueue_type; + _tmp1952_ = _tmp1964_ == G_TYPE_CHECK_INSTANCE_CAST (_tmp1965_, VALA_TYPE_TYPESYMBOL, ValaTypeSymbol); } - _tmp1946_ = _tmp1948_; + _tmp1950_ = _tmp1952_; } else { - _tmp1946_ = FALSE; + _tmp1950_ = FALSE; } - if (_tmp1946_) { - gboolean _tmp1962_ = FALSE; - ValaMemberAccess* _tmp1963_; - const gchar* _tmp1964_; - const gchar* _tmp1965_; - _tmp1963_ = ma; - _tmp1964_ = vala_member_access_get_member_name (_tmp1963_); - _tmp1965_ = _tmp1964_; - if (g_strcmp0 (_tmp1965_, "remove") == 0) { - _tmp1962_ = TRUE; - } else { - ValaMemberAccess* _tmp1966_; - const gchar* _tmp1967_; - const gchar* _tmp1968_; - _tmp1966_ = ma; - _tmp1967_ = vala_member_access_get_member_name (_tmp1966_); - _tmp1968_ = _tmp1967_; - _tmp1962_ = g_strcmp0 (_tmp1968_, "remove_all") == 0; + if (_tmp1950_) { + gboolean _tmp1966_ = FALSE; + ValaMemberAccess* _tmp1967_; + const gchar* _tmp1968_; + const gchar* _tmp1969_; + _tmp1967_ = ma; + _tmp1968_ = vala_member_access_get_member_name (_tmp1967_); + _tmp1969_ = _tmp1968_; + if (g_strcmp0 (_tmp1969_, "remove") == 0) { + _tmp1966_ = TRUE; + } else { + ValaMemberAccess* _tmp1970_; + const gchar* _tmp1971_; + const gchar* _tmp1972_; + _tmp1970_ = ma; + _tmp1971_ = vala_member_access_get_member_name (_tmp1970_); + _tmp1972_ = _tmp1971_; + _tmp1966_ = g_strcmp0 (_tmp1972_, "remove_all") == 0; } - _tmp1945_ = _tmp1962_; + _tmp1949_ = _tmp1966_; } else { - _tmp1945_ = FALSE; + _tmp1949_ = FALSE; } - if (_tmp1945_) { - ValaDataType* _tmp1969_; - ValaCodeContext* _tmp1970_; - ValaCodeContext* _tmp1971_; - _tmp1969_ = collection_type; - _tmp1970_ = vala_ccode_base_module_get_context ((ValaCCodeBaseModule*) self); - _tmp1971_ = _tmp1970_; - _tmp1944_ = vala_data_type_check_type_arguments (_tmp1969_, _tmp1971_, FALSE); + if (_tmp1949_) { + ValaDataType* _tmp1973_; + ValaCodeContext* _tmp1974_; + ValaCodeContext* _tmp1975_; + _tmp1973_ = collection_type; + _tmp1974_ = vala_ccode_base_module_get_context ((ValaCCodeBaseModule*) self); + _tmp1975_ = _tmp1974_; + _tmp1948_ = vala_data_type_check_type_arguments (_tmp1973_, _tmp1975_, FALSE); } else { - _tmp1944_ = FALSE; + _tmp1948_ = FALSE; } - if (_tmp1944_) { + if (_tmp1948_) { ValaMethod* remove_method = NULL; - ValaDataType* _tmp1972_; - ValaTypeSymbol* _tmp1973_; - ValaTypeSymbol* _tmp1974_; - ValaScope* _tmp1975_; - ValaScope* _tmp1976_; - ValaMemberAccess* _tmp1977_; - const gchar* _tmp1978_; - const gchar* _tmp1979_; - gchar* _tmp1980_; - gchar* _tmp1981_; - ValaSymbol* _tmp1982_; - ValaMethod* _tmp1983_; + ValaDataType* _tmp1976_; + ValaTypeSymbol* _tmp1977_; + ValaTypeSymbol* _tmp1978_; + ValaScope* _tmp1979_; + ValaScope* _tmp1980_; + ValaMemberAccess* _tmp1981_; + const gchar* _tmp1982_; + const gchar* _tmp1983_; + gchar* _tmp1984_; + gchar* _tmp1985_; + ValaSymbol* _tmp1986_; + ValaMethod* _tmp1987_; ValaDataType* type_arg = NULL; - ValaDataType* _tmp1984_; - ValaList* _tmp1985_; - gpointer _tmp1986_; - gboolean _tmp1987_ = FALSE; - ValaMethod* _tmp1988_; - _tmp1972_ = collection_type; - _tmp1973_ = vala_data_type_get_type_symbol (_tmp1972_); - _tmp1974_ = _tmp1973_; - _tmp1975_ = vala_symbol_get_scope ((ValaSymbol*) _tmp1974_); - _tmp1976_ = _tmp1975_; - _tmp1977_ = ma; - _tmp1978_ = vala_member_access_get_member_name (_tmp1977_); - _tmp1979_ = _tmp1978_; - _tmp1980_ = g_strconcat (_tmp1979_, "_full", NULL); - _tmp1981_ = _tmp1980_; - _tmp1982_ = vala_scope_lookup (_tmp1976_, _tmp1981_); - _tmp1983_ = G_TYPE_CHECK_INSTANCE_CAST (_tmp1982_, VALA_TYPE_METHOD, ValaMethod); - _g_free0 (_tmp1981_); - remove_method = _tmp1983_; - _tmp1984_ = collection_type; - _tmp1985_ = vala_data_type_get_type_arguments (_tmp1984_); - _tmp1986_ = vala_list_get (_tmp1985_, 0); - type_arg = (ValaDataType*) _tmp1986_; - _tmp1988_ = remove_method; - if (_tmp1988_ != NULL) { - ValaDataType* _tmp1989_; - _tmp1989_ = type_arg; - _tmp1987_ = vala_ccode_base_module_requires_destroy (_tmp1989_); - } else { - _tmp1987_ = FALSE; - } - if (_tmp1987_) { - ValaMethod* _tmp1990_; - ValaCCodeFunctionCall* _tmp1992_; - ValaMethod* _tmp1993_; - gchar* _tmp1994_; - gchar* _tmp1995_; - ValaCCodeIdentifier* _tmp1996_; - ValaCCodeIdentifier* _tmp1997_; - ValaCCodeFunctionCall* _tmp1998_; - ValaDataType* _tmp1999_; - ValaCCodeExpression* _tmp2000_; - ValaCCodeExpression* _tmp2001_; - _tmp1990_ = remove_method; - if (vala_ccode_base_module_add_generated_external_symbol ((ValaCCodeBaseModule*) self, (ValaSymbol*) _tmp1990_)) { - ValaMethod* _tmp1991_; - _tmp1991_ = remove_method; - vala_code_visitor_visit_method ((ValaCodeVisitor*) self, _tmp1991_); - } - _tmp1992_ = ccall; - _tmp1993_ = remove_method; - _tmp1994_ = vala_get_ccode_name ((ValaCodeNode*) _tmp1993_); - _tmp1995_ = _tmp1994_; - _tmp1996_ = vala_ccode_identifier_new (_tmp1995_); - _tmp1997_ = _tmp1996_; - vala_ccode_function_call_set_call (_tmp1992_, (ValaCCodeExpression*) _tmp1997_); - _vala_ccode_node_unref0 (_tmp1997_); - _g_free0 (_tmp1995_); - _tmp1998_ = ccall; - _tmp1999_ = type_arg; - _tmp2000_ = vala_ccode_base_module_get_destroy0_func_expression ((ValaCCodeBaseModule*) self, _tmp1999_, FALSE); + ValaDataType* _tmp1988_; + ValaList* _tmp1989_; + gpointer _tmp1990_; + gboolean _tmp1991_ = FALSE; + ValaMethod* _tmp1992_; + _tmp1976_ = collection_type; + _tmp1977_ = vala_data_type_get_type_symbol (_tmp1976_); + _tmp1978_ = _tmp1977_; + _tmp1979_ = vala_symbol_get_scope ((ValaSymbol*) _tmp1978_); + _tmp1980_ = _tmp1979_; + _tmp1981_ = ma; + _tmp1982_ = vala_member_access_get_member_name (_tmp1981_); + _tmp1983_ = _tmp1982_; + _tmp1984_ = g_strconcat (_tmp1983_, "_full", NULL); + _tmp1985_ = _tmp1984_; + _tmp1986_ = vala_scope_lookup (_tmp1980_, _tmp1985_); + _tmp1987_ = G_TYPE_CHECK_INSTANCE_CAST (_tmp1986_, VALA_TYPE_METHOD, ValaMethod); + _g_free0 (_tmp1985_); + remove_method = _tmp1987_; + _tmp1988_ = collection_type; + _tmp1989_ = vala_data_type_get_type_arguments (_tmp1988_); + _tmp1990_ = vala_list_get (_tmp1989_, 0); + type_arg = (ValaDataType*) _tmp1990_; + _tmp1992_ = remove_method; + if (_tmp1992_ != NULL) { + ValaDataType* _tmp1993_; + _tmp1993_ = type_arg; + _tmp1991_ = vala_ccode_base_module_requires_destroy (_tmp1993_); + } else { + _tmp1991_ = FALSE; + } + if (_tmp1991_) { + ValaMethod* _tmp1994_; + ValaCCodeFunctionCall* _tmp1996_; + ValaMethod* _tmp1997_; + gchar* _tmp1998_; + gchar* _tmp1999_; + ValaCCodeIdentifier* _tmp2000_; + ValaCCodeIdentifier* _tmp2001_; + ValaCCodeFunctionCall* _tmp2002_; + ValaDataType* _tmp2003_; + ValaCCodeExpression* _tmp2004_; + ValaCCodeExpression* _tmp2005_; + _tmp1994_ = remove_method; + if (vala_ccode_base_module_add_generated_external_symbol ((ValaCCodeBaseModule*) self, (ValaSymbol*) _tmp1994_)) { + ValaMethod* _tmp1995_; + _tmp1995_ = remove_method; + vala_code_visitor_visit_method ((ValaCodeVisitor*) self, _tmp1995_); + } + _tmp1996_ = ccall; + _tmp1997_ = remove_method; + _tmp1998_ = vala_get_ccode_name ((ValaCodeNode*) _tmp1997_); + _tmp1999_ = _tmp1998_; + _tmp2000_ = vala_ccode_identifier_new (_tmp1999_); _tmp2001_ = _tmp2000_; - vala_ccode_function_call_add_argument (_tmp1998_, _tmp2001_); + vala_ccode_function_call_set_call (_tmp1996_, (ValaCCodeExpression*) _tmp2001_); _vala_ccode_node_unref0 (_tmp2001_); + _g_free0 (_tmp1999_); + _tmp2002_ = ccall; + _tmp2003_ = type_arg; + _tmp2004_ = vala_ccode_base_module_get_destroy0_func_expression ((ValaCCodeBaseModule*) self, _tmp2003_, FALSE); + _tmp2005_ = _tmp2004_; + vala_ccode_function_call_add_argument (_tmp2002_, _tmp2005_); + _vala_ccode_node_unref0 (_tmp2005_); } _vala_code_node_unref0 (type_arg); _vala_code_node_unref0 (remove_method); } if (return_result_via_out_param) { - ValaCCodeFunction* _tmp2002_; - ValaCCodeFunction* _tmp2003_; - ValaCCodeExpression* _tmp2004_; - ValaCCodeExpression* _tmp2005_; - ValaCCodeExpression* _tmp2006_; - _tmp2002_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); - _tmp2003_ = _tmp2002_; - _tmp2004_ = ccall_expr; - vala_ccode_function_add_expression (_tmp2003_, _tmp2004_); - _tmp2005_ = out_param_ref; - _tmp2006_ = _vala_ccode_node_ref0 (_tmp2005_); + ValaCCodeFunction* _tmp2006_; + ValaCCodeFunction* _tmp2007_; + ValaCCodeExpression* _tmp2008_; + ValaCCodeExpression* _tmp2009_; + ValaCCodeExpression* _tmp2010_; + _tmp2006_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp2007_ = _tmp2006_; + _tmp2008_ = ccall_expr; + vala_ccode_function_add_expression (_tmp2007_, _tmp2008_); + _tmp2009_ = out_param_ref; + _tmp2010_ = _vala_ccode_node_ref0 (_tmp2009_); _vala_ccode_node_unref0 (ccall_expr); - ccall_expr = _tmp2006_; + ccall_expr = _tmp2010_; } - _tmp2009_ = m; - if (_tmp2009_ != NULL) { - ValaMethod* _tmp2010_; - ValaMemberBinding _tmp2011_; - ValaMemberBinding _tmp2012_; - _tmp2010_ = m; - _tmp2011_ = vala_method_get_binding (_tmp2010_); - _tmp2012_ = _tmp2011_; - _tmp2008_ = _tmp2012_ == VALA_MEMBER_BINDING_INSTANCE; + _tmp2013_ = m; + if (_tmp2013_ != NULL) { + ValaMethod* _tmp2014_; + ValaMemberBinding _tmp2015_; + ValaMemberBinding _tmp2016_; + _tmp2014_ = m; + _tmp2015_ = vala_method_get_binding (_tmp2014_); + _tmp2016_ = _tmp2015_; + _tmp2012_ = _tmp2016_ == VALA_MEMBER_BINDING_INSTANCE; } else { - _tmp2008_ = FALSE; + _tmp2012_ = FALSE; } - if (_tmp2008_) { - ValaMethod* _tmp2013_; - gboolean _tmp2014_; - gboolean _tmp2015_; - _tmp2013_ = m; - _tmp2014_ = vala_method_get_returns_modified_pointer (_tmp2013_); - _tmp2015_ = _tmp2014_; - _tmp2007_ = _tmp2015_; + if (_tmp2012_) { + ValaMethod* _tmp2017_; + gboolean _tmp2018_; + gboolean _tmp2019_; + _tmp2017_ = m; + _tmp2018_ = vala_method_get_returns_modified_pointer (_tmp2017_); + _tmp2019_ = _tmp2018_; + _tmp2011_ = _tmp2019_; } else { - _tmp2007_ = FALSE; + _tmp2011_ = FALSE; } - if (_tmp2007_) { - gboolean _tmp2016_ = FALSE; - gboolean _tmp2017_ = FALSE; - ValaMemberAccess* _tmp2018_; - _tmp2018_ = ma; - if (_tmp2018_ != NULL) { - ValaMemberAccess* _tmp2019_; - ValaExpression* _tmp2020_; - ValaExpression* _tmp2021_; - ValaSymbol* _tmp2022_; - ValaSymbol* _tmp2023_; - _tmp2019_ = ma; - _tmp2020_ = vala_member_access_get_inner (_tmp2019_); - _tmp2021_ = _tmp2020_; - _tmp2022_ = vala_expression_get_symbol_reference (_tmp2021_); - _tmp2023_ = _tmp2022_; - _tmp2017_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp2023_, VALA_TYPE_PROPERTY); + if (_tmp2011_) { + gboolean _tmp2020_ = FALSE; + gboolean _tmp2021_ = FALSE; + ValaMemberAccess* _tmp2022_; + _tmp2022_ = ma; + if (_tmp2022_ != NULL) { + ValaMemberAccess* _tmp2023_; + ValaExpression* _tmp2024_; + ValaExpression* _tmp2025_; + ValaSymbol* _tmp2026_; + ValaSymbol* _tmp2027_; + _tmp2023_ = ma; + _tmp2024_ = vala_member_access_get_inner (_tmp2023_); + _tmp2025_ = _tmp2024_; + _tmp2026_ = vala_expression_get_symbol_reference (_tmp2025_); + _tmp2027_ = _tmp2026_; + _tmp2021_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp2027_, VALA_TYPE_PROPERTY); } else { - _tmp2017_ = FALSE; + _tmp2021_ = FALSE; } - if (_tmp2017_) { - ValaMemberAccess* _tmp2024_; - ValaExpression* _tmp2025_; - ValaExpression* _tmp2026_; - _tmp2024_ = ma; - _tmp2025_ = vala_member_access_get_inner (_tmp2024_); - _tmp2026_ = _tmp2025_; - _tmp2016_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp2026_, VALA_TYPE_MEMBER_ACCESS); + if (_tmp2021_) { + ValaMemberAccess* _tmp2028_; + ValaExpression* _tmp2029_; + ValaExpression* _tmp2030_; + _tmp2028_ = ma; + _tmp2029_ = vala_member_access_get_inner (_tmp2028_); + _tmp2030_ = _tmp2029_; + _tmp2020_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp2030_, VALA_TYPE_MEMBER_ACCESS); } else { - _tmp2016_ = FALSE; + _tmp2020_ = FALSE; } - if (_tmp2016_) { + if (_tmp2020_) { ValaProperty* prop = NULL; - ValaMemberAccess* _tmp2027_; - ValaExpression* _tmp2028_; - ValaExpression* _tmp2029_; - ValaSymbol* _tmp2030_; - ValaSymbol* _tmp2031_; - ValaProperty* _tmp2032_; - ValaProperty* _tmp2033_; - ValaMemberAccess* _tmp2034_; - ValaExpression* _tmp2035_; - ValaExpression* _tmp2036_; - ValaExpression* _tmp2037_; - ValaExpression* _tmp2038_; - ValaDataType* _tmp2039_; - ValaDataType* _tmp2040_; - ValaCCodeExpression* _tmp2041_; - ValaGLibValue* _tmp2042_; - ValaGLibValue* _tmp2043_; - _tmp2027_ = ma; - _tmp2028_ = vala_member_access_get_inner (_tmp2027_); - _tmp2029_ = _tmp2028_; - _tmp2030_ = vala_expression_get_symbol_reference (_tmp2029_); - _tmp2031_ = _tmp2030_; - _tmp2032_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp2031_, VALA_TYPE_PROPERTY, ValaProperty)); - prop = _tmp2032_; - _tmp2033_ = prop; - _tmp2034_ = ma; - _tmp2035_ = vala_member_access_get_inner (_tmp2034_); - _tmp2036_ = _tmp2035_; - _tmp2037_ = vala_member_access_get_inner (G_TYPE_CHECK_INSTANCE_CAST (_tmp2036_, VALA_TYPE_MEMBER_ACCESS, ValaMemberAccess)); - _tmp2038_ = _tmp2037_; - _tmp2039_ = vala_expression_get_value_type ((ValaExpression*) expr); + ValaMemberAccess* _tmp2031_; + ValaExpression* _tmp2032_; + ValaExpression* _tmp2033_; + ValaSymbol* _tmp2034_; + ValaSymbol* _tmp2035_; + ValaProperty* _tmp2036_; + ValaProperty* _tmp2037_; + ValaMemberAccess* _tmp2038_; + ValaExpression* _tmp2039_; + ValaExpression* _tmp2040_; + ValaExpression* _tmp2041_; + ValaExpression* _tmp2042_; + ValaDataType* _tmp2043_; + ValaDataType* _tmp2044_; + ValaCCodeExpression* _tmp2045_; + ValaGLibValue* _tmp2046_; + ValaGLibValue* _tmp2047_; + _tmp2031_ = ma; + _tmp2032_ = vala_member_access_get_inner (_tmp2031_); + _tmp2033_ = _tmp2032_; + _tmp2034_ = vala_expression_get_symbol_reference (_tmp2033_); + _tmp2035_ = _tmp2034_; + _tmp2036_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp2035_, VALA_TYPE_PROPERTY, ValaProperty)); + prop = _tmp2036_; + _tmp2037_ = prop; + _tmp2038_ = ma; + _tmp2039_ = vala_member_access_get_inner (_tmp2038_); _tmp2040_ = _tmp2039_; - _tmp2041_ = ccall_expr; - _tmp2042_ = vala_glib_value_new (_tmp2040_, _tmp2041_, FALSE); - _tmp2043_ = _tmp2042_; - vala_ccode_base_module_store_property ((ValaCCodeBaseModule*) self, _tmp2033_, _tmp2038_, (ValaTargetValue*) _tmp2043_); - _vala_target_value_unref0 (_tmp2043_); + _tmp2041_ = vala_member_access_get_inner (G_TYPE_CHECK_INSTANCE_CAST (_tmp2040_, VALA_TYPE_MEMBER_ACCESS, ValaMemberAccess)); + _tmp2042_ = _tmp2041_; + _tmp2043_ = vala_expression_get_value_type ((ValaExpression*) expr); + _tmp2044_ = _tmp2043_; + _tmp2045_ = ccall_expr; + _tmp2046_ = vala_glib_value_new (_tmp2044_, _tmp2045_, FALSE); + _tmp2047_ = _tmp2046_; + vala_ccode_base_module_store_property ((ValaCCodeBaseModule*) self, _tmp2037_, _tmp2042_, (ValaTargetValue*) _tmp2047_); + _vala_target_value_unref0 (_tmp2047_); _vala_ccode_node_unref0 (ccall_expr); ccall_expr = NULL; _vala_code_node_unref0 (prop); } else { - ValaCCodeExpression* _tmp2044_; - ValaCCodeExpression* _tmp2045_; - ValaCCodeAssignment* _tmp2046_; - _tmp2044_ = instance; - _tmp2045_ = ccall_expr; - _tmp2046_ = vala_ccode_assignment_new (_tmp2044_, _tmp2045_, VALA_CCODE_ASSIGNMENT_OPERATOR_SIMPLE); + ValaCCodeExpression* _tmp2048_; + ValaCCodeExpression* _tmp2049_; + ValaCCodeAssignment* _tmp2050_; + _tmp2048_ = instance; + _tmp2049_ = ccall_expr; + _tmp2050_ = vala_ccode_assignment_new (_tmp2048_, _tmp2049_, VALA_CCODE_ASSIGNMENT_OPERATOR_SIMPLE); _vala_ccode_node_unref0 (ccall_expr); - ccall_expr = (ValaCCodeExpression*) _tmp2046_; + ccall_expr = (ValaCCodeExpression*) _tmp2050_; } } - _tmp2052_ = m; - if (_tmp2052_ != NULL) { - ValaMethod* _tmp2053_; - _tmp2053_ = m; - _tmp2051_ = vala_get_ccode_simple_generics (_tmp2053_); - } else { - _tmp2051_ = FALSE; - } - if (_tmp2051_) { - ValaMethod* _tmp2054_; - ValaDataType* _tmp2055_; - ValaDataType* _tmp2056_; - _tmp2054_ = m; - _tmp2055_ = vala_callable_get_return_type ((ValaCallable*) _tmp2054_); - _tmp2056_ = _tmp2055_; - _tmp2050_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp2056_, VALA_TYPE_GENERIC_TYPE); - } else { - _tmp2050_ = FALSE; - } - if (_tmp2050_) { - ValaDataType* _tmp2057_; - ValaDataType* _tmp2058_; - _tmp2057_ = vala_expression_get_value_type ((ValaExpression*) expr); - _tmp2058_ = _tmp2057_; - _tmp2049_ = vala_data_type_is_real_struct_type (_tmp2058_); + _tmp2056_ = m; + if (_tmp2056_ != NULL) { + ValaMethod* _tmp2057_; + _tmp2057_ = m; + _tmp2055_ = vala_get_ccode_simple_generics (_tmp2057_); } else { - _tmp2049_ = FALSE; + _tmp2055_ = FALSE; } - if (_tmp2049_) { + if (_tmp2055_) { + ValaMethod* _tmp2058_; ValaDataType* _tmp2059_; ValaDataType* _tmp2060_; - gboolean _tmp2061_; - gboolean _tmp2062_; - _tmp2059_ = vala_expression_get_value_type ((ValaExpression*) expr); + _tmp2058_ = m; + _tmp2059_ = vala_callable_get_return_type ((ValaCallable*) _tmp2058_); _tmp2060_ = _tmp2059_; - _tmp2061_ = vala_data_type_get_nullable (_tmp2060_); + _tmp2054_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp2060_, VALA_TYPE_GENERIC_TYPE); + } else { + _tmp2054_ = FALSE; + } + if (_tmp2054_) { + ValaDataType* _tmp2061_; + ValaDataType* _tmp2062_; + _tmp2061_ = vala_expression_get_value_type ((ValaExpression*) expr); _tmp2062_ = _tmp2061_; - _tmp2048_ = !_tmp2062_; + _tmp2053_ = vala_data_type_is_real_struct_type (_tmp2062_); } else { - _tmp2048_ = FALSE; + _tmp2053_ = FALSE; } - if (_tmp2048_) { + if (_tmp2053_) { ValaDataType* _tmp2063_; ValaDataType* _tmp2064_; + gboolean _tmp2065_; + gboolean _tmp2066_; _tmp2063_ = vala_expression_get_value_type ((ValaExpression*) expr); _tmp2064_ = _tmp2063_; - _tmp2047_ = !G_TYPE_CHECK_INSTANCE_TYPE (_tmp2064_, VALA_TYPE_POINTER_TYPE); + _tmp2065_ = vala_data_type_get_nullable (_tmp2064_); + _tmp2066_ = _tmp2065_; + _tmp2052_ = !_tmp2066_; } else { - _tmp2047_ = FALSE; + _tmp2052_ = FALSE; } - if (_tmp2047_) { - ValaCCodeExpression* _tmp2065_; - ValaCCodeParenthesizedExpression* _tmp2066_; - ValaCCodeParenthesizedExpression* _tmp2067_; - ValaCCodeUnaryExpression* _tmp2068_; - _tmp2065_ = ccall_expr; - _tmp2066_ = vala_ccode_parenthesized_expression_new (_tmp2065_); - _tmp2067_ = _tmp2066_; - _tmp2068_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_POINTER_INDIRECTION, (ValaCCodeExpression*) _tmp2067_); + if (_tmp2052_) { + ValaDataType* _tmp2067_; + ValaDataType* _tmp2068_; + _tmp2067_ = vala_expression_get_value_type ((ValaExpression*) expr); + _tmp2068_ = _tmp2067_; + _tmp2051_ = !G_TYPE_CHECK_INSTANCE_TYPE (_tmp2068_, VALA_TYPE_POINTER_TYPE); + } else { + _tmp2051_ = FALSE; + } + if (_tmp2051_) { + ValaCCodeExpression* _tmp2069_; + ValaCCodeParenthesizedExpression* _tmp2070_; + ValaCCodeParenthesizedExpression* _tmp2071_; + ValaCCodeUnaryExpression* _tmp2072_; + _tmp2069_ = ccall_expr; + _tmp2070_ = vala_ccode_parenthesized_expression_new (_tmp2069_); + _tmp2071_ = _tmp2070_; + _tmp2072_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_POINTER_INDIRECTION, (ValaCCodeExpression*) _tmp2071_); _vala_ccode_node_unref0 (ccall_expr); - ccall_expr = (ValaCCodeExpression*) _tmp2068_; - _vala_ccode_node_unref0 (_tmp2067_); + ccall_expr = (ValaCCodeExpression*) _tmp2072_; + _vala_ccode_node_unref0 (_tmp2071_); } - _tmp2071_ = m; - if (_tmp2071_ != NULL) { - ValaMethod* _tmp2072_; - gchar* _tmp2073_; - gchar* _tmp2074_; - _tmp2072_ = m; - _tmp2073_ = vala_get_ccode_type ((ValaCodeNode*) _tmp2072_); - _tmp2074_ = _tmp2073_; - _tmp2070_ = _tmp2074_ != NULL; - _g_free0 (_tmp2074_); + _tmp2075_ = m; + if (_tmp2075_ != NULL) { + ValaMethod* _tmp2076_; + gchar* _tmp2077_; + gchar* _tmp2078_; + _tmp2076_ = m; + _tmp2077_ = vala_get_ccode_type ((ValaCodeNode*) _tmp2076_); + _tmp2078_ = _tmp2077_; + _tmp2074_ = _tmp2078_ != NULL; + _g_free0 (_tmp2078_); } else { - _tmp2070_ = FALSE; + _tmp2074_ = FALSE; } - if (_tmp2070_) { - ValaMethod* _tmp2075_; - gchar* _tmp2076_; - gchar* _tmp2077_; - ValaMethod* _tmp2078_; - ValaDataType* _tmp2079_; - ValaDataType* _tmp2080_; + if (_tmp2074_) { + ValaMethod* _tmp2079_; + gchar* _tmp2080_; gchar* _tmp2081_; - gchar* _tmp2082_; - _tmp2075_ = m; - _tmp2076_ = vala_get_ccode_type ((ValaCodeNode*) _tmp2075_); - _tmp2077_ = _tmp2076_; - _tmp2078_ = m; - _tmp2079_ = vala_callable_get_return_type ((ValaCallable*) _tmp2078_); - _tmp2080_ = _tmp2079_; - _tmp2081_ = vala_get_ccode_name ((ValaCodeNode*) _tmp2080_); - _tmp2082_ = _tmp2081_; - _tmp2069_ = g_strcmp0 (_tmp2077_, _tmp2082_) != 0; - _g_free0 (_tmp2082_); - _g_free0 (_tmp2077_); + ValaMethod* _tmp2082_; + ValaDataType* _tmp2083_; + ValaDataType* _tmp2084_; + gchar* _tmp2085_; + gchar* _tmp2086_; + _tmp2079_ = m; + _tmp2080_ = vala_get_ccode_type ((ValaCodeNode*) _tmp2079_); + _tmp2081_ = _tmp2080_; + _tmp2082_ = m; + _tmp2083_ = vala_callable_get_return_type ((ValaCallable*) _tmp2082_); + _tmp2084_ = _tmp2083_; + _tmp2085_ = vala_get_ccode_name ((ValaCodeNode*) _tmp2084_); + _tmp2086_ = _tmp2085_; + _tmp2073_ = g_strcmp0 (_tmp2081_, _tmp2086_) != 0; + _g_free0 (_tmp2086_); + _g_free0 (_tmp2081_); } else { - _tmp2069_ = FALSE; + _tmp2073_ = FALSE; } - if (_tmp2069_) { - ValaCCodeExpression* _tmp2083_; - ValaMethod* _tmp2084_; - ValaDataType* _tmp2085_; - ValaDataType* _tmp2086_; - gchar* _tmp2087_; - gchar* _tmp2088_; - ValaCCodeCastExpression* _tmp2089_; - _tmp2083_ = ccall_expr; - _tmp2084_ = m; - _tmp2085_ = vala_callable_get_return_type ((ValaCallable*) _tmp2084_); - _tmp2086_ = _tmp2085_; - _tmp2087_ = vala_get_ccode_name ((ValaCodeNode*) _tmp2086_); - _tmp2088_ = _tmp2087_; - _tmp2089_ = vala_ccode_cast_expression_new (_tmp2083_, _tmp2088_); + if (_tmp2073_) { + ValaCCodeExpression* _tmp2087_; + ValaMethod* _tmp2088_; + ValaDataType* _tmp2089_; + ValaDataType* _tmp2090_; + gchar* _tmp2091_; + gchar* _tmp2092_; + ValaCCodeCastExpression* _tmp2093_; + _tmp2087_ = ccall_expr; + _tmp2088_ = m; + _tmp2089_ = vala_callable_get_return_type ((ValaCallable*) _tmp2088_); + _tmp2090_ = _tmp2089_; + _tmp2091_ = vala_get_ccode_name ((ValaCodeNode*) _tmp2090_); + _tmp2092_ = _tmp2091_; + _tmp2093_ = vala_ccode_cast_expression_new (_tmp2087_, _tmp2092_); _vala_ccode_node_unref0 (ccall_expr); - ccall_expr = (ValaCCodeExpression*) _tmp2089_; - _g_free0 (_tmp2088_); + ccall_expr = (ValaCCodeExpression*) _tmp2093_; + _g_free0 (_tmp2092_); } - _tmp2090_ = m; - if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp2090_, VALA_TYPE_ARRAY_RESIZE_METHOD)) { + _tmp2094_ = m; + if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp2094_, VALA_TYPE_ARRAY_RESIZE_METHOD)) { ValaIterator* arg_it = NULL; - ValaList* _tmp2091_; - ValaIterator* _tmp2092_; - ValaIterator* _tmp2093_; + ValaList* _tmp2095_; + ValaIterator* _tmp2096_; + ValaIterator* _tmp2097_; ValaCCodeExpression* new_size = NULL; - ValaIterator* _tmp2094_; - gpointer _tmp2095_; - ValaExpression* _tmp2096_; - ValaCCodeExpression* _tmp2097_; - ValaCCodeExpression* _tmp2098_; - ValaCCodeExpression* _tmp2099_; + ValaIterator* _tmp2098_; + gpointer _tmp2099_; + ValaExpression* _tmp2100_; + ValaCCodeExpression* _tmp2101_; + ValaCCodeExpression* _tmp2102_; + ValaCCodeExpression* _tmp2103_; ValaArrayType* array_type = NULL; - ValaMemberAccess* _tmp2100_; - ValaExpression* _tmp2101_; - ValaExpression* _tmp2102_; - ValaDataType* _tmp2103_; - ValaDataType* _tmp2104_; - ValaArrayType* _tmp2105_; - ValaLocalVariable* temp_decl = NULL; - ValaArrayType* _tmp2106_; + ValaMemberAccess* _tmp2104_; + ValaExpression* _tmp2105_; + ValaExpression* _tmp2106_; ValaDataType* _tmp2107_; ValaDataType* _tmp2108_; - ValaLocalVariable* _tmp2109_; + ValaArrayType* _tmp2109_; + ValaLocalVariable* temp_decl = NULL; + ValaArrayType* _tmp2110_; + ValaDataType* _tmp2111_; + ValaDataType* _tmp2112_; + ValaLocalVariable* _tmp2113_; ValaCCodeExpression* temp_ref = NULL; - ValaLocalVariable* _tmp2110_; - const gchar* _tmp2111_; - const gchar* _tmp2112_; - ValaCCodeExpression* _tmp2113_; ValaLocalVariable* _tmp2114_; - ValaCCodeFile* _tmp2115_; + const gchar* _tmp2115_; + const gchar* _tmp2116_; + ValaCCodeExpression* _tmp2117_; + ValaLocalVariable* _tmp2118_; + ValaCCodeFile* _tmp2119_; ValaCCodeExpression* clen = NULL; - ValaMemberAccess* _tmp2116_; - ValaExpression* _tmp2117_; - ValaExpression* _tmp2118_; - ValaCCodeExpression* _tmp2119_; - ValaCCodeExpression* celems = NULL; ValaMemberAccess* _tmp2120_; ValaExpression* _tmp2121_; ValaExpression* _tmp2122_; ValaCCodeExpression* _tmp2123_; - ValaCCodeExpression* _tmp2124_; + ValaCCodeExpression* celems = NULL; + ValaMemberAccess* _tmp2124_; + ValaExpression* _tmp2125_; + ValaExpression* _tmp2126_; + ValaCCodeExpression* _tmp2127_; + ValaCCodeExpression* _tmp2128_; ValaCCodeIdentifier* csizeof = NULL; - ValaArrayType* _tmp2125_; - ValaDataType* _tmp2126_; - ValaDataType* _tmp2127_; - gchar* _tmp2128_; - gchar* _tmp2129_; - gchar* _tmp2130_; - gchar* _tmp2131_; - ValaCCodeIdentifier* _tmp2132_; - ValaCCodeIdentifier* _tmp2133_; + ValaArrayType* _tmp2129_; + ValaDataType* _tmp2130_; + ValaDataType* _tmp2131_; + gchar* _tmp2132_; + gchar* _tmp2133_; + gchar* _tmp2134_; + gchar* _tmp2135_; + ValaCCodeIdentifier* _tmp2136_; + ValaCCodeIdentifier* _tmp2137_; ValaCCodeBinaryExpression* cdelta = NULL; - ValaCCodeExpression* _tmp2134_; - ValaCCodeExpression* _tmp2135_; - ValaCCodeBinaryExpression* _tmp2136_; - ValaCCodeBinaryExpression* ccheck = NULL; - ValaCCodeExpression* _tmp2137_; ValaCCodeExpression* _tmp2138_; - ValaCCodeBinaryExpression* _tmp2139_; + ValaCCodeExpression* _tmp2139_; + ValaCCodeBinaryExpression* _tmp2140_; + ValaCCodeBinaryExpression* ccheck = NULL; + ValaCCodeExpression* _tmp2141_; + ValaCCodeExpression* _tmp2142_; + ValaCCodeBinaryExpression* _tmp2143_; ValaCCodeFunctionCall* czero = NULL; - ValaCCodeIdentifier* _tmp2140_; - ValaCCodeIdentifier* _tmp2141_; - ValaCCodeFunctionCall* _tmp2142_; - ValaCCodeFunctionCall* _tmp2143_; - ValaCCodeFunctionCall* _tmp2144_; - ValaCCodeExpression* _tmp2145_; - ValaCCodeExpression* _tmp2146_; - ValaCCodeBinaryExpression* _tmp2147_; - ValaCCodeBinaryExpression* _tmp2148_; - ValaCCodeFunctionCall* _tmp2149_; - ValaCCodeConstant* _tmp2150_; - ValaCCodeConstant* _tmp2151_; - ValaCCodeFunctionCall* _tmp2152_; - ValaCCodeIdentifier* _tmp2153_; - ValaCCodeBinaryExpression* _tmp2154_; - ValaCCodeBinaryExpression* _tmp2155_; - ValaCCodeBinaryExpression* _tmp2156_; - ValaCCodeFunction* _tmp2157_; - ValaCCodeFunction* _tmp2158_; - ValaCCodeExpression* _tmp2159_; - ValaCCodeExpression* _tmp2160_; + ValaCCodeIdentifier* _tmp2144_; + ValaCCodeIdentifier* _tmp2145_; + ValaCCodeFunctionCall* _tmp2146_; + ValaCCodeFunctionCall* _tmp2147_; + ValaCCodeFunctionCall* _tmp2148_; + ValaCCodeExpression* _tmp2149_; + ValaCCodeExpression* _tmp2150_; + ValaCCodeBinaryExpression* _tmp2151_; + ValaCCodeBinaryExpression* _tmp2152_; + ValaCCodeFunctionCall* _tmp2153_; + ValaCCodeConstant* _tmp2154_; + ValaCCodeConstant* _tmp2155_; + ValaCCodeFunctionCall* _tmp2156_; + ValaCCodeIdentifier* _tmp2157_; + ValaCCodeBinaryExpression* _tmp2158_; + ValaCCodeBinaryExpression* _tmp2159_; + ValaCCodeBinaryExpression* _tmp2160_; ValaCCodeFunction* _tmp2161_; ValaCCodeFunction* _tmp2162_; ValaCCodeExpression* _tmp2163_; - ValaCCodeFunction* _tmp2164_; + ValaCCodeExpression* _tmp2164_; ValaCCodeFunction* _tmp2165_; - ValaCCodeBinaryExpression* _tmp2166_; - ValaCCodeFunctionCall* _tmp2167_; - ValaCCodeConstant* _tmp2168_; - ValaCCodeConstant* _tmp2169_; - ValaCCodeConditionalExpression* _tmp2170_; - ValaCCodeConditionalExpression* _tmp2171_; - ValaCCodeFunction* _tmp2172_; - ValaCCodeFunction* _tmp2173_; - ValaMemberAccess* _tmp2174_; - ValaExpression* _tmp2175_; - ValaExpression* _tmp2176_; - ValaCCodeExpression* _tmp2177_; - ValaCCodeExpression* _tmp2178_; - ValaCCodeExpression* _tmp2179_; + ValaCCodeFunction* _tmp2166_; + ValaCCodeExpression* _tmp2167_; + ValaCCodeFunction* _tmp2168_; + ValaCCodeFunction* _tmp2169_; + ValaCCodeBinaryExpression* _tmp2170_; + ValaCCodeFunctionCall* _tmp2171_; + ValaCCodeConstant* _tmp2172_; + ValaCCodeConstant* _tmp2173_; + ValaCCodeConditionalExpression* _tmp2174_; + ValaCCodeConditionalExpression* _tmp2175_; + ValaCCodeFunction* _tmp2176_; + ValaCCodeFunction* _tmp2177_; + ValaMemberAccess* _tmp2178_; + ValaExpression* _tmp2179_; + ValaExpression* _tmp2180_; + ValaCCodeExpression* _tmp2181_; + ValaCCodeExpression* _tmp2182_; + ValaCCodeExpression* _tmp2183_; ValaSymbol* array_var = NULL; - ValaMemberAccess* _tmp2180_; - ValaExpression* _tmp2181_; - ValaExpression* _tmp2182_; - ValaSymbol* _tmp2183_; - ValaSymbol* _tmp2184_; - ValaSymbol* _tmp2185_; - gboolean _tmp2186_ = FALSE; - gboolean _tmp2187_ = FALSE; + ValaMemberAccess* _tmp2184_; + ValaExpression* _tmp2185_; + ValaExpression* _tmp2186_; + ValaSymbol* _tmp2187_; ValaSymbol* _tmp2188_; - _tmp2091_ = vala_callable_expression_get_argument_list ((ValaCallableExpression*) expr); - _tmp2092_ = vala_iterable_iterator ((ValaIterable*) _tmp2091_); - arg_it = _tmp2092_; - _tmp2093_ = arg_it; - vala_iterator_next (_tmp2093_); - _tmp2094_ = arg_it; - _tmp2095_ = vala_iterator_get (_tmp2094_); - _tmp2096_ = (ValaExpression*) _tmp2095_; - _tmp2097_ = vala_get_cvalue (_tmp2096_); - _tmp2098_ = _vala_ccode_node_ref0 (_tmp2097_); - _tmp2099_ = _tmp2098_; - _vala_code_node_unref0 (_tmp2096_); - new_size = _tmp2099_; - _tmp2100_ = ma; - _tmp2101_ = vala_member_access_get_inner (_tmp2100_); - _tmp2102_ = _tmp2101_; - _tmp2103_ = vala_expression_get_value_type (_tmp2102_); - _tmp2104_ = _tmp2103_; - _tmp2105_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp2104_, VALA_TYPE_ARRAY_TYPE, ValaArrayType)); - array_type = _tmp2105_; - _tmp2106_ = array_type; - _tmp2107_ = vala_array_type_get_length_type (_tmp2106_); + ValaSymbol* _tmp2189_; + gboolean _tmp2190_ = FALSE; + gboolean _tmp2191_ = FALSE; + ValaSymbol* _tmp2192_; + _tmp2095_ = vala_callable_expression_get_argument_list ((ValaCallableExpression*) expr); + _tmp2096_ = vala_iterable_iterator ((ValaIterable*) _tmp2095_); + arg_it = _tmp2096_; + _tmp2097_ = arg_it; + vala_iterator_next (_tmp2097_); + _tmp2098_ = arg_it; + _tmp2099_ = vala_iterator_get (_tmp2098_); + _tmp2100_ = (ValaExpression*) _tmp2099_; + _tmp2101_ = vala_get_cvalue (_tmp2100_); + _tmp2102_ = _vala_ccode_node_ref0 (_tmp2101_); + _tmp2103_ = _tmp2102_; + _vala_code_node_unref0 (_tmp2100_); + new_size = _tmp2103_; + _tmp2104_ = ma; + _tmp2105_ = vala_member_access_get_inner (_tmp2104_); + _tmp2106_ = _tmp2105_; + _tmp2107_ = vala_expression_get_value_type (_tmp2106_); _tmp2108_ = _tmp2107_; - _tmp2109_ = vala_ccode_base_module_get_temp_variable ((ValaCCodeBaseModule*) self, _tmp2108_, TRUE, NULL, FALSE); - temp_decl = _tmp2109_; - _tmp2110_ = temp_decl; - _tmp2111_ = vala_symbol_get_name ((ValaSymbol*) _tmp2110_); + _tmp2109_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp2108_, VALA_TYPE_ARRAY_TYPE, ValaArrayType)); + array_type = _tmp2109_; + _tmp2110_ = array_type; + _tmp2111_ = vala_array_type_get_length_type (_tmp2110_); _tmp2112_ = _tmp2111_; - _tmp2113_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, _tmp2112_); - temp_ref = _tmp2113_; + _tmp2113_ = vala_ccode_base_module_get_temp_variable ((ValaCCodeBaseModule*) self, _tmp2112_, TRUE, NULL, FALSE); + temp_decl = _tmp2113_; _tmp2114_ = temp_decl; - vala_ccode_base_module_emit_temp_var ((ValaCCodeBaseModule*) self, _tmp2114_, FALSE); - _tmp2115_ = ((ValaCCodeBaseModule*) self)->cfile; - vala_ccode_file_add_include (_tmp2115_, "string.h", FALSE); - _tmp2116_ = ma; - _tmp2117_ = vala_member_access_get_inner (_tmp2116_); - _tmp2118_ = _tmp2117_; - _tmp2119_ = vala_ccode_base_module_get_array_length_cexpression ((ValaCCodeBaseModule*) self, _tmp2118_, 1); - clen = _tmp2119_; + _tmp2115_ = vala_symbol_get_name ((ValaSymbol*) _tmp2114_); + _tmp2116_ = _tmp2115_; + _tmp2117_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, _tmp2116_); + temp_ref = _tmp2117_; + _tmp2118_ = temp_decl; + vala_ccode_base_module_emit_temp_var ((ValaCCodeBaseModule*) self, _tmp2118_, FALSE); + _tmp2119_ = ((ValaCCodeBaseModule*) self)->cfile; + vala_ccode_file_add_include (_tmp2119_, "string.h", FALSE); _tmp2120_ = ma; _tmp2121_ = vala_member_access_get_inner (_tmp2120_); _tmp2122_ = _tmp2121_; - _tmp2123_ = vala_get_cvalue (_tmp2122_); - _tmp2124_ = _vala_ccode_node_ref0 (_tmp2123_); - celems = _tmp2124_; - _tmp2125_ = array_type; - _tmp2126_ = vala_array_type_get_element_type (_tmp2125_); - _tmp2127_ = _tmp2126_; - _tmp2128_ = vala_get_ccode_name ((ValaCodeNode*) _tmp2127_); - _tmp2129_ = _tmp2128_; - _tmp2130_ = g_strdup_printf ("sizeof (%s)", _tmp2129_); + _tmp2123_ = vala_ccode_base_module_get_array_length_cexpression ((ValaCCodeBaseModule*) self, _tmp2122_, 1); + clen = _tmp2123_; + _tmp2124_ = ma; + _tmp2125_ = vala_member_access_get_inner (_tmp2124_); + _tmp2126_ = _tmp2125_; + _tmp2127_ = vala_get_cvalue (_tmp2126_); + _tmp2128_ = _vala_ccode_node_ref0 (_tmp2127_); + celems = _tmp2128_; + _tmp2129_ = array_type; + _tmp2130_ = vala_array_type_get_element_type (_tmp2129_); _tmp2131_ = _tmp2130_; - _tmp2132_ = vala_ccode_identifier_new (_tmp2131_); + _tmp2132_ = vala_get_ccode_name ((ValaCodeNode*) _tmp2131_); _tmp2133_ = _tmp2132_; - _g_free0 (_tmp2131_); - _g_free0 (_tmp2129_); - csizeof = _tmp2133_; - _tmp2134_ = temp_ref; - _tmp2135_ = clen; - _tmp2136_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_MINUS, _tmp2134_, _tmp2135_); - cdelta = _tmp2136_; - _tmp2137_ = temp_ref; - _tmp2138_ = clen; - _tmp2139_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_GREATER_THAN, _tmp2137_, _tmp2138_); - ccheck = _tmp2139_; - _tmp2140_ = vala_ccode_identifier_new ("memset"); - _tmp2141_ = _tmp2140_; - _tmp2142_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp2141_); - _tmp2143_ = _tmp2142_; - _vala_ccode_node_unref0 (_tmp2141_); - czero = _tmp2143_; - _tmp2144_ = czero; - _tmp2145_ = celems; - _tmp2146_ = clen; - _tmp2147_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_PLUS, _tmp2145_, _tmp2146_); - _tmp2148_ = _tmp2147_; - vala_ccode_function_call_add_argument (_tmp2144_, (ValaCCodeExpression*) _tmp2148_); - _vala_ccode_node_unref0 (_tmp2148_); - _tmp2149_ = czero; - _tmp2150_ = vala_ccode_constant_new ("0"); - _tmp2151_ = _tmp2150_; - vala_ccode_function_call_add_argument (_tmp2149_, (ValaCCodeExpression*) _tmp2151_); - _vala_ccode_node_unref0 (_tmp2151_); - _tmp2152_ = czero; - _tmp2153_ = csizeof; - _tmp2154_ = cdelta; - _tmp2155_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_MUL, (ValaCCodeExpression*) _tmp2153_, (ValaCCodeExpression*) _tmp2154_); - _tmp2156_ = _tmp2155_; - vala_ccode_function_call_add_argument (_tmp2152_, (ValaCCodeExpression*) _tmp2156_); - _vala_ccode_node_unref0 (_tmp2156_); - _tmp2157_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); - _tmp2158_ = _tmp2157_; - _tmp2159_ = temp_ref; - _tmp2160_ = new_size; - vala_ccode_function_add_assignment (_tmp2158_, _tmp2159_, _tmp2160_); + _tmp2134_ = g_strdup_printf ("sizeof (%s)", _tmp2133_); + _tmp2135_ = _tmp2134_; + _tmp2136_ = vala_ccode_identifier_new (_tmp2135_); + _tmp2137_ = _tmp2136_; + _g_free0 (_tmp2135_); + _g_free0 (_tmp2133_); + csizeof = _tmp2137_; + _tmp2138_ = temp_ref; + _tmp2139_ = clen; + _tmp2140_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_MINUS, _tmp2138_, _tmp2139_); + cdelta = _tmp2140_; + _tmp2141_ = temp_ref; + _tmp2142_ = clen; + _tmp2143_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_GREATER_THAN, _tmp2141_, _tmp2142_); + ccheck = _tmp2143_; + _tmp2144_ = vala_ccode_identifier_new ("memset"); + _tmp2145_ = _tmp2144_; + _tmp2146_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp2145_); + _tmp2147_ = _tmp2146_; + _vala_ccode_node_unref0 (_tmp2145_); + czero = _tmp2147_; + _tmp2148_ = czero; + _tmp2149_ = celems; + _tmp2150_ = clen; + _tmp2151_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_PLUS, _tmp2149_, _tmp2150_); + _tmp2152_ = _tmp2151_; + vala_ccode_function_call_add_argument (_tmp2148_, (ValaCCodeExpression*) _tmp2152_); + _vala_ccode_node_unref0 (_tmp2152_); + _tmp2153_ = czero; + _tmp2154_ = vala_ccode_constant_new ("0"); + _tmp2155_ = _tmp2154_; + vala_ccode_function_call_add_argument (_tmp2153_, (ValaCCodeExpression*) _tmp2155_); + _vala_ccode_node_unref0 (_tmp2155_); + _tmp2156_ = czero; + _tmp2157_ = csizeof; + _tmp2158_ = cdelta; + _tmp2159_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_MUL, (ValaCCodeExpression*) _tmp2157_, (ValaCCodeExpression*) _tmp2158_); + _tmp2160_ = _tmp2159_; + vala_ccode_function_call_add_argument (_tmp2156_, (ValaCCodeExpression*) _tmp2160_); + _vala_ccode_node_unref0 (_tmp2160_); _tmp2161_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); _tmp2162_ = _tmp2161_; - _tmp2163_ = ccall_expr; - vala_ccode_function_add_expression (_tmp2162_, _tmp2163_); - _tmp2164_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); - _tmp2165_ = _tmp2164_; - _tmp2166_ = ccheck; - _tmp2167_ = czero; - _tmp2168_ = vala_ccode_constant_new ("NULL"); + _tmp2163_ = temp_ref; + _tmp2164_ = new_size; + vala_ccode_function_add_assignment (_tmp2162_, _tmp2163_, _tmp2164_); + _tmp2165_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp2166_ = _tmp2165_; + _tmp2167_ = ccall_expr; + vala_ccode_function_add_expression (_tmp2166_, _tmp2167_); + _tmp2168_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); _tmp2169_ = _tmp2168_; - _tmp2170_ = vala_ccode_conditional_expression_new ((ValaCCodeExpression*) _tmp2166_, (ValaCCodeExpression*) _tmp2167_, (ValaCCodeExpression*) _tmp2169_); - _tmp2171_ = _tmp2170_; - vala_ccode_function_add_expression (_tmp2165_, (ValaCCodeExpression*) _tmp2171_); - _vala_ccode_node_unref0 (_tmp2171_); - _vala_ccode_node_unref0 (_tmp2169_); - _tmp2172_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp2170_ = ccheck; + _tmp2171_ = czero; + _tmp2172_ = vala_ccode_constant_new ("NULL"); _tmp2173_ = _tmp2172_; - _tmp2174_ = ma; - _tmp2175_ = vala_member_access_get_inner (_tmp2174_); - _tmp2176_ = _tmp2175_; - _tmp2177_ = vala_ccode_base_module_get_array_length_cexpression ((ValaCCodeBaseModule*) self, _tmp2176_, 1); - _tmp2178_ = _tmp2177_; - _tmp2179_ = temp_ref; - vala_ccode_function_add_assignment (_tmp2173_, _tmp2178_, _tmp2179_); - _vala_ccode_node_unref0 (_tmp2178_); - _tmp2180_ = ma; - _tmp2181_ = vala_member_access_get_inner (_tmp2180_); + _tmp2174_ = vala_ccode_conditional_expression_new ((ValaCCodeExpression*) _tmp2170_, (ValaCCodeExpression*) _tmp2171_, (ValaCCodeExpression*) _tmp2173_); + _tmp2175_ = _tmp2174_; + vala_ccode_function_add_expression (_tmp2169_, (ValaCCodeExpression*) _tmp2175_); + _vala_ccode_node_unref0 (_tmp2175_); + _vala_ccode_node_unref0 (_tmp2173_); + _tmp2176_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp2177_ = _tmp2176_; + _tmp2178_ = ma; + _tmp2179_ = vala_member_access_get_inner (_tmp2178_); + _tmp2180_ = _tmp2179_; + _tmp2181_ = vala_ccode_base_module_get_array_length_cexpression ((ValaCCodeBaseModule*) self, _tmp2180_, 1); _tmp2182_ = _tmp2181_; - _tmp2183_ = vala_expression_get_symbol_reference (_tmp2182_); - _tmp2184_ = _tmp2183_; - _tmp2185_ = _vala_code_node_ref0 (_tmp2184_); - array_var = _tmp2185_; - _tmp2188_ = array_var; - if (_tmp2188_ != NULL) { - ValaSymbol* _tmp2189_; - _tmp2189_ = array_var; - _tmp2187_ = vala_symbol_is_internal_symbol (_tmp2189_); - } else { - _tmp2187_ = FALSE; - } - if (_tmp2187_) { - gboolean _tmp2190_ = FALSE; - ValaSymbol* _tmp2191_; - _tmp2191_ = array_var; - if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp2191_, VALA_TYPE_LOCAL_VARIABLE)) { - _tmp2190_ = TRUE; - } else { - ValaSymbol* _tmp2192_; - _tmp2192_ = array_var; - _tmp2190_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp2192_, VALA_TYPE_FIELD); - } - _tmp2186_ = _tmp2190_; - } else { - _tmp2186_ = FALSE; - } - if (_tmp2186_) { - ValaCCodeFunction* _tmp2193_; - ValaCCodeFunction* _tmp2194_; - ValaMemberAccess* _tmp2195_; - ValaExpression* _tmp2196_; - ValaExpression* _tmp2197_; - ValaTargetValue* _tmp2198_; - ValaTargetValue* _tmp2199_; - ValaCCodeExpression* _tmp2200_; - ValaCCodeExpression* _tmp2201_; - _tmp2193_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); - _tmp2194_ = _tmp2193_; - _tmp2195_ = ma; - _tmp2196_ = vala_member_access_get_inner (_tmp2195_); - _tmp2197_ = _tmp2196_; - _tmp2198_ = vala_expression_get_target_value (_tmp2197_); - _tmp2199_ = _tmp2198_; - _tmp2200_ = vala_get_array_size_cvalue (_tmp2199_); - _tmp2201_ = temp_ref; - vala_ccode_function_add_assignment (_tmp2194_, _tmp2200_, _tmp2201_); + _tmp2183_ = temp_ref; + vala_ccode_function_add_assignment (_tmp2177_, _tmp2182_, _tmp2183_); + _vala_ccode_node_unref0 (_tmp2182_); + _tmp2184_ = ma; + _tmp2185_ = vala_member_access_get_inner (_tmp2184_); + _tmp2186_ = _tmp2185_; + _tmp2187_ = vala_expression_get_symbol_reference (_tmp2186_); + _tmp2188_ = _tmp2187_; + _tmp2189_ = _vala_code_node_ref0 (_tmp2188_); + array_var = _tmp2189_; + _tmp2192_ = array_var; + if (_tmp2192_ != NULL) { + ValaSymbol* _tmp2193_; + _tmp2193_ = array_var; + _tmp2191_ = vala_symbol_is_internal_symbol (_tmp2193_); + } else { + _tmp2191_ = FALSE; + } + if (_tmp2191_) { + gboolean _tmp2194_ = FALSE; + ValaSymbol* _tmp2195_; + _tmp2195_ = array_var; + if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp2195_, VALA_TYPE_LOCAL_VARIABLE)) { + _tmp2194_ = TRUE; + } else { + ValaSymbol* _tmp2196_; + _tmp2196_ = array_var; + _tmp2194_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp2196_, VALA_TYPE_FIELD); + } + _tmp2190_ = _tmp2194_; + } else { + _tmp2190_ = FALSE; + } + if (_tmp2190_) { + ValaCCodeFunction* _tmp2197_; + ValaCCodeFunction* _tmp2198_; + ValaMemberAccess* _tmp2199_; + ValaExpression* _tmp2200_; + ValaExpression* _tmp2201_; + ValaTargetValue* _tmp2202_; + ValaTargetValue* _tmp2203_; + ValaCCodeExpression* _tmp2204_; + ValaCCodeExpression* _tmp2205_; + _tmp2197_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp2198_ = _tmp2197_; + _tmp2199_ = ma; + _tmp2200_ = vala_member_access_get_inner (_tmp2199_); + _tmp2201_ = _tmp2200_; + _tmp2202_ = vala_expression_get_target_value (_tmp2201_); + _tmp2203_ = _tmp2202_; + _tmp2204_ = vala_get_array_size_cvalue (_tmp2203_); + _tmp2205_ = temp_ref; + vala_ccode_function_add_assignment (_tmp2198_, _tmp2204_, _tmp2205_); } _vala_code_node_unref0 (array_var); _vala_ccode_node_unref0 (czero); @@ -6817,736 +6833,946 @@ _vala_ccode_node_unref0 (ccall); return; } - _tmp2203_ = vala_code_node_get_parent_node ((ValaCodeNode*) expr); - _tmp2204_ = _tmp2203_; - if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp2204_, VALA_TYPE_EXPRESSION_STATEMENT)) { - ValaDataType* _tmp2205_; - ValaDataType* _tmp2206_; - _tmp2205_ = vala_expression_get_value_type ((ValaExpression*) expr); - _tmp2206_ = _tmp2205_; - _tmp2202_ = !vala_data_type_is_disposable (_tmp2206_); + _tmp2207_ = vala_code_node_get_parent_node ((ValaCodeNode*) expr); + _tmp2208_ = _tmp2207_; + if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp2208_, VALA_TYPE_EXPRESSION_STATEMENT)) { + ValaDataType* _tmp2209_; + ValaDataType* _tmp2210_; + _tmp2209_ = vala_expression_get_value_type ((ValaExpression*) expr); + _tmp2210_ = _tmp2209_; + _tmp2206_ = !vala_data_type_is_disposable (_tmp2210_); } else { - _tmp2202_ = FALSE; + _tmp2206_ = FALSE; } - if (_tmp2202_) { - gboolean _tmp2207_ = FALSE; - ValaCCodeExpression* _tmp2208_; - _tmp2208_ = ccall_expr; - if (_tmp2208_ != NULL) { - _tmp2207_ = !return_result_via_out_param; - } else { - _tmp2207_ = FALSE; - } - if (_tmp2207_) { - ValaCCodeFunction* _tmp2209_; - ValaCCodeFunction* _tmp2210_; - ValaCCodeExpression* _tmp2211_; - _tmp2209_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); - _tmp2210_ = _tmp2209_; - _tmp2211_ = ccall_expr; - vala_ccode_function_add_expression (_tmp2210_, _tmp2211_); + if (_tmp2206_) { + gboolean _tmp2211_ = FALSE; + ValaCCodeExpression* _tmp2212_; + _tmp2212_ = ccall_expr; + if (_tmp2212_ != NULL) { + _tmp2211_ = !return_result_via_out_param; + } else { + _tmp2211_ = FALSE; + } + if (_tmp2211_) { + ValaCCodeFunction* _tmp2213_; + ValaCCodeFunction* _tmp2214_; + ValaCCodeExpression* _tmp2215_; + _tmp2213_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp2214_ = _tmp2213_; + _tmp2215_ = ccall_expr; + vala_ccode_function_add_expression (_tmp2214_, _tmp2215_); } } else { ValaDataType* result_type = NULL; - ValaDataType* _tmp2212_; - ValaDataType* _tmp2213_; - ValaDataType* _tmp2214_; - gboolean _tmp2215_ = FALSE; ValaDataType* _tmp2216_; ValaDataType* _tmp2217_; - gboolean _tmp2270_ = FALSE; - ValaMethod* _tmp2271_; - _tmp2212_ = itype; - _tmp2213_ = vala_data_type_get_return_type (_tmp2212_); - _tmp2214_ = _vala_code_node_ref0 (_tmp2213_); - result_type = _tmp2214_; - _tmp2216_ = vala_expression_get_formal_value_type ((ValaExpression*) expr); - _tmp2217_ = _tmp2216_; - if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp2217_, VALA_TYPE_GENERIC_TYPE)) { - ValaDataType* _tmp2218_; - ValaDataType* _tmp2219_; - _tmp2218_ = vala_expression_get_value_type ((ValaExpression*) expr); - _tmp2219_ = _tmp2218_; - _tmp2215_ = !G_TYPE_CHECK_INSTANCE_TYPE (_tmp2219_, VALA_TYPE_GENERIC_TYPE); + ValaDataType* _tmp2218_; + gboolean _tmp2219_ = FALSE; + ValaDataType* _tmp2220_; + ValaDataType* _tmp2221_; + gboolean _tmp2274_ = FALSE; + ValaMethod* _tmp2275_; + _tmp2216_ = itype; + _tmp2217_ = vala_data_type_get_return_type (_tmp2216_); + _tmp2218_ = _vala_code_node_ref0 (_tmp2217_); + result_type = _tmp2218_; + _tmp2220_ = vala_expression_get_formal_value_type ((ValaExpression*) expr); + _tmp2221_ = _tmp2220_; + if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp2221_, VALA_TYPE_GENERIC_TYPE)) { + ValaDataType* _tmp2222_; + ValaDataType* _tmp2223_; + _tmp2222_ = vala_expression_get_value_type ((ValaExpression*) expr); + _tmp2223_ = _tmp2222_; + _tmp2219_ = !G_TYPE_CHECK_INSTANCE_TYPE (_tmp2223_, VALA_TYPE_GENERIC_TYPE); } else { - _tmp2215_ = FALSE; + _tmp2219_ = FALSE; } - if (_tmp2215_) { + if (_tmp2219_) { ValaTypeParameter* type_parameter = NULL; - ValaDataType* _tmp2220_; - ValaDataType* _tmp2221_; - ValaTypeParameter* _tmp2222_; - ValaTypeParameter* _tmp2223_; - ValaTypeParameter* _tmp2224_; + ValaDataType* _tmp2224_; + ValaDataType* _tmp2225_; + ValaTypeParameter* _tmp2226_; + ValaTypeParameter* _tmp2227_; + ValaTypeParameter* _tmp2228_; ValaStruct* st = NULL; - ValaTypeParameter* _tmp2225_; - ValaSymbol* _tmp2226_; - ValaSymbol* _tmp2227_; - ValaSymbol* _tmp2228_; - ValaSymbol* _tmp2229_; - ValaStruct* _tmp2230_; - gboolean _tmp2231_ = FALSE; - ValaTypeParameter* _tmp2232_; + ValaTypeParameter* _tmp2229_; + ValaSymbol* _tmp2230_; + ValaSymbol* _tmp2231_; + ValaSymbol* _tmp2232_; ValaSymbol* _tmp2233_; - ValaSymbol* _tmp2234_; - ValaClass* _tmp2235_; - gboolean _tmp2244_ = FALSE; - gboolean _tmp2245_ = FALSE; - ValaStruct* _tmp2246_; - _tmp2220_ = vala_expression_get_formal_value_type ((ValaExpression*) expr); - _tmp2221_ = _tmp2220_; - _tmp2222_ = vala_generic_type_get_type_parameter (G_TYPE_CHECK_INSTANCE_CAST (_tmp2221_, VALA_TYPE_GENERIC_TYPE, ValaGenericType)); - _tmp2223_ = _tmp2222_; - _tmp2224_ = _vala_code_node_ref0 (_tmp2223_); - type_parameter = _tmp2224_; - _tmp2225_ = type_parameter; - _tmp2226_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp2225_); + ValaStruct* _tmp2234_; + gboolean _tmp2235_ = FALSE; + ValaTypeParameter* _tmp2236_; + ValaSymbol* _tmp2237_; + ValaSymbol* _tmp2238_; + ValaClass* _tmp2239_; + gboolean _tmp2248_ = FALSE; + gboolean _tmp2249_ = FALSE; + ValaStruct* _tmp2250_; + _tmp2224_ = vala_expression_get_formal_value_type ((ValaExpression*) expr); + _tmp2225_ = _tmp2224_; + _tmp2226_ = vala_generic_type_get_type_parameter (G_TYPE_CHECK_INSTANCE_CAST (_tmp2225_, VALA_TYPE_GENERIC_TYPE, ValaGenericType)); _tmp2227_ = _tmp2226_; - _tmp2228_ = vala_symbol_get_parent_symbol (_tmp2227_); - _tmp2229_ = _tmp2228_; - _tmp2230_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp2229_, VALA_TYPE_STRUCT) ? ((ValaStruct*) _tmp2229_) : NULL); - st = _tmp2230_; - _tmp2232_ = type_parameter; - _tmp2233_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp2232_); - _tmp2234_ = _tmp2233_; - _tmp2235_ = ((ValaCCodeBaseModule*) self)->garray_type; - if (_tmp2234_ == G_TYPE_CHECK_INSTANCE_CAST (_tmp2235_, VALA_TYPE_SYMBOL, ValaSymbol)) { - _tmp2231_ = TRUE; - } else { - gboolean _tmp2236_ = FALSE; - ValaStruct* _tmp2237_; - _tmp2237_ = st; - if (_tmp2237_ != NULL) { - ValaStruct* _tmp2238_; - gchar* _tmp2239_; - gchar* _tmp2240_; - _tmp2238_ = st; - _tmp2239_ = vala_get_ccode_name ((ValaCodeNode*) _tmp2238_); - _tmp2240_ = _tmp2239_; - _tmp2236_ = g_strcmp0 (_tmp2240_, "va_list") == 0; - _g_free0 (_tmp2240_); + _tmp2228_ = _vala_code_node_ref0 (_tmp2227_); + type_parameter = _tmp2228_; + _tmp2229_ = type_parameter; + _tmp2230_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp2229_); + _tmp2231_ = _tmp2230_; + _tmp2232_ = vala_symbol_get_parent_symbol (_tmp2231_); + _tmp2233_ = _tmp2232_; + _tmp2234_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp2233_, VALA_TYPE_STRUCT) ? ((ValaStruct*) _tmp2233_) : NULL); + st = _tmp2234_; + _tmp2236_ = type_parameter; + _tmp2237_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp2236_); + _tmp2238_ = _tmp2237_; + _tmp2239_ = ((ValaCCodeBaseModule*) self)->garray_type; + if (_tmp2238_ == G_TYPE_CHECK_INSTANCE_CAST (_tmp2239_, VALA_TYPE_SYMBOL, ValaSymbol)) { + _tmp2235_ = TRUE; + } else { + gboolean _tmp2240_ = FALSE; + ValaStruct* _tmp2241_; + _tmp2241_ = st; + if (_tmp2241_ != NULL) { + ValaStruct* _tmp2242_; + gchar* _tmp2243_; + gchar* _tmp2244_; + _tmp2242_ = st; + _tmp2243_ = vala_get_ccode_name ((ValaCodeNode*) _tmp2242_); + _tmp2244_ = _tmp2243_; + _tmp2240_ = g_strcmp0 (_tmp2244_, "va_list") == 0; + _g_free0 (_tmp2244_); } else { - _tmp2236_ = FALSE; + _tmp2240_ = FALSE; } - _tmp2231_ = _tmp2236_; + _tmp2235_ = _tmp2240_; } - if (_tmp2231_) { - ValaDataType* _tmp2241_; - ValaDataType* _tmp2242_; - ValaDataType* _tmp2243_; - _tmp2241_ = vala_expression_get_value_type ((ValaExpression*) expr); - _tmp2242_ = _tmp2241_; - _tmp2243_ = _vala_code_node_ref0 (_tmp2242_); + if (_tmp2235_) { + ValaDataType* _tmp2245_; + ValaDataType* _tmp2246_; + ValaDataType* _tmp2247_; + _tmp2245_ = vala_expression_get_value_type ((ValaExpression*) expr); + _tmp2246_ = _tmp2245_; + _tmp2247_ = _vala_code_node_ref0 (_tmp2246_); _vala_code_node_unref0 (result_type); - result_type = _tmp2243_; + result_type = _tmp2247_; } - _tmp2246_ = st; - if (_tmp2246_ != NULL) { - ValaStruct* _tmp2247_; - gchar* _tmp2248_; - gchar* _tmp2249_; - _tmp2247_ = st; - _tmp2248_ = vala_get_ccode_name ((ValaCodeNode*) _tmp2247_); - _tmp2249_ = _tmp2248_; - _tmp2245_ = g_strcmp0 (_tmp2249_, "va_list") == 0; - _g_free0 (_tmp2249_); - } else { - _tmp2245_ = FALSE; - } - if (_tmp2245_) { - ValaMemberAccess* _tmp2250_; - const gchar* _tmp2251_; - const gchar* _tmp2252_; - _tmp2250_ = ma; - _tmp2251_ = vala_member_access_get_member_name (_tmp2250_); - _tmp2252_ = _tmp2251_; - _tmp2244_ = g_strcmp0 (_tmp2252_, "arg") == 0; - } else { - _tmp2244_ = FALSE; - } - if (_tmp2244_) { - gboolean _tmp2253_ = FALSE; - ValaDataType* _tmp2254_; - _tmp2254_ = result_type; - if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp2254_, VALA_TYPE_DELEGATE_TYPE)) { - ValaDataType* _tmp2255_; - ValaDelegate* _tmp2256_; - ValaDelegate* _tmp2257_; - gboolean _tmp2258_; - gboolean _tmp2259_; - _tmp2255_ = result_type; - _tmp2256_ = vala_delegate_type_get_delegate_symbol (G_TYPE_CHECK_INSTANCE_CAST (_tmp2255_, VALA_TYPE_DELEGATE_TYPE, ValaDelegateType)); - _tmp2257_ = _tmp2256_; - _tmp2258_ = vala_delegate_get_has_target (_tmp2257_); - _tmp2259_ = _tmp2258_; - _tmp2253_ = _tmp2259_; + _tmp2250_ = st; + if (_tmp2250_ != NULL) { + ValaStruct* _tmp2251_; + gchar* _tmp2252_; + gchar* _tmp2253_; + _tmp2251_ = st; + _tmp2252_ = vala_get_ccode_name ((ValaCodeNode*) _tmp2251_); + _tmp2253_ = _tmp2252_; + _tmp2249_ = g_strcmp0 (_tmp2253_, "va_list") == 0; + _g_free0 (_tmp2253_); + } else { + _tmp2249_ = FALSE; + } + if (_tmp2249_) { + ValaMemberAccess* _tmp2254_; + const gchar* _tmp2255_; + const gchar* _tmp2256_; + _tmp2254_ = ma; + _tmp2255_ = vala_member_access_get_member_name (_tmp2254_); + _tmp2256_ = _tmp2255_; + _tmp2248_ = g_strcmp0 (_tmp2256_, "arg") == 0; + } else { + _tmp2248_ = FALSE; + } + if (_tmp2248_) { + gboolean _tmp2257_ = FALSE; + ValaDataType* _tmp2258_; + _tmp2258_ = result_type; + if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp2258_, VALA_TYPE_DELEGATE_TYPE)) { + ValaDataType* _tmp2259_; + ValaDelegate* _tmp2260_; + ValaDelegate* _tmp2261_; + gboolean _tmp2262_; + gboolean _tmp2263_; + _tmp2259_ = result_type; + _tmp2260_ = vala_delegate_type_get_delegate_symbol (G_TYPE_CHECK_INSTANCE_CAST (_tmp2259_, VALA_TYPE_DELEGATE_TYPE, ValaDelegateType)); + _tmp2261_ = _tmp2260_; + _tmp2262_ = vala_delegate_get_has_target (_tmp2261_); + _tmp2263_ = _tmp2262_; + _tmp2257_ = _tmp2263_; } else { - _tmp2253_ = FALSE; + _tmp2257_ = FALSE; } - if (_tmp2253_) { + if (_tmp2257_) { ValaGLibValue* arg_value = NULL; - ValaTargetValue* _tmp2260_; - ValaTargetValue* _tmp2261_; - ValaGLibValue* _tmp2262_; - ValaCCodeExpression* _tmp2263_; + ValaTargetValue* _tmp2264_; + ValaTargetValue* _tmp2265_; ValaGLibValue* _tmp2266_; ValaCCodeExpression* _tmp2267_; + ValaGLibValue* _tmp2270_; + ValaCCodeExpression* _tmp2271_; vala_set_cvalue ((ValaExpression*) expr, NULL); - _tmp2260_ = vala_expression_get_target_value ((ValaExpression*) expr); - _tmp2261_ = _tmp2260_; - arg_value = G_TYPE_CHECK_INSTANCE_CAST (_tmp2261_, VALA_TYPE_GLIB_VALUE, ValaGLibValue); - _tmp2262_ = arg_value; - _tmp2263_ = _tmp2262_->delegate_target_cvalue; - if (_tmp2263_ == NULL) { - ValaGLibValue* _tmp2264_; - ValaCCodeConstant* _tmp2265_; - _tmp2264_ = arg_value; - _tmp2265_ = vala_ccode_constant_new ("NULL"); - _vala_ccode_node_unref0 (_tmp2264_->delegate_target_cvalue); - _tmp2264_->delegate_target_cvalue = (ValaCCodeExpression*) _tmp2265_; - } + _tmp2264_ = vala_expression_get_target_value ((ValaExpression*) expr); + _tmp2265_ = _tmp2264_; + arg_value = G_TYPE_CHECK_INSTANCE_CAST (_tmp2265_, VALA_TYPE_GLIB_VALUE, ValaGLibValue); _tmp2266_ = arg_value; - _tmp2267_ = _tmp2266_->delegate_target_destroy_notify_cvalue; + _tmp2267_ = _tmp2266_->delegate_target_cvalue; if (_tmp2267_ == NULL) { ValaGLibValue* _tmp2268_; ValaCCodeConstant* _tmp2269_; _tmp2268_ = arg_value; _tmp2269_ = vala_ccode_constant_new ("NULL"); - _vala_ccode_node_unref0 (_tmp2268_->delegate_target_destroy_notify_cvalue); - _tmp2268_->delegate_target_destroy_notify_cvalue = (ValaCCodeExpression*) _tmp2269_; + _vala_ccode_node_unref0 (_tmp2268_->delegate_target_cvalue); + _tmp2268_->delegate_target_cvalue = (ValaCCodeExpression*) _tmp2269_; + } + _tmp2270_ = arg_value; + _tmp2271_ = _tmp2270_->delegate_target_destroy_notify_cvalue; + if (_tmp2271_ == NULL) { + ValaGLibValue* _tmp2272_; + ValaCCodeConstant* _tmp2273_; + _tmp2272_ = arg_value; + _tmp2273_ = vala_ccode_constant_new ("NULL"); + _vala_ccode_node_unref0 (_tmp2272_->delegate_target_destroy_notify_cvalue); + _tmp2272_->delegate_target_destroy_notify_cvalue = (ValaCCodeExpression*) _tmp2273_; } } } _vala_code_node_unref0 (st); _vala_code_node_unref0 (type_parameter); } - _tmp2271_ = m; - if (_tmp2271_ != NULL) { - ValaMethod* _tmp2272_; - _tmp2272_ = m; - _tmp2270_ = vala_method_get_format_arg_index (_tmp2272_) >= 0; - } else { - _tmp2270_ = FALSE; - } - if (_tmp2270_) { - ValaCCodeExpression* _tmp2273_; - _tmp2273_ = ccall_expr; - vala_set_cvalue ((ValaExpression*) expr, _tmp2273_); - } else { - gboolean _tmp2274_ = FALSE; - ValaMethod* _tmp2275_; - _tmp2275_ = m; - if (_tmp2275_ != NULL) { - ValaMethod* _tmp2276_; - _tmp2276_ = m; - _tmp2274_ = vala_code_node_get_attribute_bool ((ValaCodeNode*) _tmp2276_, "CCode", "use_inplace", FALSE); - } else { - _tmp2274_ = FALSE; - } - if (_tmp2274_) { - ValaCCodeExpression* _tmp2277_; - _tmp2277_ = ccall_expr; - vala_set_cvalue ((ValaExpression*) expr, _tmp2277_); + _tmp2275_ = m; + if (_tmp2275_ != NULL) { + ValaMethod* _tmp2276_; + _tmp2276_ = m; + _tmp2274_ = vala_method_get_format_arg_index (_tmp2276_) >= 0; + } else { + _tmp2274_ = FALSE; + } + if (_tmp2274_) { + ValaCCodeExpression* _tmp2277_; + _tmp2277_ = ccall_expr; + vala_set_cvalue ((ValaExpression*) expr, _tmp2277_); + } else { + gboolean _tmp2278_ = FALSE; + ValaMethod* _tmp2279_; + _tmp2279_ = m; + if (_tmp2279_ != NULL) { + ValaMethod* _tmp2280_; + _tmp2280_ = m; + _tmp2278_ = vala_code_node_get_attribute_bool ((ValaCodeNode*) _tmp2280_, "CCode", "use_inplace", FALSE); + } else { + _tmp2278_ = FALSE; + } + if (_tmp2278_) { + ValaCCodeExpression* _tmp2281_; + _tmp2281_ = ccall_expr; + vala_set_cvalue ((ValaExpression*) expr, _tmp2281_); } else { - gboolean _tmp2278_ = FALSE; - gboolean _tmp2279_ = FALSE; + gboolean _tmp2282_ = FALSE; + gboolean _tmp2283_ = FALSE; if (!return_result_via_out_param) { - _tmp2279_ = !vala_ccode_method_call_module_has_ref_out_argument (self, expr); + _tmp2283_ = !vala_ccode_method_call_module_has_ref_out_argument (self, expr); } else { - _tmp2279_ = FALSE; + _tmp2283_ = FALSE; } - if (_tmp2279_) { - gboolean _tmp2280_ = FALSE; - ValaDataType* _tmp2281_; - _tmp2281_ = result_type; - if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp2281_, VALA_TYPE_VALUE_TYPE)) { - ValaDataType* _tmp2282_; - _tmp2282_ = result_type; - _tmp2280_ = !vala_data_type_is_disposable (_tmp2282_); + if (_tmp2283_) { + gboolean _tmp2284_ = FALSE; + ValaDataType* _tmp2285_; + _tmp2285_ = result_type; + if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp2285_, VALA_TYPE_VALUE_TYPE)) { + ValaDataType* _tmp2286_; + _tmp2286_ = result_type; + _tmp2284_ = !vala_data_type_is_disposable (_tmp2286_); } else { - _tmp2280_ = FALSE; + _tmp2284_ = FALSE; } - _tmp2278_ = _tmp2280_; + _tmp2282_ = _tmp2284_; } else { - _tmp2278_ = FALSE; + _tmp2282_ = FALSE; } - if (_tmp2278_) { - ValaCCodeExpression* _tmp2283_; - _tmp2283_ = ccall_expr; - vala_set_cvalue ((ValaExpression*) expr, _tmp2283_); + if (_tmp2282_) { + ValaCCodeExpression* _tmp2287_; + _tmp2287_ = ccall_expr; + vala_set_cvalue ((ValaExpression*) expr, _tmp2287_); } else { if (!return_result_via_out_param) { ValaLocalVariable* temp_var = NULL; - ValaDataType* _tmp2284_; - ValaDataType* _tmp2285_; - gboolean _tmp2286_; - gboolean _tmp2287_; - ValaLocalVariable* _tmp2288_; + ValaDataType* _tmp2288_; + ValaDataType* _tmp2289_; + gboolean _tmp2290_; + gboolean _tmp2291_; + ValaLocalVariable* _tmp2292_; ValaCCodeExpression* temp_ref = NULL; - ValaLocalVariable* _tmp2289_; - const gchar* _tmp2290_; - const gchar* _tmp2291_; - ValaCCodeExpression* _tmp2292_; ValaLocalVariable* _tmp2293_; - ValaCCodeFunction* _tmp2294_; - ValaCCodeFunction* _tmp2295_; + const gchar* _tmp2294_; + const gchar* _tmp2295_; ValaCCodeExpression* _tmp2296_; - ValaCCodeExpression* _tmp2297_; - ValaCCodeExpression* _tmp2298_; - ValaTargetValue* _tmp2299_; - ValaTargetValue* _tmp2300_; - _tmp2284_ = result_type; - _tmp2285_ = result_type; - _tmp2286_ = vala_data_type_get_value_owned (_tmp2285_); - _tmp2287_ = _tmp2286_; - _tmp2288_ = vala_ccode_base_module_get_temp_variable ((ValaCCodeBaseModule*) self, _tmp2284_, _tmp2287_, NULL, FALSE); - temp_var = _tmp2288_; - _tmp2289_ = temp_var; - _tmp2290_ = vala_symbol_get_name ((ValaSymbol*) _tmp2289_); + ValaLocalVariable* _tmp2297_; + ValaCCodeFunction* _tmp2298_; + ValaCCodeFunction* _tmp2299_; + ValaCCodeExpression* _tmp2300_; + ValaCCodeExpression* _tmp2301_; + ValaCCodeExpression* _tmp2302_; + ValaTargetValue* _tmp2303_; + ValaTargetValue* _tmp2304_; + _tmp2288_ = result_type; + _tmp2289_ = result_type; + _tmp2290_ = vala_data_type_get_value_owned (_tmp2289_); _tmp2291_ = _tmp2290_; - _tmp2292_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, _tmp2291_); - temp_ref = _tmp2292_; + _tmp2292_ = vala_ccode_base_module_get_temp_variable ((ValaCCodeBaseModule*) self, _tmp2288_, _tmp2291_, NULL, FALSE); + temp_var = _tmp2292_; _tmp2293_ = temp_var; - vala_ccode_base_module_emit_temp_var ((ValaCCodeBaseModule*) self, _tmp2293_, FALSE); - _tmp2294_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp2294_ = vala_symbol_get_name ((ValaSymbol*) _tmp2293_); _tmp2295_ = _tmp2294_; - _tmp2296_ = temp_ref; - _tmp2297_ = ccall_expr; - vala_ccode_function_add_assignment (_tmp2295_, _tmp2296_, _tmp2297_); - _tmp2298_ = temp_ref; - vala_set_cvalue ((ValaExpression*) expr, _tmp2298_); - _tmp2299_ = vala_expression_get_target_value ((ValaExpression*) expr); - _tmp2300_ = _tmp2299_; - G_TYPE_CHECK_INSTANCE_CAST (_tmp2300_, VALA_TYPE_GLIB_VALUE, ValaGLibValue)->lvalue = TRUE; + _tmp2296_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, _tmp2295_); + temp_ref = _tmp2296_; + _tmp2297_ = temp_var; + vala_ccode_base_module_emit_temp_var ((ValaCCodeBaseModule*) self, _tmp2297_, FALSE); + _tmp2298_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp2299_ = _tmp2298_; + _tmp2300_ = temp_ref; + _tmp2301_ = ccall_expr; + vala_ccode_function_add_assignment (_tmp2299_, _tmp2300_, _tmp2301_); + _tmp2302_ = temp_ref; + vala_set_cvalue ((ValaExpression*) expr, _tmp2302_); + _tmp2303_ = vala_expression_get_target_value ((ValaExpression*) expr); + _tmp2304_ = _tmp2303_; + G_TYPE_CHECK_INSTANCE_CAST (_tmp2304_, VALA_TYPE_GLIB_VALUE, ValaGLibValue)->lvalue = TRUE; _vala_ccode_node_unref0 (temp_ref); _vala_code_node_unref0 (temp_var); } else { - ValaCCodeExpression* _tmp2301_; - ValaTargetValue* _tmp2302_; - ValaTargetValue* _tmp2303_; - _tmp2301_ = ccall_expr; - vala_set_cvalue ((ValaExpression*) expr, _tmp2301_); - _tmp2302_ = vala_expression_get_target_value ((ValaExpression*) expr); - _tmp2303_ = _tmp2302_; - G_TYPE_CHECK_INSTANCE_CAST (_tmp2303_, VALA_TYPE_GLIB_VALUE, ValaGLibValue)->lvalue = TRUE; + ValaCCodeExpression* _tmp2305_; + ValaTargetValue* _tmp2306_; + ValaTargetValue* _tmp2307_; + _tmp2305_ = ccall_expr; + vala_set_cvalue ((ValaExpression*) expr, _tmp2305_); + _tmp2306_ = vala_expression_get_target_value ((ValaExpression*) expr); + _tmp2307_ = _tmp2306_; + G_TYPE_CHECK_INSTANCE_CAST (_tmp2307_, VALA_TYPE_GLIB_VALUE, ValaGLibValue)->lvalue = TRUE; } } } } _vala_code_node_unref0 (result_type); } - _tmp2304_ = params; - _tmp2305_ = vala_iterable_iterator ((ValaIterable*) _tmp2304_); + _tmp2308_ = params; + _tmp2309_ = vala_iterable_iterator ((ValaIterable*) _tmp2308_); _vala_iterator_unref0 (params_it); - params_it = _tmp2305_; + params_it = _tmp2309_; { ValaList* _arg_list = NULL; - ValaList* _tmp2306_; + ValaList* _tmp2310_; gint _arg_size = 0; - ValaList* _tmp2307_; - gint _tmp2308_; - gint _tmp2309_; + ValaList* _tmp2311_; + gint _tmp2312_; + gint _tmp2313_; gint _arg_index = 0; - _tmp2306_ = vala_callable_expression_get_argument_list ((ValaCallableExpression*) expr); - _arg_list = _tmp2306_; - _tmp2307_ = _arg_list; - _tmp2308_ = vala_collection_get_size ((ValaCollection*) _tmp2307_); - _tmp2309_ = _tmp2308_; - _arg_size = _tmp2309_; + _tmp2310_ = vala_callable_expression_get_argument_list ((ValaCallableExpression*) expr); + _arg_list = _tmp2310_; + _tmp2311_ = _arg_list; + _tmp2312_ = vala_collection_get_size ((ValaCollection*) _tmp2311_); + _tmp2313_ = _tmp2312_; + _arg_size = _tmp2313_; _arg_index = -1; while (TRUE) { - gint _tmp2310_; - gint _tmp2311_; + gint _tmp2314_; + gint _tmp2315_; ValaExpression* arg = NULL; - ValaList* _tmp2312_; - gpointer _tmp2313_; + ValaList* _tmp2316_; + gpointer _tmp2317_; ValaParameter* param = NULL; - ValaIterator* _tmp2314_; + ValaIterator* _tmp2318_; ValaUnaryExpression* unary = NULL; - ValaExpression* _tmp2317_; - ValaUnaryExpression* _tmp2318_; - gboolean _tmp2319_ = FALSE; - ValaUnaryExpression* _tmp2320_; + ValaExpression* _tmp2321_; + ValaUnaryExpression* _tmp2322_; + gboolean _tmp2323_ = FALSE; + gboolean _tmp2324_ = FALSE; + gboolean _tmp2325_ = FALSE; + ValaUnaryExpression* _tmp2326_; + gboolean _tmp2376_ = FALSE; + gboolean _tmp2377_ = FALSE; gboolean _tmp2378_ = FALSE; ValaUnaryExpression* _tmp2379_; - ValaUnaryExpression* _tmp2383_; - ValaExpression* _tmp2384_; - ValaExpression* _tmp2385_; - ValaDataType* _tmp2386_; - ValaDataType* _tmp2387_; - gboolean _tmp2397_ = FALSE; - ValaMemberAccess* _tmp2398_; - ValaSymbol* _tmp2399_; - ValaSymbol* _tmp2400_; - ValaUnaryExpression* _tmp2416_; - ValaExpression* _tmp2417_; - ValaExpression* _tmp2418_; - ValaTargetValue* _tmp2419_; - ValaTargetValue* _tmp2420_; - ValaUnaryExpression* _tmp2421_; - ValaTargetValue* _tmp2422_; - ValaTargetValue* _tmp2423_; - ValaUnaryExpression* _tmp2424_; - ValaExpression* _tmp2425_; - ValaExpression* _tmp2426_; - ValaDataType* _tmp2427_; - ValaDataType* _tmp2428_; - ValaExpression* _tmp2429_; - ValaTargetValue* _tmp2430_; - ValaTargetValue* _tmp2431_; - ValaSourceReference* _tmp2432_; - ValaSourceReference* _tmp2433_; - gboolean _tmp2434_ = FALSE; - ValaParameter* _tmp2435_; + gboolean _tmp2445_ = FALSE; + ValaUnaryExpression* _tmp2446_; + ValaUnaryExpression* _tmp2450_; + ValaExpression* _tmp2451_; + ValaExpression* _tmp2452_; + ValaDataType* _tmp2453_; + ValaDataType* _tmp2454_; + gboolean _tmp2464_ = FALSE; + ValaMemberAccess* _tmp2465_; + ValaSymbol* _tmp2466_; + ValaSymbol* _tmp2467_; + ValaUnaryExpression* _tmp2483_; + ValaExpression* _tmp2484_; + ValaExpression* _tmp2485_; + ValaTargetValue* _tmp2486_; + ValaTargetValue* _tmp2487_; + ValaUnaryExpression* _tmp2488_; + ValaTargetValue* _tmp2489_; + ValaTargetValue* _tmp2490_; + ValaUnaryExpression* _tmp2491_; + ValaExpression* _tmp2492_; + ValaExpression* _tmp2493_; + ValaDataType* _tmp2494_; + ValaDataType* _tmp2495_; + ValaExpression* _tmp2496_; + ValaTargetValue* _tmp2497_; + ValaTargetValue* _tmp2498_; + ValaSourceReference* _tmp2499_; + ValaSourceReference* _tmp2500_; + gboolean _tmp2501_ = FALSE; + gboolean _tmp2502_ = FALSE; + gboolean _tmp2503_ = FALSE; + gboolean _tmp2504_ = FALSE; + ValaParameter* _tmp2505_; _arg_index = _arg_index + 1; - _tmp2310_ = _arg_index; - _tmp2311_ = _arg_size; - if (!(_tmp2310_ < _tmp2311_)) { + _tmp2314_ = _arg_index; + _tmp2315_ = _arg_size; + if (!(_tmp2314_ < _tmp2315_)) { break; } - _tmp2312_ = _arg_list; - _tmp2313_ = vala_list_get (_tmp2312_, _arg_index); - arg = (ValaExpression*) _tmp2313_; + _tmp2316_ = _arg_list; + _tmp2317_ = vala_list_get (_tmp2316_, _arg_index); + arg = (ValaExpression*) _tmp2317_; param = NULL; - _tmp2314_ = params_it; - if (vala_iterator_next (_tmp2314_)) { - ValaIterator* _tmp2315_; - gpointer _tmp2316_; - _tmp2315_ = params_it; - _tmp2316_ = vala_iterator_get (_tmp2315_); + _tmp2318_ = params_it; + if (vala_iterator_next (_tmp2318_)) { + ValaIterator* _tmp2319_; + gpointer _tmp2320_; + _tmp2319_ = params_it; + _tmp2320_ = vala_iterator_get (_tmp2319_); _vala_code_node_unref0 (param); - param = (ValaParameter*) _tmp2316_; + param = (ValaParameter*) _tmp2320_; } - _tmp2317_ = arg; - _tmp2318_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp2317_, VALA_TYPE_UNARY_EXPRESSION) ? ((ValaUnaryExpression*) _tmp2317_) : NULL); - unary = _tmp2318_; - _tmp2320_ = unary; - if (_tmp2320_ != NULL) { - ValaUnaryExpression* _tmp2321_; - ValaUnaryOperator _tmp2322_; - ValaUnaryOperator _tmp2323_; - _tmp2321_ = unary; - _tmp2322_ = vala_unary_expression_get_operator (_tmp2321_); - _tmp2323_ = _tmp2322_; - _tmp2319_ = _tmp2323_ == VALA_UNARY_OPERATOR_REF; - } else { - _tmp2319_ = FALSE; - } - if (_tmp2319_) { - gboolean _tmp2324_ = FALSE; - gboolean _tmp2325_ = FALSE; - gboolean _tmp2326_ = FALSE; - gboolean _tmp2327_ = FALSE; - ValaParameter* _tmp2328_; - _tmp2328_ = param; - if (_tmp2328_ != NULL) { - ValaParameter* _tmp2329_; - _tmp2329_ = param; - _tmp2327_ = vala_get_ccode_array_length ((ValaCodeNode*) _tmp2329_); + _tmp2321_ = arg; + _tmp2322_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp2321_, VALA_TYPE_UNARY_EXPRESSION) ? ((ValaUnaryExpression*) _tmp2321_) : NULL); + unary = _tmp2322_; + _tmp2326_ = unary; + if (_tmp2326_ != NULL) { + ValaUnaryExpression* _tmp2327_; + ValaUnaryOperator _tmp2328_; + ValaUnaryOperator _tmp2329_; + _tmp2327_ = unary; + _tmp2328_ = vala_unary_expression_get_operator (_tmp2327_); + _tmp2329_ = _tmp2328_; + _tmp2325_ = _tmp2329_ == VALA_UNARY_OPERATOR_REF; + } else { + _tmp2325_ = FALSE; + } + if (_tmp2325_) { + ValaUnaryExpression* _tmp2330_; + ValaExpression* _tmp2331_; + ValaExpression* _tmp2332_; + ValaSymbol* _tmp2333_; + ValaSymbol* _tmp2334_; + _tmp2330_ = unary; + _tmp2331_ = vala_unary_expression_get_inner (_tmp2330_); + _tmp2332_ = _tmp2331_; + _tmp2333_ = vala_expression_get_symbol_reference (_tmp2332_); + _tmp2334_ = _tmp2333_; + _tmp2324_ = _tmp2334_ != NULL; + } else { + _tmp2324_ = FALSE; + } + if (_tmp2324_) { + ValaUnaryExpression* _tmp2335_; + ValaExpression* _tmp2336_; + ValaExpression* _tmp2337_; + ValaSymbol* _tmp2338_; + ValaSymbol* _tmp2339_; + _tmp2335_ = unary; + _tmp2336_ = vala_unary_expression_get_inner (_tmp2335_); + _tmp2337_ = _tmp2336_; + _tmp2338_ = vala_expression_get_symbol_reference (_tmp2337_); + _tmp2339_ = _tmp2338_; + _tmp2323_ = vala_get_ccode_array_length ((ValaCodeNode*) _tmp2339_); + } else { + _tmp2323_ = FALSE; + } + if (_tmp2323_) { + gboolean _tmp2340_ = FALSE; + gboolean _tmp2341_ = FALSE; + gboolean _tmp2342_ = FALSE; + gboolean _tmp2343_ = FALSE; + ValaParameter* _tmp2344_; + _tmp2344_ = param; + if (_tmp2344_ != NULL) { + ValaParameter* _tmp2345_; + _tmp2345_ = param; + _tmp2343_ = vala_get_ccode_array_null_terminated ((ValaCodeNode*) _tmp2345_); } else { - _tmp2327_ = FALSE; + _tmp2343_ = FALSE; } - if (_tmp2327_) { - ValaParameter* _tmp2330_; - ValaDataType* _tmp2331_; - ValaDataType* _tmp2332_; - _tmp2330_ = param; - _tmp2331_ = vala_variable_get_variable_type ((ValaVariable*) _tmp2330_); - _tmp2332_ = _tmp2331_; - _tmp2326_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp2332_, VALA_TYPE_ARRAY_TYPE); + if (_tmp2343_) { + ValaParameter* _tmp2346_; + _tmp2346_ = param; + _tmp2342_ = !vala_get_ccode_array_length ((ValaCodeNode*) _tmp2346_); } else { - _tmp2326_ = FALSE; + _tmp2342_ = FALSE; } - if (_tmp2326_) { - ValaParameter* _tmp2333_; - ValaDataType* _tmp2334_; - ValaDataType* _tmp2335_; - gboolean _tmp2336_; - gboolean _tmp2337_; - _tmp2333_ = param; - _tmp2334_ = vala_variable_get_variable_type ((ValaVariable*) _tmp2333_); - _tmp2335_ = _tmp2334_; - _tmp2336_ = vala_array_type_get_fixed_length (G_TYPE_CHECK_INSTANCE_CAST (_tmp2335_, VALA_TYPE_ARRAY_TYPE, ValaArrayType)); - _tmp2337_ = _tmp2336_; - _tmp2325_ = !_tmp2337_; + if (_tmp2342_) { + ValaParameter* _tmp2347_; + ValaDataType* _tmp2348_; + ValaDataType* _tmp2349_; + _tmp2347_ = param; + _tmp2348_ = vala_variable_get_variable_type ((ValaVariable*) _tmp2347_); + _tmp2349_ = _tmp2348_; + _tmp2341_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp2349_, VALA_TYPE_ARRAY_TYPE); } else { - _tmp2325_ = FALSE; + _tmp2341_ = FALSE; } - if (_tmp2325_) { - ValaParameter* _tmp2338_; - ValaDataType* _tmp2339_; - ValaDataType* _tmp2340_; - gint _tmp2341_; - gint _tmp2342_; - _tmp2338_ = param; - _tmp2339_ = vala_variable_get_variable_type ((ValaVariable*) _tmp2338_); - _tmp2340_ = _tmp2339_; - _tmp2341_ = vala_array_type_get_rank (G_TYPE_CHECK_INSTANCE_CAST (_tmp2340_, VALA_TYPE_ARRAY_TYPE, ValaArrayType)); - _tmp2342_ = _tmp2341_; - _tmp2324_ = _tmp2342_ == 1; + if (_tmp2341_) { + ValaParameter* _tmp2350_; + ValaDataType* _tmp2351_; + ValaDataType* _tmp2352_; + gint _tmp2353_; + gint _tmp2354_; + _tmp2350_ = param; + _tmp2351_ = vala_variable_get_variable_type ((ValaVariable*) _tmp2350_); + _tmp2352_ = _tmp2351_; + _tmp2353_ = vala_array_type_get_rank (G_TYPE_CHECK_INSTANCE_CAST (_tmp2352_, VALA_TYPE_ARRAY_TYPE, ValaArrayType)); + _tmp2354_ = _tmp2353_; + _tmp2340_ = _tmp2354_ == 1; } else { - _tmp2324_ = FALSE; + _tmp2340_ = FALSE; + } + if (_tmp2340_) { + ValaCCodeFunctionCall* len_call = NULL; + ValaCCodeIdentifier* _tmp2355_; + ValaCCodeIdentifier* _tmp2356_; + ValaCCodeFunctionCall* _tmp2357_; + ValaCCodeFunctionCall* _tmp2358_; + ValaCCodeFunctionCall* _tmp2359_; + ValaUnaryExpression* _tmp2360_; + ValaExpression* _tmp2361_; + ValaExpression* _tmp2362_; + ValaTargetValue* _tmp2363_; + ValaTargetValue* _tmp2364_; + ValaCCodeExpression* _tmp2365_; + ValaCCodeFunction* _tmp2366_; + ValaCCodeFunction* _tmp2367_; + ValaUnaryExpression* _tmp2368_; + ValaExpression* _tmp2369_; + ValaExpression* _tmp2370_; + ValaTargetValue* _tmp2371_; + ValaTargetValue* _tmp2372_; + ValaCCodeExpression* _tmp2373_; + ValaCCodeExpression* _tmp2374_; + ValaCCodeFunctionCall* _tmp2375_; + ((ValaCCodeBaseModule*) self)->requires_array_length = TRUE; + _tmp2355_ = vala_ccode_identifier_new ("_vala_array_length"); + _tmp2356_ = _tmp2355_; + _tmp2357_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp2356_); + _tmp2358_ = _tmp2357_; + _vala_ccode_node_unref0 (_tmp2356_); + len_call = _tmp2358_; + _tmp2359_ = len_call; + _tmp2360_ = unary; + _tmp2361_ = vala_unary_expression_get_inner (_tmp2360_); + _tmp2362_ = _tmp2361_; + _tmp2363_ = vala_expression_get_target_value (_tmp2362_); + _tmp2364_ = _tmp2363_; + _tmp2365_ = vala_get_cvalue_ (_tmp2364_); + vala_ccode_function_call_add_argument (_tmp2359_, _tmp2365_); + _tmp2366_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp2367_ = _tmp2366_; + _tmp2368_ = unary; + _tmp2369_ = vala_unary_expression_get_inner (_tmp2368_); + _tmp2370_ = _tmp2369_; + _tmp2371_ = vala_expression_get_target_value (_tmp2370_); + _tmp2372_ = _tmp2371_; + _tmp2373_ = vala_ccode_base_module_get_array_length_cvalue ((ValaCCodeBaseModule*) self, _tmp2372_, 1); + _tmp2374_ = _tmp2373_; + _tmp2375_ = len_call; + vala_ccode_function_add_assignment (_tmp2367_, _tmp2374_, (ValaCCodeExpression*) _tmp2375_); + _vala_ccode_node_unref0 (_tmp2374_); + _vala_ccode_node_unref0 (len_call); } - if (_tmp2324_) { + } + _tmp2379_ = unary; + if (_tmp2379_ != NULL) { + ValaUnaryExpression* _tmp2380_; + ValaUnaryOperator _tmp2381_; + ValaUnaryOperator _tmp2382_; + _tmp2380_ = unary; + _tmp2381_ = vala_unary_expression_get_operator (_tmp2380_); + _tmp2382_ = _tmp2381_; + _tmp2378_ = _tmp2382_ == VALA_UNARY_OPERATOR_REF; + } else { + _tmp2378_ = FALSE; + } + if (_tmp2378_) { + ValaUnaryExpression* _tmp2383_; + ValaExpression* _tmp2384_; + ValaExpression* _tmp2385_; + ValaSymbol* _tmp2386_; + ValaSymbol* _tmp2387_; + _tmp2383_ = unary; + _tmp2384_ = vala_unary_expression_get_inner (_tmp2383_); + _tmp2385_ = _tmp2384_; + _tmp2386_ = vala_expression_get_symbol_reference (_tmp2385_); + _tmp2387_ = _tmp2386_; + _tmp2377_ = _tmp2387_ != NULL; + } else { + _tmp2377_ = FALSE; + } + if (_tmp2377_) { + ValaUnaryExpression* _tmp2388_; + ValaExpression* _tmp2389_; + ValaExpression* _tmp2390_; + ValaSymbol* _tmp2391_; + ValaSymbol* _tmp2392_; + _tmp2388_ = unary; + _tmp2389_ = vala_unary_expression_get_inner (_tmp2388_); + _tmp2390_ = _tmp2389_; + _tmp2391_ = vala_expression_get_symbol_reference (_tmp2390_); + _tmp2392_ = _tmp2391_; + _tmp2376_ = vala_get_ccode_array_length ((ValaCodeNode*) _tmp2392_); + } else { + _tmp2376_ = FALSE; + } + if (_tmp2376_) { + gboolean _tmp2393_ = FALSE; + gboolean _tmp2394_ = FALSE; + gboolean _tmp2395_ = FALSE; + ValaParameter* _tmp2396_; + _tmp2396_ = param; + if (_tmp2396_ != NULL) { + ValaParameter* _tmp2397_; + ValaDataType* _tmp2398_; + ValaDataType* _tmp2399_; + _tmp2397_ = param; + _tmp2398_ = vala_variable_get_variable_type ((ValaVariable*) _tmp2397_); + _tmp2399_ = _tmp2398_; + _tmp2395_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp2399_, VALA_TYPE_ARRAY_TYPE); + } else { + _tmp2395_ = FALSE; + } + if (_tmp2395_) { + ValaParameter* _tmp2400_; + ValaDataType* _tmp2401_; + ValaDataType* _tmp2402_; + gboolean _tmp2403_; + gboolean _tmp2404_; + _tmp2400_ = param; + _tmp2401_ = vala_variable_get_variable_type ((ValaVariable*) _tmp2400_); + _tmp2402_ = _tmp2401_; + _tmp2403_ = vala_array_type_get_fixed_length (G_TYPE_CHECK_INSTANCE_CAST (_tmp2402_, VALA_TYPE_ARRAY_TYPE, ValaArrayType)); + _tmp2404_ = _tmp2403_; + _tmp2394_ = !_tmp2404_; + } else { + _tmp2394_ = FALSE; + } + if (_tmp2394_) { + ValaParameter* _tmp2405_; + ValaDataType* _tmp2406_; + ValaDataType* _tmp2407_; + gint _tmp2408_; + gint _tmp2409_; + _tmp2405_ = param; + _tmp2406_ = vala_variable_get_variable_type ((ValaVariable*) _tmp2405_); + _tmp2407_ = _tmp2406_; + _tmp2408_ = vala_array_type_get_rank (G_TYPE_CHECK_INSTANCE_CAST (_tmp2407_, VALA_TYPE_ARRAY_TYPE, ValaArrayType)); + _tmp2409_ = _tmp2408_; + _tmp2393_ = _tmp2409_ == 1; + } else { + _tmp2393_ = FALSE; + } + if (_tmp2393_) { ValaVariable* array_var = NULL; - ValaUnaryExpression* _tmp2343_; - ValaExpression* _tmp2344_; - ValaExpression* _tmp2345_; - ValaSymbol* _tmp2346_; - ValaSymbol* _tmp2347_; - gboolean _tmp2348_ = FALSE; - gboolean _tmp2349_ = FALSE; - gboolean _tmp2350_ = FALSE; - gboolean _tmp2351_ = FALSE; - ValaVariable* _tmp2352_; - _tmp2343_ = unary; - _tmp2344_ = vala_unary_expression_get_inner (_tmp2343_); - _tmp2345_ = _tmp2344_; - _tmp2346_ = vala_expression_get_symbol_reference (_tmp2345_); - _tmp2347_ = _tmp2346_; - array_var = G_TYPE_CHECK_INSTANCE_TYPE (_tmp2347_, VALA_TYPE_VARIABLE) ? ((ValaVariable*) _tmp2347_) : NULL; - _tmp2352_ = array_var; - if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp2352_, VALA_TYPE_LOCAL_VARIABLE)) { - _tmp2351_ = TRUE; + ValaUnaryExpression* _tmp2410_; + ValaExpression* _tmp2411_; + ValaExpression* _tmp2412_; + ValaSymbol* _tmp2413_; + ValaSymbol* _tmp2414_; + gboolean _tmp2415_ = FALSE; + gboolean _tmp2416_ = FALSE; + gboolean _tmp2417_ = FALSE; + gboolean _tmp2418_ = FALSE; + ValaVariable* _tmp2419_; + _tmp2410_ = unary; + _tmp2411_ = vala_unary_expression_get_inner (_tmp2410_); + _tmp2412_ = _tmp2411_; + _tmp2413_ = vala_expression_get_symbol_reference (_tmp2412_); + _tmp2414_ = _tmp2413_; + array_var = G_TYPE_CHECK_INSTANCE_TYPE (_tmp2414_, VALA_TYPE_VARIABLE) ? ((ValaVariable*) _tmp2414_) : NULL; + _tmp2419_ = array_var; + if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp2419_, VALA_TYPE_LOCAL_VARIABLE)) { + _tmp2418_ = TRUE; } else { - ValaVariable* _tmp2353_; - _tmp2353_ = array_var; - _tmp2351_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp2353_, VALA_TYPE_FIELD); - } - if (_tmp2351_) { - ValaVariable* _tmp2354_; - _tmp2354_ = array_var; - _tmp2350_ = vala_symbol_is_internal_symbol ((ValaSymbol*) _tmp2354_); + ValaVariable* _tmp2420_; + _tmp2420_ = array_var; + _tmp2418_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp2420_, VALA_TYPE_FIELD); + } + if (_tmp2418_) { + ValaVariable* _tmp2421_; + _tmp2421_ = array_var; + _tmp2417_ = vala_symbol_is_internal_symbol ((ValaSymbol*) _tmp2421_); } else { - _tmp2350_ = FALSE; + _tmp2417_ = FALSE; } - if (_tmp2350_) { - ValaVariable* _tmp2355_; - ValaDataType* _tmp2356_; - ValaDataType* _tmp2357_; - _tmp2355_ = array_var; - _tmp2356_ = vala_variable_get_variable_type (_tmp2355_); - _tmp2357_ = _tmp2356_; - _tmp2349_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp2357_, VALA_TYPE_ARRAY_TYPE); + if (_tmp2417_) { + ValaVariable* _tmp2422_; + ValaDataType* _tmp2423_; + ValaDataType* _tmp2424_; + _tmp2422_ = array_var; + _tmp2423_ = vala_variable_get_variable_type (_tmp2422_); + _tmp2424_ = _tmp2423_; + _tmp2416_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp2424_, VALA_TYPE_ARRAY_TYPE); } else { - _tmp2349_ = FALSE; + _tmp2416_ = FALSE; } - if (_tmp2349_) { - ValaVariable* _tmp2358_; - ValaDataType* _tmp2359_; - ValaDataType* _tmp2360_; - gboolean _tmp2361_; - gboolean _tmp2362_; - _tmp2358_ = array_var; - _tmp2359_ = vala_variable_get_variable_type (_tmp2358_); - _tmp2360_ = _tmp2359_; - _tmp2361_ = vala_array_type_get_fixed_length (G_TYPE_CHECK_INSTANCE_CAST (_tmp2360_, VALA_TYPE_ARRAY_TYPE, ValaArrayType)); - _tmp2362_ = _tmp2361_; - _tmp2348_ = !_tmp2362_; + if (_tmp2416_) { + ValaVariable* _tmp2425_; + ValaDataType* _tmp2426_; + ValaDataType* _tmp2427_; + gboolean _tmp2428_; + gboolean _tmp2429_; + _tmp2425_ = array_var; + _tmp2426_ = vala_variable_get_variable_type (_tmp2425_); + _tmp2427_ = _tmp2426_; + _tmp2428_ = vala_array_type_get_fixed_length (G_TYPE_CHECK_INSTANCE_CAST (_tmp2427_, VALA_TYPE_ARRAY_TYPE, ValaArrayType)); + _tmp2429_ = _tmp2428_; + _tmp2415_ = !_tmp2429_; } else { - _tmp2348_ = FALSE; + _tmp2415_ = FALSE; } - if (_tmp2348_) { - ValaCCodeFunction* _tmp2363_; - ValaCCodeFunction* _tmp2364_; - ValaUnaryExpression* _tmp2365_; - ValaExpression* _tmp2366_; - ValaExpression* _tmp2367_; - ValaTargetValue* _tmp2368_; - ValaTargetValue* _tmp2369_; - ValaCCodeExpression* _tmp2370_; - ValaUnaryExpression* _tmp2371_; - ValaExpression* _tmp2372_; - ValaExpression* _tmp2373_; - ValaTargetValue* _tmp2374_; - ValaTargetValue* _tmp2375_; - ValaCCodeExpression* _tmp2376_; - ValaCCodeExpression* _tmp2377_; - _tmp2363_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); - _tmp2364_ = _tmp2363_; - _tmp2365_ = unary; - _tmp2366_ = vala_unary_expression_get_inner (_tmp2365_); - _tmp2367_ = _tmp2366_; - _tmp2368_ = vala_expression_get_target_value (_tmp2367_); - _tmp2369_ = _tmp2368_; - _tmp2370_ = vala_get_array_size_cvalue (_tmp2369_); - _tmp2371_ = unary; - _tmp2372_ = vala_unary_expression_get_inner (_tmp2371_); - _tmp2373_ = _tmp2372_; - _tmp2374_ = vala_expression_get_target_value (_tmp2373_); - _tmp2375_ = _tmp2374_; - _tmp2376_ = vala_ccode_base_module_get_array_length_cvalue ((ValaCCodeBaseModule*) self, _tmp2375_, 1); - _tmp2377_ = _tmp2376_; - vala_ccode_function_add_assignment (_tmp2364_, _tmp2370_, _tmp2377_); - _vala_ccode_node_unref0 (_tmp2377_); + if (_tmp2415_) { + ValaCCodeFunction* _tmp2430_; + ValaCCodeFunction* _tmp2431_; + ValaUnaryExpression* _tmp2432_; + ValaExpression* _tmp2433_; + ValaExpression* _tmp2434_; + ValaTargetValue* _tmp2435_; + ValaTargetValue* _tmp2436_; + ValaCCodeExpression* _tmp2437_; + ValaUnaryExpression* _tmp2438_; + ValaExpression* _tmp2439_; + ValaExpression* _tmp2440_; + ValaTargetValue* _tmp2441_; + ValaTargetValue* _tmp2442_; + ValaCCodeExpression* _tmp2443_; + ValaCCodeExpression* _tmp2444_; + _tmp2430_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp2431_ = _tmp2430_; + _tmp2432_ = unary; + _tmp2433_ = vala_unary_expression_get_inner (_tmp2432_); + _tmp2434_ = _tmp2433_; + _tmp2435_ = vala_expression_get_target_value (_tmp2434_); + _tmp2436_ = _tmp2435_; + _tmp2437_ = vala_get_array_size_cvalue (_tmp2436_); + _tmp2438_ = unary; + _tmp2439_ = vala_unary_expression_get_inner (_tmp2438_); + _tmp2440_ = _tmp2439_; + _tmp2441_ = vala_expression_get_target_value (_tmp2440_); + _tmp2442_ = _tmp2441_; + _tmp2443_ = vala_ccode_base_module_get_array_length_cvalue ((ValaCCodeBaseModule*) self, _tmp2442_, 1); + _tmp2444_ = _tmp2443_; + vala_ccode_function_add_assignment (_tmp2431_, _tmp2437_, _tmp2444_); + _vala_ccode_node_unref0 (_tmp2444_); } } } - _tmp2379_ = unary; - if (_tmp2379_ == NULL) { - _tmp2378_ = TRUE; - } else { - ValaUnaryExpression* _tmp2380_; - ValaUnaryOperator _tmp2381_; - ValaUnaryOperator _tmp2382_; - _tmp2380_ = unary; - _tmp2381_ = vala_unary_expression_get_operator (_tmp2380_); - _tmp2382_ = _tmp2381_; - _tmp2378_ = _tmp2382_ != VALA_UNARY_OPERATOR_OUT; + _tmp2446_ = unary; + if (_tmp2446_ == NULL) { + _tmp2445_ = TRUE; + } else { + ValaUnaryExpression* _tmp2447_; + ValaUnaryOperator _tmp2448_; + ValaUnaryOperator _tmp2449_; + _tmp2447_ = unary; + _tmp2448_ = vala_unary_expression_get_operator (_tmp2447_); + _tmp2449_ = _tmp2448_; + _tmp2445_ = _tmp2449_ != VALA_UNARY_OPERATOR_OUT; } - if (_tmp2378_) { + if (_tmp2445_) { _vala_code_node_unref0 (unary); _vala_code_node_unref0 (param); _vala_code_node_unref0 (arg); continue; } - _tmp2383_ = unary; - _tmp2384_ = vala_unary_expression_get_inner (_tmp2383_); - _tmp2385_ = _tmp2384_; - _tmp2386_ = vala_expression_get_value_type (_tmp2385_); - _tmp2387_ = _tmp2386_; - if (vala_ccode_base_module_requires_destroy (_tmp2387_)) { - ValaCCodeFunction* _tmp2388_; - ValaCCodeFunction* _tmp2389_; - ValaUnaryExpression* _tmp2390_; - ValaExpression* _tmp2391_; - ValaExpression* _tmp2392_; - ValaTargetValue* _tmp2393_; - ValaTargetValue* _tmp2394_; - ValaCCodeExpression* _tmp2395_; - ValaCCodeExpression* _tmp2396_; - _tmp2388_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); - _tmp2389_ = _tmp2388_; - _tmp2390_ = unary; - _tmp2391_ = vala_unary_expression_get_inner (_tmp2390_); - _tmp2392_ = _tmp2391_; - _tmp2393_ = vala_expression_get_target_value (_tmp2392_); - _tmp2394_ = _tmp2393_; - _tmp2395_ = vala_ccode_base_module_destroy_value ((ValaCCodeBaseModule*) self, _tmp2394_, FALSE); - _tmp2396_ = _tmp2395_; - vala_ccode_function_add_expression (_tmp2389_, _tmp2396_); - _vala_ccode_node_unref0 (_tmp2396_); - } - _tmp2398_ = ma; - _tmp2399_ = vala_expression_get_symbol_reference ((ValaExpression*) _tmp2398_); - _tmp2400_ = _tmp2399_; - if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp2400_, VALA_TYPE_DYNAMIC_METHOD)) { - ValaUnaryExpression* _tmp2401_; - ValaTargetValue* _tmp2402_; - ValaTargetValue* _tmp2403_; - ValaDataType* _tmp2404_; - ValaDataType* _tmp2405_; - _tmp2401_ = unary; - _tmp2402_ = vala_expression_get_target_value ((ValaExpression*) _tmp2401_); - _tmp2403_ = _tmp2402_; - _tmp2404_ = vala_target_value_get_value_type (_tmp2403_); - _tmp2405_ = _tmp2404_; - _tmp2397_ = _tmp2405_ == NULL; - } else { - _tmp2397_ = FALSE; - } - if (_tmp2397_) { - ValaUnaryExpression* _tmp2406_; - ValaTargetValue* _tmp2407_; - ValaTargetValue* _tmp2408_; - ValaUnaryExpression* _tmp2409_; - ValaExpression* _tmp2410_; - ValaExpression* _tmp2411_; - ValaDataType* _tmp2412_; - ValaDataType* _tmp2413_; - ValaDataType* _tmp2414_; - ValaDataType* _tmp2415_; - _tmp2406_ = unary; - _tmp2407_ = vala_expression_get_target_value ((ValaExpression*) _tmp2406_); - _tmp2408_ = _tmp2407_; - _tmp2409_ = unary; - _tmp2410_ = vala_unary_expression_get_inner (_tmp2409_); - _tmp2411_ = _tmp2410_; - _tmp2412_ = vala_expression_get_value_type (_tmp2411_); - _tmp2413_ = _tmp2412_; - _tmp2414_ = vala_data_type_copy (_tmp2413_); - _tmp2415_ = _tmp2414_; - vala_target_value_set_value_type (_tmp2408_, _tmp2415_); - _vala_code_node_unref0 (_tmp2415_); - } - _tmp2416_ = unary; - _tmp2417_ = vala_unary_expression_get_inner (_tmp2416_); - _tmp2418_ = _tmp2417_; - _tmp2419_ = vala_expression_get_target_value (_tmp2418_); - _tmp2420_ = _tmp2419_; - _tmp2421_ = unary; - _tmp2422_ = vala_expression_get_target_value ((ValaExpression*) _tmp2421_); - _tmp2423_ = _tmp2422_; - _tmp2424_ = unary; - _tmp2425_ = vala_unary_expression_get_inner (_tmp2424_); - _tmp2426_ = _tmp2425_; - _tmp2427_ = vala_expression_get_value_type (_tmp2426_); - _tmp2428_ = _tmp2427_; - _tmp2429_ = arg; - _tmp2430_ = vala_ccode_base_module_transform_value ((ValaCCodeBaseModule*) self, _tmp2423_, _tmp2428_, (ValaCodeNode*) _tmp2429_); - _tmp2431_ = _tmp2430_; - _tmp2432_ = vala_code_node_get_source_reference ((ValaCodeNode*) expr); - _tmp2433_ = _tmp2432_; - vala_ccode_base_module_store_value ((ValaCCodeBaseModule*) self, _tmp2420_, _tmp2431_, _tmp2433_); - _vala_target_value_unref0 (_tmp2431_); - _tmp2435_ = param; - if (_tmp2435_ != NULL) { - ValaParameter* _tmp2436_; - _tmp2436_ = param; - _tmp2434_ = vala_get_ccode_array_null_terminated ((ValaCodeNode*) _tmp2436_); + _tmp2450_ = unary; + _tmp2451_ = vala_unary_expression_get_inner (_tmp2450_); + _tmp2452_ = _tmp2451_; + _tmp2453_ = vala_expression_get_value_type (_tmp2452_); + _tmp2454_ = _tmp2453_; + if (vala_ccode_base_module_requires_destroy (_tmp2454_)) { + ValaCCodeFunction* _tmp2455_; + ValaCCodeFunction* _tmp2456_; + ValaUnaryExpression* _tmp2457_; + ValaExpression* _tmp2458_; + ValaExpression* _tmp2459_; + ValaTargetValue* _tmp2460_; + ValaTargetValue* _tmp2461_; + ValaCCodeExpression* _tmp2462_; + ValaCCodeExpression* _tmp2463_; + _tmp2455_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp2456_ = _tmp2455_; + _tmp2457_ = unary; + _tmp2458_ = vala_unary_expression_get_inner (_tmp2457_); + _tmp2459_ = _tmp2458_; + _tmp2460_ = vala_expression_get_target_value (_tmp2459_); + _tmp2461_ = _tmp2460_; + _tmp2462_ = vala_ccode_base_module_destroy_value ((ValaCCodeBaseModule*) self, _tmp2461_, FALSE); + _tmp2463_ = _tmp2462_; + vala_ccode_function_add_expression (_tmp2456_, _tmp2463_); + _vala_ccode_node_unref0 (_tmp2463_); + } + _tmp2465_ = ma; + _tmp2466_ = vala_expression_get_symbol_reference ((ValaExpression*) _tmp2465_); + _tmp2467_ = _tmp2466_; + if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp2467_, VALA_TYPE_DYNAMIC_METHOD)) { + ValaUnaryExpression* _tmp2468_; + ValaTargetValue* _tmp2469_; + ValaTargetValue* _tmp2470_; + ValaDataType* _tmp2471_; + ValaDataType* _tmp2472_; + _tmp2468_ = unary; + _tmp2469_ = vala_expression_get_target_value ((ValaExpression*) _tmp2468_); + _tmp2470_ = _tmp2469_; + _tmp2471_ = vala_target_value_get_value_type (_tmp2470_); + _tmp2472_ = _tmp2471_; + _tmp2464_ = _tmp2472_ == NULL; + } else { + _tmp2464_ = FALSE; + } + if (_tmp2464_) { + ValaUnaryExpression* _tmp2473_; + ValaTargetValue* _tmp2474_; + ValaTargetValue* _tmp2475_; + ValaUnaryExpression* _tmp2476_; + ValaExpression* _tmp2477_; + ValaExpression* _tmp2478_; + ValaDataType* _tmp2479_; + ValaDataType* _tmp2480_; + ValaDataType* _tmp2481_; + ValaDataType* _tmp2482_; + _tmp2473_ = unary; + _tmp2474_ = vala_expression_get_target_value ((ValaExpression*) _tmp2473_); + _tmp2475_ = _tmp2474_; + _tmp2476_ = unary; + _tmp2477_ = vala_unary_expression_get_inner (_tmp2476_); + _tmp2478_ = _tmp2477_; + _tmp2479_ = vala_expression_get_value_type (_tmp2478_); + _tmp2480_ = _tmp2479_; + _tmp2481_ = vala_data_type_copy (_tmp2480_); + _tmp2482_ = _tmp2481_; + vala_target_value_set_value_type (_tmp2475_, _tmp2482_); + _vala_code_node_unref0 (_tmp2482_); + } + _tmp2483_ = unary; + _tmp2484_ = vala_unary_expression_get_inner (_tmp2483_); + _tmp2485_ = _tmp2484_; + _tmp2486_ = vala_expression_get_target_value (_tmp2485_); + _tmp2487_ = _tmp2486_; + _tmp2488_ = unary; + _tmp2489_ = vala_expression_get_target_value ((ValaExpression*) _tmp2488_); + _tmp2490_ = _tmp2489_; + _tmp2491_ = unary; + _tmp2492_ = vala_unary_expression_get_inner (_tmp2491_); + _tmp2493_ = _tmp2492_; + _tmp2494_ = vala_expression_get_value_type (_tmp2493_); + _tmp2495_ = _tmp2494_; + _tmp2496_ = arg; + _tmp2497_ = vala_ccode_base_module_transform_value ((ValaCCodeBaseModule*) self, _tmp2490_, _tmp2495_, (ValaCodeNode*) _tmp2496_); + _tmp2498_ = _tmp2497_; + _tmp2499_ = vala_code_node_get_source_reference ((ValaCodeNode*) expr); + _tmp2500_ = _tmp2499_; + vala_ccode_base_module_store_value ((ValaCCodeBaseModule*) self, _tmp2487_, _tmp2498_, _tmp2500_); + _vala_target_value_unref0 (_tmp2498_); + _tmp2505_ = param; + if (_tmp2505_ != NULL) { + ValaParameter* _tmp2506_; + _tmp2506_ = param; + _tmp2504_ = vala_get_ccode_array_null_terminated ((ValaCodeNode*) _tmp2506_); + } else { + _tmp2504_ = FALSE; + } + if (_tmp2504_) { + ValaParameter* _tmp2507_; + _tmp2507_ = param; + _tmp2503_ = !vala_get_ccode_array_length ((ValaCodeNode*) _tmp2507_); + } else { + _tmp2503_ = FALSE; + } + if (_tmp2503_) { + ValaUnaryExpression* _tmp2508_; + ValaExpression* _tmp2509_; + ValaExpression* _tmp2510_; + ValaSymbol* _tmp2511_; + ValaSymbol* _tmp2512_; + _tmp2508_ = unary; + _tmp2509_ = vala_unary_expression_get_inner (_tmp2508_); + _tmp2510_ = _tmp2509_; + _tmp2511_ = vala_expression_get_symbol_reference (_tmp2510_); + _tmp2512_ = _tmp2511_; + _tmp2502_ = _tmp2512_ != NULL; + } else { + _tmp2502_ = FALSE; + } + if (_tmp2502_) { + ValaUnaryExpression* _tmp2513_; + ValaExpression* _tmp2514_; + ValaExpression* _tmp2515_; + ValaSymbol* _tmp2516_; + ValaSymbol* _tmp2517_; + _tmp2513_ = unary; + _tmp2514_ = vala_unary_expression_get_inner (_tmp2513_); + _tmp2515_ = _tmp2514_; + _tmp2516_ = vala_expression_get_symbol_reference (_tmp2515_); + _tmp2517_ = _tmp2516_; + _tmp2501_ = vala_get_ccode_array_length ((ValaCodeNode*) _tmp2517_); } else { - _tmp2434_ = FALSE; + _tmp2501_ = FALSE; } - if (_tmp2434_) { + if (_tmp2501_) { ValaCCodeFunctionCall* len_call = NULL; - ValaCCodeIdentifier* _tmp2437_; - ValaCCodeIdentifier* _tmp2438_; - ValaCCodeFunctionCall* _tmp2439_; - ValaCCodeFunctionCall* _tmp2440_; - ValaCCodeFunctionCall* _tmp2441_; - ValaUnaryExpression* _tmp2442_; - ValaExpression* _tmp2443_; - ValaExpression* _tmp2444_; - ValaTargetValue* _tmp2445_; - ValaTargetValue* _tmp2446_; - ValaCCodeExpression* _tmp2447_; - ValaCCodeFunction* _tmp2448_; - ValaCCodeFunction* _tmp2449_; - ValaUnaryExpression* _tmp2450_; - ValaExpression* _tmp2451_; - ValaExpression* _tmp2452_; - ValaTargetValue* _tmp2453_; - ValaTargetValue* _tmp2454_; - ValaCCodeExpression* _tmp2455_; - ValaCCodeExpression* _tmp2456_; - ValaCCodeFunctionCall* _tmp2457_; + ValaCCodeIdentifier* _tmp2518_; + ValaCCodeIdentifier* _tmp2519_; + ValaCCodeFunctionCall* _tmp2520_; + ValaCCodeFunctionCall* _tmp2521_; + ValaCCodeFunctionCall* _tmp2522_; + ValaUnaryExpression* _tmp2523_; + ValaExpression* _tmp2524_; + ValaExpression* _tmp2525_; + ValaTargetValue* _tmp2526_; + ValaTargetValue* _tmp2527_; + ValaCCodeExpression* _tmp2528_; + ValaCCodeFunction* _tmp2529_; + ValaCCodeFunction* _tmp2530_; + ValaUnaryExpression* _tmp2531_; + ValaExpression* _tmp2532_; + ValaExpression* _tmp2533_; + ValaTargetValue* _tmp2534_; + ValaTargetValue* _tmp2535_; + ValaCCodeExpression* _tmp2536_; + ValaCCodeExpression* _tmp2537_; + ValaCCodeFunctionCall* _tmp2538_; ((ValaCCodeBaseModule*) self)->requires_array_length = TRUE; - _tmp2437_ = vala_ccode_identifier_new ("_vala_array_length"); - _tmp2438_ = _tmp2437_; - _tmp2439_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp2438_); - _tmp2440_ = _tmp2439_; - _vala_ccode_node_unref0 (_tmp2438_); - len_call = _tmp2440_; - _tmp2441_ = len_call; - _tmp2442_ = unary; - _tmp2443_ = vala_unary_expression_get_inner (_tmp2442_); - _tmp2444_ = _tmp2443_; - _tmp2445_ = vala_expression_get_target_value (_tmp2444_); - _tmp2446_ = _tmp2445_; - _tmp2447_ = vala_get_cvalue_ (_tmp2446_); - vala_ccode_function_call_add_argument (_tmp2441_, _tmp2447_); - _tmp2448_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); - _tmp2449_ = _tmp2448_; - _tmp2450_ = unary; - _tmp2451_ = vala_unary_expression_get_inner (_tmp2450_); - _tmp2452_ = _tmp2451_; - _tmp2453_ = vala_expression_get_target_value (_tmp2452_); - _tmp2454_ = _tmp2453_; - _tmp2455_ = vala_ccode_base_module_get_array_length_cvalue ((ValaCCodeBaseModule*) self, _tmp2454_, 1); - _tmp2456_ = _tmp2455_; - _tmp2457_ = len_call; - vala_ccode_function_add_assignment (_tmp2449_, _tmp2456_, (ValaCCodeExpression*) _tmp2457_); - _vala_ccode_node_unref0 (_tmp2456_); + _tmp2518_ = vala_ccode_identifier_new ("_vala_array_length"); + _tmp2519_ = _tmp2518_; + _tmp2520_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp2519_); + _tmp2521_ = _tmp2520_; + _vala_ccode_node_unref0 (_tmp2519_); + len_call = _tmp2521_; + _tmp2522_ = len_call; + _tmp2523_ = unary; + _tmp2524_ = vala_unary_expression_get_inner (_tmp2523_); + _tmp2525_ = _tmp2524_; + _tmp2526_ = vala_expression_get_target_value (_tmp2525_); + _tmp2527_ = _tmp2526_; + _tmp2528_ = vala_get_cvalue_ (_tmp2527_); + vala_ccode_function_call_add_argument (_tmp2522_, _tmp2528_); + _tmp2529_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp2530_ = _tmp2529_; + _tmp2531_ = unary; + _tmp2532_ = vala_unary_expression_get_inner (_tmp2531_); + _tmp2533_ = _tmp2532_; + _tmp2534_ = vala_expression_get_target_value (_tmp2533_); + _tmp2535_ = _tmp2534_; + _tmp2536_ = vala_ccode_base_module_get_array_length_cvalue ((ValaCCodeBaseModule*) self, _tmp2535_, 1); + _tmp2537_ = _tmp2536_; + _tmp2538_ = len_call; + vala_ccode_function_add_assignment (_tmp2530_, _tmp2537_, (ValaCCodeExpression*) _tmp2538_); + _vala_ccode_node_unref0 (_tmp2537_); _vala_ccode_node_unref0 (len_call); } _vala_code_node_unref0 (unary); @@ -7554,116 +7780,116 @@ _vala_code_node_unref0 (arg); } } - _tmp2460_ = m; - if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp2460_, VALA_TYPE_CREATION_METHOD)) { - ValaMethod* _tmp2461_; - ValaSymbol* _tmp2462_; - ValaSymbol* _tmp2463_; - _tmp2461_ = m; - _tmp2462_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp2461_); - _tmp2463_ = _tmp2462_; - _tmp2459_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp2463_, VALA_TYPE_CLASS); + _tmp2541_ = m; + if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp2541_, VALA_TYPE_CREATION_METHOD)) { + ValaMethod* _tmp2542_; + ValaSymbol* _tmp2543_; + ValaSymbol* _tmp2544_; + _tmp2542_ = m; + _tmp2543_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp2542_); + _tmp2544_ = _tmp2543_; + _tmp2540_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp2544_, VALA_TYPE_CLASS); } else { - _tmp2459_ = FALSE; + _tmp2540_ = FALSE; } - if (_tmp2459_) { - gboolean _tmp2464_ = FALSE; - gboolean _tmp2465_ = FALSE; - ValaClass* _tmp2466_; - ValaClass* _tmp2467_; - gboolean _tmp2468_; - gboolean _tmp2469_; - _tmp2466_ = vala_ccode_base_module_get_current_class ((ValaCCodeBaseModule*) self); - _tmp2467_ = _tmp2466_; - _tmp2468_ = vala_class_get_is_compact (_tmp2467_); - _tmp2469_ = _tmp2468_; - if (_tmp2469_) { - ValaClass* _tmp2470_; - ValaClass* _tmp2471_; - ValaClass* _tmp2472_; - ValaClass* _tmp2473_; - _tmp2470_ = vala_ccode_base_module_get_current_class ((ValaCCodeBaseModule*) self); - _tmp2471_ = _tmp2470_; - _tmp2472_ = vala_class_get_base_class (_tmp2471_); - _tmp2473_ = _tmp2472_; - _tmp2465_ = _tmp2473_ != NULL; - } else { - _tmp2465_ = FALSE; - } - if (_tmp2465_) { - _tmp2464_ = TRUE; - } else { - ValaClass* _tmp2474_; - ValaClass* _tmp2475_; - ValaClass* _tmp2476_; - _tmp2474_ = vala_ccode_base_module_get_current_class ((ValaCCodeBaseModule*) self); - _tmp2475_ = _tmp2474_; - _tmp2476_ = ((ValaCCodeBaseModule*) self)->gsource_type; - _tmp2464_ = vala_typesymbol_is_subtype_of ((ValaTypeSymbol*) _tmp2475_, (ValaTypeSymbol*) _tmp2476_); + if (_tmp2540_) { + gboolean _tmp2545_ = FALSE; + gboolean _tmp2546_ = FALSE; + ValaClass* _tmp2547_; + ValaClass* _tmp2548_; + gboolean _tmp2549_; + gboolean _tmp2550_; + _tmp2547_ = vala_ccode_base_module_get_current_class ((ValaCCodeBaseModule*) self); + _tmp2548_ = _tmp2547_; + _tmp2549_ = vala_class_get_is_compact (_tmp2548_); + _tmp2550_ = _tmp2549_; + if (_tmp2550_) { + ValaClass* _tmp2551_; + ValaClass* _tmp2552_; + ValaClass* _tmp2553_; + ValaClass* _tmp2554_; + _tmp2551_ = vala_ccode_base_module_get_current_class ((ValaCCodeBaseModule*) self); + _tmp2552_ = _tmp2551_; + _tmp2553_ = vala_class_get_base_class (_tmp2552_); + _tmp2554_ = _tmp2553_; + _tmp2546_ = _tmp2554_ != NULL; + } else { + _tmp2546_ = FALSE; + } + if (_tmp2546_) { + _tmp2545_ = TRUE; + } else { + ValaClass* _tmp2555_; + ValaClass* _tmp2556_; + ValaClass* _tmp2557_; + _tmp2555_ = vala_ccode_base_module_get_current_class ((ValaCCodeBaseModule*) self); + _tmp2556_ = _tmp2555_; + _tmp2557_ = ((ValaCCodeBaseModule*) self)->gsource_type; + _tmp2545_ = vala_typesymbol_is_subtype_of ((ValaTypeSymbol*) _tmp2556_, (ValaTypeSymbol*) _tmp2557_); } - _tmp2458_ = _tmp2464_; + _tmp2539_ = _tmp2545_; } else { - _tmp2458_ = FALSE; + _tmp2539_ = FALSE; } - if (_tmp2458_) { + if (_tmp2539_) { ValaCCodeFunctionCall* cinitcall = NULL; - ValaClass* _tmp2477_; - ValaClass* _tmp2478_; - gchar* _tmp2479_; - gchar* _tmp2480_; - gchar* _tmp2481_; - gchar* _tmp2482_; - ValaCCodeIdentifier* _tmp2483_; - ValaCCodeIdentifier* _tmp2484_; - ValaCCodeFunctionCall* _tmp2485_; - ValaCCodeFunctionCall* _tmp2486_; - ValaCCodeFunctionCall* _tmp2487_; - ValaCCodeExpression* _tmp2488_; - ValaCCodeExpression* _tmp2489_; - ValaClass* _tmp2490_; - ValaClass* _tmp2491_; - gboolean _tmp2492_; - gboolean _tmp2493_; - ValaCCodeFunction* _tmp2497_; - ValaCCodeFunction* _tmp2498_; - ValaCCodeFunctionCall* _tmp2499_; - _tmp2477_ = vala_ccode_base_module_get_current_class ((ValaCCodeBaseModule*) self); - _tmp2478_ = _tmp2477_; - _tmp2479_ = vala_get_ccode_lower_case_name ((ValaCodeNode*) _tmp2478_, NULL); - _tmp2480_ = _tmp2479_; - _tmp2481_ = g_strdup_printf ("%s_instance_init", _tmp2480_); - _tmp2482_ = _tmp2481_; - _tmp2483_ = vala_ccode_identifier_new (_tmp2482_); - _tmp2484_ = _tmp2483_; - _tmp2485_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp2484_); - _tmp2486_ = _tmp2485_; - _vala_ccode_node_unref0 (_tmp2484_); - _g_free0 (_tmp2482_); - _g_free0 (_tmp2480_); - cinitcall = _tmp2486_; - _tmp2487_ = cinitcall; - _tmp2488_ = vala_ccode_base_module_get_this_cexpression ((ValaCCodeBaseModule*) self); - _tmp2489_ = _tmp2488_; - vala_ccode_function_call_add_argument (_tmp2487_, _tmp2489_); - _vala_ccode_node_unref0 (_tmp2489_); - _tmp2490_ = vala_ccode_base_module_get_current_class ((ValaCCodeBaseModule*) self); - _tmp2491_ = _tmp2490_; - _tmp2492_ = vala_class_get_is_compact (_tmp2491_); - _tmp2493_ = _tmp2492_; - if (!_tmp2493_) { - ValaCCodeFunctionCall* _tmp2494_; - ValaCCodeConstant* _tmp2495_; - ValaCCodeConstant* _tmp2496_; - _tmp2494_ = cinitcall; - _tmp2495_ = vala_ccode_constant_new ("NULL"); - _tmp2496_ = _tmp2495_; - vala_ccode_function_call_add_argument (_tmp2494_, (ValaCCodeExpression*) _tmp2496_); - _vala_ccode_node_unref0 (_tmp2496_); - } - _tmp2497_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); - _tmp2498_ = _tmp2497_; - _tmp2499_ = cinitcall; - vala_ccode_function_add_expression (_tmp2498_, (ValaCCodeExpression*) _tmp2499_); + ValaClass* _tmp2558_; + ValaClass* _tmp2559_; + gchar* _tmp2560_; + gchar* _tmp2561_; + gchar* _tmp2562_; + gchar* _tmp2563_; + ValaCCodeIdentifier* _tmp2564_; + ValaCCodeIdentifier* _tmp2565_; + ValaCCodeFunctionCall* _tmp2566_; + ValaCCodeFunctionCall* _tmp2567_; + ValaCCodeFunctionCall* _tmp2568_; + ValaCCodeExpression* _tmp2569_; + ValaCCodeExpression* _tmp2570_; + ValaClass* _tmp2571_; + ValaClass* _tmp2572_; + gboolean _tmp2573_; + gboolean _tmp2574_; + ValaCCodeFunction* _tmp2578_; + ValaCCodeFunction* _tmp2579_; + ValaCCodeFunctionCall* _tmp2580_; + _tmp2558_ = vala_ccode_base_module_get_current_class ((ValaCCodeBaseModule*) self); + _tmp2559_ = _tmp2558_; + _tmp2560_ = vala_get_ccode_lower_case_name ((ValaCodeNode*) _tmp2559_, NULL); + _tmp2561_ = _tmp2560_; + _tmp2562_ = g_strdup_printf ("%s_instance_init", _tmp2561_); + _tmp2563_ = _tmp2562_; + _tmp2564_ = vala_ccode_identifier_new (_tmp2563_); + _tmp2565_ = _tmp2564_; + _tmp2566_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp2565_); + _tmp2567_ = _tmp2566_; + _vala_ccode_node_unref0 (_tmp2565_); + _g_free0 (_tmp2563_); + _g_free0 (_tmp2561_); + cinitcall = _tmp2567_; + _tmp2568_ = cinitcall; + _tmp2569_ = vala_ccode_base_module_get_this_cexpression ((ValaCCodeBaseModule*) self); + _tmp2570_ = _tmp2569_; + vala_ccode_function_call_add_argument (_tmp2568_, _tmp2570_); + _vala_ccode_node_unref0 (_tmp2570_); + _tmp2571_ = vala_ccode_base_module_get_current_class ((ValaCCodeBaseModule*) self); + _tmp2572_ = _tmp2571_; + _tmp2573_ = vala_class_get_is_compact (_tmp2572_); + _tmp2574_ = _tmp2573_; + if (!_tmp2574_) { + ValaCCodeFunctionCall* _tmp2575_; + ValaCCodeConstant* _tmp2576_; + ValaCCodeConstant* _tmp2577_; + _tmp2575_ = cinitcall; + _tmp2576_ = vala_ccode_constant_new ("NULL"); + _tmp2577_ = _tmp2576_; + vala_ccode_function_call_add_argument (_tmp2575_, (ValaCCodeExpression*) _tmp2577_); + _vala_ccode_node_unref0 (_tmp2577_); + } + _tmp2578_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp2579_ = _tmp2578_; + _tmp2580_ = cinitcall; + vala_ccode_function_add_expression (_tmp2579_, (ValaCCodeExpression*) _tmp2580_); _vala_ccode_node_unref0 (cinitcall); } _vala_ccode_node_unref0 (out_param_ref); diff -Nru vala-0.56.16/codegen/valaccodemethodcallmodule.vala vala-0.56.17/codegen/valaccodemethodcallmodule.vala --- vala-0.56.16/codegen/valaccodemethodcallmodule.vala 2024-02-04 12:00:38.000000000 +0000 +++ vala-0.56.17/codegen/valaccodemethodcallmodule.vala 2024-04-19 10:23:32.000000000 +0000 @@ -222,7 +222,7 @@ var funcs = new CCodeDeclaration ("const GSourceFuncs"); funcs.modifiers = CCodeModifiers.STATIC; - funcs.add_declarator (new CCodeVariableDeclarator ("_source_funcs", new CCodeConstant ("{ %s, %s, %s_real_dispatch, %s_finalize}".printf (prepare_func, check_func, class_prefix, class_prefix)))); + funcs.add_declarator (new CCodeVariableDeclarator ("_source_funcs", new CCodeConstant ("{ %s, %s, %s_real_dispatch, %s_finalize, NULL, NULL}".printf (prepare_func, check_func, class_prefix, class_prefix)))); ccode.add_statement (funcs); ccall.add_argument (new CCodeCastExpression (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, new CCodeIdentifier ("_source_funcs")), "GSourceFuncs *")); @@ -585,7 +585,7 @@ if (m != null && m.return_type is ArrayType && async_call != ccall) { var array_type = (ArrayType) m.return_type; for (int dim = 1; dim <= array_type.rank; dim++) { - if (get_ccode_array_null_terminated (m)) { + if (get_ccode_array_null_terminated (m) && !get_ccode_array_length (m)) { // handle calls to methods returning null-terminated arrays var temp_var = get_temp_variable (itype.get_return_type (), true, null, false); var temp_ref = get_variable_cexpression (temp_var.name); @@ -652,7 +652,7 @@ if (deleg != null && deleg.return_type is ArrayType) { var array_type = (ArrayType) deleg.return_type; for (int dim = 1; dim <= array_type.rank; dim++) { - if (get_ccode_array_null_terminated (deleg)) { + if (get_ccode_array_null_terminated (deleg) && !get_ccode_array_length (deleg)) { // handle calls to methods returning null-terminated arrays var temp_var = get_temp_variable (itype.get_return_type (), true, null, false); var temp_ref = get_variable_cexpression (temp_var.name); @@ -980,9 +980,22 @@ var unary = arg as UnaryExpression; + // handle ref null terminated arrays + if (unary != null && unary.operator == UnaryOperator.REF + && unary.inner.symbol_reference != null && get_ccode_array_length (unary.inner.symbol_reference)) { + if (param != null && get_ccode_array_null_terminated (param) && !get_ccode_array_length (param) + && param.variable_type is ArrayType && ((ArrayType) param.variable_type).rank == 1) { + requires_array_length = true; + var len_call = new CCodeFunctionCall (new CCodeIdentifier ("_vala_array_length")); + len_call.add_argument (get_cvalue_ (unary.inner.target_value)); + ccode.add_assignment (get_array_length_cvalue (unary.inner.target_value, 1), len_call); + } + } + // update possible stale _*_size_ variable - if (unary != null && unary.operator == UnaryOperator.REF) { - if (param != null && get_ccode_array_length (param) && param.variable_type is ArrayType + if (unary != null && unary.operator == UnaryOperator.REF + && unary.inner.symbol_reference != null && get_ccode_array_length (unary.inner.symbol_reference)) { + if (param != null && param.variable_type is ArrayType && !((ArrayType) param.variable_type).fixed_length && ((ArrayType) param.variable_type).rank == 1) { unowned Variable? array_var = unary.inner.symbol_reference as Variable; if ((array_var is LocalVariable || array_var is Field) && array_var.is_internal_symbol () @@ -1010,7 +1023,8 @@ store_value (unary.inner.target_value, transform_value (unary.target_value, unary.inner.value_type, arg), expr.source_reference); // handle out null terminated arrays - if (param != null && get_ccode_array_null_terminated (param)) { + if (param != null && get_ccode_array_null_terminated (param) && !get_ccode_array_length (param) + && unary.inner.symbol_reference != null && get_ccode_array_length (unary.inner.symbol_reference)) { requires_array_length = true; var len_call = new CCodeFunctionCall (new CCodeIdentifier ("_vala_array_length")); len_call.add_argument (get_cvalue_ (unary.inner.target_value)); diff -Nru vala-0.56.16/configure vala-0.56.17/configure --- vala-0.56.16/configure 2024-03-14 09:03:00.000000000 +0000 +++ vala-0.56.17/configure 2024-04-19 11:03:09.000000000 +0000 @@ -1,6 +1,6 @@ #! /bin/sh # Guess values for system-dependent variables and create Makefiles. -# Generated by GNU Autoconf 2.71 for vala 0.56.16. +# Generated by GNU Autoconf 2.71 for vala 0.56.17. # # Report bugs to . # @@ -681,8 +681,8 @@ # Identity of this package. PACKAGE_NAME='vala' PACKAGE_TARNAME='vala' -PACKAGE_VERSION='0.56.16' -PACKAGE_STRING='vala 0.56.16' +PACKAGE_VERSION='0.56.17' +PACKAGE_STRING='vala 0.56.17' PACKAGE_BUGREPORT='https://gitlab.gnome.org/GNOME/vala/issues' PACKAGE_URL='https://wiki.gnome.org/Projects/Vala' @@ -1490,7 +1490,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.56.16 to adapt to many kinds of systems. +\`configure' configures vala 0.56.17 to adapt to many kinds of systems. Usage: $0 [OPTION]... [VAR=VALUE]... @@ -1561,7 +1561,7 @@ if test -n "$ac_init_help"; then case $ac_init_help in - short | recursive ) echo "Configuration of vala 0.56.16:";; + short | recursive ) echo "Configuration of vala 0.56.17:";; esac cat <<\_ACEOF @@ -1699,7 +1699,7 @@ test -n "$ac_init_help" && exit $ac_status if $ac_init_version; then cat <<\_ACEOF -vala configure 0.56.16 +vala configure 0.56.17 generated by GNU Autoconf 2.71 Copyright (C) 2021 Free Software Foundation, Inc. @@ -1960,7 +1960,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.56.16, which was +It was created by vala $as_me 0.56.17, which was generated by GNU Autoconf 2.71. Invocation command line was $ $0$ac_configure_args_raw @@ -3234,7 +3234,7 @@ # Define the identity of the package. PACKAGE='vala' - VERSION='0.56.16' + VERSION='0.56.17' printf "%s\n" "#define PACKAGE \"$PACKAGE\"" >>confdefs.h @@ -13478,6 +13478,7 @@ -Werror=compare-distinct-pointer-types \ -Werror=empty-body \ -Werror=comment \ +-Werror=null-dereference \ -Werror=strict-overflow \ -Werror=shift-overflow \ -Wformat=2 \ @@ -14912,7 +14913,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.56.16, which was +This file was extended by vala $as_me 0.56.17, which was generated by GNU Autoconf 2.71. Invocation command line was CONFIG_FILES = $CONFIG_FILES @@ -14981,7 +14982,7 @@ cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 ac_cs_config='$ac_cs_config_escaped' ac_cs_version="\\ -vala config.status 0.56.16 +vala config.status 0.56.17 configured by $0, generated by GNU Autoconf 2.71, with options \\"\$ac_cs_config\\" diff -Nru vala-0.56.16/configure.ac vala-0.56.17/configure.ac --- vala-0.56.16/configure.ac 2024-03-13 19:27:31.000000000 +0000 +++ vala-0.56.17/configure.ac 2024-04-19 10:23:19.000000000 +0000 @@ -135,6 +135,7 @@ -Werror=compare-distinct-pointer-types \ -Werror=empty-body \ -Werror=comment \ +-Werror=null-dereference \ -Werror=strict-overflow \ -Werror=shift-overflow \ -Wformat=2 \ diff -Nru vala-0.56.16/debian/changelog vala-0.56.17/debian/changelog --- vala-0.56.16/debian/changelog 2024-04-01 05:21:02.000000000 +0000 +++ vala-0.56.17/debian/changelog 2024-04-19 11:13:38.000000000 +0000 @@ -1,8 +1,10 @@ -vala (0.56.16-3build1) noble; urgency=medium +vala (0.56.17-1) unstable; urgency=medium - * No-change rebuild for CVE-2024-3094 + * New upstream release + * d/p/vala-Correctly-use-Path.build_path.patch: + Dropped, it is included upstream - -- William Grant Mon, 01 Apr 2024 16:21:02 +1100 + -- Rico Tzschichholz Fri, 19 Apr 2024 13:13:38 +0200 vala (0.56.16-3) unstable; urgency=medium diff -Nru vala-0.56.16/debian/control vala-0.56.17/debian/control --- vala-0.56.16/debian/control 2024-04-01 05:21:02.000000000 +0000 +++ vala-0.56.17/debian/control 2024-04-19 11:13:38.000000000 +0000 @@ -1,8 +1,7 @@ Source: vala Section: devel Priority: optional -Maintainer: Ubuntu Developers -XSBC-Original-Maintainer: Debian GNOME Maintainers +Maintainer: Debian GNOME Maintainers Uploaders: Iain Lane , Jeremy Bícha , Rico Tzschichholz Build-Depends: debhelper-compat (= 13), dh-sequence-gnome, diff -Nru vala-0.56.16/debian/patches/series vala-0.56.17/debian/patches/series --- vala-0.56.16/debian/patches/series 2024-03-26 10:47:15.000000000 +0000 +++ vala-0.56.17/debian/patches/series 1970-01-01 00:00:00.000000000 +0000 @@ -1 +0,0 @@ -vala-Correctly-use-Path.build_path.patch diff -Nru vala-0.56.16/debian/patches/vala-Correctly-use-Path.build_path.patch vala-0.56.17/debian/patches/vala-Correctly-use-Path.build_path.patch --- vala-0.56.16/debian/patches/vala-Correctly-use-Path.build_path.patch 2024-03-26 10:47:15.000000000 +0000 +++ vala-0.56.17/debian/patches/vala-Correctly-use-Path.build_path.patch 1970-01-01 00:00:00.000000000 +0000 @@ -1,36 +0,0 @@ -From: Simon McVittie -Date: Tue, 19 Mar 2024 02:13:52 +0000 -Subject: vala: Correctly use Path.build_path() - -The first argument to Path.build_path() is a separator, and for it to be -practically useful, at least two subsequent arguments are needed. - -Also to find GIR XML in /usr/share we should make the second argument be -an absolute path. - -Forwarded: https://gitlab.gnome.org/GNOME/vala/-/merge_requests/379 -Applied-upstream: 0.56.17, commit:5e963bf138bcac53c8a8cae4fa9053cfbf13a714 ---- - vala/valacodecontext.vala | 4 ++-- - 1 file changed, 2 insertions(+), 2 deletions(-) - -diff --git a/vala/valacodecontext.vala b/vala/valacodecontext.vala -index 8461403..59ef28c 100644 ---- a/vala/valacodecontext.vala -+++ b/vala/valacodecontext.vala -@@ -726,13 +726,13 @@ public class Vala.CodeContext { - } - - // Search $GI_GIRDIR set by user or retrieved from gobject-introspection-1.0.pc -- path = Path.build_path (Config.GI_GIRDIR, girname); -+ path = Path.build_path ("/", Config.GI_GIRDIR, girname); - if (FileUtils.test (path, FileTest.EXISTS | FileTest.IS_REGULAR)) { - return path; - } - - // Search /usr/share -- path = Path.build_path ("/", "usr", "share", GIR_SUFFIX, girname); -+ path = Path.build_path ("/", "/usr", "share", GIR_SUFFIX, girname); - if (FileUtils.test (path, FileTest.EXISTS | FileTest.IS_REGULAR)) { - return path; - } diff -Nru vala-0.56.16/doc/vala-gen-introspect.1 vala-0.56.17/doc/vala-gen-introspect.1 --- vala-0.56.16/doc/vala-gen-introspect.1 2024-03-14 08:58:51.000000000 +0000 +++ vala-0.56.17/doc/vala-gen-introspect.1 2024-04-19 10:52:38.000000000 +0000 @@ -1,5 +1,5 @@ .\" DO NOT MODIFY THIS FILE! It was generated by help2man 1.49.3. -.TH VALA-GEN-INTROSPECT "1" "March 2024" "gen-introspect 0.56.16" "User Commands" +.TH VALA-GEN-INTROSPECT "1" "April 2024" "gen-introspect 0.56.17" "User Commands" .SH NAME vala-gen-introspect \- generate a GI file for GObject and glib based packages .SH SYNOPSIS diff -Nru vala-0.56.16/doc/valac.1 vala-0.56.17/doc/valac.1 --- vala-0.56.16/doc/valac.1 2024-03-14 08:58:42.000000000 +0000 +++ vala-0.56.17/doc/valac.1 2024-04-19 10:52:30.000000000 +0000 @@ -1,5 +1,5 @@ .\" DO NOT MODIFY THIS FILE! It was generated by help2man 1.49.3. -.TH VALAC "1" "March 2024" "Vala 0.56.16" "User Commands" +.TH VALAC "1" "April 2024" "Vala 0.56.17" "User Commands" .SH NAME valac \- compiler that translates Vala source code into C source and header files .SH SYNOPSIS diff -Nru vala-0.56.16/doc/valadoc.1 vala-0.56.17/doc/valadoc.1 --- vala-0.56.16/doc/valadoc.1 2024-03-14 08:58:46.000000000 +0000 +++ vala-0.56.17/doc/valadoc.1 2024-04-19 10:52:33.000000000 +0000 @@ -1,5 +1,5 @@ .\" DO NOT MODIFY THIS FILE! It was generated by help2man 1.49.3. -.TH VALADOC "1" "March 2024" "Valadoc 0.56.16" "User Commands" +.TH VALADOC "1" "April 2024" "Valadoc 0.56.17" "User Commands" .SH NAME valadoc \- Vala Documentation Tool .SH SYNOPSIS diff -Nru vala-0.56.16/doc/vapigen.1 vala-0.56.17/doc/vapigen.1 --- vala-0.56.16/doc/vapigen.1 2024-03-14 08:58:55.000000000 +0000 +++ vala-0.56.17/doc/vapigen.1 2024-04-19 10:52:43.000000000 +0000 @@ -1,5 +1,5 @@ .\" DO NOT MODIFY THIS FILE! It was generated by help2man 1.49.3. -.TH VAPIGEN "1" "March 2024" "Vala API Generator 0.56.16" "User Commands" +.TH VAPIGEN "1" "April 2024" "Vala API Generator 0.56.17" "User Commands" .SH NAME vapigen \- generate a Vala API .SH SYNOPSIS diff -Nru vala-0.56.16/tests/Makefile.am vala-0.56.17/tests/Makefile.am --- vala-0.56.16/tests/Makefile.am 2024-03-13 19:27:39.000000000 +0000 +++ vala-0.56.17/tests/Makefile.am 2024-04-19 10:23:19.000000000 +0000 @@ -196,10 +196,13 @@ methods/extern.vala \ methods/iterator.vala \ methods/local-functions.vala \ + methods/local-functions-to-delegate.vala \ methods/parameter-fixed-array-initializer.vala \ methods/parameter-out-free-on-error.vala \ + methods/parameter-out-array-resize-null-terminated.vala \ methods/parameter-ref-array-resize.vala \ methods/parameter-ref-array-resize-captured.vala \ + methods/parameter-ref-array-resize-null-terminated.vala \ methods/parameter-ref-delegate.vala \ methods/parameter-ref-element-access.vala \ methods/preconditions-temp-variables.vala \ @@ -1085,6 +1088,7 @@ semantic/assignment-signal-incompatible-method.test \ semantic/assignment-signal-incompatible-type.test \ semantic/assignment-invalid-type.test \ + semantic/assignment-invalid-type-2.test \ semantic/cast-gvalue-unsupported.test \ semantic/cast-gvariant-unsupported.test \ semantic/cast-void-not-allowed.test \ diff -Nru vala-0.56.16/tests/Makefile.in vala-0.56.17/tests/Makefile.in --- vala-0.56.16/tests/Makefile.in 2024-03-14 09:03:01.000000000 +0000 +++ vala-0.56.17/tests/Makefile.in 2024-04-19 11:03:10.000000000 +0000 @@ -188,10 +188,13 @@ methods/contains.vala methods/ellipsis-preceding.test \ methods/extern.vala methods/iterator.vala \ methods/local-functions.vala \ + methods/local-functions-to-delegate.vala \ methods/parameter-fixed-array-initializer.vala \ methods/parameter-out-free-on-error.vala \ + methods/parameter-out-array-resize-null-terminated.vala \ methods/parameter-ref-array-resize.vala \ methods/parameter-ref-array-resize-captured.vala \ + methods/parameter-ref-array-resize-null-terminated.vala \ methods/parameter-ref-delegate.vala \ methods/parameter-ref-element-access.vala \ methods/preconditions-temp-variables.vala \ @@ -818,6 +821,7 @@ semantic/assignment-signal-incompatible-method.test \ semantic/assignment-signal-incompatible-type.test \ semantic/assignment-invalid-type.test \ + semantic/assignment-invalid-type-2.test \ semantic/cast-gvalue-unsupported.test \ semantic/cast-gvariant-unsupported.test \ semantic/cast-void-not-allowed.test \ diff -Nru vala-0.56.16/tests/gir/off_t.gir vala-0.56.17/tests/gir/off_t.gir --- vala-0.56.16/tests/gir/off_t.gir 2024-03-13 19:27:39.000000000 +0000 +++ vala-0.56.17/tests/gir/off_t.gir 2024-04-15 18:32:17.000000000 +0000 @@ -6,10 +6,20 @@ + + + + + + + + + + - + diff -Nru vala-0.56.16/tests/gir/off_t.vapi-expected vala-0.56.17/tests/gir/off_t.vapi-expected --- vala-0.56.16/tests/gir/off_t.vapi-expected 2024-03-13 19:27:39.000000000 +0000 +++ vala-0.56.17/tests/gir/off_t.vapi-expected 2024-04-15 18:32:17.000000000 +0000 @@ -1,5 +1,7 @@ [CCode (cprefix = "Test", gir_namespace = "Test", gir_version = "1.0", lower_case_cprefix = "test_")] namespace Test { [CCode (cheader_filename = "test.h")] - public static off_t function (off_t time); + public static off_t function (off_t offset); + [CCode (cheader_filename = "test.h")] + public static off_t function_compat (off_t offset); } diff -Nru vala-0.56.16/tests/gir/time_t.gir vala-0.56.17/tests/gir/time_t.gir --- vala-0.56.16/tests/gir/time_t.gir 2024-03-13 10:35:28.000000000 +0000 +++ vala-0.56.17/tests/gir/time_t.gir 2024-04-15 18:32:17.000000000 +0000 @@ -6,6 +6,16 @@ + + + + + + + + + + diff -Nru vala-0.56.16/tests/gir/time_t.vapi-expected vala-0.56.17/tests/gir/time_t.vapi-expected --- vala-0.56.16/tests/gir/time_t.vapi-expected 2024-03-13 10:35:28.000000000 +0000 +++ vala-0.56.17/tests/gir/time_t.vapi-expected 2024-04-15 18:32:17.000000000 +0000 @@ -2,4 +2,6 @@ namespace Test { [CCode (cheader_filename = "test.h")] public static time_t function (time_t time); + [CCode (cheader_filename = "test.h")] + public static time_t function_compat (time_t time); } diff -Nru vala-0.56.16/tests/methods/array-length-type.c-expected vala-0.56.17/tests/methods/array-length-type.c-expected --- vala-0.56.16/tests/methods/array-length-type.c-expected 2024-03-13 19:31:19.000000000 +0000 +++ vala-0.56.17/tests/methods/array-length-type.c-expected 2024-04-19 10:31:05.000000000 +0000 @@ -90,8 +90,8 @@ gint _manam_length1; gint __manam_size_; gint* _manar; - gint _manar_length1; - gint __manar_size_; + guint8 _manar_length1; + guint8 __manar_size_; }; struct _ParamSpecFoo { diff -Nru vala-0.56.16/tests/methods/local-functions-to-delegate.c-expected vala-0.56.17/tests/methods/local-functions-to-delegate.c-expected --- vala-0.56.16/tests/methods/local-functions-to-delegate.c-expected 1970-01-01 00:00:00.000000000 +0000 +++ vala-0.56.17/tests/methods/local-functions-to-delegate.c-expected 2024-04-19 10:31:05.000000000 +0000 @@ -0,0 +1,160 @@ +/* methods_local_functions_to_delegate.c generated by valac, the Vala compiler + * generated from methods_local_functions_to_delegate.vala, do not modify */ + +#include + +#if !defined(VALA_STRICT_C) +#if !defined(__clang__) && defined(__GNUC__) && (__GNUC__ >= 14) +#pragma GCC diagnostic warning "-Wincompatible-pointer-types" +#elif defined(__clang__) && (__clang_major__ >= 16) +#pragma clang diagnostic ignored "-Wincompatible-function-pointer-types" +#pragma clang diagnostic ignored "-Wincompatible-pointer-types" +#endif +#endif +#if !defined(VALA_EXTERN) +#if defined(_MSC_VER) +#define VALA_EXTERN __declspec(dllexport) extern +#elif __GNUC__ >= 4 +#define VALA_EXTERN __attribute__((visibility("default"))) extern +#else +#define VALA_EXTERN extern +#endif +#endif + +typedef gint (*Foo) (gint i, gpointer user_data); +typedef gint (*Bar) (gint i); +typedef gint (*_LocalFunc0_) (gint i, gpointer user_data); +typedef gint (*_LocalFunc1_) (gint i); +typedef struct _Block1Data Block1Data; +#define _vala_assert(expr, msg) if G_LIKELY (expr) ; else g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, msg); +#define _vala_return_if_fail(expr, msg) if G_LIKELY (expr) ; else { g_return_if_fail_warning (G_LOG_DOMAIN, G_STRFUNC, msg); return; } +#define _vala_return_val_if_fail(expr, msg, val) if G_LIKELY (expr) ; else { g_return_if_fail_warning (G_LOG_DOMAIN, G_STRFUNC, msg); return val; } +#define _vala_warn_if_fail(expr, msg) if G_LIKELY (expr) ; else g_warn_message (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, msg); + +struct _Block1Data { + int _ref_count_; + gint j; +}; + +VALA_EXTERN void foo (Foo f, + gpointer f_target); +VALA_EXTERN void bar (Bar b); +static void _vala_main (void); +static Block1Data* block1_data_ref (Block1Data* _data1_); +static void block1_data_unref (void * _userdata_); +static gint ___lambda4_ (Block1Data* _data1_, + gint i); +static gint ____lambda4___localfunc0_ (gint i, + gpointer self); +static gint ___lambda5_ (gint i); +static gint ____lambda5___localfunc1_ (gint i); + +void +foo (Foo f, + gpointer f_target) +{ + _vala_assert (f (13, f_target) == 39, "f (13) == 39"); +} + +void +bar (Bar b) +{ + _vala_assert (b (42) == 84, "b (42) == 84"); +} + +static Block1Data* +block1_data_ref (Block1Data* _data1_) +{ + g_atomic_int_inc (&_data1_->_ref_count_); + return _data1_; +} + +static void +block1_data_unref (void * _userdata_) +{ + Block1Data* _data1_; + _data1_ = (Block1Data*) _userdata_; + if (g_atomic_int_dec_and_test (&_data1_->_ref_count_)) { + g_slice_free (Block1Data, _data1_); + } +} + +static gint +___lambda4_ (Block1Data* _data1_, + gint i) +{ + gint result; + result = i * _data1_->j; + return result; +} + +static gint +____lambda4___localfunc0_ (gint i, + gpointer self) +{ + gint result; + result = ___lambda4_ (self, i); + return result; +} + +static gint +___lambda5_ (gint i) +{ + gint result; + result = 2 * i; + return result; +} + +static gint +____lambda5___localfunc1_ (gint i) +{ + gint result; + result = ___lambda5_ (i); + return result; +} + +static void +_vala_main (void) +{ + { + Block1Data* _data1_; + _LocalFunc0_ func = NULL; + gpointer func_target; + Foo f = NULL; + gpointer f_target; + GDestroyNotify f_target_destroy_notify; + _data1_ = g_slice_new0 (Block1Data); + _data1_->_ref_count_ = 1; + _data1_->j = 3; + func = ____lambda4___localfunc0_; + func_target = _data1_; + foo (func, func_target); + f = func; + f_target = func_target; + f_target_destroy_notify = NULL; + _vala_assert (f (23, f_target) == 69, "f (23) == 69"); + (f_target_destroy_notify == NULL) ? NULL : (f_target_destroy_notify (f_target), NULL); + f = NULL; + f_target = NULL; + f_target_destroy_notify = NULL; + block1_data_unref (_data1_); + _data1_ = NULL; + } + { + _LocalFunc1_ func = NULL; + Bar b = NULL; + func = ____lambda5___localfunc1_; + bar (func); + b = func; + _vala_assert (b (23) == 46, "b (23) == 46"); + } +} + +int +main (int argc, + char ** argv) +{ + _vala_main (); + return 0; +} + diff -Nru vala-0.56.16/tests/methods/local-functions-to-delegate.vala vala-0.56.17/tests/methods/local-functions-to-delegate.vala --- vala-0.56.16/tests/methods/local-functions-to-delegate.vala 1970-01-01 00:00:00.000000000 +0000 +++ vala-0.56.17/tests/methods/local-functions-to-delegate.vala 2024-04-15 18:32:17.000000000 +0000 @@ -0,0 +1,35 @@ +delegate int Foo (int i); + +[CCode (has_target = false)] +delegate int Bar (int i); + +void foo (Foo f) { + assert (f (13) == 39); +} + +void bar (Bar b) { + assert (b (42) == 84); +} + +void main () { + { + int j = 3; + int func (int i) { + return i * j; + } + foo (func); + + Foo f = func; + assert (f (23) == 69); + } + { + static int func (int i) { + return 2 * i; + } + bar (func); + + Bar b = func; + assert (b (23) == 46); + } +} + diff -Nru vala-0.56.16/tests/methods/parameter-out-array-resize-null-terminated.c-expected vala-0.56.17/tests/methods/parameter-out-array-resize-null-terminated.c-expected --- vala-0.56.16/tests/methods/parameter-out-array-resize-null-terminated.c-expected 1970-01-01 00:00:00.000000000 +0000 +++ vala-0.56.17/tests/methods/parameter-out-array-resize-null-terminated.c-expected 2024-04-19 10:31:05.000000000 +0000 @@ -0,0 +1,175 @@ +/* methods_parameter_out_array_resize_null_terminated.c generated by valac, the Vala compiler + * generated from methods_parameter_out_array_resize_null_terminated.vala, do not modify */ + +#include +#include +#include + +#if !defined(VALA_STRICT_C) +#if !defined(__clang__) && defined(__GNUC__) && (__GNUC__ >= 14) +#pragma GCC diagnostic warning "-Wincompatible-pointer-types" +#elif defined(__clang__) && (__clang_major__ >= 16) +#pragma clang diagnostic ignored "-Wincompatible-function-pointer-types" +#pragma clang diagnostic ignored "-Wincompatible-pointer-types" +#endif +#endif +#if !defined(VALA_EXTERN) +#if defined(_MSC_VER) +#define VALA_EXTERN __declspec(dllexport) extern +#elif __GNUC__ >= 4 +#define VALA_EXTERN __attribute__((visibility("default"))) extern +#else +#define VALA_EXTERN extern +#endif +#endif + +#define _vala_assert(expr, msg) if G_LIKELY (expr) ; else g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, msg); +#define _vala_return_if_fail(expr, msg) if G_LIKELY (expr) ; else { g_return_if_fail_warning (G_LOG_DOMAIN, G_STRFUNC, msg); return; } +#define _vala_return_val_if_fail(expr, msg, val) if G_LIKELY (expr) ; else { g_return_if_fail_warning (G_LOG_DOMAIN, G_STRFUNC, msg); return val; } +#define _vala_warn_if_fail(expr, msg) if G_LIKELY (expr) ; else g_warn_message (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, msg); + +VALA_EXTERN void foo (gchar*** bar); +VALA_EXTERN void faz (gchar*** bar); +static void _vala_main (void); +static void _vala_array_destroy (gpointer array, + gssize array_length, + GDestroyNotify destroy_func); +static void _vala_array_free (gpointer array, + gssize array_length, + GDestroyNotify destroy_func); +static gssize _vala_array_length (gpointer array); + +void +foo (gchar*** bar) +{ + gchar** _vala_bar = NULL; + gint _vala_bar_length1 = 0; + gchar* _tmp0_; + gchar* _tmp1_; + gchar* _tmp2_; + gchar* _tmp3_; + gchar** _tmp4_; + _tmp0_ = g_strdup ("foo"); + _tmp1_ = g_strdup ("bar"); + _tmp2_ = g_strdup ("manam"); + _tmp3_ = g_strdup ("!"); + _tmp4_ = g_new0 (gchar*, 4 + 1); + _tmp4_[0] = _tmp0_; + _tmp4_[1] = _tmp1_; + _tmp4_[2] = _tmp2_; + _tmp4_[3] = _tmp3_; + _vala_bar = (_vala_array_free (_vala_bar, _vala_array_length (_vala_bar), (GDestroyNotify) g_free), NULL); + _vala_bar = _tmp4_; + if (bar) { + *bar = _vala_bar; + } else { + _vala_bar = (_vala_array_free (_vala_bar, _vala_array_length (_vala_bar), (GDestroyNotify) g_free), NULL); + } +} + +void +faz (gchar*** bar) +{ + gchar** _vala_bar = NULL; + gint _vala_bar_length1 = 0; + gchar** _tmp0_ = NULL; + foo (&_tmp0_); + _vala_bar = (_vala_array_free (_vala_bar, _vala_array_length (_vala_bar), (GDestroyNotify) g_free), NULL); + _vala_bar = _tmp0_; + if (bar) { + *bar = _vala_bar; + } else { + _vala_bar = (_vala_array_free (_vala_bar, _vala_array_length (_vala_bar), (GDestroyNotify) g_free), NULL); + } +} + +static void +_vala_main (void) +{ + { + gchar** bar = NULL; + gint bar_length1 = 0; + gint _bar_size_ = 0; + gchar** _tmp0_ = NULL; + const gchar* _tmp1_; + const gchar* _tmp2_; + foo (&_tmp0_); + bar = (_vala_array_free (bar, bar_length1, (GDestroyNotify) g_free), NULL); + bar = _tmp0_; + bar_length1 = -1; + _bar_size_ = bar_length1; + bar_length1 = _vala_array_length (bar); + _vala_assert (bar_length1 == 4, "bar.length == 4"); + _tmp1_ = bar[2]; + _vala_assert (g_strcmp0 (_tmp1_, "manam") == 0, "bar[2] == \"manam\""); + _tmp2_ = bar[4]; + _vala_assert (_tmp2_ == NULL, "bar[4] == null"); + bar = (_vala_array_free (bar, bar_length1, (GDestroyNotify) g_free), NULL); + } + { + gchar** bar = NULL; + gint bar_length1 = 0; + gint _bar_size_ = 0; + gchar** _tmp3_ = NULL; + const gchar* _tmp4_; + const gchar* _tmp5_; + faz (&_tmp3_); + bar = (_vala_array_free (bar, bar_length1, (GDestroyNotify) g_free), NULL); + bar = _tmp3_; + bar_length1 = -1; + _bar_size_ = bar_length1; + bar_length1 = _vala_array_length (bar); + _vala_assert (bar_length1 == 4, "bar.length == 4"); + _tmp4_ = bar[2]; + _vala_assert (g_strcmp0 (_tmp4_, "manam") == 0, "bar[2] == \"manam\""); + _tmp5_ = bar[4]; + _vala_assert (_tmp5_ == NULL, "bar[4] == null"); + bar = (_vala_array_free (bar, bar_length1, (GDestroyNotify) g_free), NULL); + } +} + +int +main (int argc, + char ** argv) +{ + _vala_main (); + return 0; +} + +static void +_vala_array_destroy (gpointer array, + gssize array_length, + GDestroyNotify destroy_func) +{ + if ((array != NULL) && (destroy_func != NULL)) { + gssize i; + for (i = 0; i < array_length; i = i + 1) { + if (((gpointer*) array)[i] != NULL) { + destroy_func (((gpointer*) array)[i]); + } + } + } +} + +static void +_vala_array_free (gpointer array, + gssize array_length, + GDestroyNotify destroy_func) +{ + _vala_array_destroy (array, array_length, destroy_func); + g_free (array); +} + +static gssize +_vala_array_length (gpointer array) +{ + gssize length; + length = 0; + if (array) { + while (((gpointer*) array)[length]) { + length++; + } + } + return length; +} + diff -Nru vala-0.56.16/tests/methods/parameter-out-array-resize-null-terminated.vala vala-0.56.17/tests/methods/parameter-out-array-resize-null-terminated.vala --- vala-0.56.16/tests/methods/parameter-out-array-resize-null-terminated.vala 1970-01-01 00:00:00.000000000 +0000 +++ vala-0.56.17/tests/methods/parameter-out-array-resize-null-terminated.vala 2024-04-16 17:19:19.000000000 +0000 @@ -0,0 +1,24 @@ +void foo ([CCode (array_length = false, array_null_terminated = true)] out string[] bar) { + bar = { "foo", "bar", "manam", "!" }; +} + +void faz ([CCode (array_length = false, array_null_terminated = true)] out string[] bar) { + foo (out bar); +} + +void main () { + { + string[] bar; + foo (out bar); + assert (bar.length == 4); + assert (bar[2] == "manam"); + assert (bar[4] == null); + } + { + string[] bar; + faz (out bar); + assert (bar.length == 4); + assert (bar[2] == "manam"); + assert (bar[4] == null); + } +} diff -Nru vala-0.56.16/tests/methods/parameter-ref-array-resize-null-terminated.c-expected vala-0.56.17/tests/methods/parameter-ref-array-resize-null-terminated.c-expected --- vala-0.56.16/tests/methods/parameter-ref-array-resize-null-terminated.c-expected 1970-01-01 00:00:00.000000000 +0000 +++ vala-0.56.17/tests/methods/parameter-ref-array-resize-null-terminated.c-expected 2024-04-19 10:31:05.000000000 +0000 @@ -0,0 +1,190 @@ +/* methods_parameter_ref_array_resize_null_terminated.c generated by valac, the Vala compiler + * generated from methods_parameter_ref_array_resize_null_terminated.vala, do not modify */ + +#include +#include +#include + +#if !defined(VALA_STRICT_C) +#if !defined(__clang__) && defined(__GNUC__) && (__GNUC__ >= 14) +#pragma GCC diagnostic warning "-Wincompatible-pointer-types" +#elif defined(__clang__) && (__clang_major__ >= 16) +#pragma clang diagnostic ignored "-Wincompatible-function-pointer-types" +#pragma clang diagnostic ignored "-Wincompatible-pointer-types" +#endif +#endif +#if !defined(VALA_EXTERN) +#if defined(_MSC_VER) +#define VALA_EXTERN __declspec(dllexport) extern +#elif __GNUC__ >= 4 +#define VALA_EXTERN __attribute__((visibility("default"))) extern +#else +#define VALA_EXTERN extern +#endif +#endif + +#define _vala_assert(expr, msg) if G_LIKELY (expr) ; else g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, msg); +#define _vala_return_if_fail(expr, msg) if G_LIKELY (expr) ; else { g_return_if_fail_warning (G_LOG_DOMAIN, G_STRFUNC, msg); return; } +#define _vala_return_val_if_fail(expr, msg, val) if G_LIKELY (expr) ; else { g_return_if_fail_warning (G_LOG_DOMAIN, G_STRFUNC, msg); return val; } +#define _vala_warn_if_fail(expr, msg) if G_LIKELY (expr) ; else g_warn_message (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, msg); + +VALA_EXTERN void foo (gchar*** bar); +VALA_EXTERN void faz (gchar*** bar); +static void _vala_main (void); +static void _vala_array_destroy (gpointer array, + gssize array_length, + GDestroyNotify destroy_func); +static void _vala_array_free (gpointer array, + gssize array_length, + GDestroyNotify destroy_func); +static gssize _vala_array_length (gpointer array); + +void +foo (gchar*** bar) +{ + gchar* _tmp0_; + gchar* _tmp1_; + gchar* _tmp2_; + gchar* _tmp3_; + gchar** _tmp4_; + _tmp0_ = g_strdup ("foo"); + _tmp1_ = g_strdup ("bar"); + _tmp2_ = g_strdup ("manam"); + _tmp3_ = g_strdup ("!"); + _tmp4_ = g_new0 (gchar*, 4 + 1); + _tmp4_[0] = _tmp0_; + _tmp4_[1] = _tmp1_; + _tmp4_[2] = _tmp2_; + _tmp4_[3] = _tmp3_; + *bar = (_vala_array_free (*bar, _vala_array_length (*bar), (GDestroyNotify) g_free), NULL); + *bar = _tmp4_; +} + +void +faz (gchar*** bar) +{ + foo (bar); +} + +static void +_vala_main (void) +{ + { + gchar** bar = NULL; + gchar* _tmp0_; + gchar** _tmp1_; + gint bar_length1; + gint _bar_size_; + gchar** _tmp2_; + gint _tmp2__length1; + gchar** _tmp3_; + gint _tmp3__length1; + const gchar* _tmp4_; + gchar** _tmp5_; + gint _tmp5__length1; + const gchar* _tmp6_; + _tmp0_ = g_strdup ("bar"); + _tmp1_ = g_new0 (gchar*, 1 + 1); + _tmp1_[0] = _tmp0_; + bar = _tmp1_; + bar_length1 = 1; + _bar_size_ = bar_length1; + foo (&bar); + bar_length1 = _vala_array_length (bar); + _bar_size_ = bar_length1; + _tmp2_ = bar; + _tmp2__length1 = bar_length1; + _vala_assert (_tmp2__length1 == 4, "bar.length == 4"); + _tmp3_ = bar; + _tmp3__length1 = bar_length1; + _tmp4_ = _tmp3_[2]; + _vala_assert (g_strcmp0 (_tmp4_, "manam") == 0, "bar[2] == \"manam\""); + _tmp5_ = bar; + _tmp5__length1 = bar_length1; + _tmp6_ = _tmp5_[4]; + _vala_assert (_tmp6_ == NULL, "bar[4] == null"); + bar = (_vala_array_free (bar, bar_length1, (GDestroyNotify) g_free), NULL); + } + { + gchar** bar = NULL; + gchar* _tmp7_; + gchar** _tmp8_; + gint bar_length1; + gint _bar_size_; + gchar** _tmp9_; + gint _tmp9__length1; + gchar** _tmp10_; + gint _tmp10__length1; + const gchar* _tmp11_; + gchar** _tmp12_; + gint _tmp12__length1; + const gchar* _tmp13_; + _tmp7_ = g_strdup ("bar"); + _tmp8_ = g_new0 (gchar*, 1 + 1); + _tmp8_[0] = _tmp7_; + bar = _tmp8_; + bar_length1 = 1; + _bar_size_ = bar_length1; + faz (&bar); + bar_length1 = _vala_array_length (bar); + _bar_size_ = bar_length1; + _tmp9_ = bar; + _tmp9__length1 = bar_length1; + _vala_assert (_tmp9__length1 == 4, "bar.length == 4"); + _tmp10_ = bar; + _tmp10__length1 = bar_length1; + _tmp11_ = _tmp10_[2]; + _vala_assert (g_strcmp0 (_tmp11_, "manam") == 0, "bar[2] == \"manam\""); + _tmp12_ = bar; + _tmp12__length1 = bar_length1; + _tmp13_ = _tmp12_[4]; + _vala_assert (_tmp13_ == NULL, "bar[4] == null"); + bar = (_vala_array_free (bar, bar_length1, (GDestroyNotify) g_free), NULL); + } +} + +int +main (int argc, + char ** argv) +{ + _vala_main (); + return 0; +} + +static void +_vala_array_destroy (gpointer array, + gssize array_length, + GDestroyNotify destroy_func) +{ + if ((array != NULL) && (destroy_func != NULL)) { + gssize i; + for (i = 0; i < array_length; i = i + 1) { + if (((gpointer*) array)[i] != NULL) { + destroy_func (((gpointer*) array)[i]); + } + } + } +} + +static void +_vala_array_free (gpointer array, + gssize array_length, + GDestroyNotify destroy_func) +{ + _vala_array_destroy (array, array_length, destroy_func); + g_free (array); +} + +static gssize +_vala_array_length (gpointer array) +{ + gssize length; + length = 0; + if (array) { + while (((gpointer*) array)[length]) { + length++; + } + } + return length; +} + diff -Nru vala-0.56.16/tests/methods/parameter-ref-array-resize-null-terminated.vala vala-0.56.17/tests/methods/parameter-ref-array-resize-null-terminated.vala --- vala-0.56.16/tests/methods/parameter-ref-array-resize-null-terminated.vala 1970-01-01 00:00:00.000000000 +0000 +++ vala-0.56.17/tests/methods/parameter-ref-array-resize-null-terminated.vala 2024-04-16 17:19:19.000000000 +0000 @@ -0,0 +1,24 @@ +void foo ([CCode (array_length = false, array_null_terminated = true)] ref string[] bar) { + bar = { "foo", "bar", "manam", "!" }; +} + +void faz ([CCode (array_length = false, array_null_terminated = true)] ref string[] bar) { + foo (ref bar); +} + +void main () { + { + string[] bar = { "bar" }; + foo (ref bar); + assert (bar.length == 4); + assert (bar[2] == "manam"); + assert (bar[4] == null); + } + { + string[] bar = { "bar" }; + faz (ref bar); + assert (bar.length == 4); + assert (bar[2] == "manam"); + assert (bar[4] == null); + } +} diff -Nru vala-0.56.16/tests/objects/gsource.c-expected vala-0.56.17/tests/objects/gsource.c-expected --- vala-0.56.16/tests/objects/gsource.c-expected 2024-03-13 19:31:34.000000000 +0000 +++ vala-0.56.17/tests/objects/gsource.c-expected 2024-04-19 10:31:18.000000000 +0000 @@ -99,7 +99,7 @@ foo_source_new (void) { FooSource* self; - static const GSourceFuncs _source_funcs = { foo_source_real_prepare, foo_source_real_check, foo_source_real_dispatch, foo_source_finalize}; + static const GSourceFuncs _source_funcs = { foo_source_real_prepare, foo_source_real_check, foo_source_real_dispatch, foo_source_finalize, NULL, NULL}; self = (FooSource*) g_source_new ((GSourceFuncs *) (&_source_funcs), sizeof (FooSource)); foo_source_instance_init (self); return self; @@ -121,7 +121,7 @@ bar_source_new (gint timeout) { BarSource* self; - static const GSourceFuncs _source_funcs = { bar_source_real_prepare, bar_source_real_check, bar_source_real_dispatch, bar_source_finalize}; + static const GSourceFuncs _source_funcs = { bar_source_real_prepare, bar_source_real_check, bar_source_real_dispatch, bar_source_finalize, NULL, NULL}; self = (BarSource*) g_source_new ((GSourceFuncs *) (&_source_funcs), sizeof (BarSource)); bar_source_instance_init (self); self->custom_timeout = timeout; @@ -194,7 +194,7 @@ manam_source_new (void) { ManamSource* self; - static const GSourceFuncs _source_funcs = { NULL, NULL, manam_source_real_dispatch, manam_source_finalize}; + static const GSourceFuncs _source_funcs = { NULL, NULL, manam_source_real_dispatch, manam_source_finalize, NULL, NULL}; self = (ManamSource*) g_source_new ((GSourceFuncs *) (&_source_funcs), sizeof (ManamSource)); manam_source_instance_init (self); return self; diff -Nru vala-0.56.16/tests/objects/property-array.c-expected vala-0.56.17/tests/objects/property-array.c-expected --- vala-0.56.16/tests/objects/property-array.c-expected 2024-03-13 19:31:36.000000000 +0000 +++ vala-0.56.17/tests/objects/property-array.c-expected 2024-04-19 10:31:20.000000000 +0000 @@ -95,17 +95,9 @@ gint _array_v_length1; gint __array_v_size_; Manam** _array_no_length; - gint _array_no_length_length1; - gint __array_no_length_size_; Manam** _array_no_length_v; - gint _array_no_length_v_length1; - gint __array_no_length_v_size_; gchar** _strv; - gint _strv_length1; - gint __strv_size_; gchar** _strv_v; - gint _strv_v_length1; - gint __strv_v_size_; }; struct _ParamSpecFoo { @@ -127,17 +119,9 @@ struct _BarPrivate { Manam** _array; - gint _array_length1; - gint __array_size_; Manam** _array_v; - gint _array_v_length1; - gint __array_v_size_; gchar** _strv; - gint _strv_length1; - gint __strv_size_; gchar** _strv_v; - gint _strv_v_length1; - gint __strv_v_size_; }; static gint Foo_private_offset; @@ -450,7 +434,7 @@ gint _tmp0__length1; g_return_val_if_fail (IS_FOO (self), NULL); _tmp0_ = self->priv->_array_no_length; - _tmp0__length1 = self->priv->_array_no_length_length1; + _tmp0__length1 = _vala_array_length (self->priv->_array_no_length); result = _tmp0_; return result; } @@ -482,10 +466,8 @@ g_return_if_fail (IS_FOO (self)); _tmp0_ = (value != NULL) ? _vala_array_dup3 (value, _vala_array_length (value)) : value; _tmp0__length1 = _vala_array_length (value); - self->priv->_array_no_length = (_vala_array_free (self->priv->_array_no_length, self->priv->_array_no_length_length1, (GDestroyNotify) manam_free), NULL); + self->priv->_array_no_length = (_vala_array_free (self->priv->_array_no_length, _vala_array_length (self->priv->_array_no_length), (GDestroyNotify) manam_free), NULL); self->priv->_array_no_length = _tmp0_; - self->priv->_array_no_length_length1 = _tmp0__length1; - self->priv->__array_no_length_size_ = self->priv->_array_no_length_length1; } Manam** @@ -509,7 +491,7 @@ gint _tmp0__length1; self = base; _tmp0_ = self->priv->_array_no_length_v; - _tmp0__length1 = self->priv->_array_no_length_v_length1; + _tmp0__length1 = _vala_array_length (self->priv->_array_no_length_v); result = _tmp0_; return result; } @@ -554,10 +536,8 @@ self = base; _tmp0_ = (value != NULL) ? _vala_array_dup4 (value, _vala_array_length (value)) : value; _tmp0__length1 = _vala_array_length (value); - self->priv->_array_no_length_v = (_vala_array_free (self->priv->_array_no_length_v, self->priv->_array_no_length_v_length1, (GDestroyNotify) manam_free), NULL); + self->priv->_array_no_length_v = (_vala_array_free (self->priv->_array_no_length_v, _vala_array_length (self->priv->_array_no_length_v), (GDestroyNotify) manam_free), NULL); self->priv->_array_no_length_v = _tmp0_; - self->priv->_array_no_length_v_length1 = _tmp0__length1; - self->priv->__array_no_length_v_size_ = self->priv->_array_no_length_v_length1; } gchar** @@ -568,7 +548,7 @@ gint _tmp0__length1; g_return_val_if_fail (IS_FOO (self), NULL); _tmp0_ = self->priv->_strv; - _tmp0__length1 = self->priv->_strv_length1; + _tmp0__length1 = _vala_array_length (self->priv->_strv); result = _tmp0_; return result; } @@ -600,10 +580,8 @@ g_return_if_fail (IS_FOO (self)); _tmp0_ = (value != NULL) ? _vala_array_dup5 (value, _vala_array_length (value)) : value; _tmp0__length1 = _vala_array_length (value); - self->priv->_strv = (_vala_array_free (self->priv->_strv, self->priv->_strv_length1, (GDestroyNotify) g_free), NULL); + self->priv->_strv = (_vala_array_free (self->priv->_strv, _vala_array_length (self->priv->_strv), (GDestroyNotify) g_free), NULL); self->priv->_strv = _tmp0_; - self->priv->_strv_length1 = _tmp0__length1; - self->priv->__strv_size_ = self->priv->_strv_length1; } gchar** @@ -627,7 +605,7 @@ gint _tmp0__length1; self = base; _tmp0_ = self->priv->_strv_v; - _tmp0__length1 = self->priv->_strv_v_length1; + _tmp0__length1 = _vala_array_length (self->priv->_strv_v); result = _tmp0_; return result; } @@ -672,10 +650,8 @@ self = base; _tmp0_ = (value != NULL) ? _vala_array_dup6 (value, _vala_array_length (value)) : value; _tmp0__length1 = _vala_array_length (value); - self->priv->_strv_v = (_vala_array_free (self->priv->_strv_v, self->priv->_strv_v_length1, (GDestroyNotify) g_free), NULL); + self->priv->_strv_v = (_vala_array_free (self->priv->_strv_v, _vala_array_length (self->priv->_strv_v), (GDestroyNotify) g_free), NULL); self->priv->_strv_v = _tmp0_; - self->priv->_strv_v_length1 = _tmp0__length1; - self->priv->__strv_v_size_ = self->priv->_strv_v_length1; } static void @@ -842,10 +818,10 @@ g_signal_handlers_destroy (self); self->priv->_array = (_vala_array_free (self->priv->_array, self->priv->_array_length1, (GDestroyNotify) manam_free), NULL); self->priv->_array_v = (_vala_array_free (self->priv->_array_v, self->priv->_array_v_length1, (GDestroyNotify) manam_free), NULL); - self->priv->_array_no_length = (_vala_array_free (self->priv->_array_no_length, self->priv->_array_no_length_length1, (GDestroyNotify) manam_free), NULL); - self->priv->_array_no_length_v = (_vala_array_free (self->priv->_array_no_length_v, self->priv->_array_no_length_v_length1, (GDestroyNotify) manam_free), NULL); - self->priv->_strv = (_vala_array_free (self->priv->_strv, self->priv->_strv_length1, (GDestroyNotify) g_free), NULL); - self->priv->_strv_v = (_vala_array_free (self->priv->_strv_v, self->priv->_strv_v_length1, (GDestroyNotify) g_free), NULL); + self->priv->_array_no_length = (_vala_array_free (self->priv->_array_no_length, _vala_array_length (self->priv->_array_no_length), (GDestroyNotify) manam_free), NULL); + self->priv->_array_no_length_v = (_vala_array_free (self->priv->_array_no_length_v, _vala_array_length (self->priv->_array_no_length_v), (GDestroyNotify) manam_free), NULL); + self->priv->_strv = (_vala_array_free (self->priv->_strv, _vala_array_length (self->priv->_strv), (GDestroyNotify) g_free), NULL); + self->priv->_strv_v = (_vala_array_free (self->priv->_strv_v, _vala_array_length (self->priv->_strv_v), (GDestroyNotify) g_free), NULL); } static GType @@ -920,7 +896,7 @@ gint _tmp0__length1; g_return_val_if_fail (IS_BAR (self), NULL); _tmp0_ = self->priv->_array; - _tmp0__length1 = self->priv->_array_length1; + _tmp0__length1 = _vala_array_length (self->priv->_array); result = _tmp0_; return result; } @@ -955,10 +931,8 @@ gint _tmp0__length1; _tmp0_ = (value != NULL) ? _vala_array_dup7 (value, _vala_array_length (value)) : value; _tmp0__length1 = _vala_array_length (value); - self->priv->_array = (_vala_array_free (self->priv->_array, self->priv->_array_length1, (GDestroyNotify) manam_free), NULL); + self->priv->_array = (_vala_array_free (self->priv->_array, _vala_array_length (self->priv->_array), (GDestroyNotify) manam_free), NULL); self->priv->_array = _tmp0_; - self->priv->_array_length1 = _tmp0__length1; - self->priv->__array_size_ = self->priv->_array_length1; g_object_notify_by_pspec ((GObject *) self, bar_properties[BAR_ARRAY_PROPERTY]); } } @@ -984,7 +958,7 @@ gint _tmp0__length1; self = base; _tmp0_ = self->priv->_array_v; - _tmp0__length1 = self->priv->_array_v_length1; + _tmp0__length1 = _vala_array_length (self->priv->_array_v); result = _tmp0_; return result; } @@ -1032,10 +1006,8 @@ gint _tmp0__length1; _tmp0_ = (value != NULL) ? _vala_array_dup8 (value, _vala_array_length (value)) : value; _tmp0__length1 = _vala_array_length (value); - self->priv->_array_v = (_vala_array_free (self->priv->_array_v, self->priv->_array_v_length1, (GDestroyNotify) manam_free), NULL); + self->priv->_array_v = (_vala_array_free (self->priv->_array_v, _vala_array_length (self->priv->_array_v), (GDestroyNotify) manam_free), NULL); self->priv->_array_v = _tmp0_; - self->priv->_array_v_length1 = _tmp0__length1; - self->priv->__array_v_size_ = self->priv->_array_v_length1; g_object_notify_by_pspec ((GObject *) self, bar_properties[BAR_ARRAY_V_PROPERTY]); } } @@ -1048,7 +1020,7 @@ gint _tmp0__length1; g_return_val_if_fail (IS_BAR (self), NULL); _tmp0_ = self->priv->_strv; - _tmp0__length1 = self->priv->_strv_length1; + _tmp0__length1 = _vala_array_length (self->priv->_strv); result = _tmp0_; return result; } @@ -1083,10 +1055,8 @@ gint _tmp0__length1; _tmp0_ = (value != NULL) ? _vala_array_dup9 (value, _vala_array_length (value)) : value; _tmp0__length1 = _vala_array_length (value); - self->priv->_strv = (_vala_array_free (self->priv->_strv, self->priv->_strv_length1, (GDestroyNotify) g_free), NULL); + self->priv->_strv = (_vala_array_free (self->priv->_strv, _vala_array_length (self->priv->_strv), (GDestroyNotify) g_free), NULL); self->priv->_strv = _tmp0_; - self->priv->_strv_length1 = _tmp0__length1; - self->priv->__strv_size_ = self->priv->_strv_length1; g_object_notify_by_pspec ((GObject *) self, bar_properties[BAR_STRV_PROPERTY]); } } @@ -1112,7 +1082,7 @@ gint _tmp0__length1; self = base; _tmp0_ = self->priv->_strv_v; - _tmp0__length1 = self->priv->_strv_v_length1; + _tmp0__length1 = _vala_array_length (self->priv->_strv_v); result = _tmp0_; return result; } @@ -1160,10 +1130,8 @@ gint _tmp0__length1; _tmp0_ = (value != NULL) ? _vala_array_dup10 (value, _vala_array_length (value)) : value; _tmp0__length1 = _vala_array_length (value); - self->priv->_strv_v = (_vala_array_free (self->priv->_strv_v, self->priv->_strv_v_length1, (GDestroyNotify) g_free), NULL); + self->priv->_strv_v = (_vala_array_free (self->priv->_strv_v, _vala_array_length (self->priv->_strv_v), (GDestroyNotify) g_free), NULL); self->priv->_strv_v = _tmp0_; - self->priv->_strv_v_length1 = _tmp0__length1; - self->priv->__strv_v_size_ = self->priv->_strv_v_length1; g_object_notify_by_pspec ((GObject *) self, bar_properties[BAR_STRV_V_PROPERTY]); } } @@ -1199,10 +1167,10 @@ { Bar * self; self = G_TYPE_CHECK_INSTANCE_CAST (obj, TYPE_BAR, Bar); - self->priv->_array = (_vala_array_free (self->priv->_array, self->priv->_array_length1, (GDestroyNotify) manam_free), NULL); - self->priv->_array_v = (_vala_array_free (self->priv->_array_v, self->priv->_array_v_length1, (GDestroyNotify) manam_free), NULL); - self->priv->_strv = (_vala_array_free (self->priv->_strv, self->priv->_strv_length1, (GDestroyNotify) g_free), NULL); - self->priv->_strv_v = (_vala_array_free (self->priv->_strv_v, self->priv->_strv_v_length1, (GDestroyNotify) g_free), NULL); + self->priv->_array = (_vala_array_free (self->priv->_array, _vala_array_length (self->priv->_array), (GDestroyNotify) manam_free), NULL); + self->priv->_array_v = (_vala_array_free (self->priv->_array_v, _vala_array_length (self->priv->_array_v), (GDestroyNotify) manam_free), NULL); + self->priv->_strv = (_vala_array_free (self->priv->_strv, _vala_array_length (self->priv->_strv), (GDestroyNotify) g_free), NULL); + self->priv->_strv_v = (_vala_array_free (self->priv->_strv_v, _vala_array_length (self->priv->_strv_v), (GDestroyNotify) g_free), NULL); G_OBJECT_CLASS (bar_parent_class)->finalize (obj); } diff -Nru vala-0.56.16/tests/objects/property-delegate.c-expected vala-0.56.17/tests/objects/property-delegate.c-expected --- vala-0.56.16/tests/objects/property-delegate.c-expected 2024-03-13 19:31:36.000000000 +0000 +++ vala-0.56.17/tests/objects/property-delegate.c-expected 2024-04-19 10:31:21.000000000 +0000 @@ -86,11 +86,7 @@ gpointer _deleg_v_target; GDestroyNotify _deleg_v_target_destroy_notify; Manam _deleg_no_target; - gpointer _deleg_no_target_target; - GDestroyNotify _deleg_no_target_target_destroy_notify; Manam _deleg_no_target_v; - gpointer _deleg_no_target_v_target; - GDestroyNotify _deleg_no_target_v_target_destroy_notify; }; struct _ParamSpecFoo { @@ -110,11 +106,7 @@ struct _BarPrivate { Manam _deleg; - gpointer _deleg_target; - GDestroyNotify _deleg_target_destroy_notify; Manam _deleg_v; - gpointer _deleg_v_target; - GDestroyNotify _deleg_v_target_destroy_notify; }; static gint Foo_private_offset; @@ -303,7 +295,7 @@ gpointer _tmp0__target; g_return_val_if_fail (IS_FOO (self), NULL); _tmp0_ = self->priv->_deleg_no_target; - _tmp0__target = self->priv->_deleg_no_target_target; + _tmp0__target = NULL; result = _tmp0_; return result; } @@ -313,13 +305,7 @@ Manam value) { g_return_if_fail (IS_FOO (self)); - (self->priv->_deleg_no_target_target_destroy_notify == NULL) ? NULL : (self->priv->_deleg_no_target_target_destroy_notify (self->priv->_deleg_no_target_target), NULL); - self->priv->_deleg_no_target = NULL; - self->priv->_deleg_no_target_target = NULL; - self->priv->_deleg_no_target_target_destroy_notify = NULL; self->priv->_deleg_no_target = value; - self->priv->_deleg_no_target_target = NULL; - self->priv->_deleg_no_target_target_destroy_notify = NULL; } Manam @@ -343,7 +329,7 @@ gpointer _tmp0__target; self = base; _tmp0_ = self->priv->_deleg_no_target_v; - _tmp0__target = self->priv->_deleg_no_target_v_target; + _tmp0__target = NULL; result = _tmp0_; return result; } @@ -366,13 +352,7 @@ { Foo* self; self = base; - (self->priv->_deleg_no_target_v_target_destroy_notify == NULL) ? NULL : (self->priv->_deleg_no_target_v_target_destroy_notify (self->priv->_deleg_no_target_v_target), NULL); - self->priv->_deleg_no_target_v = NULL; - self->priv->_deleg_no_target_v_target = NULL; - self->priv->_deleg_no_target_v_target_destroy_notify = NULL; self->priv->_deleg_no_target_v = value; - self->priv->_deleg_no_target_v_target = NULL; - self->priv->_deleg_no_target_v_target_destroy_notify = NULL; } static void @@ -543,14 +523,6 @@ self->priv->_deleg_v = NULL; self->priv->_deleg_v_target = NULL; self->priv->_deleg_v_target_destroy_notify = NULL; - (self->priv->_deleg_no_target_target_destroy_notify == NULL) ? NULL : (self->priv->_deleg_no_target_target_destroy_notify (self->priv->_deleg_no_target_target), NULL); - self->priv->_deleg_no_target = NULL; - self->priv->_deleg_no_target_target = NULL; - self->priv->_deleg_no_target_target_destroy_notify = NULL; - (self->priv->_deleg_no_target_v_target_destroy_notify == NULL) ? NULL : (self->priv->_deleg_no_target_v_target_destroy_notify (self->priv->_deleg_no_target_v_target), NULL); - self->priv->_deleg_no_target_v = NULL; - self->priv->_deleg_no_target_v_target = NULL; - self->priv->_deleg_no_target_v_target_destroy_notify = NULL; } static GType @@ -625,7 +597,7 @@ gpointer _tmp0__target; g_return_val_if_fail (IS_BAR (self), NULL); _tmp0_ = self->priv->_deleg; - _tmp0__target = self->priv->_deleg_target; + _tmp0__target = NULL; result = _tmp0_; return result; } @@ -638,13 +610,7 @@ g_return_if_fail (IS_BAR (self)); old_value = bar_get_deleg (self); if (old_value != value) { - (self->priv->_deleg_target_destroy_notify == NULL) ? NULL : (self->priv->_deleg_target_destroy_notify (self->priv->_deleg_target), NULL); - self->priv->_deleg = NULL; - self->priv->_deleg_target = NULL; - self->priv->_deleg_target_destroy_notify = NULL; self->priv->_deleg = value; - self->priv->_deleg_target = NULL; - self->priv->_deleg_target_destroy_notify = NULL; g_object_notify_by_pspec ((GObject *) self, bar_properties[BAR_DELEG_PROPERTY]); } } @@ -670,7 +636,7 @@ gpointer _tmp0__target; self = base; _tmp0_ = self->priv->_deleg_v; - _tmp0__target = self->priv->_deleg_v_target; + _tmp0__target = NULL; result = _tmp0_; return result; } @@ -696,13 +662,7 @@ self = base; old_value = bar_real_get_deleg_v (base); if (old_value != value) { - (self->priv->_deleg_v_target_destroy_notify == NULL) ? NULL : (self->priv->_deleg_v_target_destroy_notify (self->priv->_deleg_v_target), NULL); - self->priv->_deleg_v = NULL; - self->priv->_deleg_v_target = NULL; - self->priv->_deleg_v_target_destroy_notify = NULL; self->priv->_deleg_v = value; - self->priv->_deleg_v_target = NULL; - self->priv->_deleg_v_target_destroy_notify = NULL; g_object_notify_by_pspec ((GObject *) self, bar_properties[BAR_DELEG_V_PROPERTY]); } } @@ -734,14 +694,6 @@ { Bar * self; self = G_TYPE_CHECK_INSTANCE_CAST (obj, TYPE_BAR, Bar); - (self->priv->_deleg_target_destroy_notify == NULL) ? NULL : (self->priv->_deleg_target_destroy_notify (self->priv->_deleg_target), NULL); - self->priv->_deleg = NULL; - self->priv->_deleg_target = NULL; - self->priv->_deleg_target_destroy_notify = NULL; - (self->priv->_deleg_v_target_destroy_notify == NULL) ? NULL : (self->priv->_deleg_v_target_destroy_notify (self->priv->_deleg_v_target), NULL); - self->priv->_deleg_v = NULL; - self->priv->_deleg_v_target = NULL; - self->priv->_deleg_v_target_destroy_notify = NULL; G_OBJECT_CLASS (bar_parent_class)->finalize (obj); } diff -Nru vala-0.56.16/tests/objects/property-strv-noaccessor.c-expected vala-0.56.17/tests/objects/property-strv-noaccessor.c-expected --- vala-0.56.16/tests/objects/property-strv-noaccessor.c-expected 2024-03-13 19:31:37.000000000 +0000 +++ vala-0.56.17/tests/objects/property-strv-noaccessor.c-expected 2024-04-19 10:31:21.000000000 +0000 @@ -57,8 +57,6 @@ struct _FooPrivate { gchar** _bar; - gint _bar_length1; - gint __bar_size_; }; static gint Foo_private_offset; @@ -142,7 +140,7 @@ gint _tmp1__length1; g_return_val_if_fail (IS_FOO (self), NULL); _tmp0_ = self->priv->_bar; - _tmp0__length1 = self->priv->_bar_length1; + _tmp0__length1 = _vala_array_length (self->priv->_bar); _tmp1_ = (_tmp0_ != NULL) ? _vala_array_dup1 (_tmp0_, _tmp0__length1) : _tmp0_; _tmp1__length1 = _tmp0__length1; result = _tmp1_; @@ -179,10 +177,8 @@ gint _tmp0__length1; _tmp0_ = (value != NULL) ? _vala_array_dup2 (value, _vala_array_length (value)) : value; _tmp0__length1 = _vala_array_length (value); - self->priv->_bar = (_vala_array_free (self->priv->_bar, self->priv->_bar_length1, (GDestroyNotify) g_free), NULL); + self->priv->_bar = (_vala_array_free (self->priv->_bar, _vala_array_length (self->priv->_bar), (GDestroyNotify) g_free), NULL); self->priv->_bar = _tmp0_; - self->priv->_bar_length1 = _tmp0__length1; - self->priv->__bar_size_ = self->priv->_bar_length1; g_object_notify_by_pspec ((GObject *) self, foo_properties[FOO_BAR_PROPERTY]); } old_value = (g_free (old_value), NULL); @@ -212,7 +208,7 @@ { Foo * self; self = G_TYPE_CHECK_INSTANCE_CAST (obj, TYPE_FOO, Foo); - self->priv->_bar = (_vala_array_free (self->priv->_bar, self->priv->_bar_length1, (GDestroyNotify) g_free), NULL); + self->priv->_bar = (_vala_array_free (self->priv->_bar, _vala_array_length (self->priv->_bar), (GDestroyNotify) g_free), NULL); G_OBJECT_CLASS (foo_parent_class)->finalize (obj); } diff -Nru vala-0.56.16/tests/semantic/assignment-invalid-type-2.test vala-0.56.17/tests/semantic/assignment-invalid-type-2.test --- vala-0.56.16/tests/semantic/assignment-invalid-type-2.test 1970-01-01 00:00:00.000000000 +0000 +++ vala-0.56.17/tests/semantic/assignment-invalid-type-2.test 2024-04-17 07:08:19.000000000 +0000 @@ -0,0 +1,14 @@ +Invalid Code + +enum Foo { + MANAM; +} + +class Bar : Object { + public Foo foo { get; set; } +} + +void main () { + var bar = new Bar (); + bar.foo = Foo; +} diff -Nru vala-0.56.16/vala/vala.h vala-0.56.17/vala/vala.h --- vala-0.56.16/vala/vala.h 2024-03-14 09:03:18.000000000 +0000 +++ vala-0.56.17/vala/vala.h 2024-04-19 11:03:19.000000000 +0000 @@ -24,9 +24,9 @@ #endif #define VALA_MAJOR_VERSION 0 #define VALA_MINOR_VERSION 56 -#define VALA_MICRO_VERSION 16 +#define VALA_MICRO_VERSION 17 #define VALA_API_VERSION "0.56" -#define VALA_BUILD_VERSION "0.56.16" +#define VALA_BUILD_VERSION "0.56.17" #define VALA_TYPE_CODE_NODE (vala_code_node_get_type ()) #define VALA_CODE_NODE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CODE_NODE, ValaCodeNode)) diff -Nru vala-0.56.16/vala/valaassignment.c vala-0.56.17/vala/valaassignment.c --- vala-0.56.16/vala/valaassignment.c 2024-03-14 09:03:17.000000000 +0000 +++ vala-0.56.17/vala/valaassignment.c 2024-04-19 11:03:18.000000000 +0000 @@ -386,14 +386,14 @@ gboolean _tmp283_ = FALSE; ValaAssignmentOperator _tmp284_; ValaMemberAccess* _tmp348_; - ValaExpression* _tmp679_; - ValaExpression* _tmp680_; - ValaDataType* _tmp681_; - ValaDataType* _tmp682_; - ValaDataType* _tmp691_; - ValaDataType* _tmp692_; - gboolean _tmp695_; - gboolean _tmp696_; + ValaExpression* _tmp685_; + ValaExpression* _tmp686_; + ValaDataType* _tmp687_; + ValaDataType* _tmp688_; + ValaDataType* _tmp697_; + ValaDataType* _tmp698_; + gboolean _tmp701_; + gboolean _tmp702_; gboolean result; self = (ValaAssignment*) base; g_return_val_if_fail (context != NULL, FALSE); @@ -1417,16 +1417,16 @@ ValaMemberAccess* _tmp349_; ValaSymbol* _tmp350_; ValaSymbol* _tmp351_; - gboolean _tmp468_ = FALSE; - ValaExpression* _tmp469_; - ValaExpression* _tmp470_; - ValaDataType* _tmp471_; - ValaDataType* _tmp472_; + gboolean _tmp474_ = FALSE; + ValaExpression* _tmp475_; + ValaExpression* _tmp476_; + ValaDataType* _tmp477_; + ValaDataType* _tmp478_; ValaMemberAccess* right_ma = NULL; - ValaExpression* _tmp556_; - ValaExpression* _tmp557_; - gboolean _tmp558_ = FALSE; - ValaMemberAccess* _tmp559_; + ValaExpression* _tmp562_; + ValaExpression* _tmp563_; + gboolean _tmp564_ = FALSE; + ValaMemberAccess* _tmp565_; _tmp349_ = ma; _tmp350_ = vala_expression_get_symbol_reference ((ValaExpression*) _tmp349_); _tmp351_ = _tmp350_; @@ -1435,313 +1435,331 @@ ValaMemberAccess* _tmp352_; ValaSymbol* _tmp353_; ValaSymbol* _tmp354_; + ValaExpression* _tmp355_; + ValaExpression* _tmp356_; + ValaDataType* _tmp357_; + ValaDataType* _tmp358_; ValaDynamicProperty* dynamic_prop = NULL; - ValaProperty* _tmp355_; - ValaDynamicProperty* _tmp356_; + ValaProperty* _tmp361_; + ValaDynamicProperty* _tmp362_; _tmp352_ = ma; _tmp353_ = vala_expression_get_symbol_reference ((ValaExpression*) _tmp352_); _tmp354_ = _tmp353_; prop = G_TYPE_CHECK_INSTANCE_CAST (_tmp354_, VALA_TYPE_PROPERTY, ValaProperty); - _tmp355_ = prop; - dynamic_prop = VALA_IS_DYNAMIC_PROPERTY (_tmp355_) ? ((ValaDynamicProperty*) _tmp355_) : NULL; - _tmp356_ = dynamic_prop; - if (_tmp356_ != NULL) { - ValaDynamicProperty* _tmp357_; - ValaExpression* _tmp358_; - ValaExpression* _tmp359_; - ValaDataType* _tmp360_; - ValaDataType* _tmp361_; - ValaDataType* _tmp362_; - ValaDataType* _tmp363_; + _tmp355_ = vala_assignment_get_right (self); + _tmp356_ = _tmp355_; + _tmp357_ = vala_expression_get_value_type (_tmp356_); + _tmp358_ = _tmp357_; + if (_tmp358_ == NULL) { + ValaSourceReference* _tmp359_; + ValaSourceReference* _tmp360_; + vala_code_node_set_error ((ValaCodeNode*) self, TRUE); + _tmp359_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); + _tmp360_ = _tmp359_; + vala_report_error (_tmp360_, "Assignment: Invalid assignment attempt"); + result = FALSE; + return result; + } + _tmp361_ = prop; + dynamic_prop = VALA_IS_DYNAMIC_PROPERTY (_tmp361_) ? ((ValaDynamicProperty*) _tmp361_) : NULL; + _tmp362_ = dynamic_prop; + if (_tmp362_ != NULL) { + ValaDynamicProperty* _tmp363_; ValaExpression* _tmp364_; ValaExpression* _tmp365_; - ValaDynamicProperty* _tmp366_; + ValaDataType* _tmp366_; ValaDataType* _tmp367_; ValaDataType* _tmp368_; ValaDataType* _tmp369_; - ValaDataType* _tmp370_; - _tmp357_ = dynamic_prop; - _tmp358_ = vala_assignment_get_right (self); - _tmp359_ = _tmp358_; - _tmp360_ = vala_expression_get_value_type (_tmp359_); - _tmp361_ = _tmp360_; - _tmp362_ = vala_data_type_copy (_tmp361_); - _tmp363_ = _tmp362_; - vala_property_set_property_type ((ValaProperty*) _tmp357_, _tmp363_); - _vala_code_node_unref0 (_tmp363_); - _tmp364_ = vala_assignment_get_left (self); + ValaExpression* _tmp370_; + ValaExpression* _tmp371_; + ValaDynamicProperty* _tmp372_; + ValaDataType* _tmp373_; + ValaDataType* _tmp374_; + ValaDataType* _tmp375_; + ValaDataType* _tmp376_; + _tmp363_ = dynamic_prop; + _tmp364_ = vala_assignment_get_right (self); _tmp365_ = _tmp364_; - _tmp366_ = dynamic_prop; - _tmp367_ = vala_property_get_property_type ((ValaProperty*) _tmp366_); - _tmp368_ = _tmp367_; - _tmp369_ = vala_data_type_copy (_tmp368_); - _tmp370_ = _tmp369_; - vala_expression_set_value_type (_tmp365_, _tmp370_); - _vala_code_node_unref0 (_tmp370_); + _tmp366_ = vala_expression_get_value_type (_tmp365_); + _tmp367_ = _tmp366_; + _tmp368_ = vala_data_type_copy (_tmp367_); + _tmp369_ = _tmp368_; + vala_property_set_property_type ((ValaProperty*) _tmp363_, _tmp369_); + _vala_code_node_unref0 (_tmp369_); + _tmp370_ = vala_assignment_get_left (self); + _tmp371_ = _tmp370_; + _tmp372_ = dynamic_prop; + _tmp373_ = vala_property_get_property_type ((ValaProperty*) _tmp372_); + _tmp374_ = _tmp373_; + _tmp375_ = vala_data_type_copy (_tmp374_); + _tmp376_ = _tmp375_; + vala_expression_set_value_type (_tmp371_, _tmp376_); + _vala_code_node_unref0 (_tmp376_); } } else { - gboolean _tmp371_ = FALSE; - ValaMemberAccess* _tmp372_; - ValaSymbol* _tmp373_; - ValaSymbol* _tmp374_; - _tmp372_ = ma; - _tmp373_ = vala_expression_get_symbol_reference ((ValaExpression*) _tmp372_); - _tmp374_ = _tmp373_; - if (VALA_IS_ARRAY_LENGTH_FIELD (_tmp374_)) { - ValaMemberAccess* _tmp375_; - ValaExpression* _tmp376_; - ValaExpression* _tmp377_; - ValaDataType* _tmp378_; - ValaDataType* _tmp379_; - gboolean _tmp380_; - gboolean _tmp381_; - _tmp375_ = ma; - _tmp376_ = vala_member_access_get_inner (_tmp375_); - _tmp377_ = _tmp376_; - _tmp378_ = vala_expression_get_value_type (_tmp377_); - _tmp379_ = _tmp378_; - _tmp380_ = vala_array_type_get_inline_allocated (G_TYPE_CHECK_INSTANCE_CAST (_tmp379_, VALA_TYPE_ARRAY_TYPE, ValaArrayType)); - _tmp381_ = _tmp380_; - _tmp371_ = _tmp381_; + gboolean _tmp377_ = FALSE; + ValaMemberAccess* _tmp378_; + ValaSymbol* _tmp379_; + ValaSymbol* _tmp380_; + _tmp378_ = ma; + _tmp379_ = vala_expression_get_symbol_reference ((ValaExpression*) _tmp378_); + _tmp380_ = _tmp379_; + if (VALA_IS_ARRAY_LENGTH_FIELD (_tmp380_)) { + ValaMemberAccess* _tmp381_; + ValaExpression* _tmp382_; + ValaExpression* _tmp383_; + ValaDataType* _tmp384_; + ValaDataType* _tmp385_; + gboolean _tmp386_; + gboolean _tmp387_; + _tmp381_ = ma; + _tmp382_ = vala_member_access_get_inner (_tmp381_); + _tmp383_ = _tmp382_; + _tmp384_ = vala_expression_get_value_type (_tmp383_); + _tmp385_ = _tmp384_; + _tmp386_ = vala_array_type_get_inline_allocated (G_TYPE_CHECK_INSTANCE_CAST (_tmp385_, VALA_TYPE_ARRAY_TYPE, ValaArrayType)); + _tmp387_ = _tmp386_; + _tmp377_ = _tmp387_; } else { - _tmp371_ = FALSE; + _tmp377_ = FALSE; } - if (_tmp371_) { - ValaSourceReference* _tmp382_; - ValaSourceReference* _tmp383_; + if (_tmp377_) { + ValaSourceReference* _tmp388_; + ValaSourceReference* _tmp389_; vala_code_node_set_error ((ValaCodeNode*) self, TRUE); - _tmp382_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); - _tmp383_ = _tmp382_; - vala_report_error (_tmp383_, "`length' field of fixed length arrays is read-only"); + _tmp388_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); + _tmp389_ = _tmp388_; + vala_report_error (_tmp389_, "`length' field of fixed length arrays is read-only"); result = FALSE; return result; } else { - gboolean _tmp384_ = FALSE; - ValaMemberAccess* _tmp385_; - ValaSymbol* _tmp386_; - ValaSymbol* _tmp387_; - _tmp385_ = ma; - _tmp386_ = vala_expression_get_symbol_reference ((ValaExpression*) _tmp385_); - _tmp387_ = _tmp386_; - if (VALA_IS_VARIABLE (_tmp387_)) { - ValaExpression* _tmp388_; - ValaExpression* _tmp389_; - ValaDataType* _tmp390_; - ValaDataType* _tmp391_; - _tmp388_ = vala_assignment_get_right (self); - _tmp389_ = _tmp388_; - _tmp390_ = vala_expression_get_value_type (_tmp389_); - _tmp391_ = _tmp390_; - _tmp384_ = VALA_IS_METHOD_TYPE (_tmp391_); - } else { - _tmp384_ = FALSE; - } - if (_tmp384_) { - ValaVariable* variable = NULL; - ValaMemberAccess* _tmp392_; - ValaSymbol* _tmp393_; - ValaSymbol* _tmp394_; - ValaVariable* _tmp395_; + gboolean _tmp390_ = FALSE; + ValaMemberAccess* _tmp391_; + ValaSymbol* _tmp392_; + ValaSymbol* _tmp393_; + _tmp391_ = ma; + _tmp392_ = vala_expression_get_symbol_reference ((ValaExpression*) _tmp391_); + _tmp393_ = _tmp392_; + if (VALA_IS_VARIABLE (_tmp393_)) { + ValaExpression* _tmp394_; + ValaExpression* _tmp395_; ValaDataType* _tmp396_; ValaDataType* _tmp397_; - _tmp392_ = ma; - _tmp393_ = vala_expression_get_symbol_reference ((ValaExpression*) _tmp392_); - _tmp394_ = _tmp393_; - variable = G_TYPE_CHECK_INSTANCE_CAST (_tmp394_, VALA_TYPE_VARIABLE, ValaVariable); - _tmp395_ = variable; - _tmp396_ = vala_variable_get_variable_type (_tmp395_); + _tmp394_ = vala_assignment_get_right (self); + _tmp395_ = _tmp394_; + _tmp396_ = vala_expression_get_value_type (_tmp395_); _tmp397_ = _tmp396_; - if (VALA_IS_DELEGATE_TYPE (_tmp397_)) { - ValaExpression* _tmp398_; - ValaExpression* _tmp399_; - ValaDataType* _tmp400_; - ValaDataType* _tmp401_; - ValaVariable* _tmp402_; - ValaDataType* _tmp403_; - ValaDataType* _tmp404_; - _tmp398_ = vala_assignment_get_right (self); - _tmp399_ = _tmp398_; - _tmp400_ = vala_expression_get_value_type (_tmp399_); - _tmp401_ = _tmp400_; - _tmp402_ = variable; - _tmp403_ = vala_variable_get_variable_type (_tmp402_); - _tmp404_ = _tmp403_; - if (!vala_data_type_compatible (_tmp401_, _tmp404_)) { + _tmp390_ = VALA_IS_METHOD_TYPE (_tmp397_); + } else { + _tmp390_ = FALSE; + } + if (_tmp390_) { + ValaVariable* variable = NULL; + ValaMemberAccess* _tmp398_; + ValaSymbol* _tmp399_; + ValaSymbol* _tmp400_; + ValaVariable* _tmp401_; + ValaDataType* _tmp402_; + ValaDataType* _tmp403_; + _tmp398_ = ma; + _tmp399_ = vala_expression_get_symbol_reference ((ValaExpression*) _tmp398_); + _tmp400_ = _tmp399_; + variable = G_TYPE_CHECK_INSTANCE_CAST (_tmp400_, VALA_TYPE_VARIABLE, ValaVariable); + _tmp401_ = variable; + _tmp402_ = vala_variable_get_variable_type (_tmp401_); + _tmp403_ = _tmp402_; + if (VALA_IS_DELEGATE_TYPE (_tmp403_)) { + ValaExpression* _tmp404_; + ValaExpression* _tmp405_; + ValaDataType* _tmp406_; + ValaDataType* _tmp407_; + ValaVariable* _tmp408_; + ValaDataType* _tmp409_; + ValaDataType* _tmp410_; + _tmp404_ = vala_assignment_get_right (self); + _tmp405_ = _tmp404_; + _tmp406_ = vala_expression_get_value_type (_tmp405_); + _tmp407_ = _tmp406_; + _tmp408_ = variable; + _tmp409_ = vala_variable_get_variable_type (_tmp408_); + _tmp410_ = _tmp409_; + if (!vala_data_type_compatible (_tmp407_, _tmp410_)) { ValaMethod* m = NULL; - ValaExpression* _tmp405_; - ValaExpression* _tmp406_; - ValaSymbol* _tmp407_; - ValaSymbol* _tmp408_; + ValaExpression* _tmp411_; + ValaExpression* _tmp412_; + ValaSymbol* _tmp413_; + ValaSymbol* _tmp414_; ValaDelegate* cb = NULL; - ValaVariable* _tmp409_; - ValaDataType* _tmp410_; - ValaDataType* _tmp411_; - ValaDelegate* _tmp412_; - ValaDelegate* _tmp413_; - ValaSourceReference* _tmp414_; - ValaSourceReference* _tmp415_; - ValaMethod* _tmp416_; - gchar* _tmp417_; - gchar* _tmp418_; + ValaVariable* _tmp415_; + ValaDataType* _tmp416_; + ValaDataType* _tmp417_; + ValaDelegate* _tmp418_; ValaDelegate* _tmp419_; - gchar* _tmp420_; - gchar* _tmp421_; - _tmp405_ = vala_assignment_get_right (self); - _tmp406_ = _tmp405_; - _tmp407_ = vala_expression_get_symbol_reference (_tmp406_); - _tmp408_ = _tmp407_; - m = G_TYPE_CHECK_INSTANCE_CAST (_tmp408_, VALA_TYPE_METHOD, ValaMethod); - _tmp409_ = variable; - _tmp410_ = vala_variable_get_variable_type (_tmp409_); - _tmp411_ = _tmp410_; - _tmp412_ = vala_delegate_type_get_delegate_symbol (G_TYPE_CHECK_INSTANCE_CAST (_tmp411_, VALA_TYPE_DELEGATE_TYPE, ValaDelegateType)); - _tmp413_ = _tmp412_; - cb = _tmp413_; + ValaSourceReference* _tmp420_; + ValaSourceReference* _tmp421_; + ValaMethod* _tmp422_; + gchar* _tmp423_; + gchar* _tmp424_; + ValaDelegate* _tmp425_; + gchar* _tmp426_; + gchar* _tmp427_; + _tmp411_ = vala_assignment_get_right (self); + _tmp412_ = _tmp411_; + _tmp413_ = vala_expression_get_symbol_reference (_tmp412_); + _tmp414_ = _tmp413_; + m = G_TYPE_CHECK_INSTANCE_CAST (_tmp414_, VALA_TYPE_METHOD, ValaMethod); + _tmp415_ = variable; + _tmp416_ = vala_variable_get_variable_type (_tmp415_); + _tmp417_ = _tmp416_; + _tmp418_ = vala_delegate_type_get_delegate_symbol (G_TYPE_CHECK_INSTANCE_CAST (_tmp417_, VALA_TYPE_DELEGATE_TYPE, ValaDelegateType)); + _tmp419_ = _tmp418_; + cb = _tmp419_; vala_code_node_set_error ((ValaCodeNode*) self, TRUE); - _tmp414_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); - _tmp415_ = _tmp414_; - _tmp416_ = m; - _tmp417_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp416_); - _tmp418_ = _tmp417_; - _tmp419_ = cb; - _tmp420_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp419_); + _tmp420_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); _tmp421_ = _tmp420_; - vala_report_error (_tmp415_, "Declaration of method `%s' is not compatible with delegate `%s'", _tmp418_, _tmp421_); - _g_free0 (_tmp421_); - _g_free0 (_tmp418_); + _tmp422_ = m; + _tmp423_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp422_); + _tmp424_ = _tmp423_; + _tmp425_ = cb; + _tmp426_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp425_); + _tmp427_ = _tmp426_; + vala_report_error (_tmp421_, "Declaration of method `%s' is not compatible with delegate `%s'", _tmp424_, _tmp427_); + _g_free0 (_tmp427_); + _g_free0 (_tmp424_); result = FALSE; return result; } } else { - ValaSourceReference* _tmp422_; - ValaSourceReference* _tmp423_; + ValaSourceReference* _tmp428_; + ValaSourceReference* _tmp429_; vala_code_node_set_error ((ValaCodeNode*) self, TRUE); - _tmp422_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); - _tmp423_ = _tmp422_; - vala_report_error (_tmp423_, "Assignment: Invalid assignment attempt"); + _tmp428_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); + _tmp429_ = _tmp428_; + vala_report_error (_tmp429_, "Assignment: Invalid assignment attempt"); result = FALSE; return result; } } else { - gboolean _tmp424_ = FALSE; - ValaMemberAccess* _tmp425_; - ValaSymbol* _tmp426_; - ValaSymbol* _tmp427_; - _tmp425_ = ma; - _tmp426_ = vala_expression_get_symbol_reference ((ValaExpression*) _tmp425_); - _tmp427_ = _tmp426_; - if (VALA_IS_VARIABLE (_tmp427_)) { - ValaExpression* _tmp428_; - ValaExpression* _tmp429_; - ValaDataType* _tmp430_; - ValaDataType* _tmp431_; - _tmp428_ = vala_assignment_get_right (self); - _tmp429_ = _tmp428_; - _tmp430_ = vala_expression_get_value_type (_tmp429_); - _tmp431_ = _tmp430_; - _tmp424_ = _tmp431_ == NULL; + gboolean _tmp430_ = FALSE; + ValaMemberAccess* _tmp431_; + ValaSymbol* _tmp432_; + ValaSymbol* _tmp433_; + _tmp431_ = ma; + _tmp432_ = vala_expression_get_symbol_reference ((ValaExpression*) _tmp431_); + _tmp433_ = _tmp432_; + if (VALA_IS_VARIABLE (_tmp433_)) { + ValaExpression* _tmp434_; + ValaExpression* _tmp435_; + ValaDataType* _tmp436_; + ValaDataType* _tmp437_; + _tmp434_ = vala_assignment_get_right (self); + _tmp435_ = _tmp434_; + _tmp436_ = vala_expression_get_value_type (_tmp435_); + _tmp437_ = _tmp436_; + _tmp430_ = _tmp437_ == NULL; } else { - _tmp424_ = FALSE; + _tmp430_ = FALSE; } - if (_tmp424_) { - ValaSourceReference* _tmp432_; - ValaSourceReference* _tmp433_; + if (_tmp430_) { + ValaSourceReference* _tmp438_; + ValaSourceReference* _tmp439_; vala_code_node_set_error ((ValaCodeNode*) self, TRUE); - _tmp432_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); - _tmp433_ = _tmp432_; - vala_report_error (_tmp433_, "Assignment: Invalid assignment attempt"); + _tmp438_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); + _tmp439_ = _tmp438_; + vala_report_error (_tmp439_, "Assignment: Invalid assignment attempt"); result = FALSE; return result; } else { - ValaMemberAccess* _tmp434_; - ValaSymbol* _tmp435_; - ValaSymbol* _tmp436_; - _tmp434_ = ma; - _tmp435_ = vala_expression_get_symbol_reference ((ValaExpression*) _tmp434_); - _tmp436_ = _tmp435_; - if (VALA_IS_VARIABLE (_tmp436_)) { + ValaMemberAccess* _tmp440_; + ValaSymbol* _tmp441_; + ValaSymbol* _tmp442_; + _tmp440_ = ma; + _tmp441_ = vala_expression_get_symbol_reference ((ValaExpression*) _tmp440_); + _tmp442_ = _tmp441_; + if (VALA_IS_VARIABLE (_tmp442_)) { ValaVariable* variable = NULL; - ValaMemberAccess* _tmp437_; - ValaSymbol* _tmp438_; - ValaSymbol* _tmp439_; + ValaMemberAccess* _tmp443_; + ValaSymbol* _tmp444_; + ValaSymbol* _tmp445_; ValaArrayType* variable_array_type = NULL; - ValaVariable* _tmp440_; - ValaDataType* _tmp441_; - ValaDataType* _tmp442_; - gboolean _tmp443_ = FALSE; - gboolean _tmp444_ = FALSE; - gboolean _tmp445_ = FALSE; - ValaArrayType* _tmp446_; - _tmp437_ = ma; - _tmp438_ = vala_expression_get_symbol_reference ((ValaExpression*) _tmp437_); - _tmp439_ = _tmp438_; - variable = G_TYPE_CHECK_INSTANCE_CAST (_tmp439_, VALA_TYPE_VARIABLE, ValaVariable); - _tmp440_ = variable; - _tmp441_ = vala_variable_get_variable_type (_tmp440_); - _tmp442_ = _tmp441_; - variable_array_type = VALA_IS_ARRAY_TYPE (_tmp442_) ? ((ValaArrayType*) _tmp442_) : NULL; - _tmp446_ = variable_array_type; - if (_tmp446_ != NULL) { - ValaArrayType* _tmp447_; - gboolean _tmp448_; - gboolean _tmp449_; - _tmp447_ = variable_array_type; - _tmp448_ = vala_array_type_get_inline_allocated (_tmp447_); - _tmp449_ = _tmp448_; - _tmp445_ = _tmp449_; - } else { - _tmp445_ = FALSE; - } - if (_tmp445_) { - ValaExpression* _tmp450_; - ValaExpression* _tmp451_; - _tmp450_ = vala_assignment_get_right (self); - _tmp451_ = _tmp450_; - _tmp444_ = VALA_IS_ARRAY_CREATION_EXPRESSION (_tmp451_); - } else { - _tmp444_ = FALSE; - } - if (_tmp444_) { - ValaExpression* _tmp452_; - ValaExpression* _tmp453_; - ValaInitializerList* _tmp454_; - ValaInitializerList* _tmp455_; - _tmp452_ = vala_assignment_get_right (self); - _tmp453_ = _tmp452_; - _tmp454_ = vala_array_creation_expression_get_initializer_list (G_TYPE_CHECK_INSTANCE_CAST (_tmp453_, VALA_TYPE_ARRAY_CREATION_EXPRESSION, ValaArrayCreationExpression)); + ValaVariable* _tmp446_; + ValaDataType* _tmp447_; + ValaDataType* _tmp448_; + gboolean _tmp449_ = FALSE; + gboolean _tmp450_ = FALSE; + gboolean _tmp451_ = FALSE; + ValaArrayType* _tmp452_; + _tmp443_ = ma; + _tmp444_ = vala_expression_get_symbol_reference ((ValaExpression*) _tmp443_); + _tmp445_ = _tmp444_; + variable = G_TYPE_CHECK_INSTANCE_CAST (_tmp445_, VALA_TYPE_VARIABLE, ValaVariable); + _tmp446_ = variable; + _tmp447_ = vala_variable_get_variable_type (_tmp446_); + _tmp448_ = _tmp447_; + variable_array_type = VALA_IS_ARRAY_TYPE (_tmp448_) ? ((ValaArrayType*) _tmp448_) : NULL; + _tmp452_ = variable_array_type; + if (_tmp452_ != NULL) { + ValaArrayType* _tmp453_; + gboolean _tmp454_; + gboolean _tmp455_; + _tmp453_ = variable_array_type; + _tmp454_ = vala_array_type_get_inline_allocated (_tmp453_); _tmp455_ = _tmp454_; - _tmp443_ = _tmp455_ == NULL; + _tmp451_ = _tmp455_; } else { - _tmp443_ = FALSE; + _tmp451_ = FALSE; } - if (_tmp443_) { - ValaSourceReference* _tmp456_; - ValaSourceReference* _tmp457_; - ValaCodeNode* _tmp458_; - ValaCodeNode* _tmp459_; - ValaCodeNode* _tmp460_; - ValaCodeNode* _tmp461_; - ValaCodeNode* _tmp462_; - ValaCodeNode* _tmp463_; - ValaSourceReference* _tmp464_; - ValaSourceReference* _tmp465_; - ValaEmptyStatement* _tmp466_; - ValaEmptyStatement* _tmp467_; - _tmp456_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); + if (_tmp451_) { + ValaExpression* _tmp456_; + ValaExpression* _tmp457_; + _tmp456_ = vala_assignment_get_right (self); _tmp457_ = _tmp456_; - vala_report_warning (_tmp457_, "Inline allocated arrays don't require an explicit instantiation"); - _tmp458_ = vala_code_node_get_parent_node ((ValaCodeNode*) self); + _tmp450_ = VALA_IS_ARRAY_CREATION_EXPRESSION (_tmp457_); + } else { + _tmp450_ = FALSE; + } + if (_tmp450_) { + ValaExpression* _tmp458_; + ValaExpression* _tmp459_; + ValaInitializerList* _tmp460_; + ValaInitializerList* _tmp461_; + _tmp458_ = vala_assignment_get_right (self); _tmp459_ = _tmp458_; - _tmp460_ = vala_code_node_get_parent_node (_tmp459_); + _tmp460_ = vala_array_creation_expression_get_initializer_list (G_TYPE_CHECK_INSTANCE_CAST (_tmp459_, VALA_TYPE_ARRAY_CREATION_EXPRESSION, ValaArrayCreationExpression)); _tmp461_ = _tmp460_; - _tmp462_ = vala_code_node_get_parent_node ((ValaCodeNode*) self); + _tmp449_ = _tmp461_ == NULL; + } else { + _tmp449_ = FALSE; + } + if (_tmp449_) { + ValaSourceReference* _tmp462_; + ValaSourceReference* _tmp463_; + ValaCodeNode* _tmp464_; + ValaCodeNode* _tmp465_; + ValaCodeNode* _tmp466_; + ValaCodeNode* _tmp467_; + ValaCodeNode* _tmp468_; + ValaCodeNode* _tmp469_; + ValaSourceReference* _tmp470_; + ValaSourceReference* _tmp471_; + ValaEmptyStatement* _tmp472_; + ValaEmptyStatement* _tmp473_; + _tmp462_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); _tmp463_ = _tmp462_; - _tmp464_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); + vala_report_warning (_tmp463_, "Inline allocated arrays don't require an explicit instantiation"); + _tmp464_ = vala_code_node_get_parent_node ((ValaCodeNode*) self); _tmp465_ = _tmp464_; - _tmp466_ = vala_empty_statement_new (_tmp465_); + _tmp466_ = vala_code_node_get_parent_node (_tmp465_); _tmp467_ = _tmp466_; - vala_block_replace_statement (G_TYPE_CHECK_INSTANCE_CAST (_tmp461_, VALA_TYPE_BLOCK, ValaBlock), G_TYPE_CHECK_INSTANCE_CAST (_tmp463_, VALA_TYPE_STATEMENT, ValaStatement), (ValaStatement*) _tmp467_); - _vala_code_node_unref0 (_tmp467_); + _tmp468_ = vala_code_node_get_parent_node ((ValaCodeNode*) self); + _tmp469_ = _tmp468_; + _tmp470_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); + _tmp471_ = _tmp470_; + _tmp472_ = vala_empty_statement_new (_tmp471_); + _tmp473_ = _tmp472_; + vala_block_replace_statement (G_TYPE_CHECK_INSTANCE_CAST (_tmp467_, VALA_TYPE_BLOCK, ValaBlock), G_TYPE_CHECK_INSTANCE_CAST (_tmp469_, VALA_TYPE_STATEMENT, ValaStatement), (ValaStatement*) _tmp473_); + _vala_code_node_unref0 (_tmp473_); result = TRUE; return result; } @@ -1750,555 +1768,555 @@ } } } - _tmp469_ = vala_assignment_get_left (self); - _tmp470_ = _tmp469_; - _tmp471_ = vala_expression_get_value_type (_tmp470_); - _tmp472_ = _tmp471_; - if (_tmp472_ != NULL) { - ValaExpression* _tmp473_; - ValaExpression* _tmp474_; - ValaDataType* _tmp475_; - ValaDataType* _tmp476_; - _tmp473_ = vala_assignment_get_right (self); - _tmp474_ = _tmp473_; - _tmp475_ = vala_expression_get_value_type (_tmp474_); - _tmp476_ = _tmp475_; - _tmp468_ = _tmp476_ != NULL; - } else { - _tmp468_ = FALSE; - } - if (_tmp468_) { - ValaExpression* _tmp477_; - ValaExpression* _tmp478_; - ValaDataType* _tmp479_; - ValaDataType* _tmp480_; - ValaExpression* _tmp481_; - ValaExpression* _tmp482_; - ValaDataType* _tmp483_; - ValaDataType* _tmp484_; - ValaMemberAccess* _tmp530_; - ValaSymbol* _tmp531_; - ValaSymbol* _tmp532_; - _tmp477_ = vala_assignment_get_right (self); - _tmp478_ = _tmp477_; - _tmp479_ = vala_expression_get_value_type (_tmp478_); + _tmp475_ = vala_assignment_get_left (self); + _tmp476_ = _tmp475_; + _tmp477_ = vala_expression_get_value_type (_tmp476_); + _tmp478_ = _tmp477_; + if (_tmp478_ != NULL) { + ValaExpression* _tmp479_; + ValaExpression* _tmp480_; + ValaDataType* _tmp481_; + ValaDataType* _tmp482_; + _tmp479_ = vala_assignment_get_right (self); _tmp480_ = _tmp479_; - _tmp481_ = vala_assignment_get_left (self); + _tmp481_ = vala_expression_get_value_type (_tmp480_); _tmp482_ = _tmp481_; - _tmp483_ = vala_expression_get_value_type (_tmp482_); + _tmp474_ = _tmp482_ != NULL; + } else { + _tmp474_ = FALSE; + } + if (_tmp474_) { + ValaExpression* _tmp483_; + ValaExpression* _tmp484_; + ValaDataType* _tmp485_; + ValaDataType* _tmp486_; + ValaExpression* _tmp487_; + ValaExpression* _tmp488_; + ValaDataType* _tmp489_; + ValaDataType* _tmp490_; + ValaMemberAccess* _tmp536_; + ValaSymbol* _tmp537_; + ValaSymbol* _tmp538_; + _tmp483_ = vala_assignment_get_right (self); _tmp484_ = _tmp483_; - if (!vala_data_type_compatible (_tmp480_, _tmp484_)) { - ValaSourceReference* _tmp485_; - ValaSourceReference* _tmp486_; - ValaExpression* _tmp487_; - ValaExpression* _tmp488_; - ValaDataType* _tmp489_; - ValaDataType* _tmp490_; - gchar* _tmp491_; - gchar* _tmp492_; + _tmp485_ = vala_expression_get_value_type (_tmp484_); + _tmp486_ = _tmp485_; + _tmp487_ = vala_assignment_get_left (self); + _tmp488_ = _tmp487_; + _tmp489_ = vala_expression_get_value_type (_tmp488_); + _tmp490_ = _tmp489_; + if (!vala_data_type_compatible (_tmp486_, _tmp490_)) { + ValaSourceReference* _tmp491_; + ValaSourceReference* _tmp492_; ValaExpression* _tmp493_; ValaExpression* _tmp494_; ValaDataType* _tmp495_; ValaDataType* _tmp496_; gchar* _tmp497_; gchar* _tmp498_; + ValaExpression* _tmp499_; + ValaExpression* _tmp500_; + ValaDataType* _tmp501_; + ValaDataType* _tmp502_; + gchar* _tmp503_; + gchar* _tmp504_; vala_code_node_set_error ((ValaCodeNode*) self, TRUE); - _tmp485_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); - _tmp486_ = _tmp485_; - _tmp487_ = vala_assignment_get_right (self); - _tmp488_ = _tmp487_; - _tmp489_ = vala_expression_get_value_type (_tmp488_); - _tmp490_ = _tmp489_; - _tmp491_ = vala_code_node_to_string ((ValaCodeNode*) _tmp490_); + _tmp491_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); _tmp492_ = _tmp491_; - _tmp493_ = vala_assignment_get_left (self); + _tmp493_ = vala_assignment_get_right (self); _tmp494_ = _tmp493_; _tmp495_ = vala_expression_get_value_type (_tmp494_); _tmp496_ = _tmp495_; _tmp497_ = vala_code_node_to_string ((ValaCodeNode*) _tmp496_); _tmp498_ = _tmp497_; - vala_report_error (_tmp486_, "Assignment: Cannot convert from `%s' to `%s'", _tmp492_, _tmp498_); + _tmp499_ = vala_assignment_get_left (self); + _tmp500_ = _tmp499_; + _tmp501_ = vala_expression_get_value_type (_tmp500_); + _tmp502_ = _tmp501_; + _tmp503_ = vala_code_node_to_string ((ValaCodeNode*) _tmp502_); + _tmp504_ = _tmp503_; + vala_report_error (_tmp492_, "Assignment: Cannot convert from `%s' to `%s'", _tmp498_, _tmp504_); + _g_free0 (_tmp504_); _g_free0 (_tmp498_); - _g_free0 (_tmp492_); result = FALSE; return result; } else { - gboolean _tmp499_ = FALSE; - gboolean _tmp500_ = FALSE; - ValaExpression* _tmp501_; - ValaExpression* _tmp502_; - ValaDataType* _tmp503_; - ValaDataType* _tmp504_; - _tmp501_ = vala_assignment_get_left (self); - _tmp502_ = _tmp501_; - _tmp503_ = vala_expression_get_value_type (_tmp502_); - _tmp504_ = _tmp503_; - if (VALA_IS_ENUM_VALUE_TYPE (_tmp504_)) { - ValaExpression* _tmp505_; - ValaExpression* _tmp506_; - ValaDataType* _tmp507_; - ValaDataType* _tmp508_; - _tmp505_ = vala_assignment_get_right (self); - _tmp506_ = _tmp505_; - _tmp507_ = vala_expression_get_value_type (_tmp506_); - _tmp508_ = _tmp507_; - _tmp500_ = VALA_IS_INTEGER_TYPE (_tmp508_); + gboolean _tmp505_ = FALSE; + gboolean _tmp506_ = FALSE; + ValaExpression* _tmp507_; + ValaExpression* _tmp508_; + ValaDataType* _tmp509_; + ValaDataType* _tmp510_; + _tmp507_ = vala_assignment_get_left (self); + _tmp508_ = _tmp507_; + _tmp509_ = vala_expression_get_value_type (_tmp508_); + _tmp510_ = _tmp509_; + if (VALA_IS_ENUM_VALUE_TYPE (_tmp510_)) { + ValaExpression* _tmp511_; + ValaExpression* _tmp512_; + ValaDataType* _tmp513_; + ValaDataType* _tmp514_; + _tmp511_ = vala_assignment_get_right (self); + _tmp512_ = _tmp511_; + _tmp513_ = vala_expression_get_value_type (_tmp512_); + _tmp514_ = _tmp513_; + _tmp506_ = VALA_IS_INTEGER_TYPE (_tmp514_); } else { - _tmp500_ = FALSE; + _tmp506_ = FALSE; } - if (_tmp500_) { - gboolean _tmp509_ = FALSE; - ValaExpression* _tmp510_; - ValaExpression* _tmp511_; - _tmp510_ = vala_assignment_get_right (self); - _tmp511_ = _tmp510_; - if (!VALA_IS_INTEGER_LITERAL (_tmp511_)) { - _tmp509_ = TRUE; + if (_tmp506_) { + gboolean _tmp515_ = FALSE; + ValaExpression* _tmp516_; + ValaExpression* _tmp517_; + _tmp516_ = vala_assignment_get_right (self); + _tmp517_ = _tmp516_; + if (!VALA_IS_INTEGER_LITERAL (_tmp517_)) { + _tmp515_ = TRUE; } else { - ValaExpression* _tmp512_; - ValaExpression* _tmp513_; - const gchar* _tmp514_; - const gchar* _tmp515_; - _tmp512_ = vala_assignment_get_right (self); - _tmp513_ = _tmp512_; - _tmp514_ = vala_integer_literal_get_value (G_TYPE_CHECK_INSTANCE_CAST (_tmp513_, VALA_TYPE_INTEGER_LITERAL, ValaIntegerLiteral)); - _tmp515_ = _tmp514_; - _tmp509_ = g_strcmp0 (_tmp515_, "0") != 0; + ValaExpression* _tmp518_; + ValaExpression* _tmp519_; + const gchar* _tmp520_; + const gchar* _tmp521_; + _tmp518_ = vala_assignment_get_right (self); + _tmp519_ = _tmp518_; + _tmp520_ = vala_integer_literal_get_value (G_TYPE_CHECK_INSTANCE_CAST (_tmp519_, VALA_TYPE_INTEGER_LITERAL, ValaIntegerLiteral)); + _tmp521_ = _tmp520_; + _tmp515_ = g_strcmp0 (_tmp521_, "0") != 0; } - _tmp499_ = _tmp509_; + _tmp505_ = _tmp515_; } else { - _tmp499_ = FALSE; + _tmp505_ = FALSE; } - if (_tmp499_) { - ValaSourceReference* _tmp516_; - ValaSourceReference* _tmp517_; - ValaExpression* _tmp518_; - ValaExpression* _tmp519_; - ValaDataType* _tmp520_; - ValaDataType* _tmp521_; - gchar* _tmp522_; - gchar* _tmp523_; + if (_tmp505_) { + ValaSourceReference* _tmp522_; + ValaSourceReference* _tmp523_; ValaExpression* _tmp524_; ValaExpression* _tmp525_; ValaDataType* _tmp526_; ValaDataType* _tmp527_; gchar* _tmp528_; gchar* _tmp529_; - _tmp516_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); - _tmp517_ = _tmp516_; - _tmp518_ = vala_assignment_get_right (self); - _tmp519_ = _tmp518_; - _tmp520_ = vala_expression_get_value_type (_tmp519_); - _tmp521_ = _tmp520_; - _tmp522_ = vala_code_node_to_string ((ValaCodeNode*) _tmp521_); + ValaExpression* _tmp530_; + ValaExpression* _tmp531_; + ValaDataType* _tmp532_; + ValaDataType* _tmp533_; + gchar* _tmp534_; + gchar* _tmp535_; + _tmp522_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); _tmp523_ = _tmp522_; - _tmp524_ = vala_assignment_get_left (self); + _tmp524_ = vala_assignment_get_right (self); _tmp525_ = _tmp524_; _tmp526_ = vala_expression_get_value_type (_tmp525_); _tmp527_ = _tmp526_; _tmp528_ = vala_code_node_to_string ((ValaCodeNode*) _tmp527_); _tmp529_ = _tmp528_; - vala_report_notice (_tmp517_, "Assignment: Unsafe conversion from `%s' to `%s'", _tmp523_, _tmp529_); + _tmp530_ = vala_assignment_get_left (self); + _tmp531_ = _tmp530_; + _tmp532_ = vala_expression_get_value_type (_tmp531_); + _tmp533_ = _tmp532_; + _tmp534_ = vala_code_node_to_string ((ValaCodeNode*) _tmp533_); + _tmp535_ = _tmp534_; + vala_report_notice (_tmp523_, "Assignment: Unsafe conversion from `%s' to `%s'", _tmp529_, _tmp535_); + _g_free0 (_tmp535_); _g_free0 (_tmp529_); - _g_free0 (_tmp523_); } } - _tmp530_ = ma; - _tmp531_ = vala_expression_get_symbol_reference ((ValaExpression*) _tmp530_); - _tmp532_ = _tmp531_; - if (!VALA_IS_PROPERTY (_tmp532_)) { - ValaExpression* _tmp533_; - ValaExpression* _tmp534_; - ValaDataType* _tmp535_; - ValaDataType* _tmp536_; - _tmp533_ = vala_assignment_get_right (self); - _tmp534_ = _tmp533_; - _tmp535_ = vala_expression_get_value_type (_tmp534_); - _tmp536_ = _tmp535_; - if (vala_data_type_is_disposable (_tmp536_)) { - gboolean _tmp537_ = FALSE; - ValaExpression* _tmp538_; - ValaExpression* _tmp539_; - ValaDataType* _tmp540_; - ValaDataType* _tmp541_; - _tmp538_ = vala_assignment_get_left (self); - _tmp539_ = _tmp538_; - _tmp540_ = vala_expression_get_value_type (_tmp539_); - _tmp541_ = _tmp540_; - if (!VALA_IS_POINTER_TYPE (_tmp541_)) { - ValaExpression* _tmp542_; - ValaExpression* _tmp543_; - ValaDataType* _tmp544_; - ValaDataType* _tmp545_; - gboolean _tmp546_; - gboolean _tmp547_; - _tmp542_ = vala_assignment_get_left (self); - _tmp543_ = _tmp542_; - _tmp544_ = vala_expression_get_value_type (_tmp543_); - _tmp545_ = _tmp544_; - _tmp546_ = vala_data_type_get_value_owned (_tmp545_); - _tmp547_ = _tmp546_; - _tmp537_ = !_tmp547_; + _tmp536_ = ma; + _tmp537_ = vala_expression_get_symbol_reference ((ValaExpression*) _tmp536_); + _tmp538_ = _tmp537_; + if (!VALA_IS_PROPERTY (_tmp538_)) { + ValaExpression* _tmp539_; + ValaExpression* _tmp540_; + ValaDataType* _tmp541_; + ValaDataType* _tmp542_; + _tmp539_ = vala_assignment_get_right (self); + _tmp540_ = _tmp539_; + _tmp541_ = vala_expression_get_value_type (_tmp540_); + _tmp542_ = _tmp541_; + if (vala_data_type_is_disposable (_tmp542_)) { + gboolean _tmp543_ = FALSE; + ValaExpression* _tmp544_; + ValaExpression* _tmp545_; + ValaDataType* _tmp546_; + ValaDataType* _tmp547_; + _tmp544_ = vala_assignment_get_left (self); + _tmp545_ = _tmp544_; + _tmp546_ = vala_expression_get_value_type (_tmp545_); + _tmp547_ = _tmp546_; + if (!VALA_IS_POINTER_TYPE (_tmp547_)) { + ValaExpression* _tmp548_; + ValaExpression* _tmp549_; + ValaDataType* _tmp550_; + ValaDataType* _tmp551_; + gboolean _tmp552_; + gboolean _tmp553_; + _tmp548_ = vala_assignment_get_left (self); + _tmp549_ = _tmp548_; + _tmp550_ = vala_expression_get_value_type (_tmp549_); + _tmp551_ = _tmp550_; + _tmp552_ = vala_data_type_get_value_owned (_tmp551_); + _tmp553_ = _tmp552_; + _tmp543_ = !_tmp553_; } else { - _tmp537_ = FALSE; + _tmp543_ = FALSE; } - if (_tmp537_) { - ValaSourceReference* _tmp548_; - ValaSourceReference* _tmp549_; + if (_tmp543_) { + ValaSourceReference* _tmp554_; + ValaSourceReference* _tmp555_; vala_code_node_set_error ((ValaCodeNode*) self, TRUE); - _tmp548_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); - _tmp549_ = _tmp548_; - vala_report_error (_tmp549_, "Invalid assignment from owned expression to unowned variable"); + _tmp554_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); + _tmp555_ = _tmp554_; + vala_report_error (_tmp555_, "Invalid assignment from owned expression to unowned variable"); } } else { - ValaExpression* _tmp550_; - ValaExpression* _tmp551_; - ValaDataType* _tmp552_; - ValaDataType* _tmp553_; - gboolean _tmp554_; - gboolean _tmp555_; - _tmp550_ = vala_assignment_get_left (self); - _tmp551_ = _tmp550_; - _tmp552_ = vala_expression_get_value_type (_tmp551_); - _tmp553_ = _tmp552_; - _tmp554_ = vala_data_type_get_value_owned (_tmp553_); - _tmp555_ = _tmp554_; - if (_tmp555_) { + ValaExpression* _tmp556_; + ValaExpression* _tmp557_; + ValaDataType* _tmp558_; + ValaDataType* _tmp559_; + gboolean _tmp560_; + gboolean _tmp561_; + _tmp556_ = vala_assignment_get_left (self); + _tmp557_ = _tmp556_; + _tmp558_ = vala_expression_get_value_type (_tmp557_); + _tmp559_ = _tmp558_; + _tmp560_ = vala_data_type_get_value_owned (_tmp559_); + _tmp561_ = _tmp560_; + if (_tmp561_) { } } } } - _tmp556_ = vala_assignment_get_right (self); - _tmp557_ = _tmp556_; - right_ma = VALA_IS_MEMBER_ACCESS (_tmp557_) ? ((ValaMemberAccess*) _tmp557_) : NULL; - _tmp559_ = right_ma; - if (_tmp559_ != NULL) { - ValaMemberAccess* _tmp560_; - ValaSymbol* _tmp561_; - ValaSymbol* _tmp562_; - ValaMemberAccess* _tmp563_; - ValaSymbol* _tmp564_; - ValaSymbol* _tmp565_; - _tmp560_ = ma; - _tmp561_ = vala_expression_get_symbol_reference ((ValaExpression*) _tmp560_); - _tmp562_ = _tmp561_; - _tmp563_ = right_ma; - _tmp564_ = vala_expression_get_symbol_reference ((ValaExpression*) _tmp563_); - _tmp565_ = _tmp564_; - _tmp558_ = _tmp562_ == _tmp565_; + _tmp562_ = vala_assignment_get_right (self); + _tmp563_ = _tmp562_; + right_ma = VALA_IS_MEMBER_ACCESS (_tmp563_) ? ((ValaMemberAccess*) _tmp563_) : NULL; + _tmp565_ = right_ma; + if (_tmp565_ != NULL) { + ValaMemberAccess* _tmp566_; + ValaSymbol* _tmp567_; + ValaSymbol* _tmp568_; + ValaMemberAccess* _tmp569_; + ValaSymbol* _tmp570_; + ValaSymbol* _tmp571_; + _tmp566_ = ma; + _tmp567_ = vala_expression_get_symbol_reference ((ValaExpression*) _tmp566_); + _tmp568_ = _tmp567_; + _tmp569_ = right_ma; + _tmp570_ = vala_expression_get_symbol_reference ((ValaExpression*) _tmp569_); + _tmp571_ = _tmp570_; + _tmp564_ = _tmp568_ == _tmp571_; } else { - _tmp558_ = FALSE; + _tmp564_ = FALSE; } - if (_tmp558_) { - gboolean _tmp566_ = FALSE; - ValaMemberAccess* _tmp567_; - ValaSymbol* _tmp568_; - ValaSymbol* _tmp569_; - _tmp567_ = ma; - _tmp568_ = vala_expression_get_symbol_reference ((ValaExpression*) _tmp567_); - _tmp569_ = _tmp568_; - if (VALA_IS_LOCAL_VARIABLE (_tmp569_)) { - _tmp566_ = TRUE; - } else { - ValaMemberAccess* _tmp570_; - ValaSymbol* _tmp571_; - ValaSymbol* _tmp572_; - _tmp570_ = ma; - _tmp571_ = vala_expression_get_symbol_reference ((ValaExpression*) _tmp570_); - _tmp572_ = _tmp571_; - _tmp566_ = VALA_IS_PARAMETER (_tmp572_); - } - if (_tmp566_) { - ValaSourceReference* _tmp573_; - ValaSourceReference* _tmp574_; - _tmp573_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); - _tmp574_ = _tmp573_; - vala_report_warning (_tmp574_, "Assignment to same variable"); + if (_tmp564_) { + gboolean _tmp572_ = FALSE; + ValaMemberAccess* _tmp573_; + ValaSymbol* _tmp574_; + ValaSymbol* _tmp575_; + _tmp573_ = ma; + _tmp574_ = vala_expression_get_symbol_reference ((ValaExpression*) _tmp573_); + _tmp575_ = _tmp574_; + if (VALA_IS_LOCAL_VARIABLE (_tmp575_)) { + _tmp572_ = TRUE; } else { - ValaMemberAccess* _tmp575_; - ValaSymbol* _tmp576_; + ValaMemberAccess* _tmp576_; ValaSymbol* _tmp577_; - _tmp575_ = ma; - _tmp576_ = vala_expression_get_symbol_reference ((ValaExpression*) _tmp575_); - _tmp577_ = _tmp576_; - if (VALA_IS_FIELD (_tmp577_)) { + ValaSymbol* _tmp578_; + _tmp576_ = ma; + _tmp577_ = vala_expression_get_symbol_reference ((ValaExpression*) _tmp576_); + _tmp578_ = _tmp577_; + _tmp572_ = VALA_IS_PARAMETER (_tmp578_); + } + if (_tmp572_) { + ValaSourceReference* _tmp579_; + ValaSourceReference* _tmp580_; + _tmp579_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); + _tmp580_ = _tmp579_; + vala_report_warning (_tmp580_, "Assignment to same variable"); + } else { + ValaMemberAccess* _tmp581_; + ValaSymbol* _tmp582_; + ValaSymbol* _tmp583_; + _tmp581_ = ma; + _tmp582_ = vala_expression_get_symbol_reference ((ValaExpression*) _tmp581_); + _tmp583_ = _tmp582_; + if (VALA_IS_FIELD (_tmp583_)) { ValaField* f = NULL; - ValaMemberAccess* _tmp578_; - ValaSymbol* _tmp579_; - ValaSymbol* _tmp580_; - ValaField* _tmp581_; - ValaMemberBinding _tmp582_; - ValaMemberBinding _tmp583_; - _tmp578_ = ma; - _tmp579_ = vala_expression_get_symbol_reference ((ValaExpression*) _tmp578_); - _tmp580_ = _tmp579_; - f = G_TYPE_CHECK_INSTANCE_CAST (_tmp580_, VALA_TYPE_FIELD, ValaField); - _tmp581_ = f; - _tmp582_ = vala_field_get_binding (_tmp581_); - _tmp583_ = _tmp582_; - if (_tmp583_ == VALA_MEMBER_BINDING_STATIC) { - ValaSourceReference* _tmp584_; - ValaSourceReference* _tmp585_; - _tmp584_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); - _tmp585_ = _tmp584_; - vala_report_warning (_tmp585_, "Assignment to same variable"); + ValaMemberAccess* _tmp584_; + ValaSymbol* _tmp585_; + ValaSymbol* _tmp586_; + ValaField* _tmp587_; + ValaMemberBinding _tmp588_; + ValaMemberBinding _tmp589_; + _tmp584_ = ma; + _tmp585_ = vala_expression_get_symbol_reference ((ValaExpression*) _tmp584_); + _tmp586_ = _tmp585_; + f = G_TYPE_CHECK_INSTANCE_CAST (_tmp586_, VALA_TYPE_FIELD, ValaField); + _tmp587_ = f; + _tmp588_ = vala_field_get_binding (_tmp587_); + _tmp589_ = _tmp588_; + if (_tmp589_ == VALA_MEMBER_BINDING_STATIC) { + ValaSourceReference* _tmp590_; + ValaSourceReference* _tmp591_; + _tmp590_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); + _tmp591_ = _tmp590_; + vala_report_warning (_tmp591_, "Assignment to same variable"); } else { ValaMemberAccess* ma_inner = NULL; - ValaMemberAccess* _tmp586_; - ValaExpression* _tmp587_; - ValaExpression* _tmp588_; + ValaMemberAccess* _tmp592_; + ValaExpression* _tmp593_; + ValaExpression* _tmp594_; ValaMemberAccess* right_ma_inner = NULL; - ValaMemberAccess* _tmp589_; - ValaExpression* _tmp590_; - ValaExpression* _tmp591_; - gboolean _tmp592_ = FALSE; - gboolean _tmp593_ = FALSE; - gboolean _tmp594_ = FALSE; - gboolean _tmp595_ = FALSE; - gboolean _tmp596_ = FALSE; - ValaMemberAccess* _tmp597_; - _tmp586_ = ma; - _tmp587_ = vala_member_access_get_inner (_tmp586_); - _tmp588_ = _tmp587_; - ma_inner = VALA_IS_MEMBER_ACCESS (_tmp588_) ? ((ValaMemberAccess*) _tmp588_) : NULL; - _tmp589_ = right_ma; - _tmp590_ = vala_member_access_get_inner (_tmp589_); - _tmp591_ = _tmp590_; - right_ma_inner = VALA_IS_MEMBER_ACCESS (_tmp591_) ? ((ValaMemberAccess*) _tmp591_) : NULL; - _tmp597_ = ma_inner; - if (_tmp597_ != NULL) { - ValaMemberAccess* _tmp598_; - const gchar* _tmp599_; - const gchar* _tmp600_; - _tmp598_ = ma_inner; - _tmp599_ = vala_member_access_get_member_name (_tmp598_); - _tmp600_ = _tmp599_; - _tmp596_ = g_strcmp0 (_tmp600_, "this") == 0; + ValaMemberAccess* _tmp595_; + ValaExpression* _tmp596_; + ValaExpression* _tmp597_; + gboolean _tmp598_ = FALSE; + gboolean _tmp599_ = FALSE; + gboolean _tmp600_ = FALSE; + gboolean _tmp601_ = FALSE; + gboolean _tmp602_ = FALSE; + ValaMemberAccess* _tmp603_; + _tmp592_ = ma; + _tmp593_ = vala_member_access_get_inner (_tmp592_); + _tmp594_ = _tmp593_; + ma_inner = VALA_IS_MEMBER_ACCESS (_tmp594_) ? ((ValaMemberAccess*) _tmp594_) : NULL; + _tmp595_ = right_ma; + _tmp596_ = vala_member_access_get_inner (_tmp595_); + _tmp597_ = _tmp596_; + right_ma_inner = VALA_IS_MEMBER_ACCESS (_tmp597_) ? ((ValaMemberAccess*) _tmp597_) : NULL; + _tmp603_ = ma_inner; + if (_tmp603_ != NULL) { + ValaMemberAccess* _tmp604_; + const gchar* _tmp605_; + const gchar* _tmp606_; + _tmp604_ = ma_inner; + _tmp605_ = vala_member_access_get_member_name (_tmp604_); + _tmp606_ = _tmp605_; + _tmp602_ = g_strcmp0 (_tmp606_, "this") == 0; } else { - _tmp596_ = FALSE; + _tmp602_ = FALSE; } - if (_tmp596_) { - ValaMemberAccess* _tmp601_; - ValaExpression* _tmp602_; - ValaExpression* _tmp603_; - _tmp601_ = ma_inner; - _tmp602_ = vala_member_access_get_inner (_tmp601_); - _tmp603_ = _tmp602_; - _tmp595_ = _tmp603_ == NULL; + if (_tmp602_) { + ValaMemberAccess* _tmp607_; + ValaExpression* _tmp608_; + ValaExpression* _tmp609_; + _tmp607_ = ma_inner; + _tmp608_ = vala_member_access_get_inner (_tmp607_); + _tmp609_ = _tmp608_; + _tmp601_ = _tmp609_ == NULL; } else { - _tmp595_ = FALSE; + _tmp601_ = FALSE; } - if (_tmp595_) { - ValaMemberAccess* _tmp604_; - _tmp604_ = right_ma_inner; - _tmp594_ = _tmp604_ != NULL; + if (_tmp601_) { + ValaMemberAccess* _tmp610_; + _tmp610_ = right_ma_inner; + _tmp600_ = _tmp610_ != NULL; } else { - _tmp594_ = FALSE; + _tmp600_ = FALSE; } - if (_tmp594_) { - ValaMemberAccess* _tmp605_; - const gchar* _tmp606_; - const gchar* _tmp607_; - _tmp605_ = right_ma_inner; - _tmp606_ = vala_member_access_get_member_name (_tmp605_); - _tmp607_ = _tmp606_; - _tmp593_ = g_strcmp0 (_tmp607_, "this") == 0; + if (_tmp600_) { + ValaMemberAccess* _tmp611_; + const gchar* _tmp612_; + const gchar* _tmp613_; + _tmp611_ = right_ma_inner; + _tmp612_ = vala_member_access_get_member_name (_tmp611_); + _tmp613_ = _tmp612_; + _tmp599_ = g_strcmp0 (_tmp613_, "this") == 0; } else { - _tmp593_ = FALSE; + _tmp599_ = FALSE; } - if (_tmp593_) { - ValaMemberAccess* _tmp608_; - ValaExpression* _tmp609_; - ValaExpression* _tmp610_; - _tmp608_ = right_ma_inner; - _tmp609_ = vala_member_access_get_inner (_tmp608_); - _tmp610_ = _tmp609_; - _tmp592_ = _tmp610_ == NULL; + if (_tmp599_) { + ValaMemberAccess* _tmp614_; + ValaExpression* _tmp615_; + ValaExpression* _tmp616_; + _tmp614_ = right_ma_inner; + _tmp615_ = vala_member_access_get_inner (_tmp614_); + _tmp616_ = _tmp615_; + _tmp598_ = _tmp616_ == NULL; } else { - _tmp592_ = FALSE; + _tmp598_ = FALSE; } - if (_tmp592_) { - ValaSourceReference* _tmp611_; - ValaSourceReference* _tmp612_; - _tmp611_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); - _tmp612_ = _tmp611_; - vala_report_warning (_tmp612_, "Assignment to same variable"); + if (_tmp598_) { + ValaSourceReference* _tmp617_; + ValaSourceReference* _tmp618_; + _tmp617_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); + _tmp618_ = _tmp617_; + vala_report_warning (_tmp618_, "Assignment to same variable"); } } } } } } else { - ValaElementAccess* _tmp613_; - _tmp613_ = ea; - if (_tmp613_ != NULL) { - ValaExpression* _tmp614_; - ValaExpression* _tmp615_; - ValaDataType* _tmp616_; - ValaDataType* _tmp617_; - ValaExpression* _tmp618_; - ValaExpression* _tmp619_; - ValaDataType* _tmp620_; - ValaDataType* _tmp621_; - ValaExpression* _tmp636_; - ValaExpression* _tmp637_; - ValaDataType* _tmp638_; - ValaDataType* _tmp639_; - _tmp614_ = vala_assignment_get_right (self); - _tmp615_ = _tmp614_; - _tmp616_ = vala_expression_get_value_type (_tmp615_); - _tmp617_ = _tmp616_; - _tmp618_ = vala_assignment_get_left (self); - _tmp619_ = _tmp618_; - _tmp620_ = vala_expression_get_value_type (_tmp619_); + ValaElementAccess* _tmp619_; + _tmp619_ = ea; + if (_tmp619_ != NULL) { + ValaExpression* _tmp620_; + ValaExpression* _tmp621_; + ValaDataType* _tmp622_; + ValaDataType* _tmp623_; + ValaExpression* _tmp624_; + ValaExpression* _tmp625_; + ValaDataType* _tmp626_; + ValaDataType* _tmp627_; + ValaExpression* _tmp642_; + ValaExpression* _tmp643_; + ValaDataType* _tmp644_; + ValaDataType* _tmp645_; + _tmp620_ = vala_assignment_get_right (self); _tmp621_ = _tmp620_; - if (!vala_data_type_compatible (_tmp617_, _tmp621_)) { - ValaSourceReference* _tmp622_; - ValaSourceReference* _tmp623_; - ValaExpression* _tmp624_; - ValaExpression* _tmp625_; - ValaDataType* _tmp626_; - ValaDataType* _tmp627_; - gchar* _tmp628_; - gchar* _tmp629_; + _tmp622_ = vala_expression_get_value_type (_tmp621_); + _tmp623_ = _tmp622_; + _tmp624_ = vala_assignment_get_left (self); + _tmp625_ = _tmp624_; + _tmp626_ = vala_expression_get_value_type (_tmp625_); + _tmp627_ = _tmp626_; + if (!vala_data_type_compatible (_tmp623_, _tmp627_)) { + ValaSourceReference* _tmp628_; + ValaSourceReference* _tmp629_; ValaExpression* _tmp630_; ValaExpression* _tmp631_; ValaDataType* _tmp632_; ValaDataType* _tmp633_; gchar* _tmp634_; gchar* _tmp635_; + ValaExpression* _tmp636_; + ValaExpression* _tmp637_; + ValaDataType* _tmp638_; + ValaDataType* _tmp639_; + gchar* _tmp640_; + gchar* _tmp641_; vala_code_node_set_error ((ValaCodeNode*) self, TRUE); - _tmp622_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); - _tmp623_ = _tmp622_; - _tmp624_ = vala_assignment_get_right (self); - _tmp625_ = _tmp624_; - _tmp626_ = vala_expression_get_value_type (_tmp625_); - _tmp627_ = _tmp626_; - _tmp628_ = vala_code_node_to_string ((ValaCodeNode*) _tmp627_); + _tmp628_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); _tmp629_ = _tmp628_; - _tmp630_ = vala_assignment_get_left (self); + _tmp630_ = vala_assignment_get_right (self); _tmp631_ = _tmp630_; _tmp632_ = vala_expression_get_value_type (_tmp631_); _tmp633_ = _tmp632_; _tmp634_ = vala_code_node_to_string ((ValaCodeNode*) _tmp633_); _tmp635_ = _tmp634_; - vala_report_error (_tmp623_, "Assignment: Cannot convert from `%s' to `%s'", _tmp629_, _tmp635_); + _tmp636_ = vala_assignment_get_left (self); + _tmp637_ = _tmp636_; + _tmp638_ = vala_expression_get_value_type (_tmp637_); + _tmp639_ = _tmp638_; + _tmp640_ = vala_code_node_to_string ((ValaCodeNode*) _tmp639_); + _tmp641_ = _tmp640_; + vala_report_error (_tmp629_, "Assignment: Cannot convert from `%s' to `%s'", _tmp635_, _tmp641_); + _g_free0 (_tmp641_); _g_free0 (_tmp635_); - _g_free0 (_tmp629_); result = FALSE; return result; } - _tmp636_ = vala_assignment_get_right (self); - _tmp637_ = _tmp636_; - _tmp638_ = vala_expression_get_value_type (_tmp637_); - _tmp639_ = _tmp638_; - if (vala_data_type_is_disposable (_tmp639_)) { + _tmp642_ = vala_assignment_get_right (self); + _tmp643_ = _tmp642_; + _tmp644_ = vala_expression_get_value_type (_tmp643_); + _tmp645_ = _tmp644_; + if (vala_data_type_is_disposable (_tmp645_)) { ValaDataType* element_type = NULL; - ValaElementAccess* _tmp640_; - ValaExpression* _tmp641_; - ValaExpression* _tmp642_; - ValaDataType* _tmp643_; - ValaDataType* _tmp644_; - gboolean _tmp666_ = FALSE; - ValaDataType* _tmp667_; - _tmp640_ = ea; - _tmp641_ = vala_element_access_get_container (_tmp640_); - _tmp642_ = _tmp641_; - _tmp643_ = vala_expression_get_value_type (_tmp642_); - _tmp644_ = _tmp643_; - if (VALA_IS_ARRAY_TYPE (_tmp644_)) { + ValaElementAccess* _tmp646_; + ValaExpression* _tmp647_; + ValaExpression* _tmp648_; + ValaDataType* _tmp649_; + ValaDataType* _tmp650_; + gboolean _tmp672_ = FALSE; + ValaDataType* _tmp673_; + _tmp646_ = ea; + _tmp647_ = vala_element_access_get_container (_tmp646_); + _tmp648_ = _tmp647_; + _tmp649_ = vala_expression_get_value_type (_tmp648_); + _tmp650_ = _tmp649_; + if (VALA_IS_ARRAY_TYPE (_tmp650_)) { ValaArrayType* array_type = NULL; - ValaElementAccess* _tmp645_; - ValaExpression* _tmp646_; - ValaExpression* _tmp647_; - ValaDataType* _tmp648_; - ValaDataType* _tmp649_; - ValaArrayType* _tmp650_; - ValaDataType* _tmp651_; - ValaDataType* _tmp652_; - ValaDataType* _tmp653_; - _tmp645_ = ea; - _tmp646_ = vala_element_access_get_container (_tmp645_); - _tmp647_ = _tmp646_; - _tmp648_ = vala_expression_get_value_type (_tmp647_); - _tmp649_ = _tmp648_; - array_type = G_TYPE_CHECK_INSTANCE_CAST (_tmp649_, VALA_TYPE_ARRAY_TYPE, ValaArrayType); - _tmp650_ = array_type; - _tmp651_ = vala_array_type_get_element_type (_tmp650_); - _tmp652_ = _tmp651_; - _tmp653_ = _vala_code_node_ref0 (_tmp652_); - _vala_code_node_unref0 (element_type); - element_type = _tmp653_; - } else { - ValaList* args = NULL; - ValaElementAccess* _tmp654_; - ValaExpression* _tmp655_; - ValaExpression* _tmp656_; + ValaElementAccess* _tmp651_; + ValaExpression* _tmp652_; + ValaExpression* _tmp653_; + ValaDataType* _tmp654_; + ValaDataType* _tmp655_; + ValaArrayType* _tmp656_; ValaDataType* _tmp657_; ValaDataType* _tmp658_; - ValaList* _tmp659_; - ValaList* _tmp660_; - ValaList* _tmp661_; - gint _tmp662_; - gint _tmp663_; - ValaList* _tmp664_; - gpointer _tmp665_; - _tmp654_ = ea; - _tmp655_ = vala_element_access_get_container (_tmp654_); - _tmp656_ = _tmp655_; - _tmp657_ = vala_expression_get_value_type (_tmp656_); + ValaDataType* _tmp659_; + _tmp651_ = ea; + _tmp652_ = vala_element_access_get_container (_tmp651_); + _tmp653_ = _tmp652_; + _tmp654_ = vala_expression_get_value_type (_tmp653_); + _tmp655_ = _tmp654_; + array_type = G_TYPE_CHECK_INSTANCE_CAST (_tmp655_, VALA_TYPE_ARRAY_TYPE, ValaArrayType); + _tmp656_ = array_type; + _tmp657_ = vala_array_type_get_element_type (_tmp656_); _tmp658_ = _tmp657_; - _tmp659_ = vala_data_type_get_type_arguments (_tmp658_); - _tmp660_ = _vala_iterable_ref0 (_tmp659_); - args = _tmp660_; - _tmp661_ = args; - _tmp662_ = vala_collection_get_size ((ValaCollection*) _tmp661_); - _tmp663_ = _tmp662_; - _vala_assert (_tmp663_ == 1, "args.size == 1"); - _tmp664_ = args; - _tmp665_ = vala_list_get (_tmp664_, 0); + _tmp659_ = _vala_code_node_ref0 (_tmp658_); _vala_code_node_unref0 (element_type); - element_type = (ValaDataType*) _tmp665_; + element_type = _tmp659_; + } else { + ValaList* args = NULL; + ValaElementAccess* _tmp660_; + ValaExpression* _tmp661_; + ValaExpression* _tmp662_; + ValaDataType* _tmp663_; + ValaDataType* _tmp664_; + ValaList* _tmp665_; + ValaList* _tmp666_; + ValaList* _tmp667_; + gint _tmp668_; + gint _tmp669_; + ValaList* _tmp670_; + gpointer _tmp671_; + _tmp660_ = ea; + _tmp661_ = vala_element_access_get_container (_tmp660_); + _tmp662_ = _tmp661_; + _tmp663_ = vala_expression_get_value_type (_tmp662_); + _tmp664_ = _tmp663_; + _tmp665_ = vala_data_type_get_type_arguments (_tmp664_); + _tmp666_ = _vala_iterable_ref0 (_tmp665_); + args = _tmp666_; + _tmp667_ = args; + _tmp668_ = vala_collection_get_size ((ValaCollection*) _tmp667_); + _tmp669_ = _tmp668_; + _vala_assert (_tmp669_ == 1, "args.size == 1"); + _tmp670_ = args; + _tmp671_ = vala_list_get (_tmp670_, 0); + _vala_code_node_unref0 (element_type); + element_type = (ValaDataType*) _tmp671_; _vala_iterable_unref0 (args); } - _tmp667_ = element_type; - if (!VALA_IS_POINTER_TYPE (_tmp667_)) { - ValaDataType* _tmp668_; - gboolean _tmp669_; - gboolean _tmp670_; - _tmp668_ = element_type; - _tmp669_ = vala_data_type_get_value_owned (_tmp668_); - _tmp670_ = _tmp669_; - _tmp666_ = !_tmp670_; + _tmp673_ = element_type; + if (!VALA_IS_POINTER_TYPE (_tmp673_)) { + ValaDataType* _tmp674_; + gboolean _tmp675_; + gboolean _tmp676_; + _tmp674_ = element_type; + _tmp675_ = vala_data_type_get_value_owned (_tmp674_); + _tmp676_ = _tmp675_; + _tmp672_ = !_tmp676_; } else { - _tmp666_ = FALSE; + _tmp672_ = FALSE; } - if (_tmp666_) { - ValaSourceReference* _tmp671_; - ValaSourceReference* _tmp672_; + if (_tmp672_) { + ValaSourceReference* _tmp677_; + ValaSourceReference* _tmp678_; vala_code_node_set_error ((ValaCodeNode*) self, TRUE); - _tmp671_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); - _tmp672_ = _tmp671_; - vala_report_error (_tmp672_, "Invalid assignment from owned expression to unowned variable"); + _tmp677_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); + _tmp678_ = _tmp677_; + vala_report_error (_tmp678_, "Invalid assignment from owned expression to unowned variable"); result = FALSE; _vala_code_node_unref0 (element_type); return result; } _vala_code_node_unref0 (element_type); } else { - ValaExpression* _tmp673_; - ValaExpression* _tmp674_; - ValaDataType* _tmp675_; - ValaDataType* _tmp676_; - gboolean _tmp677_; - gboolean _tmp678_; - _tmp673_ = vala_assignment_get_left (self); - _tmp674_ = _tmp673_; - _tmp675_ = vala_expression_get_value_type (_tmp674_); - _tmp676_ = _tmp675_; - _tmp677_ = vala_data_type_get_value_owned (_tmp676_); - _tmp678_ = _tmp677_; - if (_tmp678_) { + ValaExpression* _tmp679_; + ValaExpression* _tmp680_; + ValaDataType* _tmp681_; + ValaDataType* _tmp682_; + gboolean _tmp683_; + gboolean _tmp684_; + _tmp679_ = vala_assignment_get_left (self); + _tmp680_ = _tmp679_; + _tmp681_ = vala_expression_get_value_type (_tmp680_); + _tmp682_ = _tmp681_; + _tmp683_ = vala_data_type_get_value_owned (_tmp682_); + _tmp684_ = _tmp683_; + if (_tmp684_) { } } } else { @@ -2306,45 +2324,45 @@ return result; } } - _tmp679_ = vala_assignment_get_left (self); - _tmp680_ = _tmp679_; - _tmp681_ = vala_expression_get_value_type (_tmp680_); - _tmp682_ = _tmp681_; - if (_tmp682_ != NULL) { - ValaExpression* _tmp683_; - ValaExpression* _tmp684_; - ValaDataType* _tmp685_; - ValaDataType* _tmp686_; - ValaDataType* _tmp687_; - ValaDataType* _tmp688_; - ValaDataType* _tmp689_; - ValaDataType* _tmp690_; - _tmp683_ = vala_assignment_get_left (self); - _tmp684_ = _tmp683_; - _tmp685_ = vala_expression_get_value_type (_tmp684_); - _tmp686_ = _tmp685_; - _tmp687_ = vala_data_type_copy (_tmp686_); - _tmp688_ = _tmp687_; - vala_expression_set_value_type ((ValaExpression*) self, _tmp688_); - _vala_code_node_unref0 (_tmp688_); - _tmp689_ = vala_expression_get_value_type ((ValaExpression*) self); + _tmp685_ = vala_assignment_get_left (self); + _tmp686_ = _tmp685_; + _tmp687_ = vala_expression_get_value_type (_tmp686_); + _tmp688_ = _tmp687_; + if (_tmp688_ != NULL) { + ValaExpression* _tmp689_; + ValaExpression* _tmp690_; + ValaDataType* _tmp691_; + ValaDataType* _tmp692_; + ValaDataType* _tmp693_; + ValaDataType* _tmp694_; + ValaDataType* _tmp695_; + ValaDataType* _tmp696_; + _tmp689_ = vala_assignment_get_left (self); _tmp690_ = _tmp689_; - vala_data_type_set_value_owned (_tmp690_, FALSE); + _tmp691_ = vala_expression_get_value_type (_tmp690_); + _tmp692_ = _tmp691_; + _tmp693_ = vala_data_type_copy (_tmp692_); + _tmp694_ = _tmp693_; + vala_expression_set_value_type ((ValaExpression*) self, _tmp694_); + _vala_code_node_unref0 (_tmp694_); + _tmp695_ = vala_expression_get_value_type ((ValaExpression*) self); + _tmp696_ = _tmp695_; + vala_data_type_set_value_owned (_tmp696_, FALSE); } else { vala_expression_set_value_type ((ValaExpression*) self, NULL); } - _tmp691_ = vala_expression_get_value_type ((ValaExpression*) self); - _tmp692_ = _tmp691_; - if (_tmp692_ != NULL) { - ValaDataType* _tmp693_; - ValaDataType* _tmp694_; - _tmp693_ = vala_expression_get_value_type ((ValaExpression*) self); - _tmp694_ = _tmp693_; - vala_code_node_check ((ValaCodeNode*) _tmp694_, context); + _tmp697_ = vala_expression_get_value_type ((ValaExpression*) self); + _tmp698_ = _tmp697_; + if (_tmp698_ != NULL) { + ValaDataType* _tmp699_; + ValaDataType* _tmp700_; + _tmp699_ = vala_expression_get_value_type ((ValaExpression*) self); + _tmp700_ = _tmp699_; + vala_code_node_check ((ValaCodeNode*) _tmp700_, context); } - _tmp695_ = vala_code_node_get_error ((ValaCodeNode*) self); - _tmp696_ = _tmp695_; - result = !_tmp696_; + _tmp701_ = vala_code_node_get_error ((ValaCodeNode*) self); + _tmp702_ = _tmp701_; + result = !_tmp702_; return result; } diff -Nru vala-0.56.16/vala/valaassignment.vala vala-0.56.17/vala/valaassignment.vala --- vala-0.56.16/vala/valaassignment.vala 2024-03-13 19:27:31.000000000 +0000 +++ vala-0.56.17/vala/valaassignment.vala 2024-04-19 10:23:20.000000000 +0000 @@ -293,6 +293,11 @@ if (ma != null) { if (ma.symbol_reference is Property) { unowned Property prop = (Property) ma.symbol_reference; + if (right.value_type == null) { + error = true; + Report.error (source_reference, "Assignment: Invalid assignment attempt"); + return false; + } unowned DynamicProperty? dynamic_prop = prop as DynamicProperty; if (dynamic_prop != null) { diff -Nru vala-0.56.16/vala/valacodecontext.c vala-0.56.17/vala/valacodecontext.c --- vala-0.56.16/vala/valacodecontext.c 2024-03-14 09:03:17.000000000 +0000 +++ vala-0.56.17/vala/valacodecontext.c 2024-04-19 11:03:18.000000000 +0000 @@ -2575,7 +2575,7 @@ } } _tmp28_ = girname; - _tmp29_ = g_build_path (GI_GIRDIR, _tmp28_, NULL); + _tmp29_ = g_build_path ("/", GI_GIRDIR, _tmp28_, NULL); _g_free0 (path); path = _tmp29_; _tmp30_ = path; @@ -2585,7 +2585,7 @@ return result; } _tmp31_ = girname; - _tmp32_ = g_build_path ("/", "usr", "share", GIR_SUFFIX, _tmp31_, NULL); + _tmp32_ = g_build_path ("/", "/usr", "share", GIR_SUFFIX, _tmp31_, NULL); _g_free0 (path); path = _tmp32_; _tmp33_ = path; diff -Nru vala-0.56.16/vala/valacodecontext.vala vala-0.56.17/vala/valacodecontext.vala --- vala-0.56.16/vala/valacodecontext.vala 2024-03-13 19:27:31.000000000 +0000 +++ vala-0.56.17/vala/valacodecontext.vala 2024-04-19 10:23:20.000000000 +0000 @@ -726,13 +726,13 @@ } // Search $GI_GIRDIR set by user or retrieved from gobject-introspection-1.0.pc - path = Path.build_path (Config.GI_GIRDIR, girname); + path = Path.build_path ("/", Config.GI_GIRDIR, girname); if (FileUtils.test (path, FileTest.EXISTS | FileTest.IS_REGULAR)) { return path; } // Search /usr/share - path = Path.build_path ("/", "usr", "share", GIR_SUFFIX, girname); + path = Path.build_path ("/", "/usr", "share", GIR_SUFFIX, girname); if (FileUtils.test (path, FileTest.EXISTS | FileTest.IS_REGULAR)) { return path; } diff -Nru vala-0.56.16/vala/valafield.c vala-0.56.17/vala/valafield.c --- vala-0.56.16/vala/valafield.c 2024-03-14 09:03:17.000000000 +0000 +++ vala-0.56.17/vala/valafield.c 2024-04-19 11:03:18.000000000 +0000 @@ -296,23 +296,23 @@ ValaArrayType* _tmp103_; ValaExpression* _tmp112_; ValaExpression* _tmp113_; - gboolean _tmp234_ = FALSE; - ValaMemberBinding _tmp235_; + gboolean _tmp236_ = FALSE; + ValaMemberBinding _tmp237_; gboolean field_in_header = FALSE; - ValaSymbol* _tmp240_; - ValaSymbol* _tmp241_; - gboolean _tmp250_ = FALSE; - gboolean _tmp251_ = FALSE; - gboolean _tmp252_; - gboolean _tmp253_; - ValaSemanticAnalyzer* _tmp266_; - ValaSemanticAnalyzer* _tmp267_; - ValaSourceFile* _tmp268_; + ValaSymbol* _tmp242_; + ValaSymbol* _tmp243_; + gboolean _tmp252_ = FALSE; + gboolean _tmp253_ = FALSE; + gboolean _tmp254_; + gboolean _tmp255_; + ValaSemanticAnalyzer* _tmp268_; ValaSemanticAnalyzer* _tmp269_; - ValaSemanticAnalyzer* _tmp270_; - ValaSymbol* _tmp271_; - gboolean _tmp272_; - gboolean _tmp273_; + ValaSourceFile* _tmp270_; + ValaSemanticAnalyzer* _tmp271_; + ValaSemanticAnalyzer* _tmp272_; + ValaSymbol* _tmp273_; + gboolean _tmp274_; + gboolean _tmp275_; gboolean result; self = (ValaField*) base; g_return_val_if_fail (context != NULL, FALSE); @@ -595,36 +595,36 @@ ValaExpression* _tmp127_; ValaDataType* _tmp128_; ValaDataType* _tmp129_; - ValaExpression* _tmp132_; - ValaExpression* _tmp133_; - ValaDataType* _tmp134_; - ValaDataType* _tmp135_; + ValaExpression* _tmp134_; + ValaExpression* _tmp135_; ValaDataType* _tmp136_; ValaDataType* _tmp137_; - gboolean _tmp150_ = FALSE; - gboolean _tmp151_ = FALSE; + ValaDataType* _tmp138_; + ValaDataType* _tmp139_; gboolean _tmp152_ = FALSE; - ValaArrayType* _tmp153_; - gboolean _tmp167_ = FALSE; - gboolean _tmp168_ = FALSE; - ValaArrayType* _tmp169_; - ValaExpression* _tmp179_; - ValaExpression* _tmp180_; - ValaDataType* _tmp181_; - ValaDataType* _tmp182_; - gboolean _tmp192_ = FALSE; - ValaSymbol* _tmp193_; - ValaSymbol* _tmp194_; - gboolean _tmp199_ = FALSE; - gboolean _tmp200_ = FALSE; - ValaSymbol* _tmp201_; - ValaSymbol* _tmp202_; - gboolean _tmp216_ = FALSE; - gboolean _tmp217_ = FALSE; + gboolean _tmp153_ = FALSE; + gboolean _tmp154_ = FALSE; + ValaArrayType* _tmp155_; + gboolean _tmp169_ = FALSE; + gboolean _tmp170_ = FALSE; + ValaArrayType* _tmp171_; + ValaExpression* _tmp181_; + ValaExpression* _tmp182_; + ValaDataType* _tmp183_; + ValaDataType* _tmp184_; + gboolean _tmp194_ = FALSE; + ValaSymbol* _tmp195_; + ValaSymbol* _tmp196_; + gboolean _tmp201_ = FALSE; + gboolean _tmp202_ = FALSE; + ValaSymbol* _tmp203_; + ValaSymbol* _tmp204_; gboolean _tmp218_ = FALSE; - ValaMemberBinding _tmp219_; - gboolean _tmp230_; - gboolean _tmp231_; + gboolean _tmp219_ = FALSE; + gboolean _tmp220_ = FALSE; + ValaMemberBinding _tmp221_; + gboolean _tmp232_; + gboolean _tmp233_; _tmp114_ = vala_variable_get_initializer ((ValaVariable*) self); _tmp115_ = _tmp114_; _tmp116_ = vala_variable_get_variable_type ((ValaVariable*) self); @@ -660,417 +660,421 @@ _tmp128_ = vala_expression_get_value_type (_tmp127_); _tmp129_ = _tmp128_; if (_tmp129_ == NULL) { - ValaSourceReference* _tmp130_; - ValaSourceReference* _tmp131_; + ValaExpression* _tmp130_; + ValaExpression* _tmp131_; + ValaSourceReference* _tmp132_; + ValaSourceReference* _tmp133_; vala_code_node_set_error ((ValaCodeNode*) self, TRUE); - _tmp130_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); + _tmp130_ = vala_variable_get_initializer ((ValaVariable*) self); _tmp131_ = _tmp130_; - vala_report_error (_tmp131_, "expression type not allowed as initializer"); + _tmp132_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp131_); + _tmp133_ = _tmp132_; + vala_report_error (_tmp133_, "expression type not allowed as initializer"); result = FALSE; _vala_code_node_unref0 (old_symbol); _vala_source_file_unref0 (old_source_file); return result; } - _tmp132_ = vala_variable_get_initializer ((ValaVariable*) self); - _tmp133_ = _tmp132_; - _tmp134_ = vala_expression_get_value_type (_tmp133_); + _tmp134_ = vala_variable_get_initializer ((ValaVariable*) self); _tmp135_ = _tmp134_; - _tmp136_ = vala_variable_get_variable_type ((ValaVariable*) self); + _tmp136_ = vala_expression_get_value_type (_tmp135_); _tmp137_ = _tmp136_; - if (!vala_data_type_compatible (_tmp135_, _tmp137_)) { - ValaSourceReference* _tmp138_; - ValaSourceReference* _tmp139_; - ValaExpression* _tmp140_; - ValaExpression* _tmp141_; - ValaDataType* _tmp142_; - ValaDataType* _tmp143_; - gchar* _tmp144_; - gchar* _tmp145_; - ValaDataType* _tmp146_; - ValaDataType* _tmp147_; - gchar* _tmp148_; - gchar* _tmp149_; + _tmp138_ = vala_variable_get_variable_type ((ValaVariable*) self); + _tmp139_ = _tmp138_; + if (!vala_data_type_compatible (_tmp137_, _tmp139_)) { + ValaSourceReference* _tmp140_; + ValaSourceReference* _tmp141_; + ValaExpression* _tmp142_; + ValaExpression* _tmp143_; + ValaDataType* _tmp144_; + ValaDataType* _tmp145_; + gchar* _tmp146_; + gchar* _tmp147_; + ValaDataType* _tmp148_; + ValaDataType* _tmp149_; + gchar* _tmp150_; + gchar* _tmp151_; vala_code_node_set_error ((ValaCodeNode*) self, TRUE); - _tmp138_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); - _tmp139_ = _tmp138_; - _tmp140_ = vala_variable_get_initializer ((ValaVariable*) self); + _tmp140_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); _tmp141_ = _tmp140_; - _tmp142_ = vala_expression_get_value_type (_tmp141_); + _tmp142_ = vala_variable_get_initializer ((ValaVariable*) self); _tmp143_ = _tmp142_; - _tmp144_ = vala_code_node_to_string ((ValaCodeNode*) _tmp143_); + _tmp144_ = vala_expression_get_value_type (_tmp143_); _tmp145_ = _tmp144_; - _tmp146_ = vala_variable_get_variable_type ((ValaVariable*) self); + _tmp146_ = vala_code_node_to_string ((ValaCodeNode*) _tmp145_); _tmp147_ = _tmp146_; - _tmp148_ = vala_code_node_to_string ((ValaCodeNode*) _tmp147_); + _tmp148_ = vala_variable_get_variable_type ((ValaVariable*) self); _tmp149_ = _tmp148_; - vala_report_error (_tmp139_, "Cannot convert from `%s' to `%s'", _tmp145_, _tmp149_); - _g_free0 (_tmp149_); - _g_free0 (_tmp145_); + _tmp150_ = vala_code_node_to_string ((ValaCodeNode*) _tmp149_); + _tmp151_ = _tmp150_; + vala_report_error (_tmp141_, "Cannot convert from `%s' to `%s'", _tmp147_, _tmp151_); + _g_free0 (_tmp151_); + _g_free0 (_tmp147_); result = FALSE; _vala_code_node_unref0 (old_symbol); _vala_source_file_unref0 (old_source_file); return result; } - _tmp153_ = variable_array_type; - if (_tmp153_ != NULL) { - ValaArrayType* _tmp154_; - gboolean _tmp155_; - gboolean _tmp156_; - _tmp154_ = variable_array_type; - _tmp155_ = vala_array_type_get_inline_allocated (_tmp154_); - _tmp156_ = _tmp155_; - _tmp152_ = _tmp156_; + _tmp155_ = variable_array_type; + if (_tmp155_ != NULL) { + ValaArrayType* _tmp156_; + gboolean _tmp157_; + gboolean _tmp158_; + _tmp156_ = variable_array_type; + _tmp157_ = vala_array_type_get_inline_allocated (_tmp156_); + _tmp158_ = _tmp157_; + _tmp154_ = _tmp158_; + } else { + _tmp154_ = FALSE; + } + if (_tmp154_) { + ValaArrayType* _tmp159_; + gboolean _tmp160_; + gboolean _tmp161_; + _tmp159_ = variable_array_type; + _tmp160_ = vala_array_type_get_fixed_length (_tmp159_); + _tmp161_ = _tmp160_; + _tmp153_ = !_tmp161_; + } else { + _tmp153_ = FALSE; + } + if (_tmp153_) { + _tmp152_ = is_initializer_list; } else { _tmp152_ = FALSE; } if (_tmp152_) { - ValaArrayType* _tmp157_; - gboolean _tmp158_; - gboolean _tmp159_; - _tmp157_ = variable_array_type; - _tmp158_ = vala_array_type_get_fixed_length (_tmp157_); - _tmp159_ = _tmp158_; - _tmp151_ = !_tmp159_; - } else { - _tmp151_ = FALSE; - } - if (_tmp151_) { - _tmp150_ = is_initializer_list; - } else { - _tmp150_ = FALSE; - } - if (_tmp150_) { - ValaArrayType* _tmp160_; - gchar* _tmp161_; - gchar* _tmp162_; - ValaIntegerLiteral* _tmp163_; - ValaIntegerLiteral* _tmp164_; - ValaArrayType* _tmp165_; - ValaArrayType* _tmp166_; - _tmp160_ = variable_array_type; - _tmp161_ = g_strdup_printf ("%i", initializer_size); - _tmp162_ = _tmp161_; - _tmp163_ = vala_integer_literal_new (_tmp162_, NULL); + ValaArrayType* _tmp162_; + gchar* _tmp163_; + gchar* _tmp164_; + ValaIntegerLiteral* _tmp165_; + ValaIntegerLiteral* _tmp166_; + ValaArrayType* _tmp167_; + ValaArrayType* _tmp168_; + _tmp162_ = variable_array_type; + _tmp163_ = g_strdup_printf ("%i", initializer_size); _tmp164_ = _tmp163_; - vala_array_type_set_length (_tmp160_, (ValaExpression*) _tmp164_); - _vala_code_node_unref0 (_tmp164_); - _g_free0 (_tmp162_); - _tmp165_ = variable_array_type; - vala_array_type_set_fixed_length (_tmp165_, TRUE); - _tmp166_ = variable_array_type; - vala_data_type_set_nullable ((ValaDataType*) _tmp166_, FALSE); - } - _tmp169_ = variable_array_type; - if (_tmp169_ != NULL) { - ValaArrayType* _tmp170_; - gboolean _tmp171_; - gboolean _tmp172_; - _tmp170_ = variable_array_type; - _tmp171_ = vala_array_type_get_inline_allocated (_tmp170_); - _tmp172_ = _tmp171_; - _tmp168_ = _tmp172_; - } else { - _tmp168_ = FALSE; - } - if (_tmp168_) { - ValaExpression* _tmp173_; - ValaExpression* _tmp174_; - ValaDataType* _tmp175_; - ValaDataType* _tmp176_; - _tmp173_ = vala_variable_get_initializer ((ValaVariable*) self); + _tmp165_ = vala_integer_literal_new (_tmp164_, NULL); + _tmp166_ = _tmp165_; + vala_array_type_set_length (_tmp162_, (ValaExpression*) _tmp166_); + _vala_code_node_unref0 (_tmp166_); + _g_free0 (_tmp164_); + _tmp167_ = variable_array_type; + vala_array_type_set_fixed_length (_tmp167_, TRUE); + _tmp168_ = variable_array_type; + vala_data_type_set_nullable ((ValaDataType*) _tmp168_, FALSE); + } + _tmp171_ = variable_array_type; + if (_tmp171_ != NULL) { + ValaArrayType* _tmp172_; + gboolean _tmp173_; + gboolean _tmp174_; + _tmp172_ = variable_array_type; + _tmp173_ = vala_array_type_get_inline_allocated (_tmp172_); _tmp174_ = _tmp173_; - _tmp175_ = vala_expression_get_value_type (_tmp174_); + _tmp170_ = _tmp174_; + } else { + _tmp170_ = FALSE; + } + if (_tmp170_) { + ValaExpression* _tmp175_; + ValaExpression* _tmp176_; + ValaDataType* _tmp177_; + ValaDataType* _tmp178_; + _tmp175_ = vala_variable_get_initializer ((ValaVariable*) self); _tmp176_ = _tmp175_; - _tmp167_ = !VALA_IS_ARRAY_TYPE (_tmp176_); + _tmp177_ = vala_expression_get_value_type (_tmp176_); + _tmp178_ = _tmp177_; + _tmp169_ = !VALA_IS_ARRAY_TYPE (_tmp178_); } else { - _tmp167_ = FALSE; + _tmp169_ = FALSE; } - if (_tmp167_) { - ValaSourceReference* _tmp177_; - ValaSourceReference* _tmp178_; + if (_tmp169_) { + ValaSourceReference* _tmp179_; + ValaSourceReference* _tmp180_; vala_code_node_set_error ((ValaCodeNode*) self, TRUE); - _tmp177_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); - _tmp178_ = _tmp177_; - vala_report_error (_tmp178_, "only arrays are allowed as initializer for arrays with fixed length"); + _tmp179_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); + _tmp180_ = _tmp179_; + vala_report_error (_tmp180_, "only arrays are allowed as initializer for arrays with fixed length"); result = FALSE; _vala_code_node_unref0 (old_symbol); _vala_source_file_unref0 (old_source_file); return result; } - _tmp179_ = vala_variable_get_initializer ((ValaVariable*) self); - _tmp180_ = _tmp179_; - _tmp181_ = vala_expression_get_value_type (_tmp180_); + _tmp181_ = vala_variable_get_initializer ((ValaVariable*) self); _tmp182_ = _tmp181_; - if (vala_data_type_is_disposable (_tmp182_)) { - gboolean _tmp183_ = FALSE; - ValaDataType* _tmp184_; - ValaDataType* _tmp185_; - _tmp184_ = vala_variable_get_variable_type ((ValaVariable*) self); - _tmp185_ = _tmp184_; - if (!VALA_IS_POINTER_TYPE (_tmp185_)) { - ValaDataType* _tmp186_; - ValaDataType* _tmp187_; - gboolean _tmp188_; - gboolean _tmp189_; - _tmp186_ = vala_variable_get_variable_type ((ValaVariable*) self); - _tmp187_ = _tmp186_; - _tmp188_ = vala_data_type_get_value_owned (_tmp187_); + _tmp183_ = vala_expression_get_value_type (_tmp182_); + _tmp184_ = _tmp183_; + if (vala_data_type_is_disposable (_tmp184_)) { + gboolean _tmp185_ = FALSE; + ValaDataType* _tmp186_; + ValaDataType* _tmp187_; + _tmp186_ = vala_variable_get_variable_type ((ValaVariable*) self); + _tmp187_ = _tmp186_; + if (!VALA_IS_POINTER_TYPE (_tmp187_)) { + ValaDataType* _tmp188_; + ValaDataType* _tmp189_; + gboolean _tmp190_; + gboolean _tmp191_; + _tmp188_ = vala_variable_get_variable_type ((ValaVariable*) self); _tmp189_ = _tmp188_; - _tmp183_ = !_tmp189_; + _tmp190_ = vala_data_type_get_value_owned (_tmp189_); + _tmp191_ = _tmp190_; + _tmp185_ = !_tmp191_; } else { - _tmp183_ = FALSE; + _tmp185_ = FALSE; } - if (_tmp183_) { - ValaSourceReference* _tmp190_; - ValaSourceReference* _tmp191_; + if (_tmp185_) { + ValaSourceReference* _tmp192_; + ValaSourceReference* _tmp193_; vala_code_node_set_error ((ValaCodeNode*) self, TRUE); - _tmp190_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); - _tmp191_ = _tmp190_; - vala_report_error (_tmp191_, "Invalid assignment from owned expression to unowned variable"); + _tmp192_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); + _tmp193_ = _tmp192_; + vala_report_error (_tmp193_, "Invalid assignment from owned expression to unowned variable"); result = FALSE; _vala_code_node_unref0 (old_symbol); _vala_source_file_unref0 (old_source_file); return result; } } - _tmp193_ = vala_symbol_get_parent_symbol ((ValaSymbol*) self); - _tmp194_ = _tmp193_; - if (VALA_IS_NAMESPACE (_tmp194_)) { - ValaExpression* _tmp195_; - ValaExpression* _tmp196_; - _tmp195_ = vala_variable_get_initializer ((ValaVariable*) self); - _tmp196_ = _tmp195_; - _tmp192_ = !vala_expression_is_constant (_tmp196_); - } else { - _tmp192_ = FALSE; - } - if (_tmp192_) { - ValaSourceReference* _tmp197_; - ValaSourceReference* _tmp198_; - vala_code_node_set_error ((ValaCodeNode*) self, TRUE); - _tmp197_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); + _tmp195_ = vala_symbol_get_parent_symbol ((ValaSymbol*) self); + _tmp196_ = _tmp195_; + if (VALA_IS_NAMESPACE (_tmp196_)) { + ValaExpression* _tmp197_; + ValaExpression* _tmp198_; + _tmp197_ = vala_variable_get_initializer ((ValaVariable*) self); _tmp198_ = _tmp197_; - vala_report_error (_tmp198_, "Non-constant field initializers not supported in this context"); + _tmp194_ = !vala_expression_is_constant (_tmp198_); + } else { + _tmp194_ = FALSE; + } + if (_tmp194_) { + ValaSourceReference* _tmp199_; + ValaSourceReference* _tmp200_; + vala_code_node_set_error ((ValaCodeNode*) self, TRUE); + _tmp199_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); + _tmp200_ = _tmp199_; + vala_report_error (_tmp200_, "Non-constant field initializers not supported in this context"); result = FALSE; _vala_code_node_unref0 (old_symbol); _vala_source_file_unref0 (old_source_file); return result; } - _tmp201_ = vala_symbol_get_parent_symbol ((ValaSymbol*) self); - _tmp202_ = _tmp201_; - if (VALA_IS_NAMESPACE (_tmp202_)) { - ValaExpression* _tmp203_; - ValaExpression* _tmp204_; - _tmp203_ = vala_variable_get_initializer ((ValaVariable*) self); - _tmp204_ = _tmp203_; - _tmp200_ = vala_expression_is_constant (_tmp204_); - } else { - _tmp200_ = FALSE; - } - if (_tmp200_) { + _tmp203_ = vala_symbol_get_parent_symbol ((ValaSymbol*) self); + _tmp204_ = _tmp203_; + if (VALA_IS_NAMESPACE (_tmp204_)) { ValaExpression* _tmp205_; ValaExpression* _tmp206_; _tmp205_ = vala_variable_get_initializer ((ValaVariable*) self); _tmp206_ = _tmp205_; - _tmp199_ = vala_expression_is_non_null (_tmp206_); + _tmp202_ = vala_expression_is_constant (_tmp206_); } else { - _tmp199_ = FALSE; + _tmp202_ = FALSE; } - if (_tmp199_) { - gboolean _tmp207_ = FALSE; - ValaDataType* _tmp208_; - ValaDataType* _tmp209_; - _tmp208_ = vala_variable_get_variable_type ((ValaVariable*) self); - _tmp209_ = _tmp208_; - if (vala_data_type_is_disposable (_tmp209_)) { - ValaDataType* _tmp210_; - ValaDataType* _tmp211_; - gboolean _tmp212_; - gboolean _tmp213_; - _tmp210_ = vala_variable_get_variable_type ((ValaVariable*) self); - _tmp211_ = _tmp210_; - _tmp212_ = vala_data_type_get_value_owned (_tmp211_); + if (_tmp202_) { + ValaExpression* _tmp207_; + ValaExpression* _tmp208_; + _tmp207_ = vala_variable_get_initializer ((ValaVariable*) self); + _tmp208_ = _tmp207_; + _tmp201_ = vala_expression_is_non_null (_tmp208_); + } else { + _tmp201_ = FALSE; + } + if (_tmp201_) { + gboolean _tmp209_ = FALSE; + ValaDataType* _tmp210_; + ValaDataType* _tmp211_; + _tmp210_ = vala_variable_get_variable_type ((ValaVariable*) self); + _tmp211_ = _tmp210_; + if (vala_data_type_is_disposable (_tmp211_)) { + ValaDataType* _tmp212_; + ValaDataType* _tmp213_; + gboolean _tmp214_; + gboolean _tmp215_; + _tmp212_ = vala_variable_get_variable_type ((ValaVariable*) self); _tmp213_ = _tmp212_; - _tmp207_ = _tmp213_; + _tmp214_ = vala_data_type_get_value_owned (_tmp213_); + _tmp215_ = _tmp214_; + _tmp209_ = _tmp215_; } else { - _tmp207_ = FALSE; + _tmp209_ = FALSE; } - if (_tmp207_) { - ValaSourceReference* _tmp214_; - ValaSourceReference* _tmp215_; + if (_tmp209_) { + ValaSourceReference* _tmp216_; + ValaSourceReference* _tmp217_; vala_code_node_set_error ((ValaCodeNode*) self, TRUE); - _tmp214_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); - _tmp215_ = _tmp214_; - vala_report_error (_tmp215_, "Owned namespace fields can only be initialized in a function or method"); + _tmp216_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); + _tmp217_ = _tmp216_; + vala_report_error (_tmp217_, "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; } } - _tmp219_ = self->priv->_binding; - if (_tmp219_ == VALA_MEMBER_BINDING_STATIC) { - ValaSymbol* _tmp220_; - ValaSymbol* _tmp221_; - _tmp220_ = vala_symbol_get_parent_symbol ((ValaSymbol*) self); - _tmp221_ = _tmp220_; - _tmp218_ = VALA_IS_CLASS (_tmp221_); - } else { - _tmp218_ = FALSE; - } - if (_tmp218_) { + _tmp221_ = self->priv->_binding; + if (_tmp221_ == VALA_MEMBER_BINDING_STATIC) { ValaSymbol* _tmp222_; ValaSymbol* _tmp223_; - gboolean _tmp224_; - gboolean _tmp225_; _tmp222_ = vala_symbol_get_parent_symbol ((ValaSymbol*) self); _tmp223_ = _tmp222_; - _tmp224_ = vala_class_get_is_compact (G_TYPE_CHECK_INSTANCE_CAST (_tmp223_, VALA_TYPE_CLASS, ValaClass)); - _tmp225_ = _tmp224_; - _tmp217_ = _tmp225_; + _tmp220_ = VALA_IS_CLASS (_tmp223_); } else { - _tmp217_ = FALSE; + _tmp220_ = FALSE; } - if (_tmp217_) { - ValaExpression* _tmp226_; - ValaExpression* _tmp227_; - _tmp226_ = vala_variable_get_initializer ((ValaVariable*) self); + if (_tmp220_) { + ValaSymbol* _tmp224_; + ValaSymbol* _tmp225_; + gboolean _tmp226_; + gboolean _tmp227_; + _tmp224_ = vala_symbol_get_parent_symbol ((ValaSymbol*) self); + _tmp225_ = _tmp224_; + _tmp226_ = vala_class_get_is_compact (G_TYPE_CHECK_INSTANCE_CAST (_tmp225_, VALA_TYPE_CLASS, ValaClass)); _tmp227_ = _tmp226_; - _tmp216_ = !vala_expression_is_constant (_tmp227_); + _tmp219_ = _tmp227_; } else { - _tmp216_ = FALSE; + _tmp219_ = FALSE; } - if (_tmp216_) { - ValaSourceReference* _tmp228_; - ValaSourceReference* _tmp229_; - vala_code_node_set_error ((ValaCodeNode*) self, TRUE); - _tmp228_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); + if (_tmp219_) { + ValaExpression* _tmp228_; + ValaExpression* _tmp229_; + _tmp228_ = vala_variable_get_initializer ((ValaVariable*) self); _tmp229_ = _tmp228_; - vala_report_error (_tmp229_, "Static fields in compact classes cannot have non-constant initializers"); + _tmp218_ = !vala_expression_is_constant (_tmp229_); + } else { + _tmp218_ = FALSE; + } + if (_tmp218_) { + ValaSourceReference* _tmp230_; + ValaSourceReference* _tmp231_; + vala_code_node_set_error ((ValaCodeNode*) self, TRUE); + _tmp230_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); + _tmp231_ = _tmp230_; + vala_report_error (_tmp231_, "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; } - _tmp230_ = vala_symbol_get_external ((ValaSymbol*) self); - _tmp231_ = _tmp230_; - if (_tmp231_) { - ValaSourceReference* _tmp232_; - ValaSourceReference* _tmp233_; + _tmp232_ = vala_symbol_get_external ((ValaSymbol*) self); + _tmp233_ = _tmp232_; + if (_tmp233_) { + ValaSourceReference* _tmp234_; + ValaSourceReference* _tmp235_; vala_code_node_set_error ((ValaCodeNode*) self, TRUE); - _tmp232_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); - _tmp233_ = _tmp232_; - vala_report_error (_tmp233_, "External fields cannot use initializers"); + _tmp234_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); + _tmp235_ = _tmp234_; + vala_report_error (_tmp235_, "External fields cannot use initializers"); } } - _tmp235_ = self->priv->_binding; - if (_tmp235_ == VALA_MEMBER_BINDING_INSTANCE) { - ValaSymbol* _tmp236_; - ValaSymbol* _tmp237_; - _tmp236_ = vala_symbol_get_parent_symbol ((ValaSymbol*) self); - _tmp237_ = _tmp236_; - _tmp234_ = VALA_IS_INTERFACE (_tmp237_); + _tmp237_ = self->priv->_binding; + if (_tmp237_ == VALA_MEMBER_BINDING_INSTANCE) { + ValaSymbol* _tmp238_; + ValaSymbol* _tmp239_; + _tmp238_ = vala_symbol_get_parent_symbol ((ValaSymbol*) self); + _tmp239_ = _tmp238_; + _tmp236_ = VALA_IS_INTERFACE (_tmp239_); } else { - _tmp234_ = FALSE; + _tmp236_ = FALSE; } - if (_tmp234_) { - ValaSourceReference* _tmp238_; - ValaSourceReference* _tmp239_; + if (_tmp236_) { + ValaSourceReference* _tmp240_; + ValaSourceReference* _tmp241_; vala_code_node_set_error ((ValaCodeNode*) self, TRUE); - _tmp238_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); - _tmp239_ = _tmp238_; - vala_report_error (_tmp239_, "Interfaces may not have instance fields"); + _tmp240_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); + _tmp241_ = _tmp240_; + vala_report_error (_tmp241_, "Interfaces may not have instance fields"); result = FALSE; _vala_code_node_unref0 (old_symbol); _vala_source_file_unref0 (old_source_file); return result; } field_in_header = !vala_symbol_is_internal_symbol ((ValaSymbol*) self); - _tmp240_ = vala_symbol_get_parent_symbol ((ValaSymbol*) self); - _tmp241_ = _tmp240_; - if (VALA_IS_CLASS (_tmp241_)) { + _tmp242_ = vala_symbol_get_parent_symbol ((ValaSymbol*) self); + _tmp243_ = _tmp242_; + if (VALA_IS_CLASS (_tmp243_)) { ValaClass* cl = NULL; - ValaSymbol* _tmp242_; - ValaSymbol* _tmp243_; - ValaClass* _tmp244_; - gboolean _tmp245_ = FALSE; + ValaSymbol* _tmp244_; + ValaSymbol* _tmp245_; ValaClass* _tmp246_; - gboolean _tmp247_; - gboolean _tmp248_; - _tmp242_ = vala_symbol_get_parent_symbol ((ValaSymbol*) self); - _tmp243_ = _tmp242_; - _tmp244_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp243_, VALA_TYPE_CLASS, ValaClass)); - cl = _tmp244_; - _tmp246_ = cl; - _tmp247_ = vala_class_get_is_compact (_tmp246_); - _tmp248_ = _tmp247_; - if (_tmp248_) { - ValaClass* _tmp249_; - _tmp249_ = cl; - _tmp245_ = !vala_symbol_is_internal_symbol ((ValaSymbol*) _tmp249_); + gboolean _tmp247_ = FALSE; + ValaClass* _tmp248_; + gboolean _tmp249_; + gboolean _tmp250_; + _tmp244_ = vala_symbol_get_parent_symbol ((ValaSymbol*) self); + _tmp245_ = _tmp244_; + _tmp246_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp245_, VALA_TYPE_CLASS, ValaClass)); + cl = _tmp246_; + _tmp248_ = cl; + _tmp249_ = vala_class_get_is_compact (_tmp248_); + _tmp250_ = _tmp249_; + if (_tmp250_) { + ValaClass* _tmp251_; + _tmp251_ = cl; + _tmp247_ = !vala_symbol_is_internal_symbol ((ValaSymbol*) _tmp251_); } else { - _tmp245_ = FALSE; + _tmp247_ = FALSE; } - if (_tmp245_) { + if (_tmp247_) { field_in_header = TRUE; } _vala_code_node_unref0 (cl); } - _tmp252_ = vala_symbol_get_external_package ((ValaSymbol*) self); - _tmp253_ = _tmp252_; - if (!_tmp253_) { - gboolean _tmp254_; - gboolean _tmp255_; - _tmp254_ = vala_symbol_get_hides ((ValaSymbol*) self); - _tmp255_ = _tmp254_; - _tmp251_ = !_tmp255_; - } else { - _tmp251_ = FALSE; - } - if (_tmp251_) { - ValaSymbol* _tmp256_; - ValaSymbol* _tmp257_; - _tmp256_ = vala_symbol_get_hidden_member ((ValaSymbol*) self); + _tmp254_ = vala_symbol_get_external_package ((ValaSymbol*) self); + _tmp255_ = _tmp254_; + if (!_tmp255_) { + gboolean _tmp256_; + gboolean _tmp257_; + _tmp256_ = vala_symbol_get_hides ((ValaSymbol*) self); _tmp257_ = _tmp256_; - _tmp250_ = _tmp257_ != NULL; - _vala_code_node_unref0 (_tmp257_); + _tmp253_ = !_tmp257_; } else { - _tmp250_ = FALSE; + _tmp253_ = FALSE; } - if (_tmp250_) { - ValaSourceReference* _tmp258_; - ValaSourceReference* _tmp259_; - gchar* _tmp260_; - gchar* _tmp261_; - ValaSymbol* _tmp262_; - ValaSymbol* _tmp263_; - gchar* _tmp264_; - gchar* _tmp265_; - _tmp258_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); + if (_tmp253_) { + ValaSymbol* _tmp258_; + ValaSymbol* _tmp259_; + _tmp258_ = vala_symbol_get_hidden_member ((ValaSymbol*) self); _tmp259_ = _tmp258_; - _tmp260_ = vala_symbol_get_full_name ((ValaSymbol*) self); + _tmp252_ = _tmp259_ != NULL; + _vala_code_node_unref0 (_tmp259_); + } else { + _tmp252_ = FALSE; + } + if (_tmp252_) { + ValaSourceReference* _tmp260_; + ValaSourceReference* _tmp261_; + gchar* _tmp262_; + gchar* _tmp263_; + ValaSymbol* _tmp264_; + ValaSymbol* _tmp265_; + gchar* _tmp266_; + gchar* _tmp267_; + _tmp260_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); _tmp261_ = _tmp260_; - _tmp262_ = vala_symbol_get_hidden_member ((ValaSymbol*) self); + _tmp262_ = vala_symbol_get_full_name ((ValaSymbol*) self); _tmp263_ = _tmp262_; - _tmp264_ = vala_symbol_get_full_name (_tmp263_); + _tmp264_ = vala_symbol_get_hidden_member ((ValaSymbol*) self); _tmp265_ = _tmp264_; - vala_report_warning (_tmp259_, "%s hides inherited field `%s'. Use the `new' keyword if hiding was int" \ -"entional", _tmp261_, _tmp265_); - _g_free0 (_tmp265_); - _vala_code_node_unref0 (_tmp263_); - _g_free0 (_tmp261_); - } - _tmp266_ = vala_code_context_get_analyzer (context); - _tmp267_ = _tmp266_; - _tmp268_ = old_source_file; - vala_semantic_analyzer_set_current_source_file (_tmp267_, _tmp268_); - _tmp269_ = vala_code_context_get_analyzer (context); - _tmp270_ = _tmp269_; - _tmp271_ = old_symbol; - vala_semantic_analyzer_set_current_symbol (_tmp270_, _tmp271_); - _tmp272_ = vala_code_node_get_error ((ValaCodeNode*) self); - _tmp273_ = _tmp272_; - result = !_tmp273_; + _tmp266_ = vala_symbol_get_full_name (_tmp265_); + _tmp267_ = _tmp266_; + vala_report_warning (_tmp261_, "%s hides inherited field `%s'. Use the `new' keyword if hiding was int" \ +"entional", _tmp263_, _tmp267_); + _g_free0 (_tmp267_); + _vala_code_node_unref0 (_tmp265_); + _g_free0 (_tmp263_); + } + _tmp268_ = vala_code_context_get_analyzer (context); + _tmp269_ = _tmp268_; + _tmp270_ = old_source_file; + vala_semantic_analyzer_set_current_source_file (_tmp269_, _tmp270_); + _tmp271_ = vala_code_context_get_analyzer (context); + _tmp272_ = _tmp271_; + _tmp273_ = old_symbol; + vala_semantic_analyzer_set_current_symbol (_tmp272_, _tmp273_); + _tmp274_ = vala_code_node_get_error ((ValaCodeNode*) self); + _tmp275_ = _tmp274_; + result = !_tmp275_; _vala_code_node_unref0 (old_symbol); _vala_source_file_unref0 (old_source_file); return result; diff -Nru vala-0.56.16/vala/valafield.vala vala-0.56.17/vala/valafield.vala --- vala-0.56.16/vala/valafield.vala 2024-03-13 19:27:31.000000000 +0000 +++ vala-0.56.17/vala/valafield.vala 2024-04-19 10:23:20.000000000 +0000 @@ -157,7 +157,7 @@ if (initializer.value_type == null) { error = true; - Report.error (source_reference, "expression type not allowed as initializer"); + Report.error (initializer.source_reference, "expression type not allowed as initializer"); return false; } diff -Nru vala-0.56.16/vala/valalocalvariable.c vala-0.56.17/vala/valalocalvariable.c --- vala-0.56.16/vala/valalocalvariable.c 2024-03-14 09:03:17.000000000 +0000 +++ vala-0.56.17/vala/valalocalvariable.c 2024-04-19 11:03:19.000000000 +0000 @@ -281,13 +281,13 @@ ValaExpression* _tmp179_; ValaExpression* _tmp180_; ValaBlock* block = NULL; - ValaSemanticAnalyzer* _tmp315_; - ValaSemanticAnalyzer* _tmp316_; - ValaSymbol* _tmp317_; - ValaSymbol* _tmp318_; - ValaBlock* _tmp319_; - gboolean _tmp321_; - gboolean _tmp322_; + ValaSemanticAnalyzer* _tmp321_; + ValaSemanticAnalyzer* _tmp322_; + ValaSymbol* _tmp323_; + ValaSymbol* _tmp324_; + ValaBlock* _tmp325_; + gboolean _tmp327_; + gboolean _tmp328_; gboolean result; self = (ValaLocalVariable*) base; g_return_val_if_fail (context != NULL, FALSE); @@ -776,23 +776,23 @@ ValaExpression* _tmp186_; ValaDataType* _tmp187_; ValaDataType* _tmp188_; - ValaExpression* _tmp228_; - ValaExpression* _tmp229_; - ValaDataType* _tmp230_; - ValaDataType* _tmp231_; - ValaDataType* _tmp232_; - ValaDataType* _tmp233_; - gboolean _tmp273_ = FALSE; - gboolean _tmp274_ = FALSE; - gboolean _tmp275_ = FALSE; - ValaArrayType* _tmp276_; - gboolean _tmp290_ = FALSE; - gboolean _tmp291_ = FALSE; - ValaArrayType* _tmp292_; - ValaExpression* _tmp302_; - ValaExpression* _tmp303_; - ValaDataType* _tmp304_; - ValaDataType* _tmp305_; + ValaExpression* _tmp234_; + ValaExpression* _tmp235_; + ValaDataType* _tmp236_; + ValaDataType* _tmp237_; + ValaDataType* _tmp238_; + ValaDataType* _tmp239_; + gboolean _tmp279_ = FALSE; + gboolean _tmp280_ = FALSE; + gboolean _tmp281_ = FALSE; + ValaArrayType* _tmp282_; + gboolean _tmp296_ = FALSE; + gboolean _tmp297_ = FALSE; + ValaArrayType* _tmp298_; + ValaExpression* _tmp308_; + ValaExpression* _tmp309_; + ValaDataType* _tmp310_; + ValaDataType* _tmp311_; _tmp185_ = vala_variable_get_initializer ((ValaVariable*) self); _tmp186_ = _tmp185_; _tmp187_ = vala_expression_get_value_type (_tmp186_); @@ -801,8 +801,8 @@ gboolean _tmp189_ = FALSE; ValaExpression* _tmp190_; ValaExpression* _tmp191_; - ValaDataType* _tmp196_; - ValaDataType* _tmp197_; + ValaDataType* _tmp198_; + ValaDataType* _tmp199_; _tmp190_ = vala_variable_get_initializer ((ValaVariable*) self); _tmp191_ = _tmp190_; if (!VALA_IS_MEMBER_ACCESS (_tmp191_)) { @@ -815,348 +815,360 @@ _tmp189_ = FALSE; } if (_tmp189_) { - ValaSourceReference* _tmp194_; - ValaSourceReference* _tmp195_; + ValaExpression* _tmp194_; + ValaExpression* _tmp195_; + ValaSourceReference* _tmp196_; + ValaSourceReference* _tmp197_; vala_code_node_set_error ((ValaCodeNode*) self, TRUE); - _tmp194_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); + _tmp194_ = vala_variable_get_initializer ((ValaVariable*) self); _tmp195_ = _tmp194_; - vala_report_error (_tmp195_, "expression type not allowed as initializer"); + _tmp196_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp195_); + _tmp197_ = _tmp196_; + vala_report_error (_tmp197_, "expression type not allowed as initializer"); result = FALSE; return result; } - _tmp196_ = vala_variable_get_variable_type ((ValaVariable*) self); - _tmp197_ = _tmp196_; - if (VALA_IS_DELEGATE_TYPE (_tmp197_)) { - ValaExpression* _tmp198_; - ValaExpression* _tmp199_; - ValaDataType* _tmp200_; - ValaDataType* _tmp201_; + _tmp198_ = vala_variable_get_variable_type ((ValaVariable*) self); + _tmp199_ = _tmp198_; + if (VALA_IS_DELEGATE_TYPE (_tmp199_)) { + ValaExpression* _tmp200_; + ValaExpression* _tmp201_; ValaDataType* _tmp202_; ValaDataType* _tmp203_; - _tmp198_ = vala_variable_get_initializer ((ValaVariable*) self); - _tmp199_ = _tmp198_; - _tmp200_ = vala_expression_get_value_type (_tmp199_); + ValaDataType* _tmp204_; + ValaDataType* _tmp205_; + _tmp200_ = vala_variable_get_initializer ((ValaVariable*) self); _tmp201_ = _tmp200_; - _tmp202_ = vala_variable_get_variable_type ((ValaVariable*) self); + _tmp202_ = vala_expression_get_value_type (_tmp201_); _tmp203_ = _tmp202_; - if (!vala_data_type_compatible (_tmp201_, _tmp203_)) { + _tmp204_ = vala_variable_get_variable_type ((ValaVariable*) self); + _tmp205_ = _tmp204_; + if (!vala_data_type_compatible (_tmp203_, _tmp205_)) { ValaMethod* m = NULL; - ValaExpression* _tmp204_; - ValaExpression* _tmp205_; - ValaSymbol* _tmp206_; - ValaSymbol* _tmp207_; + ValaExpression* _tmp206_; + ValaExpression* _tmp207_; + ValaSymbol* _tmp208_; + ValaSymbol* _tmp209_; ValaDelegate* cb = NULL; - ValaDataType* _tmp208_; - ValaDataType* _tmp209_; - ValaDelegate* _tmp210_; - ValaDelegate* _tmp211_; - ValaSourceReference* _tmp212_; - ValaSourceReference* _tmp213_; - ValaMethod* _tmp214_; - gchar* _tmp215_; - gchar* _tmp216_; - ValaDelegate* _tmp217_; + ValaDataType* _tmp210_; + ValaDataType* _tmp211_; + ValaDelegate* _tmp212_; + ValaDelegate* _tmp213_; + ValaSourceReference* _tmp214_; + ValaSourceReference* _tmp215_; + ValaMethod* _tmp216_; + gchar* _tmp217_; gchar* _tmp218_; - gchar* _tmp219_; - _tmp204_ = vala_variable_get_initializer ((ValaVariable*) self); - _tmp205_ = _tmp204_; - _tmp206_ = vala_expression_get_symbol_reference (_tmp205_); + ValaDelegate* _tmp219_; + gchar* _tmp220_; + gchar* _tmp221_; + _tmp206_ = vala_variable_get_initializer ((ValaVariable*) self); _tmp207_ = _tmp206_; - m = G_TYPE_CHECK_INSTANCE_CAST (_tmp207_, VALA_TYPE_METHOD, ValaMethod); - _tmp208_ = vala_variable_get_variable_type ((ValaVariable*) self); + _tmp208_ = vala_expression_get_symbol_reference (_tmp207_); _tmp209_ = _tmp208_; - _tmp210_ = vala_delegate_type_get_delegate_symbol (G_TYPE_CHECK_INSTANCE_CAST (_tmp209_, VALA_TYPE_DELEGATE_TYPE, ValaDelegateType)); + m = G_TYPE_CHECK_INSTANCE_CAST (_tmp209_, VALA_TYPE_METHOD, ValaMethod); + _tmp210_ = vala_variable_get_variable_type ((ValaVariable*) self); _tmp211_ = _tmp210_; - cb = _tmp211_; - vala_code_node_set_error ((ValaCodeNode*) self, TRUE); - _tmp212_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); + _tmp212_ = vala_delegate_type_get_delegate_symbol (G_TYPE_CHECK_INSTANCE_CAST (_tmp211_, VALA_TYPE_DELEGATE_TYPE, ValaDelegateType)); _tmp213_ = _tmp212_; - _tmp214_ = m; - _tmp215_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp214_); - _tmp216_ = _tmp215_; - _tmp217_ = cb; - _tmp218_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp217_); - _tmp219_ = _tmp218_; - vala_report_error (_tmp213_, "Declaration of method `%s' is not compatible with delegate `%s'", _tmp216_, _tmp219_); - _g_free0 (_tmp219_); - _g_free0 (_tmp216_); + cb = _tmp213_; + vala_code_node_set_error ((ValaCodeNode*) self, TRUE); + _tmp214_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); + _tmp215_ = _tmp214_; + _tmp216_ = m; + _tmp217_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp216_); + _tmp218_ = _tmp217_; + _tmp219_ = cb; + _tmp220_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp219_); + _tmp221_ = _tmp220_; + vala_report_error (_tmp215_, "Declaration of method `%s' is not compatible with delegate `%s'", _tmp218_, _tmp221_); + _g_free0 (_tmp221_); + _g_free0 (_tmp218_); result = FALSE; return result; } } else { - ValaSourceReference* _tmp220_; - ValaSourceReference* _tmp221_; + ValaExpression* _tmp222_; + ValaExpression* _tmp223_; + ValaSourceReference* _tmp224_; + ValaSourceReference* _tmp225_; vala_code_node_set_error ((ValaCodeNode*) self, TRUE); - _tmp220_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); - _tmp221_ = _tmp220_; - vala_report_error (_tmp221_, "expression type not allowed as initializer"); + _tmp222_ = vala_variable_get_initializer ((ValaVariable*) self); + _tmp223_ = _tmp222_; + _tmp224_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp223_); + _tmp225_ = _tmp224_; + vala_report_error (_tmp225_, "expression type not allowed as initializer"); result = FALSE; return result; } } else { - ValaExpression* _tmp222_; - ValaExpression* _tmp223_; - ValaDataType* _tmp224_; - ValaDataType* _tmp225_; - _tmp222_ = vala_variable_get_initializer ((ValaVariable*) self); - _tmp223_ = _tmp222_; - _tmp224_ = vala_expression_get_value_type (_tmp223_); - _tmp225_ = _tmp224_; - if (_tmp225_ == NULL) { - ValaSourceReference* _tmp226_; - ValaSourceReference* _tmp227_; + ValaExpression* _tmp226_; + ValaExpression* _tmp227_; + ValaDataType* _tmp228_; + ValaDataType* _tmp229_; + _tmp226_ = vala_variable_get_initializer ((ValaVariable*) self); + _tmp227_ = _tmp226_; + _tmp228_ = vala_expression_get_value_type (_tmp227_); + _tmp229_ = _tmp228_; + if (_tmp229_ == NULL) { + ValaExpression* _tmp230_; + ValaExpression* _tmp231_; + ValaSourceReference* _tmp232_; + ValaSourceReference* _tmp233_; vala_code_node_set_error ((ValaCodeNode*) self, TRUE); - _tmp226_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); - _tmp227_ = _tmp226_; - vala_report_error (_tmp227_, "expression type not allowed as initializer"); + _tmp230_ = vala_variable_get_initializer ((ValaVariable*) self); + _tmp231_ = _tmp230_; + _tmp232_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp231_); + _tmp233_ = _tmp232_; + vala_report_error (_tmp233_, "expression type not allowed as initializer"); result = FALSE; return result; } } - _tmp228_ = vala_variable_get_initializer ((ValaVariable*) self); - _tmp229_ = _tmp228_; - _tmp230_ = vala_expression_get_value_type (_tmp229_); - _tmp231_ = _tmp230_; - _tmp232_ = vala_variable_get_variable_type ((ValaVariable*) self); - _tmp233_ = _tmp232_; - if (!vala_data_type_compatible (_tmp231_, _tmp233_)) { - ValaSourceReference* _tmp234_; - ValaSourceReference* _tmp235_; - ValaExpression* _tmp236_; - ValaExpression* _tmp237_; - ValaDataType* _tmp238_; - ValaDataType* _tmp239_; - gchar* _tmp240_; - gchar* _tmp241_; - ValaDataType* _tmp242_; - ValaDataType* _tmp243_; - gchar* _tmp244_; - gchar* _tmp245_; + _tmp234_ = vala_variable_get_initializer ((ValaVariable*) self); + _tmp235_ = _tmp234_; + _tmp236_ = vala_expression_get_value_type (_tmp235_); + _tmp237_ = _tmp236_; + _tmp238_ = vala_variable_get_variable_type ((ValaVariable*) self); + _tmp239_ = _tmp238_; + if (!vala_data_type_compatible (_tmp237_, _tmp239_)) { + ValaSourceReference* _tmp240_; + ValaSourceReference* _tmp241_; + ValaExpression* _tmp242_; + ValaExpression* _tmp243_; + ValaDataType* _tmp244_; + ValaDataType* _tmp245_; + gchar* _tmp246_; + gchar* _tmp247_; + ValaDataType* _tmp248_; + ValaDataType* _tmp249_; + gchar* _tmp250_; + gchar* _tmp251_; vala_code_node_set_error ((ValaCodeNode*) self, TRUE); - _tmp234_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); - _tmp235_ = _tmp234_; - _tmp236_ = vala_variable_get_initializer ((ValaVariable*) self); - _tmp237_ = _tmp236_; - _tmp238_ = vala_expression_get_value_type (_tmp237_); - _tmp239_ = _tmp238_; - _tmp240_ = vala_code_node_to_string ((ValaCodeNode*) _tmp239_); + _tmp240_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); _tmp241_ = _tmp240_; - _tmp242_ = vala_variable_get_variable_type ((ValaVariable*) self); + _tmp242_ = vala_variable_get_initializer ((ValaVariable*) self); _tmp243_ = _tmp242_; - _tmp244_ = vala_code_node_to_string ((ValaCodeNode*) _tmp243_); + _tmp244_ = vala_expression_get_value_type (_tmp243_); _tmp245_ = _tmp244_; - vala_report_error (_tmp235_, "Assignment: Cannot convert from `%s' to `%s'", _tmp241_, _tmp245_); - _g_free0 (_tmp245_); - _g_free0 (_tmp241_); + _tmp246_ = vala_code_node_to_string ((ValaCodeNode*) _tmp245_); + _tmp247_ = _tmp246_; + _tmp248_ = vala_variable_get_variable_type ((ValaVariable*) self); + _tmp249_ = _tmp248_; + _tmp250_ = vala_code_node_to_string ((ValaCodeNode*) _tmp249_); + _tmp251_ = _tmp250_; + vala_report_error (_tmp241_, "Assignment: Cannot convert from `%s' to `%s'", _tmp247_, _tmp251_); + _g_free0 (_tmp251_); + _g_free0 (_tmp247_); result = FALSE; return result; } else { - gboolean _tmp246_ = FALSE; - gboolean _tmp247_ = FALSE; - ValaDataType* _tmp248_; - ValaDataType* _tmp249_; - _tmp248_ = vala_variable_get_variable_type ((ValaVariable*) self); - _tmp249_ = _tmp248_; - if (VALA_IS_ENUM_VALUE_TYPE (_tmp249_)) { - ValaExpression* _tmp250_; - ValaExpression* _tmp251_; - ValaDataType* _tmp252_; - ValaDataType* _tmp253_; - _tmp250_ = vala_variable_get_initializer ((ValaVariable*) self); - _tmp251_ = _tmp250_; - _tmp252_ = vala_expression_get_value_type (_tmp251_); - _tmp253_ = _tmp252_; - _tmp247_ = VALA_IS_INTEGER_TYPE (_tmp253_); + gboolean _tmp252_ = FALSE; + gboolean _tmp253_ = FALSE; + ValaDataType* _tmp254_; + ValaDataType* _tmp255_; + _tmp254_ = vala_variable_get_variable_type ((ValaVariable*) self); + _tmp255_ = _tmp254_; + if (VALA_IS_ENUM_VALUE_TYPE (_tmp255_)) { + ValaExpression* _tmp256_; + ValaExpression* _tmp257_; + ValaDataType* _tmp258_; + ValaDataType* _tmp259_; + _tmp256_ = vala_variable_get_initializer ((ValaVariable*) self); + _tmp257_ = _tmp256_; + _tmp258_ = vala_expression_get_value_type (_tmp257_); + _tmp259_ = _tmp258_; + _tmp253_ = VALA_IS_INTEGER_TYPE (_tmp259_); } else { - _tmp247_ = FALSE; + _tmp253_ = FALSE; } - if (_tmp247_) { - gboolean _tmp254_ = FALSE; - ValaExpression* _tmp255_; - ValaExpression* _tmp256_; - _tmp255_ = vala_variable_get_initializer ((ValaVariable*) self); - _tmp256_ = _tmp255_; - if (!VALA_IS_INTEGER_LITERAL (_tmp256_)) { - _tmp254_ = TRUE; + if (_tmp253_) { + gboolean _tmp260_ = FALSE; + ValaExpression* _tmp261_; + ValaExpression* _tmp262_; + _tmp261_ = vala_variable_get_initializer ((ValaVariable*) self); + _tmp262_ = _tmp261_; + if (!VALA_IS_INTEGER_LITERAL (_tmp262_)) { + _tmp260_ = TRUE; } else { - ValaExpression* _tmp257_; - ValaExpression* _tmp258_; - const gchar* _tmp259_; - const gchar* _tmp260_; - _tmp257_ = vala_variable_get_initializer ((ValaVariable*) self); - _tmp258_ = _tmp257_; - _tmp259_ = vala_integer_literal_get_value (G_TYPE_CHECK_INSTANCE_CAST (_tmp258_, VALA_TYPE_INTEGER_LITERAL, ValaIntegerLiteral)); - _tmp260_ = _tmp259_; - _tmp254_ = g_strcmp0 (_tmp260_, "0") != 0; + ValaExpression* _tmp263_; + ValaExpression* _tmp264_; + const gchar* _tmp265_; + const gchar* _tmp266_; + _tmp263_ = vala_variable_get_initializer ((ValaVariable*) self); + _tmp264_ = _tmp263_; + _tmp265_ = vala_integer_literal_get_value (G_TYPE_CHECK_INSTANCE_CAST (_tmp264_, VALA_TYPE_INTEGER_LITERAL, ValaIntegerLiteral)); + _tmp266_ = _tmp265_; + _tmp260_ = g_strcmp0 (_tmp266_, "0") != 0; } - _tmp246_ = _tmp254_; + _tmp252_ = _tmp260_; } else { - _tmp246_ = FALSE; + _tmp252_ = FALSE; } - if (_tmp246_) { - ValaSourceReference* _tmp261_; - ValaSourceReference* _tmp262_; - ValaExpression* _tmp263_; - ValaExpression* _tmp264_; - ValaDataType* _tmp265_; - ValaDataType* _tmp266_; - gchar* _tmp267_; - gchar* _tmp268_; - ValaDataType* _tmp269_; - ValaDataType* _tmp270_; - gchar* _tmp271_; - gchar* _tmp272_; - _tmp261_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); - _tmp262_ = _tmp261_; - _tmp263_ = vala_variable_get_initializer ((ValaVariable*) self); - _tmp264_ = _tmp263_; - _tmp265_ = vala_expression_get_value_type (_tmp264_); - _tmp266_ = _tmp265_; - _tmp267_ = vala_code_node_to_string ((ValaCodeNode*) _tmp266_); + if (_tmp252_) { + ValaSourceReference* _tmp267_; + ValaSourceReference* _tmp268_; + ValaExpression* _tmp269_; + ValaExpression* _tmp270_; + ValaDataType* _tmp271_; + ValaDataType* _tmp272_; + gchar* _tmp273_; + gchar* _tmp274_; + ValaDataType* _tmp275_; + ValaDataType* _tmp276_; + gchar* _tmp277_; + gchar* _tmp278_; + _tmp267_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); _tmp268_ = _tmp267_; - _tmp269_ = vala_variable_get_variable_type ((ValaVariable*) self); + _tmp269_ = vala_variable_get_initializer ((ValaVariable*) self); _tmp270_ = _tmp269_; - _tmp271_ = vala_code_node_to_string ((ValaCodeNode*) _tmp270_); + _tmp271_ = vala_expression_get_value_type (_tmp270_); _tmp272_ = _tmp271_; - vala_report_notice (_tmp262_, "Assignment: Unsafe conversion from `%s' to `%s'", _tmp268_, _tmp272_); - _g_free0 (_tmp272_); - _g_free0 (_tmp268_); + _tmp273_ = vala_code_node_to_string ((ValaCodeNode*) _tmp272_); + _tmp274_ = _tmp273_; + _tmp275_ = vala_variable_get_variable_type ((ValaVariable*) self); + _tmp276_ = _tmp275_; + _tmp277_ = vala_code_node_to_string ((ValaCodeNode*) _tmp276_); + _tmp278_ = _tmp277_; + vala_report_notice (_tmp268_, "Assignment: Unsafe conversion from `%s' to `%s'", _tmp274_, _tmp278_); + _g_free0 (_tmp278_); + _g_free0 (_tmp274_); } } - _tmp276_ = variable_array_type; - if (_tmp276_ != NULL) { - ValaArrayType* _tmp277_; - gboolean _tmp278_; - gboolean _tmp279_; - _tmp277_ = variable_array_type; - _tmp278_ = vala_array_type_get_inline_allocated (_tmp277_); - _tmp279_ = _tmp278_; - _tmp275_ = _tmp279_; + _tmp282_ = variable_array_type; + if (_tmp282_ != NULL) { + ValaArrayType* _tmp283_; + gboolean _tmp284_; + gboolean _tmp285_; + _tmp283_ = variable_array_type; + _tmp284_ = vala_array_type_get_inline_allocated (_tmp283_); + _tmp285_ = _tmp284_; + _tmp281_ = _tmp285_; } else { - _tmp275_ = FALSE; + _tmp281_ = FALSE; } - if (_tmp275_) { - ValaArrayType* _tmp280_; - gboolean _tmp281_; - gboolean _tmp282_; - _tmp280_ = variable_array_type; - _tmp281_ = vala_array_type_get_fixed_length (_tmp280_); - _tmp282_ = _tmp281_; - _tmp274_ = !_tmp282_; + if (_tmp281_) { + ValaArrayType* _tmp286_; + gboolean _tmp287_; + gboolean _tmp288_; + _tmp286_ = variable_array_type; + _tmp287_ = vala_array_type_get_fixed_length (_tmp286_); + _tmp288_ = _tmp287_; + _tmp280_ = !_tmp288_; } else { - _tmp274_ = FALSE; + _tmp280_ = FALSE; } - if (_tmp274_) { - _tmp273_ = is_initializer_list; + if (_tmp280_) { + _tmp279_ = is_initializer_list; } else { - _tmp273_ = FALSE; + _tmp279_ = FALSE; } - if (_tmp273_) { - ValaArrayType* _tmp283_; - gchar* _tmp284_; - gchar* _tmp285_; - ValaIntegerLiteral* _tmp286_; - ValaIntegerLiteral* _tmp287_; - ValaArrayType* _tmp288_; + if (_tmp279_) { ValaArrayType* _tmp289_; - _tmp283_ = variable_array_type; - _tmp284_ = g_strdup_printf ("%i", initializer_size); - _tmp285_ = _tmp284_; - _tmp286_ = vala_integer_literal_new (_tmp285_, NULL); - _tmp287_ = _tmp286_; - vala_array_type_set_length (_tmp283_, (ValaExpression*) _tmp287_); - _vala_code_node_unref0 (_tmp287_); - _g_free0 (_tmp285_); - _tmp288_ = variable_array_type; - vala_array_type_set_fixed_length (_tmp288_, TRUE); + gchar* _tmp290_; + gchar* _tmp291_; + ValaIntegerLiteral* _tmp292_; + ValaIntegerLiteral* _tmp293_; + ValaArrayType* _tmp294_; + ValaArrayType* _tmp295_; _tmp289_ = variable_array_type; - vala_data_type_set_nullable ((ValaDataType*) _tmp289_, FALSE); - } - _tmp292_ = variable_array_type; - if (_tmp292_ != NULL) { - ValaArrayType* _tmp293_; - gboolean _tmp294_; - gboolean _tmp295_; - _tmp293_ = variable_array_type; - _tmp294_ = vala_array_type_get_inline_allocated (_tmp293_); - _tmp295_ = _tmp294_; - _tmp291_ = _tmp295_; + _tmp290_ = g_strdup_printf ("%i", initializer_size); + _tmp291_ = _tmp290_; + _tmp292_ = vala_integer_literal_new (_tmp291_, NULL); + _tmp293_ = _tmp292_; + vala_array_type_set_length (_tmp289_, (ValaExpression*) _tmp293_); + _vala_code_node_unref0 (_tmp293_); + _g_free0 (_tmp291_); + _tmp294_ = variable_array_type; + vala_array_type_set_fixed_length (_tmp294_, TRUE); + _tmp295_ = variable_array_type; + vala_data_type_set_nullable ((ValaDataType*) _tmp295_, FALSE); + } + _tmp298_ = variable_array_type; + if (_tmp298_ != NULL) { + ValaArrayType* _tmp299_; + gboolean _tmp300_; + gboolean _tmp301_; + _tmp299_ = variable_array_type; + _tmp300_ = vala_array_type_get_inline_allocated (_tmp299_); + _tmp301_ = _tmp300_; + _tmp297_ = _tmp301_; } else { - _tmp291_ = FALSE; + _tmp297_ = FALSE; } - if (_tmp291_) { - ValaExpression* _tmp296_; - ValaExpression* _tmp297_; - ValaDataType* _tmp298_; - ValaDataType* _tmp299_; - _tmp296_ = vala_variable_get_initializer ((ValaVariable*) self); - _tmp297_ = _tmp296_; - _tmp298_ = vala_expression_get_value_type (_tmp297_); - _tmp299_ = _tmp298_; - _tmp290_ = VALA_IS_ARRAY_TYPE (_tmp299_) == FALSE; + if (_tmp297_) { + ValaExpression* _tmp302_; + ValaExpression* _tmp303_; + ValaDataType* _tmp304_; + ValaDataType* _tmp305_; + _tmp302_ = vala_variable_get_initializer ((ValaVariable*) self); + _tmp303_ = _tmp302_; + _tmp304_ = vala_expression_get_value_type (_tmp303_); + _tmp305_ = _tmp304_; + _tmp296_ = VALA_IS_ARRAY_TYPE (_tmp305_) == FALSE; } else { - _tmp290_ = FALSE; + _tmp296_ = FALSE; } - if (_tmp290_) { - ValaSourceReference* _tmp300_; - ValaSourceReference* _tmp301_; + if (_tmp296_) { + ValaSourceReference* _tmp306_; + ValaSourceReference* _tmp307_; vala_code_node_set_error ((ValaCodeNode*) self, TRUE); - _tmp300_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); - _tmp301_ = _tmp300_; - vala_report_error (_tmp301_, "only arrays are allowed as initializer for arrays with fixed length"); + _tmp306_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); + _tmp307_ = _tmp306_; + vala_report_error (_tmp307_, "only arrays are allowed as initializer for arrays with fixed length"); result = FALSE; return result; } - _tmp302_ = vala_variable_get_initializer ((ValaVariable*) self); - _tmp303_ = _tmp302_; - _tmp304_ = vala_expression_get_value_type (_tmp303_); - _tmp305_ = _tmp304_; - if (vala_data_type_is_disposable (_tmp305_)) { - gboolean _tmp306_ = FALSE; - ValaDataType* _tmp307_; - ValaDataType* _tmp308_; - _tmp307_ = vala_variable_get_variable_type ((ValaVariable*) self); - _tmp308_ = _tmp307_; - if (!VALA_IS_POINTER_TYPE (_tmp308_)) { - ValaDataType* _tmp309_; - ValaDataType* _tmp310_; - gboolean _tmp311_; - gboolean _tmp312_; - _tmp309_ = vala_variable_get_variable_type ((ValaVariable*) self); - _tmp310_ = _tmp309_; - _tmp311_ = vala_data_type_get_value_owned (_tmp310_); - _tmp312_ = _tmp311_; - _tmp306_ = !_tmp312_; + _tmp308_ = vala_variable_get_initializer ((ValaVariable*) self); + _tmp309_ = _tmp308_; + _tmp310_ = vala_expression_get_value_type (_tmp309_); + _tmp311_ = _tmp310_; + if (vala_data_type_is_disposable (_tmp311_)) { + gboolean _tmp312_ = FALSE; + ValaDataType* _tmp313_; + ValaDataType* _tmp314_; + _tmp313_ = vala_variable_get_variable_type ((ValaVariable*) self); + _tmp314_ = _tmp313_; + if (!VALA_IS_POINTER_TYPE (_tmp314_)) { + ValaDataType* _tmp315_; + ValaDataType* _tmp316_; + gboolean _tmp317_; + gboolean _tmp318_; + _tmp315_ = vala_variable_get_variable_type ((ValaVariable*) self); + _tmp316_ = _tmp315_; + _tmp317_ = vala_data_type_get_value_owned (_tmp316_); + _tmp318_ = _tmp317_; + _tmp312_ = !_tmp318_; } else { - _tmp306_ = FALSE; + _tmp312_ = FALSE; } - if (_tmp306_) { - ValaSourceReference* _tmp313_; - ValaSourceReference* _tmp314_; + if (_tmp312_) { + ValaSourceReference* _tmp319_; + ValaSourceReference* _tmp320_; vala_code_node_set_error ((ValaCodeNode*) self, TRUE); - _tmp313_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); - _tmp314_ = _tmp313_; - vala_report_error (_tmp314_, "Invalid assignment from owned expression to unowned variable"); + _tmp319_ = vala_code_node_get_source_reference ((ValaCodeNode*) self); + _tmp320_ = _tmp319_; + vala_report_error (_tmp320_, "Invalid assignment from owned expression to unowned variable"); result = FALSE; return result; } } } - _tmp315_ = vala_code_context_get_analyzer (context); - _tmp316_ = _tmp315_; - _tmp317_ = vala_semantic_analyzer_get_current_symbol (_tmp316_); - _tmp318_ = _tmp317_; - block = VALA_IS_BLOCK (_tmp318_) ? ((ValaBlock*) _tmp318_) : NULL; - _tmp319_ = block; - if (_tmp319_ != NULL) { - ValaBlock* _tmp320_; - _tmp320_ = block; - vala_block_add_local_variable (_tmp320_, self); + _tmp321_ = vala_code_context_get_analyzer (context); + _tmp322_ = _tmp321_; + _tmp323_ = vala_semantic_analyzer_get_current_symbol (_tmp322_); + _tmp324_ = _tmp323_; + block = VALA_IS_BLOCK (_tmp324_) ? ((ValaBlock*) _tmp324_) : NULL; + _tmp325_ = block; + if (_tmp325_ != NULL) { + ValaBlock* _tmp326_; + _tmp326_ = block; + vala_block_add_local_variable (_tmp326_, self); } vala_symbol_set_active ((ValaSymbol*) self, TRUE); - _tmp321_ = vala_code_node_get_error ((ValaCodeNode*) self); - _tmp322_ = _tmp321_; - result = !_tmp322_; + _tmp327_ = vala_code_node_get_error ((ValaCodeNode*) self); + _tmp328_ = _tmp327_; + result = !_tmp328_; return result; } diff -Nru vala-0.56.16/vala/valalocalvariable.vala vala-0.56.17/vala/valalocalvariable.vala --- vala-0.56.16/vala/valalocalvariable.vala 2024-03-13 19:27:31.000000000 +0000 +++ vala-0.56.17/vala/valalocalvariable.vala 2024-04-19 10:23:20.000000000 +0000 @@ -195,7 +195,7 @@ if (initializer.value_type is MethodType) { if (!(initializer is MemberAccess) && !(initializer is LambdaExpression)) { error = true; - Report.error (source_reference, "expression type not allowed as initializer"); + Report.error (initializer.source_reference, "expression type not allowed as initializer"); return false; } @@ -210,12 +210,12 @@ } } else { error = true; - Report.error (source_reference, "expression type not allowed as initializer"); + Report.error (initializer.source_reference, "expression type not allowed as initializer"); return false; } } else if (initializer.value_type == null) { error = true; - Report.error (source_reference, "expression type not allowed as initializer"); + Report.error (initializer.source_reference, "expression type not allowed as initializer"); return false; } diff -Nru vala-0.56.16/vala/valaparser.c vala-0.56.17/vala/valaparser.c --- vala-0.56.16/vala/valaparser.c 2024-03-14 09:03:18.000000000 +0000 +++ vala-0.56.17/vala/valaparser.c 2024-04-19 11:03:19.000000000 +0000 @@ -9661,6 +9661,7 @@ begin = _tmp0_; { gboolean _tmp1_ = FALSE; + vala_parser_accept (self, VALA_TOKEN_TYPE_STATIC); vala_parser_skip_type (self, &_inner_error0_); if (G_UNLIKELY (_inner_error0_ != NULL)) { goto __catch0_g_error; @@ -10925,6 +10926,7 @@ { ValaSourceLocation begin = {0}; ValaSourceLocation _tmp0_ = {0}; + gboolean is_static = FALSE; ValaDataType* type = NULL; ValaDataType* _tmp1_; ValaUnresolvedSymbol* sym = NULL; @@ -10943,38 +10945,40 @@ ValaSourceReference* _tmp15_; ValaDelegate* _tmp16_; ValaDelegate* _tmp17_; - ValaCodeContext* _tmp28_; - ValaNamespace* _tmp29_; + ValaDelegate* _tmp18_; + ValaCodeContext* _tmp29_; ValaNamespace* _tmp30_; - ValaDelegate* _tmp31_; - ValaBlock* _tmp32_ = NULL; - ValaBlock* _tmp33_; + ValaNamespace* _tmp31_; + ValaDelegate* _tmp32_; + ValaBlock* _tmp33_ = NULL; + ValaBlock* _tmp34_; ValaLambdaExpression* lambda = NULL; - ValaSourceReference* _tmp34_; - ValaLambdaExpression* _tmp35_; - ValaCodeContext* _tmp57_; - gboolean _tmp58_; + ValaSourceReference* _tmp35_; + ValaLambdaExpression* _tmp36_; + ValaCodeContext* _tmp58_; gboolean _tmp59_; + gboolean _tmp60_; ValaLocalVariable* local = NULL; - ValaDelegate* _tmp61_; - ValaDelegateType* _tmp62_; + ValaDelegate* _tmp62_; ValaDelegateType* _tmp63_; - ValaUnresolvedSymbol* _tmp64_; - const gchar* _tmp65_; + ValaDelegateType* _tmp64_; + ValaUnresolvedSymbol* _tmp65_; const gchar* _tmp66_; - ValaLambdaExpression* _tmp67_; - ValaSourceReference* _tmp68_; - ValaLocalVariable* _tmp69_; + const gchar* _tmp67_; + ValaLambdaExpression* _tmp68_; + ValaSourceReference* _tmp69_; ValaLocalVariable* _tmp70_; ValaLocalVariable* _tmp71_; - ValaSourceReference* _tmp72_; - ValaDeclarationStatement* _tmp73_; + ValaLocalVariable* _tmp72_; + ValaSourceReference* _tmp73_; ValaDeclarationStatement* _tmp74_; + ValaDeclarationStatement* _tmp75_; GError* _inner_error0_ = NULL; g_return_if_fail (self != NULL); g_return_if_fail (block != NULL); vala_parser_get_location (self, &_tmp0_); begin = _tmp0_; + is_static = vala_parser_accept (self, VALA_TOKEN_TYPE_STATIC); _tmp1_ = vala_parser_parse_type (self, TRUE, FALSE, FALSE, &_inner_error0_); type = _tmp1_; if (G_UNLIKELY (_inner_error0_ != NULL)) { @@ -11087,51 +11091,53 @@ _tmp17_ = _tmp16_; _g_free0 (_tmp13_); d = _tmp17_; + _tmp18_ = d; + vala_delegate_set_has_target (_tmp18_, !is_static); { ValaList* _param_list = NULL; - ValaList* _tmp18_; - gint _param_size = 0; ValaList* _tmp19_; - gint _tmp20_; + gint _param_size = 0; + ValaList* _tmp20_; gint _tmp21_; + gint _tmp22_; gint _param_index = 0; - _tmp18_ = params; - _param_list = _tmp18_; - _tmp19_ = _param_list; - _tmp20_ = vala_collection_get_size ((ValaCollection*) _tmp19_); - _tmp21_ = _tmp20_; - _param_size = _tmp21_; + _tmp19_ = params; + _param_list = _tmp19_; + _tmp20_ = _param_list; + _tmp21_ = vala_collection_get_size ((ValaCollection*) _tmp20_); + _tmp22_ = _tmp21_; + _param_size = _tmp22_; _param_index = -1; while (TRUE) { - gint _tmp22_; gint _tmp23_; + gint _tmp24_; ValaParameter* param = NULL; - ValaList* _tmp24_; - gpointer _tmp25_; - ValaDelegate* _tmp26_; - ValaParameter* _tmp27_; + ValaList* _tmp25_; + gpointer _tmp26_; + ValaDelegate* _tmp27_; + ValaParameter* _tmp28_; _param_index = _param_index + 1; - _tmp22_ = _param_index; - _tmp23_ = _param_size; - if (!(_tmp22_ < _tmp23_)) { + _tmp23_ = _param_index; + _tmp24_ = _param_size; + if (!(_tmp23_ < _tmp24_)) { break; } - _tmp24_ = _param_list; - _tmp25_ = vala_list_get (_tmp24_, _param_index); - param = (ValaParameter*) _tmp25_; - _tmp26_ = d; - _tmp27_ = param; - vala_callable_add_parameter ((ValaCallable*) _tmp26_, _tmp27_); + _tmp25_ = _param_list; + _tmp26_ = vala_list_get (_tmp25_, _param_index); + param = (ValaParameter*) _tmp26_; + _tmp27_ = d; + _tmp28_ = param; + vala_callable_add_parameter ((ValaCallable*) _tmp27_, _tmp28_); _vala_code_node_unref0 (param); } } - _tmp28_ = self->priv->context; - _tmp29_ = vala_code_context_get_root (_tmp28_); - _tmp30_ = _tmp29_; - _tmp31_ = d; - vala_symbol_add_delegate ((ValaSymbol*) _tmp30_, _tmp31_); - _tmp33_ = vala_parser_parse_block (self, &_inner_error0_); - _tmp32_ = _tmp33_; + _tmp29_ = self->priv->context; + _tmp30_ = vala_code_context_get_root (_tmp29_); + _tmp31_ = _tmp30_; + _tmp32_ = d; + vala_symbol_add_delegate ((ValaSymbol*) _tmp31_, _tmp32_); + _tmp34_ = vala_parser_parse_block (self, &_inner_error0_); + _tmp33_ = _tmp34_; if (G_UNLIKELY (_inner_error0_ != NULL)) { if (_inner_error0_->domain == VALA_PARSE_ERROR) { g_propagate_error (error, _inner_error0_); @@ -11152,102 +11158,102 @@ return; } } - _tmp34_ = src; - _tmp35_ = vala_lambda_expression_new_with_statement_body (_tmp32_, _tmp34_); - lambda = _tmp35_; + _tmp35_ = src; + _tmp36_ = vala_lambda_expression_new_with_statement_body (_tmp33_, _tmp35_); + lambda = _tmp36_; { ValaList* _p_list = NULL; - ValaList* _tmp36_; - gint _p_size = 0; ValaList* _tmp37_; - gint _tmp38_; + gint _p_size = 0; + ValaList* _tmp38_; gint _tmp39_; + gint _tmp40_; gint _p_index = 0; - _tmp36_ = params; - _p_list = _tmp36_; - _tmp37_ = _p_list; - _tmp38_ = vala_collection_get_size ((ValaCollection*) _tmp37_); - _tmp39_ = _tmp38_; - _p_size = _tmp39_; + _tmp37_ = params; + _p_list = _tmp37_; + _tmp38_ = _p_list; + _tmp39_ = vala_collection_get_size ((ValaCollection*) _tmp38_); + _tmp40_ = _tmp39_; + _p_size = _tmp40_; _p_index = -1; while (TRUE) { - gint _tmp40_; gint _tmp41_; + gint _tmp42_; ValaParameter* p = NULL; - ValaList* _tmp42_; - gpointer _tmp43_; + ValaList* _tmp43_; + gpointer _tmp44_; ValaParameter* param = NULL; - ValaParameter* _tmp44_; - const gchar* _tmp45_; + ValaParameter* _tmp45_; const gchar* _tmp46_; - ValaParameter* _tmp47_; - ValaSourceReference* _tmp48_; + const gchar* _tmp47_; + ValaParameter* _tmp48_; ValaSourceReference* _tmp49_; - ValaParameter* _tmp50_; + ValaSourceReference* _tmp50_; ValaParameter* _tmp51_; ValaParameter* _tmp52_; - ValaParameterDirection _tmp53_; + ValaParameter* _tmp53_; ValaParameterDirection _tmp54_; - ValaLambdaExpression* _tmp55_; - ValaParameter* _tmp56_; + ValaParameterDirection _tmp55_; + ValaLambdaExpression* _tmp56_; + ValaParameter* _tmp57_; _p_index = _p_index + 1; - _tmp40_ = _p_index; - _tmp41_ = _p_size; - if (!(_tmp40_ < _tmp41_)) { + _tmp41_ = _p_index; + _tmp42_ = _p_size; + if (!(_tmp41_ < _tmp42_)) { break; } - _tmp42_ = _p_list; - _tmp43_ = vala_list_get (_tmp42_, _p_index); - p = (ValaParameter*) _tmp43_; - _tmp44_ = p; - _tmp45_ = vala_symbol_get_name ((ValaSymbol*) _tmp44_); - _tmp46_ = _tmp45_; - _tmp47_ = p; - _tmp48_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp47_); - _tmp49_ = _tmp48_; - _tmp50_ = vala_parameter_new (_tmp46_, NULL, _tmp49_); - param = _tmp50_; - _tmp51_ = param; - _tmp52_ = p; - _tmp53_ = vala_parameter_get_direction (_tmp52_); - _tmp54_ = _tmp53_; - vala_parameter_set_direction (_tmp51_, _tmp54_); - _tmp55_ = lambda; - _tmp56_ = param; - vala_lambda_expression_add_parameter (_tmp55_, _tmp56_); + _tmp43_ = _p_list; + _tmp44_ = vala_list_get (_tmp43_, _p_index); + p = (ValaParameter*) _tmp44_; + _tmp45_ = p; + _tmp46_ = vala_symbol_get_name ((ValaSymbol*) _tmp45_); + _tmp47_ = _tmp46_; + _tmp48_ = p; + _tmp49_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp48_); + _tmp50_ = _tmp49_; + _tmp51_ = vala_parameter_new (_tmp47_, NULL, _tmp50_); + param = _tmp51_; + _tmp52_ = param; + _tmp53_ = p; + _tmp54_ = vala_parameter_get_direction (_tmp53_); + _tmp55_ = _tmp54_; + vala_parameter_set_direction (_tmp52_, _tmp55_); + _tmp56_ = lambda; + _tmp57_ = param; + vala_lambda_expression_add_parameter (_tmp56_, _tmp57_); _vala_code_node_unref0 (param); _vala_code_node_unref0 (p); } } - _tmp57_ = self->priv->context; - _tmp58_ = vala_code_context_get_experimental (_tmp57_); - _tmp59_ = _tmp58_; - if (!_tmp59_) { - ValaSourceReference* _tmp60_; - _tmp60_ = src; - vala_report_warning (_tmp60_, "local functions are experimental"); - } - _tmp61_ = d; - _tmp62_ = vala_delegate_type_new (_tmp61_, NULL); - _tmp63_ = _tmp62_; - _tmp64_ = sym; - _tmp65_ = vala_symbol_get_name ((ValaSymbol*) _tmp64_); - _tmp66_ = _tmp65_; - _tmp67_ = lambda; - _tmp68_ = src; - _tmp69_ = vala_local_variable_new ((ValaDataType*) _tmp63_, _tmp66_, (ValaExpression*) _tmp67_, _tmp68_); - _tmp70_ = _tmp69_; - _vala_code_node_unref0 (_tmp63_); - local = _tmp70_; - _tmp71_ = local; - _tmp72_ = src; - _tmp73_ = vala_declaration_statement_new ((ValaSymbol*) _tmp71_, _tmp72_); - _tmp74_ = _tmp73_; - vala_block_add_statement (block, (ValaStatement*) _tmp74_); - _vala_code_node_unref0 (_tmp74_); + _tmp58_ = self->priv->context; + _tmp59_ = vala_code_context_get_experimental (_tmp58_); + _tmp60_ = _tmp59_; + if (!_tmp60_) { + ValaSourceReference* _tmp61_; + _tmp61_ = src; + vala_report_warning (_tmp61_, "local functions are experimental"); + } + _tmp62_ = d; + _tmp63_ = vala_delegate_type_new (_tmp62_, NULL); + _tmp64_ = _tmp63_; + _tmp65_ = sym; + _tmp66_ = vala_symbol_get_name ((ValaSymbol*) _tmp65_); + _tmp67_ = _tmp66_; + _tmp68_ = lambda; + _tmp69_ = src; + _tmp70_ = vala_local_variable_new ((ValaDataType*) _tmp64_, _tmp67_, (ValaExpression*) _tmp68_, _tmp69_); + _tmp71_ = _tmp70_; + _vala_code_node_unref0 (_tmp64_); + local = _tmp71_; + _tmp72_ = local; + _tmp73_ = src; + _tmp74_ = vala_declaration_statement_new ((ValaSymbol*) _tmp72_, _tmp73_); + _tmp75_ = _tmp74_; + vala_block_add_statement (block, (ValaStatement*) _tmp75_); + _vala_code_node_unref0 (_tmp75_); _vala_code_node_unref0 (local); _vala_code_node_unref0 (lambda); - _vala_code_node_unref0 (_tmp32_); + _vala_code_node_unref0 (_tmp33_); _vala_code_node_unref0 (d); _vala_source_reference_unref0 (src); _vala_iterable_unref0 (params); diff -Nru vala-0.56.16/vala/valaparser.vala vala-0.56.17/vala/valaparser.vala --- vala-0.56.16/vala/valaparser.vala 2024-03-13 19:27:31.000000000 +0000 +++ vala-0.56.17/vala/valaparser.vala 2024-04-19 10:23:20.000000000 +0000 @@ -1934,6 +1934,7 @@ var begin = get_location (); try { + accept (TokenType.STATIC); skip_type (); if (accept (TokenType.IDENTIFIER) && accept (TokenType.OPEN_PARENS)) { rollback (begin); @@ -2166,6 +2167,7 @@ void parse_local_function_declaration (Block block) throws ParseError { var begin = get_location (); + var is_static = accept (TokenType.STATIC); var type = parse_type (true, false); var sym = parse_symbol_name (); @@ -2181,6 +2183,7 @@ var src = get_src (begin); var d = new Delegate ("_LocalFunc%i_".printf (next_local_func_id++), type, src); + d.has_target = !is_static; foreach (var param in params) { d.add_parameter (param); } diff -Nru vala-0.56.16/vala/valaproperty.c vala-0.56.17/vala/valaproperty.c --- vala-0.56.16/vala/valaproperty.c 2024-03-14 09:03:18.000000000 +0000 +++ vala-0.56.17/vala/valaproperty.c 2024-04-19 11:03:19.000000000 +0000 @@ -284,7 +284,7 @@ vala_property_get_field (ValaProperty* self) { ValaField* result; - ValaField* _tmp58_; + ValaField* _tmp62_; g_return_val_if_fail (self != NULL, NULL); if (!self->priv->_field_checked) { gboolean _tmp0_ = FALSE; @@ -408,6 +408,10 @@ ValaField* _tmp49_; ValaField* _tmp50_; ValaMemberBinding _tmp51_; + ValaField* _tmp58_; + ValaField* _tmp59_; + ValaField* _tmp60_; + ValaField* _tmp61_; if (vala_code_node_has_attribute ((ValaCodeNode*) self, "GtkChild")) { ValaDataType* _tmp28_; ValaDataType* _tmp29_; @@ -472,12 +476,20 @@ _tmp57_ = self->priv->_field; vala_code_node_set_attribute_bool ((ValaCodeNode*) _tmp57_, "GtkChild", "internal", vala_code_node_get_attribute_bool ((ValaCodeNode*) self, "GtkChild", "internal", FALSE), NULL); } + _tmp58_ = self->priv->_field; + vala_code_node_copy_attribute_bool ((ValaCodeNode*) _tmp58_, (ValaCodeNode*) self, "CCode", "array_length"); + _tmp59_ = self->priv->_field; + vala_code_node_copy_attribute_string ((ValaCodeNode*) _tmp59_, (ValaCodeNode*) self, "CCode", "array_length_type"); + _tmp60_ = self->priv->_field; + vala_code_node_copy_attribute_bool ((ValaCodeNode*) _tmp60_, (ValaCodeNode*) self, "CCode", "array_null_terminated"); + _tmp61_ = self->priv->_field; + vala_code_node_copy_attribute_bool ((ValaCodeNode*) _tmp61_, (ValaCodeNode*) self, "CCode", "delegate_target"); } } self->priv->_field_checked = TRUE; } - _tmp58_ = self->priv->_field; - result = _tmp58_; + _tmp62_ = self->priv->_field; + result = _tmp62_; return result; } diff -Nru vala-0.56.16/vala/valaproperty.vala vala-0.56.17/vala/valaproperty.vala --- vala-0.56.16/vala/valaproperty.vala 2024-03-13 19:27:31.000000000 +0000 +++ vala-0.56.17/vala/valaproperty.vala 2024-04-19 10:23:36.000000000 +0000 @@ -130,6 +130,11 @@ _field.set_attribute_string ("GtkChild", "name", get_attribute_string ("GtkChild", "name", name)); _field.set_attribute_bool ("GtkChild", "internal", get_attribute_bool ("GtkChild", "internal")); } + // Inherit important attributes + _field.copy_attribute_bool (this, "CCode", "array_length"); + _field.copy_attribute_string (this, "CCode", "array_length_type"); + _field.copy_attribute_bool (this, "CCode", "array_null_terminated"); + _field.copy_attribute_bool (this, "CCode", "delegate_target"); } } _field_checked = true; diff -Nru vala-0.56.16/vala/valaversion.vala vala-0.56.17/vala/valaversion.vala --- vala-0.56.16/vala/valaversion.vala 2024-03-14 09:03:15.000000000 +0000 +++ vala-0.56.17/vala/valaversion.vala 2024-04-19 11:03:17.000000000 +0000 @@ -35,7 +35,7 @@ * Like get_micro_version, but from the headers used at application compile time, * rather than from the library linked against at application run time */ - public const int MICRO_VERSION = 16; + public const int MICRO_VERSION = 17; /** * The API version string @@ -45,7 +45,7 @@ /** * The full build-version string generated by the build-system */ - public const string BUILD_VERSION = "0.56.16"; + public const string BUILD_VERSION = "0.56.17"; /** * Returns the major version number of the vala library. diff -Nru vala-0.56.16/valadoc/doclets/gtkdoc/utils.c vala-0.56.17/valadoc/doclets/gtkdoc/utils.c --- vala-0.56.16/valadoc/doclets/gtkdoc/utils.c 2024-03-14 09:04:04.000000000 +0000 +++ vala-0.56.17/valadoc/doclets/gtkdoc/utils.c 2024-04-19 11:04:02.000000000 +0000 @@ -1412,12 +1412,11 @@ return result; } else { GString* _tmp4_; - const gchar* _tmp5_; - gchar* _tmp6_; + gchar* _tmp5_; _tmp4_ = ret; _tmp5_ = ((GString*) _tmp4_)->str; - _tmp6_ = g_strdup (_tmp5_); - result = _tmp6_; + ((GString*) _tmp4_)->str = NULL; + result = _tmp5_; _g_string_free0 (ret); return result; } diff -Nru vala-0.56.16/vapi/glib-2.0.vapi vala-0.56.17/vapi/glib-2.0.vapi --- vala-0.56.16/vapi/glib-2.0.vapi 2024-03-13 19:27:39.000000000 +0000 +++ vala-0.56.17/vapi/glib-2.0.vapi 2024-04-19 10:23:20.000000000 +0000 @@ -1025,6 +1025,41 @@ public struct off_t { } +//FIXME [GIR (name = "pid_t")] +[GIR (name = "gint")] +[IntegerType (rank = 9)] +[CCode (cheader_filename = "sys/types.h", has_type_id = false, default_value = "0")] +public struct pid_t { +} + +//FIXME [GIR (name = "uid_t")] +[GIR (name = "guint")] +[IntegerType (rank = 9)] +[CCode (cheader_filename = "sys/types.h", has_type_id = false, default_value = "0")] +public struct uid_t { +} + +//FIXME [GIR (name = "gid_t")] +[GIR (name = "guint")] +[IntegerType (rank = 9)] +[CCode (cheader_filename = "sys/types.h", has_type_id = false, default_value = "0")] +public struct gid_t { +} + +//FIXME [GIR (name = "dev_t")] +[GIR (name = "gint")] +[IntegerType (rank = 9)] +[CCode (cheader_filename = "sys/types.h", has_type_id = false, default_value = "0")] +public struct dev_t { +} + +//FIXME [GIR (name = "socklen_t")] +[GIR (name = "gint32")] +[IntegerType (rank = 9)] +[CCode (cheader_filename = "sys/socket.h", has_type_id = false, default_value = "0")] +public struct socklen_t { +} + //FIXME [GIR (name = "time_t")] [GIR (name = "glong")] [CCode (cheader_filename = "time.h", has_type_id = false, default_value = "0")] @@ -4086,7 +4121,7 @@ if (ret == null) { return null; } else { - return ((!)(ret)).str; + return (owned) ((!)(ret)).str; } } } @@ -7027,6 +7062,8 @@ OTHER_LETTER, TITLECASE_LETTER, UPPERCASE_LETTER, + SPACING_MARK, + [Version (deprecated_since = "2.30", replacement = "SPACING_MARK")] COMBINING_MARK, ENCLOSING_MARK, NON_SPACING_MARK, diff -Nru vala-0.56.16/vapi/gnu.vapi vala-0.56.17/vapi/gnu.vapi --- vala-0.56.16/vapi/gnu.vapi 2023-12-13 07:24:35.000000000 +0000 +++ vala-0.56.17/vapi/gnu.vapi 2024-04-19 10:23:43.000000000 +0000 @@ -1,6 +1,6 @@ /* gnu.vapi * - * Copyright (C) 2020 Reuben Thomas + * Copyright (C) 2020, 2024 Reuben Thomas * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public @@ -56,6 +56,18 @@ [PrintfFormat] public void error (int status, int errnum, string format, ...); + /** + * Provides the values for the 'operation' argument of 'flock'. + */ + [CCode (cname = "int", cprefix = "LOCK_", cheader_filename = "sys/file.h", has_type_id = false)] + public enum FlockOperation { + SH, + EX, + UN + } + [CCode (cheader_filename = "sys/file.h")] + public int flock (int fd, FlockOperation operation); + [CCode (cheader_filename = "quote.h")] public string quote (string arg); }