From 259abfa7730fa34b16bd7d8c3740689b9a416544 Mon Sep 17 00:00:00 2001 From: Philippe Coval Date: Tue, 15 Jan 2013 15:54:26 +0100 Subject: [PATCH] Imported Upstream version 0.18.1 --- .tarball-version | 2 +- .version | 2 +- ChangeLog | 123 ++ Makefile.am | 2 +- Makefile.in | 2 +- NEWS | 5 + codegen/valaccodebasemodule.c | 3094 +++++++++++++++++-------------- codegen/valaccodebasemodule.vala | 67 +- codegen/valaccodemethodmodule.c | 2778 +++++++++++++-------------- codegen/valaccodemethodmodule.vala | 4 +- codegen/valagasyncmodule.c | 20 +- codegen/valagasyncmodule.vala | 4 +- codegen/valagdbusservermodule.c | 211 ++- codegen/valagdbusservermodule.vala | 2 +- configure | 20 +- gobject-introspection/scanner.c | 21 +- gobject-introspection/scannerparser.c | 525 ++---- gobject-introspection/scannerparser.h | 16 +- tests/Makefile.am | 2 + tests/Makefile.in | 25 +- tests/basic-types/bug686336.vala | 25 + tests/dbus/dicts.test | 59 + tests/testrunner.sh | 4 +- vala/valaarraytype.c | 14 +- vala/valaarraytype.vala | 3 + vapi/Makefile.am | 2 +- vapi/Makefile.in | 2 +- vapi/glib-2.0.vapi | 15 +- vapi/gstreamer-1.0.vapi | 8 +- vapi/gstreamer-audio-1.0.vapi | 2 +- vapi/gtk+-2.0.vapi | 32 +- vapi/gtk+-3.0.vapi | 39 +- vapi/gtksourceview-3.0.vapi | 44 +- vapi/libwnck-3.0.vapi | 1 + vapi/libxml-2.0.vapi | 34 +- vapi/linux.vapi | 10 +- vapi/posix.vapi | 65 +- vapi/udisks2.vapi | 89 +- vapigen/Makefile.am | 2 +- vapigen/Makefile.in | 2 +- vapigen/vala-gen-introspect/Makefile.am | 2 +- vapigen/vala-gen-introspect/Makefile.in | 2 +- 42 files changed, 3964 insertions(+), 3417 deletions(-) create mode 100644 tests/basic-types/bug686336.vala create mode 100644 tests/dbus/dicts.test diff --git a/.tarball-version b/.tarball-version index 6633391..249afd5 100644 --- a/.tarball-version +++ b/.tarball-version @@ -1 +1 @@ -0.18.0 +0.18.1 diff --git a/.version b/.version index 6633391..249afd5 100644 --- a/.version +++ b/.version @@ -1 +1 @@ -0.18.0 +0.18.1 diff --git a/ChangeLog b/ChangeLog index 3bd0ff4..f5376ce 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,126 @@ +2012-11-13 Jürg Billeter + + Release 0.18.1 + + gtk+-3.0: Fix gtk_grid_attach_next_to binding + Fixes bug 682477. + + codegen: Fix memory leak when chaining up in fundamental classes + Fixes bug 684776. + + codegen: Fix g_simple_async_result_new in interface methods + Fixes bug 684557. + + linux: Fix uinput_user_dev binding + Based on patch by Pascal Garber. + + Fixes bug 687602. + +2012-11-13 Andreas Fenkart + + gstreamer-0.10: removed static from transition_next/current. + Fixes bug 687807. + +2012-11-13 Robert Ancell + + posix: Add nl_langinfo + Fixes 685039. + +2012-11-13 Simon Werbeck + + Forbid `resize' method for multi-dimensional array + Fixes bug 687943. + +2012-11-11 Jürg Billeter + + gtk+-3.0: Add gtk_widget_has_grab binding + Reported-by: Hans Baier + + codegen: Retain array length for cast from/to generic array + Fixes bug 687728. + +2012-11-11 Arnel A. Borja + + Fix build for Windows + - Replace POSIX calls for spawning process with functions from Windows + API when compiling for Windows + - Add EXEEXT to valac and vapigen paths + - Remove EXEEXT from scripts + + Fixes bug 685180. + +2012-11-11 Evan Nemerson + + glib-2.0: add float.ROUNDS and RADIX + + glib-2.0: add Process.check_exit_status binding + +2012-11-11 Dmitry Vagin + + posix: mark inet_ntop as nullable + Fixes bug 678988. + +2012-11-11 Evan Nemerson + + gtk+-2.0, gtk+-3.0: assorted minor fixes + + gtk+-3.0: fix nullability of ColorChooserDialog constructor arguments + + gtk+-2.0, gtk+-3.0: make RadioButton radio_group_member args nullable + +2012-11-11 Rico Tzschichholz + + tests: Add D-Bus test for dictionary passing + +2012-11-11 Evan Nemerson + + gtk+-2.0, gtk+-3.0: improvements for Gtk.ScaleButton constructor args + +2012-11-11 Jürg Billeter + + codegen: Fix fields initialized by functions returning an array + Fixes bug 686336. + +2012-11-11 Evan Nemerson + + gkt+-2.0, gtk+-3.0: fix Gtk.HSV.get_* arguments + +2012-11-11 Jürg Billeter + + GDBus: Initialize array length variable in property get wrappers + This fixes a gcc warning when building with -O3. + + Based on patch by Marc-Antoine Perennou. + + Fixes bug 686123. + +2012-11-11 Evan Nemerson + + gtk+-3.0: mark Gtk.FontChooserDialog construtor arguments as nullable + +2012-11-11 Jürg Billeter + + codegen: Do not call g_thread_init when targeting GLib >= 2.32 + +2012-11-11 Evan Nemerson + + glib-2.0: use g_async_queue_new_full instead of g_async_queue_new + + glib-2.0: mark envp parameters in GLib.Environ methods as nullable + + glib-2.0: add missing parameters to Test.rand_double_range + + libxml-2.0: add has_type_id = false to all enums + +2012-10-03 Jürg Billeter + + gtk+-3.0: Fix gtk_application_inhibit binding + Fixes bug 685425. + +2012-10-01 Rico Tzschichholz + + bindings: update GIR-based bindings. + 2012-09-24 Jürg Billeter Release 0.18.0 diff --git a/Makefile.am b/Makefile.am index 3a8fc6c..12e50df 100644 --- a/Makefile.am +++ b/Makefile.am @@ -47,7 +47,7 @@ libvala@PACKAGE_SUFFIX@.pc: libvala.pc .PHONY: bootstrap bootstrap: all find $(top_srcdir) -name "*.vala.stamp" | xargs rm -f - $(MAKE) $(AM_MAKEFLAGS) all VALAC=$(abs_top_builddir)/compiler/valac V=$V + $(MAKE) $(AM_MAKEFLAGS) all VALAC=$(abs_top_builddir)/compiler/valac$(EXEEXT) V=$V .PHONY: test test: diff --git a/Makefile.in b/Makefile.in index 4a993de..82172f2 100644 --- a/Makefile.in +++ b/Makefile.in @@ -941,7 +941,7 @@ libvala@PACKAGE_SUFFIX@.pc: libvala.pc .PHONY: bootstrap bootstrap: all find $(top_srcdir) -name "*.vala.stamp" | xargs rm -f - $(MAKE) $(AM_MAKEFLAGS) all VALAC=$(abs_top_builddir)/compiler/valac V=$V + $(MAKE) $(AM_MAKEFLAGS) all VALAC=$(abs_top_builddir)/compiler/valac$(EXEEXT) V=$V .PHONY: test test: diff --git a/NEWS b/NEWS index c4442d6..a50b480 100644 --- a/NEWS +++ b/NEWS @@ -1,3 +1,8 @@ +Vala 0.18.1 +=========== + + * Bug fixes and binding updates. + Vala 0.18.0 =========== diff --git a/codegen/valaccodebasemodule.c b/codegen/valaccodebasemodule.c index 403992b..3ae1166 100644 --- a/codegen/valaccodebasemodule.c +++ b/codegen/valaccodebasemodule.c @@ -373,7 +373,9 @@ static void vala_ccode_base_module_real_visit_field (ValaCodeVisitor* base, Vala void vala_ccode_base_module_check_type (ValaCCodeBaseModule* self, ValaDataType* type); ValaTargetValue* vala_ccode_base_module_get_field_cvalue (ValaCCodeBaseModule* self, ValaField* field, ValaTargetValue* instance); ValaTargetValue* vala_ccode_base_module_load_this_parameter (ValaCCodeBaseModule* self, ValaTypeSymbol* sym); +GType vala_glib_value_get_type (void) G_GNUC_CONST; ValaCCodeExpression* vala_ccode_base_module_get_array_length_cvalue (ValaCCodeBaseModule* self, ValaTargetValue* value, gint dim); +ValaCCodeExpression* vala_ccode_base_module_get_cvalue_ (ValaCCodeBaseModule* self, ValaTargetValue* value); ValaCCodeExpression* vala_ccode_base_module_get_array_size_cvalue (ValaCCodeBaseModule* self, ValaTargetValue* value); ValaArrayList* vala_ccode_base_module_get_temp_ref_values (ValaCCodeBaseModule* self); ValaCCodeExpression* vala_ccode_base_module_destroy_value (ValaCCodeBaseModule* self, ValaTargetValue* value, gboolean is_macro_definition); @@ -407,11 +409,9 @@ gboolean vala_ccode_base_module_is_gobject_property (ValaCCodeBaseModule* self, ValaDataType* vala_ccode_base_module_get_current_return_type (ValaCCodeBaseModule* self); static void vala_ccode_base_module_create_property_type_check_statement (ValaCCodeBaseModule* self, ValaProperty* prop, gboolean check_return_type, ValaTypeSymbol* t, gboolean non_null, const gchar* var_name); gchar* vala_ccode_base_module_get_ccode_real_name (ValaSymbol* sym); -ValaCCodeExpression* vala_ccode_base_module_get_cvalue_ (ValaCCodeBaseModule* self, ValaTargetValue* value); ValaTargetValue* vala_ccode_base_module_transform_value (ValaCCodeBaseModule* self, ValaTargetValue* value, ValaDataType* target_type, ValaCodeNode* node); ValaGLibValue* vala_glib_value_new (ValaDataType* value_type, ValaCCodeExpression* cvalue, gboolean lvalue); ValaGLibValue* vala_glib_value_construct (GType object_type, ValaDataType* value_type, ValaCCodeExpression* cvalue, gboolean lvalue); -GType vala_glib_value_get_type (void) G_GNUC_CONST; gboolean vala_ccode_base_module_get_current_method_inner_error (ValaCCodeBaseModule* self); gboolean vala_ccode_base_module_get_ccode_notify (ValaProperty* prop); ValaCCodeConstant* vala_ccode_base_module_get_property_canonical_cconstant (ValaCCodeBaseModule* self, ValaProperty* prop); @@ -4729,6 +4729,11 @@ void vala_ccode_base_module_generate_field_declaration (ValaCCodeBaseModule* sel } +static gpointer _vala_target_value_ref0 (gpointer self) { + return self ? vala_target_value_ref (self) : NULL; +} + + static void vala_ccode_base_module_real_visit_field (ValaCodeVisitor* base, ValaField* f) { ValaCCodeBaseModule * self; ValaField* _tmp0_; @@ -4817,12 +4822,12 @@ static void vala_ccode_base_module_real_visit_field (ValaCodeVisitor* base, Vala ValaField* _tmp49_; ValaExpression* _tmp50_; ValaExpression* _tmp51_; - gboolean _tmp145_ = FALSE; - ValaField* _tmp146_; - ValaDataType* _tmp147_; - ValaDataType* _tmp148_; - gboolean _tmp149_ = FALSE; - gboolean _tmp151_; + gboolean _tmp173_ = FALSE; + ValaField* _tmp174_; + ValaDataType* _tmp175_; + ValaDataType* _tmp176_; + gboolean _tmp177_ = FALSE; + gboolean _tmp179_; _tmp30_ = is_gtypeinstance; if (_tmp30_) { ValaField* _tmp31_; @@ -4894,14 +4899,12 @@ static void vala_ccode_base_module_real_visit_field (ValaCodeVisitor* base, Vala ValaCCodeExpression* _tmp62_; ValaCCodeExpression* _tmp63_; gboolean _tmp64_ = FALSE; - gboolean _tmp65_ = FALSE; - ValaField* _tmp66_; + ValaField* _tmp65_; + ValaDataType* _tmp66_; ValaDataType* _tmp67_; - ValaDataType* _tmp68_; - gboolean _tmp71_; - gboolean _tmp75_; - ValaArrayList* _tmp143_; - ValaArrayList* _tmp144_; + gboolean _tmp70_; + ValaArrayList* _tmp171_; + ValaArrayList* _tmp172_; _tmp52_ = self->instance_init_context; vala_ccode_base_module_push_context (self, _tmp52_); _tmp53_ = f; @@ -4918,973 +4921,1057 @@ static void vala_ccode_base_module_real_visit_field (ValaCodeVisitor* base, Vala _tmp62_ = lhs; _tmp63_ = rhs; vala_ccode_function_add_assignment (_tmp61_, _tmp62_, _tmp63_); - _tmp66_ = f; - _tmp67_ = vala_variable_get_variable_type ((ValaVariable*) _tmp66_); - _tmp68_ = _tmp67_; - if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp68_, VALA_TYPE_ARRAY_TYPE)) { - ValaField* _tmp69_; - gboolean _tmp70_ = FALSE; - _tmp69_ = f; - _tmp70_ = vala_ccode_base_module_get_ccode_array_length ((ValaCodeNode*) _tmp69_); - _tmp65_ = _tmp70_; - } else { - _tmp65_ = FALSE; - } - _tmp71_ = _tmp65_; - if (_tmp71_) { - ValaField* _tmp72_; - ValaExpression* _tmp73_; - ValaExpression* _tmp74_; - _tmp72_ = f; - _tmp73_ = vala_variable_get_initializer ((ValaVariable*) _tmp72_); - _tmp74_ = _tmp73_; - _tmp64_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp74_, VALA_TYPE_ARRAY_CREATION_EXPRESSION); + _tmp65_ = f; + _tmp66_ = vala_variable_get_variable_type ((ValaVariable*) _tmp65_); + _tmp67_ = _tmp66_; + if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp67_, VALA_TYPE_ARRAY_TYPE)) { + ValaField* _tmp68_; + gboolean _tmp69_ = FALSE; + _tmp68_ = f; + _tmp69_ = vala_ccode_base_module_get_ccode_array_length ((ValaCodeNode*) _tmp68_); + _tmp64_ = _tmp69_; } else { _tmp64_ = FALSE; } - _tmp75_ = _tmp64_; - if (_tmp75_) { - ValaField* _tmp76_; - ValaDataType* _tmp77_; - ValaDataType* _tmp78_; - ValaArrayType* _tmp79_; + _tmp70_ = _tmp64_; + if (_tmp70_) { + ValaField* _tmp71_; + ValaDataType* _tmp72_; + ValaDataType* _tmp73_; + ValaArrayType* _tmp74_; ValaArrayType* array_type; - ValaField* _tmp80_; - ValaField* _tmp81_; - ValaSymbol* _tmp82_; - ValaSymbol* _tmp83_; - ValaTargetValue* _tmp84_ = NULL; - ValaTargetValue* _tmp85_; - ValaTargetValue* _tmp86_ = NULL; - ValaTargetValue* _tmp87_; + ValaField* _tmp75_; + ValaField* _tmp76_; + ValaSymbol* _tmp77_; + ValaSymbol* _tmp78_; + ValaTargetValue* _tmp79_ = NULL; + ValaTargetValue* _tmp80_; + ValaTargetValue* _tmp81_ = NULL; + ValaTargetValue* _tmp82_; ValaTargetValue* field_value; - ValaField* _tmp88_; - ValaExpression* _tmp89_; - ValaExpression* _tmp90_; - ValaList* _tmp91_ = NULL; - ValaList* sizes; - gboolean _tmp111_ = FALSE; - ValaArrayType* _tmp112_; - gint _tmp113_; - gint _tmp114_; - gboolean _tmp117_; + ValaField* _tmp83_; + ValaExpression* _tmp84_; + ValaExpression* _tmp85_; + ValaTargetValue* _tmp86_; + ValaTargetValue* _tmp87_; + ValaGLibValue* _tmp88_; + ValaGLibValue* glib_value; + ValaGLibValue* _tmp89_; + ValaList* _tmp90_; + gboolean _tmp139_ = FALSE; + ValaArrayType* _tmp140_; + gint _tmp141_; + gint _tmp142_; + gboolean _tmp145_; + _tmp71_ = f; + _tmp72_ = vala_variable_get_variable_type ((ValaVariable*) _tmp71_); + _tmp73_ = _tmp72_; + _tmp74_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp73_, VALA_TYPE_ARRAY_TYPE, ValaArrayType)); + array_type = _tmp74_; + _tmp75_ = f; _tmp76_ = f; - _tmp77_ = vala_variable_get_variable_type ((ValaVariable*) _tmp76_); + _tmp77_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp76_); _tmp78_ = _tmp77_; - _tmp79_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp78_, VALA_TYPE_ARRAY_TYPE, ValaArrayType)); - array_type = _tmp79_; - _tmp80_ = f; - _tmp81_ = f; - _tmp82_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp81_); - _tmp83_ = _tmp82_; - _tmp84_ = vala_ccode_base_module_load_this_parameter (self, G_TYPE_CHECK_INSTANCE_CAST (_tmp83_, VALA_TYPE_TYPESYMBOL, ValaTypeSymbol)); + _tmp79_ = vala_ccode_base_module_load_this_parameter (self, G_TYPE_CHECK_INSTANCE_CAST (_tmp78_, VALA_TYPE_TYPESYMBOL, ValaTypeSymbol)); + _tmp80_ = _tmp79_; + _tmp81_ = vala_ccode_base_module_get_field_cvalue (self, _tmp75_, _tmp80_); + _tmp82_ = _tmp81_; + _vala_target_value_unref0 (_tmp80_); + field_value = _tmp82_; + _tmp83_ = f; + _tmp84_ = vala_variable_get_initializer ((ValaVariable*) _tmp83_); _tmp85_ = _tmp84_; - _tmp86_ = vala_ccode_base_module_get_field_cvalue (self, _tmp80_, _tmp85_); + _tmp86_ = vala_expression_get_target_value (_tmp85_); _tmp87_ = _tmp86_; - _vala_target_value_unref0 (_tmp85_); - field_value = _tmp87_; - _tmp88_ = f; - _tmp89_ = vala_variable_get_initializer ((ValaVariable*) _tmp88_); - _tmp90_ = _tmp89_; - _tmp91_ = vala_array_creation_expression_get_sizes (G_TYPE_CHECK_INSTANCE_CAST (_tmp90_, VALA_TYPE_ARRAY_CREATION_EXPRESSION, ValaArrayCreationExpression)); - sizes = _tmp91_; - { - gint dim; - dim = 1; + _tmp88_ = _vala_target_value_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp87_, VALA_TYPE_GLIB_VALUE, ValaGLibValue)); + glib_value = _tmp88_; + _tmp89_ = glib_value; + _tmp90_ = _tmp89_->array_length_cvalues; + if (_tmp90_ != NULL) { { - gboolean _tmp92_; - _tmp92_ = TRUE; - while (TRUE) { - gboolean _tmp93_; - gint _tmp95_; - ValaArrayType* _tmp96_; - gint _tmp97_; - gint _tmp98_; - ValaTargetValue* _tmp99_; - gint _tmp100_; - ValaCCodeExpression* _tmp101_ = NULL; - ValaCCodeExpression* array_len_lhs; - ValaList* _tmp102_; - gint _tmp103_; - gpointer _tmp104_ = NULL; - ValaExpression* size; - ValaCCodeFunction* _tmp105_; - ValaCCodeFunction* _tmp106_; - ValaCCodeExpression* _tmp107_; - ValaExpression* _tmp108_; - ValaCCodeExpression* _tmp109_ = NULL; - ValaCCodeExpression* _tmp110_; - _tmp93_ = _tmp92_; - if (!_tmp93_) { + gint dim; + dim = 1; + { + gboolean _tmp91_; + _tmp91_ = TRUE; + while (TRUE) { + gboolean _tmp92_; gint _tmp94_; + ValaArrayType* _tmp95_; + gint _tmp96_; + gint _tmp97_; + ValaTargetValue* _tmp98_; + gint _tmp99_; + ValaCCodeExpression* _tmp100_ = NULL; + ValaCCodeExpression* array_len_lhs; + ValaCCodeFunction* _tmp101_; + ValaCCodeFunction* _tmp102_; + ValaCCodeExpression* _tmp103_; + ValaGLibValue* _tmp104_; + gint _tmp105_; + ValaCCodeExpression* _tmp106_ = NULL; + ValaCCodeExpression* _tmp107_; + _tmp92_ = _tmp91_; + if (!_tmp92_) { + gint _tmp93_; + _tmp93_ = dim; + dim = _tmp93_ + 1; + } + _tmp91_ = FALSE; _tmp94_ = dim; - dim = _tmp94_ + 1; + _tmp95_ = array_type; + _tmp96_ = vala_array_type_get_rank (_tmp95_); + _tmp97_ = _tmp96_; + if (!(_tmp94_ <= _tmp97_)) { + break; + } + _tmp98_ = field_value; + _tmp99_ = dim; + _tmp100_ = vala_ccode_base_module_get_array_length_cvalue (self, _tmp98_, _tmp99_); + array_len_lhs = _tmp100_; + _tmp101_ = vala_ccode_base_module_get_ccode (self); + _tmp102_ = _tmp101_; + _tmp103_ = array_len_lhs; + _tmp104_ = glib_value; + _tmp105_ = dim; + _tmp106_ = vala_ccode_base_module_get_array_length_cvalue (self, (ValaTargetValue*) _tmp104_, _tmp105_); + _tmp107_ = _tmp106_; + vala_ccode_function_add_assignment (_tmp102_, _tmp103_, _tmp107_); + _vala_ccode_node_unref0 (_tmp107_); + _vala_ccode_node_unref0 (array_len_lhs); } - _tmp92_ = FALSE; - _tmp95_ = dim; - _tmp96_ = array_type; - _tmp97_ = vala_array_type_get_rank (_tmp96_); - _tmp98_ = _tmp97_; - if (!(_tmp95_ <= _tmp98_)) { - break; + } + } + } else { + ValaGLibValue* _tmp108_; + gboolean _tmp109_; + _tmp108_ = glib_value; + _tmp109_ = _tmp108_->array_null_terminated; + if (_tmp109_) { + ValaCCodeIdentifier* _tmp110_; + ValaCCodeIdentifier* _tmp111_; + ValaCCodeFunctionCall* _tmp112_; + ValaCCodeFunctionCall* _tmp113_; + ValaCCodeFunctionCall* len_call; + ValaCCodeFunctionCall* _tmp114_; + ValaGLibValue* _tmp115_; + ValaCCodeExpression* _tmp116_ = NULL; + ValaCCodeExpression* _tmp117_; + ValaCCodeFunction* _tmp118_; + ValaCCodeFunction* _tmp119_; + ValaTargetValue* _tmp120_; + ValaCCodeExpression* _tmp121_ = NULL; + ValaCCodeExpression* _tmp122_; + ValaCCodeFunctionCall* _tmp123_; + self->requires_array_length = TRUE; + _tmp110_ = vala_ccode_identifier_new ("_vala_array_length"); + _tmp111_ = _tmp110_; + _tmp112_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp111_); + _tmp113_ = _tmp112_; + _vala_ccode_node_unref0 (_tmp111_); + len_call = _tmp113_; + _tmp114_ = len_call; + _tmp115_ = glib_value; + _tmp116_ = vala_ccode_base_module_get_cvalue_ (self, (ValaTargetValue*) _tmp115_); + _tmp117_ = _tmp116_; + vala_ccode_function_call_add_argument (_tmp114_, _tmp117_); + _vala_ccode_node_unref0 (_tmp117_); + _tmp118_ = vala_ccode_base_module_get_ccode (self); + _tmp119_ = _tmp118_; + _tmp120_ = field_value; + _tmp121_ = vala_ccode_base_module_get_array_length_cvalue (self, _tmp120_, 1); + _tmp122_ = _tmp121_; + _tmp123_ = len_call; + vala_ccode_function_add_assignment (_tmp119_, _tmp122_, (ValaCCodeExpression*) _tmp123_); + _vala_ccode_node_unref0 (_tmp122_); + _vala_ccode_node_unref0 (len_call); + } else { + { + gint dim; + dim = 1; + { + gboolean _tmp124_; + _tmp124_ = TRUE; + while (TRUE) { + gboolean _tmp125_; + gint _tmp127_; + ValaArrayType* _tmp128_; + gint _tmp129_; + gint _tmp130_; + ValaCCodeFunction* _tmp131_; + ValaCCodeFunction* _tmp132_; + ValaTargetValue* _tmp133_; + gint _tmp134_; + ValaCCodeExpression* _tmp135_ = NULL; + ValaCCodeExpression* _tmp136_; + ValaCCodeConstant* _tmp137_; + ValaCCodeConstant* _tmp138_; + _tmp125_ = _tmp124_; + if (!_tmp125_) { + gint _tmp126_; + _tmp126_ = dim; + dim = _tmp126_ + 1; + } + _tmp124_ = FALSE; + _tmp127_ = dim; + _tmp128_ = array_type; + _tmp129_ = vala_array_type_get_rank (_tmp128_); + _tmp130_ = _tmp129_; + if (!(_tmp127_ <= _tmp130_)) { + break; + } + _tmp131_ = vala_ccode_base_module_get_ccode (self); + _tmp132_ = _tmp131_; + _tmp133_ = field_value; + _tmp134_ = dim; + _tmp135_ = vala_ccode_base_module_get_array_length_cvalue (self, _tmp133_, _tmp134_); + _tmp136_ = _tmp135_; + _tmp137_ = vala_ccode_constant_new ("-1"); + _tmp138_ = _tmp137_; + vala_ccode_function_add_assignment (_tmp132_, _tmp136_, (ValaCCodeExpression*) _tmp138_); + _vala_ccode_node_unref0 (_tmp138_); + _vala_ccode_node_unref0 (_tmp136_); + } } - _tmp99_ = field_value; - _tmp100_ = dim; - _tmp101_ = vala_ccode_base_module_get_array_length_cvalue (self, _tmp99_, _tmp100_); - array_len_lhs = _tmp101_; - _tmp102_ = sizes; - _tmp103_ = dim; - _tmp104_ = vala_list_get (_tmp102_, _tmp103_ - 1); - size = (ValaExpression*) _tmp104_; - _tmp105_ = vala_ccode_base_module_get_ccode (self); - _tmp106_ = _tmp105_; - _tmp107_ = array_len_lhs; - _tmp108_ = size; - _tmp109_ = vala_ccode_base_module_get_cvalue (self, _tmp108_); - _tmp110_ = _tmp109_; - vala_ccode_function_add_assignment (_tmp106_, _tmp107_, _tmp110_); - _vala_ccode_node_unref0 (_tmp110_); - _vala_code_node_unref0 (size); - _vala_ccode_node_unref0 (array_len_lhs); } } } - _tmp112_ = array_type; - _tmp113_ = vala_array_type_get_rank (_tmp112_); - _tmp114_ = _tmp113_; - if (_tmp114_ == 1) { - ValaField* _tmp115_; - gboolean _tmp116_ = FALSE; - _tmp115_ = f; - _tmp116_ = vala_symbol_is_internal_symbol ((ValaSymbol*) _tmp115_); - _tmp111_ = _tmp116_; + _tmp140_ = array_type; + _tmp141_ = vala_array_type_get_rank (_tmp140_); + _tmp142_ = _tmp141_; + if (_tmp142_ == 1) { + ValaField* _tmp143_; + gboolean _tmp144_ = FALSE; + _tmp143_ = f; + _tmp144_ = vala_symbol_is_internal_symbol ((ValaSymbol*) _tmp143_); + _tmp139_ = _tmp144_; } else { - _tmp111_ = FALSE; + _tmp139_ = FALSE; } - _tmp117_ = _tmp111_; - if (_tmp117_) { - ValaTargetValue* _tmp118_; - ValaCCodeExpression* _tmp119_ = NULL; + _tmp145_ = _tmp139_; + if (_tmp145_) { + ValaTargetValue* _tmp146_; + ValaCCodeExpression* _tmp147_ = NULL; ValaCCodeExpression* lhs_array_size; - ValaTargetValue* _tmp120_; - ValaCCodeExpression* _tmp121_ = NULL; + ValaTargetValue* _tmp148_; + ValaCCodeExpression* _tmp149_ = NULL; ValaCCodeExpression* rhs_array_len; - ValaCCodeFunction* _tmp122_; - ValaCCodeFunction* _tmp123_; - ValaCCodeExpression* _tmp124_; - ValaCCodeExpression* _tmp125_; - _tmp118_ = field_value; - _tmp119_ = vala_ccode_base_module_get_array_size_cvalue (self, _tmp118_); - lhs_array_size = _tmp119_; - _tmp120_ = field_value; - _tmp121_ = vala_ccode_base_module_get_array_length_cvalue (self, _tmp120_, 1); - rhs_array_len = _tmp121_; - _tmp122_ = vala_ccode_base_module_get_ccode (self); - _tmp123_ = _tmp122_; - _tmp124_ = lhs_array_size; - _tmp125_ = rhs_array_len; - vala_ccode_function_add_assignment (_tmp123_, _tmp124_, _tmp125_); + ValaCCodeFunction* _tmp150_; + ValaCCodeFunction* _tmp151_; + ValaCCodeExpression* _tmp152_; + ValaCCodeExpression* _tmp153_; + _tmp146_ = field_value; + _tmp147_ = vala_ccode_base_module_get_array_size_cvalue (self, _tmp146_); + lhs_array_size = _tmp147_; + _tmp148_ = field_value; + _tmp149_ = vala_ccode_base_module_get_array_length_cvalue (self, _tmp148_, 1); + rhs_array_len = _tmp149_; + _tmp150_ = vala_ccode_base_module_get_ccode (self); + _tmp151_ = _tmp150_; + _tmp152_ = lhs_array_size; + _tmp153_ = rhs_array_len; + vala_ccode_function_add_assignment (_tmp151_, _tmp152_, _tmp153_); _vala_ccode_node_unref0 (rhs_array_len); _vala_ccode_node_unref0 (lhs_array_size); } - _vala_iterable_unref0 (sizes); + _vala_target_value_unref0 (glib_value); _vala_target_value_unref0 (field_value); _vala_code_node_unref0 (array_type); } { - ValaArrayList* _tmp126_; - ValaArrayList* _tmp127_; - ValaArrayList* _tmp128_; + ValaArrayList* _tmp154_; + ValaArrayList* _tmp155_; + ValaArrayList* _tmp156_; ValaArrayList* _value_list; - ValaArrayList* _tmp129_; - gint _tmp130_; - gint _tmp131_; + ValaArrayList* _tmp157_; + gint _tmp158_; + gint _tmp159_; gint _value_size; gint _value_index; - _tmp126_ = vala_ccode_base_module_get_temp_ref_values (self); - _tmp127_ = _tmp126_; - _tmp128_ = _vala_iterable_ref0 (_tmp127_); - _value_list = _tmp128_; - _tmp129_ = _value_list; - _tmp130_ = vala_collection_get_size ((ValaCollection*) _tmp129_); - _tmp131_ = _tmp130_; - _value_size = _tmp131_; + _tmp154_ = vala_ccode_base_module_get_temp_ref_values (self); + _tmp155_ = _tmp154_; + _tmp156_ = _vala_iterable_ref0 (_tmp155_); + _value_list = _tmp156_; + _tmp157_ = _value_list; + _tmp158_ = vala_collection_get_size ((ValaCollection*) _tmp157_); + _tmp159_ = _tmp158_; + _value_size = _tmp159_; _value_index = -1; while (TRUE) { - gint _tmp132_; - gint _tmp133_; - gint _tmp134_; - ValaArrayList* _tmp135_; - gint _tmp136_; - gpointer _tmp137_ = NULL; + gint _tmp160_; + gint _tmp161_; + gint _tmp162_; + ValaArrayList* _tmp163_; + gint _tmp164_; + gpointer _tmp165_ = NULL; ValaTargetValue* value; - ValaCCodeFunction* _tmp138_; - ValaCCodeFunction* _tmp139_; - ValaTargetValue* _tmp140_; - ValaCCodeExpression* _tmp141_ = NULL; - ValaCCodeExpression* _tmp142_; - _tmp132_ = _value_index; - _value_index = _tmp132_ + 1; - _tmp133_ = _value_index; - _tmp134_ = _value_size; - if (!(_tmp133_ < _tmp134_)) { + ValaCCodeFunction* _tmp166_; + ValaCCodeFunction* _tmp167_; + ValaTargetValue* _tmp168_; + ValaCCodeExpression* _tmp169_ = NULL; + ValaCCodeExpression* _tmp170_; + _tmp160_ = _value_index; + _value_index = _tmp160_ + 1; + _tmp161_ = _value_index; + _tmp162_ = _value_size; + if (!(_tmp161_ < _tmp162_)) { break; } - _tmp135_ = _value_list; - _tmp136_ = _value_index; - _tmp137_ = vala_list_get ((ValaList*) _tmp135_, _tmp136_); - value = (ValaTargetValue*) _tmp137_; - _tmp138_ = vala_ccode_base_module_get_ccode (self); - _tmp139_ = _tmp138_; - _tmp140_ = value; - _tmp141_ = vala_ccode_base_module_destroy_value (self, _tmp140_, FALSE); - _tmp142_ = _tmp141_; - vala_ccode_function_add_expression (_tmp139_, _tmp142_); - _vala_ccode_node_unref0 (_tmp142_); + _tmp163_ = _value_list; + _tmp164_ = _value_index; + _tmp165_ = vala_list_get ((ValaList*) _tmp163_, _tmp164_); + value = (ValaTargetValue*) _tmp165_; + _tmp166_ = vala_ccode_base_module_get_ccode (self); + _tmp167_ = _tmp166_; + _tmp168_ = value; + _tmp169_ = vala_ccode_base_module_destroy_value (self, _tmp168_, FALSE); + _tmp170_ = _tmp169_; + vala_ccode_function_add_expression (_tmp167_, _tmp170_); + _vala_ccode_node_unref0 (_tmp170_); _vala_target_value_unref0 (value); } _vala_iterable_unref0 (_value_list); } - _tmp143_ = vala_ccode_base_module_get_temp_ref_values (self); - _tmp144_ = _tmp143_; - vala_collection_clear ((ValaCollection*) _tmp144_); + _tmp171_ = vala_ccode_base_module_get_temp_ref_values (self); + _tmp172_ = _tmp171_; + vala_collection_clear ((ValaCollection*) _tmp172_); vala_ccode_base_module_pop_context (self); _vala_ccode_node_unref0 (rhs); } - _tmp146_ = f; - _tmp147_ = vala_variable_get_variable_type ((ValaVariable*) _tmp146_); - _tmp148_ = _tmp147_; - _tmp149_ = vala_ccode_base_module_requires_destroy (self, _tmp148_); - if (_tmp149_) { - ValaCCodeBaseModuleEmitContext* _tmp150_; - _tmp150_ = self->instance_finalize_context; - _tmp145_ = _tmp150_ != NULL; + _tmp174_ = f; + _tmp175_ = vala_variable_get_variable_type ((ValaVariable*) _tmp174_); + _tmp176_ = _tmp175_; + _tmp177_ = vala_ccode_base_module_requires_destroy (self, _tmp176_); + if (_tmp177_) { + ValaCCodeBaseModuleEmitContext* _tmp178_; + _tmp178_ = self->instance_finalize_context; + _tmp173_ = _tmp178_ != NULL; } else { - _tmp145_ = FALSE; - } - _tmp151_ = _tmp145_; - if (_tmp151_) { - ValaCCodeBaseModuleEmitContext* _tmp152_; - ValaCCodeFunction* _tmp153_; - ValaCCodeFunction* _tmp154_; - ValaField* _tmp155_; - ValaField* _tmp156_; - ValaSymbol* _tmp157_; - ValaSymbol* _tmp158_; - ValaTargetValue* _tmp159_ = NULL; - ValaTargetValue* _tmp160_; - ValaCCodeExpression* _tmp161_ = NULL; - ValaCCodeExpression* _tmp162_; - _tmp152_ = self->instance_finalize_context; - vala_ccode_base_module_push_context (self, _tmp152_); - _tmp153_ = vala_ccode_base_module_get_ccode (self); - _tmp154_ = _tmp153_; - _tmp155_ = f; - _tmp156_ = f; - _tmp157_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp156_); - _tmp158_ = _tmp157_; - _tmp159_ = vala_ccode_base_module_load_this_parameter (self, G_TYPE_CHECK_INSTANCE_CAST (_tmp158_, VALA_TYPE_TYPESYMBOL, ValaTypeSymbol)); - _tmp160_ = _tmp159_; - _tmp161_ = vala_ccode_base_module_destroy_field (self, _tmp155_, _tmp160_); - _tmp162_ = _tmp161_; - vala_ccode_function_add_expression (_tmp154_, _tmp162_); - _vala_ccode_node_unref0 (_tmp162_); - _vala_target_value_unref0 (_tmp160_); + _tmp173_ = FALSE; + } + _tmp179_ = _tmp173_; + if (_tmp179_) { + ValaCCodeBaseModuleEmitContext* _tmp180_; + ValaCCodeFunction* _tmp181_; + ValaCCodeFunction* _tmp182_; + ValaField* _tmp183_; + ValaField* _tmp184_; + ValaSymbol* _tmp185_; + ValaSymbol* _tmp186_; + ValaTargetValue* _tmp187_ = NULL; + ValaTargetValue* _tmp188_; + ValaCCodeExpression* _tmp189_ = NULL; + ValaCCodeExpression* _tmp190_; + _tmp180_ = self->instance_finalize_context; + vala_ccode_base_module_push_context (self, _tmp180_); + _tmp181_ = vala_ccode_base_module_get_ccode (self); + _tmp182_ = _tmp181_; + _tmp183_ = f; + _tmp184_ = f; + _tmp185_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp184_); + _tmp186_ = _tmp185_; + _tmp187_ = vala_ccode_base_module_load_this_parameter (self, G_TYPE_CHECK_INSTANCE_CAST (_tmp186_, VALA_TYPE_TYPESYMBOL, ValaTypeSymbol)); + _tmp188_ = _tmp187_; + _tmp189_ = vala_ccode_base_module_destroy_field (self, _tmp183_, _tmp188_); + _tmp190_ = _tmp189_; + vala_ccode_function_add_expression (_tmp182_, _tmp190_); + _vala_ccode_node_unref0 (_tmp190_); + _vala_target_value_unref0 (_tmp188_); vala_ccode_base_module_pop_context (self); } } else { - ValaField* _tmp163_; - ValaMemberBinding _tmp164_; - ValaMemberBinding _tmp165_; - _tmp163_ = f; - _tmp164_ = vala_field_get_binding (_tmp163_); - _tmp165_ = _tmp164_; - if (_tmp165_ == VALA_MEMBER_BINDING_CLASS) { - gboolean _tmp166_; - ValaField* _tmp171_; - ValaSymbolAccessibility _tmp172_; - ValaSymbolAccessibility _tmp173_; - ValaField* _tmp197_; - ValaExpression* _tmp198_; - ValaExpression* _tmp199_; - _tmp166_ = is_gtypeinstance; - if (!_tmp166_) { - ValaField* _tmp167_; - ValaSourceReference* _tmp168_; - ValaSourceReference* _tmp169_; - ValaField* _tmp170_; - _tmp167_ = f; - _tmp168_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp167_); - _tmp169_ = _tmp168_; - vala_report_error (_tmp169_, "class fields are not supported in compact classes"); - _tmp170_ = f; - vala_code_node_set_error ((ValaCodeNode*) _tmp170_, TRUE); + ValaField* _tmp191_; + ValaMemberBinding _tmp192_; + ValaMemberBinding _tmp193_; + _tmp191_ = f; + _tmp192_ = vala_field_get_binding (_tmp191_); + _tmp193_ = _tmp192_; + if (_tmp193_ == VALA_MEMBER_BINDING_CLASS) { + gboolean _tmp194_; + ValaField* _tmp199_; + ValaSymbolAccessibility _tmp200_; + ValaSymbolAccessibility _tmp201_; + ValaField* _tmp225_; + ValaExpression* _tmp226_; + ValaExpression* _tmp227_; + _tmp194_ = is_gtypeinstance; + if (!_tmp194_) { + ValaField* _tmp195_; + ValaSourceReference* _tmp196_; + ValaSourceReference* _tmp197_; + ValaField* _tmp198_; + _tmp195_ = f; + _tmp196_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp195_); + _tmp197_ = _tmp196_; + vala_report_error (_tmp197_, "class fields are not supported in compact classes"); + _tmp198_ = f; + vala_code_node_set_error ((ValaCodeNode*) _tmp198_, TRUE); _g_free0 (field_ctype); _vala_ccode_node_unref0 (lhs); _vala_code_node_unref0 (cl); return; } - _tmp171_ = f; - _tmp172_ = vala_symbol_get_access ((ValaSymbol*) _tmp171_); - _tmp173_ = _tmp172_; - if (_tmp173_ == VALA_SYMBOL_ACCESSIBILITY_PRIVATE) { - ValaClass* _tmp174_; - gchar* _tmp175_ = NULL; - gchar* _tmp176_; - gchar* _tmp177_ = NULL; - gchar* _tmp178_; - ValaCCodeIdentifier* _tmp179_; - ValaCCodeIdentifier* _tmp180_; - ValaCCodeFunctionCall* _tmp181_; - ValaCCodeFunctionCall* _tmp182_; + _tmp199_ = f; + _tmp200_ = vala_symbol_get_access ((ValaSymbol*) _tmp199_); + _tmp201_ = _tmp200_; + if (_tmp201_ == VALA_SYMBOL_ACCESSIBILITY_PRIVATE) { + ValaClass* _tmp202_; + gchar* _tmp203_ = NULL; + gchar* _tmp204_; + gchar* _tmp205_ = NULL; + gchar* _tmp206_; + ValaCCodeIdentifier* _tmp207_; + ValaCCodeIdentifier* _tmp208_; + ValaCCodeFunctionCall* _tmp209_; + ValaCCodeFunctionCall* _tmp210_; ValaCCodeFunctionCall* ccall; - ValaCCodeFunctionCall* _tmp183_; - ValaCCodeIdentifier* _tmp184_; - ValaCCodeIdentifier* _tmp185_; - ValaCCodeFunctionCall* _tmp186_; - ValaField* _tmp187_; - gchar* _tmp188_ = NULL; - gchar* _tmp189_; - ValaCCodeMemberAccess* _tmp190_; - _tmp174_ = cl; - _tmp175_ = vala_ccode_base_module_get_ccode_upper_case_name ((ValaSymbol*) _tmp174_, NULL); - _tmp176_ = _tmp175_; - _tmp177_ = g_strdup_printf ("%s_GET_CLASS_PRIVATE", _tmp176_); - _tmp178_ = _tmp177_; - _tmp179_ = vala_ccode_identifier_new (_tmp178_); - _tmp180_ = _tmp179_; - _tmp181_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp180_); - _tmp182_ = _tmp181_; - _vala_ccode_node_unref0 (_tmp180_); - _g_free0 (_tmp178_); - _g_free0 (_tmp176_); - ccall = _tmp182_; - _tmp183_ = ccall; - _tmp184_ = vala_ccode_identifier_new ("klass"); - _tmp185_ = _tmp184_; - vala_ccode_function_call_add_argument (_tmp183_, (ValaCCodeExpression*) _tmp185_); - _vala_ccode_node_unref0 (_tmp185_); - _tmp186_ = ccall; - _tmp187_ = f; - _tmp188_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp187_); - _tmp189_ = _tmp188_; - _tmp190_ = vala_ccode_member_access_new ((ValaCCodeExpression*) _tmp186_, _tmp189_, TRUE); + ValaCCodeFunctionCall* _tmp211_; + ValaCCodeIdentifier* _tmp212_; + ValaCCodeIdentifier* _tmp213_; + ValaCCodeFunctionCall* _tmp214_; + ValaField* _tmp215_; + gchar* _tmp216_ = NULL; + gchar* _tmp217_; + ValaCCodeMemberAccess* _tmp218_; + _tmp202_ = cl; + _tmp203_ = vala_ccode_base_module_get_ccode_upper_case_name ((ValaSymbol*) _tmp202_, NULL); + _tmp204_ = _tmp203_; + _tmp205_ = g_strdup_printf ("%s_GET_CLASS_PRIVATE", _tmp204_); + _tmp206_ = _tmp205_; + _tmp207_ = vala_ccode_identifier_new (_tmp206_); + _tmp208_ = _tmp207_; + _tmp209_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp208_); + _tmp210_ = _tmp209_; + _vala_ccode_node_unref0 (_tmp208_); + _g_free0 (_tmp206_); + _g_free0 (_tmp204_); + ccall = _tmp210_; + _tmp211_ = ccall; + _tmp212_ = vala_ccode_identifier_new ("klass"); + _tmp213_ = _tmp212_; + vala_ccode_function_call_add_argument (_tmp211_, (ValaCCodeExpression*) _tmp213_); + _vala_ccode_node_unref0 (_tmp213_); + _tmp214_ = ccall; + _tmp215_ = f; + _tmp216_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp215_); + _tmp217_ = _tmp216_; + _tmp218_ = vala_ccode_member_access_new ((ValaCCodeExpression*) _tmp214_, _tmp217_, TRUE); _vala_ccode_node_unref0 (lhs); - lhs = (ValaCCodeExpression*) _tmp190_; - _g_free0 (_tmp189_); + lhs = (ValaCCodeExpression*) _tmp218_; + _g_free0 (_tmp217_); _vala_ccode_node_unref0 (ccall); } else { - ValaCCodeIdentifier* _tmp191_; - ValaCCodeIdentifier* _tmp192_; - ValaField* _tmp193_; - gchar* _tmp194_ = NULL; - gchar* _tmp195_; - ValaCCodeMemberAccess* _tmp196_; - _tmp191_ = vala_ccode_identifier_new ("klass"); - _tmp192_ = _tmp191_; - _tmp193_ = f; - _tmp194_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp193_); - _tmp195_ = _tmp194_; - _tmp196_ = vala_ccode_member_access_new ((ValaCCodeExpression*) _tmp192_, _tmp195_, TRUE); + ValaCCodeIdentifier* _tmp219_; + ValaCCodeIdentifier* _tmp220_; + ValaField* _tmp221_; + gchar* _tmp222_ = NULL; + gchar* _tmp223_; + ValaCCodeMemberAccess* _tmp224_; + _tmp219_ = vala_ccode_identifier_new ("klass"); + _tmp220_ = _tmp219_; + _tmp221_ = f; + _tmp222_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp221_); + _tmp223_ = _tmp222_; + _tmp224_ = vala_ccode_member_access_new ((ValaCCodeExpression*) _tmp220_, _tmp223_, TRUE); _vala_ccode_node_unref0 (lhs); - lhs = (ValaCCodeExpression*) _tmp196_; - _g_free0 (_tmp195_); - _vala_ccode_node_unref0 (_tmp192_); + lhs = (ValaCCodeExpression*) _tmp224_; + _g_free0 (_tmp223_); + _vala_ccode_node_unref0 (_tmp220_); } - _tmp197_ = f; - _tmp198_ = vala_variable_get_initializer ((ValaVariable*) _tmp197_); - _tmp199_ = _tmp198_; - if (_tmp199_ != NULL) { - ValaCCodeBaseModuleEmitContext* _tmp200_; - ValaField* _tmp201_; - ValaExpression* _tmp202_; - ValaExpression* _tmp203_; - ValaField* _tmp204_; - ValaExpression* _tmp205_; - ValaExpression* _tmp206_; - ValaCCodeExpression* _tmp207_ = NULL; + _tmp225_ = f; + _tmp226_ = vala_variable_get_initializer ((ValaVariable*) _tmp225_); + _tmp227_ = _tmp226_; + if (_tmp227_ != NULL) { + ValaCCodeBaseModuleEmitContext* _tmp228_; + ValaField* _tmp229_; + ValaExpression* _tmp230_; + ValaExpression* _tmp231_; + ValaField* _tmp232_; + ValaExpression* _tmp233_; + ValaExpression* _tmp234_; + ValaCCodeExpression* _tmp235_ = NULL; ValaCCodeExpression* rhs; - ValaCCodeFunction* _tmp208_; - ValaCCodeFunction* _tmp209_; - ValaCCodeExpression* _tmp210_; - ValaCCodeExpression* _tmp211_; - ValaArrayList* _tmp229_; - ValaArrayList* _tmp230_; - _tmp200_ = self->class_init_context; - vala_ccode_base_module_push_context (self, _tmp200_); - _tmp201_ = f; - _tmp202_ = vala_variable_get_initializer ((ValaVariable*) _tmp201_); - _tmp203_ = _tmp202_; - vala_code_node_emit ((ValaCodeNode*) _tmp203_, (ValaCodeGenerator*) self); - _tmp204_ = f; - _tmp205_ = vala_variable_get_initializer ((ValaVariable*) _tmp204_); - _tmp206_ = _tmp205_; - _tmp207_ = vala_ccode_base_module_get_cvalue (self, _tmp206_); - rhs = _tmp207_; - _tmp208_ = vala_ccode_base_module_get_ccode (self); - _tmp209_ = _tmp208_; - _tmp210_ = lhs; - _tmp211_ = rhs; - vala_ccode_function_add_assignment (_tmp209_, _tmp210_, _tmp211_); + ValaCCodeFunction* _tmp236_; + ValaCCodeFunction* _tmp237_; + ValaCCodeExpression* _tmp238_; + ValaCCodeExpression* _tmp239_; + ValaArrayList* _tmp257_; + ValaArrayList* _tmp258_; + _tmp228_ = self->class_init_context; + vala_ccode_base_module_push_context (self, _tmp228_); + _tmp229_ = f; + _tmp230_ = vala_variable_get_initializer ((ValaVariable*) _tmp229_); + _tmp231_ = _tmp230_; + vala_code_node_emit ((ValaCodeNode*) _tmp231_, (ValaCodeGenerator*) self); + _tmp232_ = f; + _tmp233_ = vala_variable_get_initializer ((ValaVariable*) _tmp232_); + _tmp234_ = _tmp233_; + _tmp235_ = vala_ccode_base_module_get_cvalue (self, _tmp234_); + rhs = _tmp235_; + _tmp236_ = vala_ccode_base_module_get_ccode (self); + _tmp237_ = _tmp236_; + _tmp238_ = lhs; + _tmp239_ = rhs; + vala_ccode_function_add_assignment (_tmp237_, _tmp238_, _tmp239_); { - ValaArrayList* _tmp212_; - ValaArrayList* _tmp213_; - ValaArrayList* _tmp214_; + ValaArrayList* _tmp240_; + ValaArrayList* _tmp241_; + ValaArrayList* _tmp242_; ValaArrayList* _value_list; - ValaArrayList* _tmp215_; - gint _tmp216_; - gint _tmp217_; + ValaArrayList* _tmp243_; + gint _tmp244_; + gint _tmp245_; gint _value_size; gint _value_index; - _tmp212_ = vala_ccode_base_module_get_temp_ref_values (self); - _tmp213_ = _tmp212_; - _tmp214_ = _vala_iterable_ref0 (_tmp213_); - _value_list = _tmp214_; - _tmp215_ = _value_list; - _tmp216_ = vala_collection_get_size ((ValaCollection*) _tmp215_); - _tmp217_ = _tmp216_; - _value_size = _tmp217_; + _tmp240_ = vala_ccode_base_module_get_temp_ref_values (self); + _tmp241_ = _tmp240_; + _tmp242_ = _vala_iterable_ref0 (_tmp241_); + _value_list = _tmp242_; + _tmp243_ = _value_list; + _tmp244_ = vala_collection_get_size ((ValaCollection*) _tmp243_); + _tmp245_ = _tmp244_; + _value_size = _tmp245_; _value_index = -1; while (TRUE) { - gint _tmp218_; - gint _tmp219_; - gint _tmp220_; - ValaArrayList* _tmp221_; - gint _tmp222_; - gpointer _tmp223_ = NULL; + gint _tmp246_; + gint _tmp247_; + gint _tmp248_; + ValaArrayList* _tmp249_; + gint _tmp250_; + gpointer _tmp251_ = NULL; ValaTargetValue* value; - ValaCCodeFunction* _tmp224_; - ValaCCodeFunction* _tmp225_; - ValaTargetValue* _tmp226_; - ValaCCodeExpression* _tmp227_ = NULL; - ValaCCodeExpression* _tmp228_; - _tmp218_ = _value_index; - _value_index = _tmp218_ + 1; - _tmp219_ = _value_index; - _tmp220_ = _value_size; - if (!(_tmp219_ < _tmp220_)) { + ValaCCodeFunction* _tmp252_; + ValaCCodeFunction* _tmp253_; + ValaTargetValue* _tmp254_; + ValaCCodeExpression* _tmp255_ = NULL; + ValaCCodeExpression* _tmp256_; + _tmp246_ = _value_index; + _value_index = _tmp246_ + 1; + _tmp247_ = _value_index; + _tmp248_ = _value_size; + if (!(_tmp247_ < _tmp248_)) { break; } - _tmp221_ = _value_list; - _tmp222_ = _value_index; - _tmp223_ = vala_list_get ((ValaList*) _tmp221_, _tmp222_); - value = (ValaTargetValue*) _tmp223_; - _tmp224_ = vala_ccode_base_module_get_ccode (self); - _tmp225_ = _tmp224_; - _tmp226_ = value; - _tmp227_ = vala_ccode_base_module_destroy_value (self, _tmp226_, FALSE); - _tmp228_ = _tmp227_; - vala_ccode_function_add_expression (_tmp225_, _tmp228_); - _vala_ccode_node_unref0 (_tmp228_); + _tmp249_ = _value_list; + _tmp250_ = _value_index; + _tmp251_ = vala_list_get ((ValaList*) _tmp249_, _tmp250_); + value = (ValaTargetValue*) _tmp251_; + _tmp252_ = vala_ccode_base_module_get_ccode (self); + _tmp253_ = _tmp252_; + _tmp254_ = value; + _tmp255_ = vala_ccode_base_module_destroy_value (self, _tmp254_, FALSE); + _tmp256_ = _tmp255_; + vala_ccode_function_add_expression (_tmp253_, _tmp256_); + _vala_ccode_node_unref0 (_tmp256_); _vala_target_value_unref0 (value); } _vala_iterable_unref0 (_value_list); } - _tmp229_ = vala_ccode_base_module_get_temp_ref_values (self); - _tmp230_ = _tmp229_; - vala_collection_clear ((ValaCollection*) _tmp230_); + _tmp257_ = vala_ccode_base_module_get_temp_ref_values (self); + _tmp258_ = _tmp257_; + vala_collection_clear ((ValaCollection*) _tmp258_); vala_ccode_base_module_pop_context (self); _vala_ccode_node_unref0 (rhs); } } else { - ValaField* _tmp231_; - ValaCCodeFile* _tmp232_; - ValaField* _tmp233_; - gboolean _tmp234_ = FALSE; - ValaField* _tmp237_; - gboolean _tmp238_ = FALSE; - ValaField* _tmp241_; - gboolean _tmp242_; - gboolean _tmp243_; - _tmp231_ = f; - _tmp232_ = self->cfile; - vala_ccode_base_module_generate_field_declaration (self, _tmp231_, _tmp232_); - _tmp233_ = f; - _tmp234_ = vala_symbol_is_internal_symbol ((ValaSymbol*) _tmp233_); - if (!_tmp234_) { - ValaField* _tmp235_; - ValaCCodeFile* _tmp236_; - _tmp235_ = f; - _tmp236_ = self->header_file; - vala_ccode_base_module_generate_field_declaration (self, _tmp235_, _tmp236_); + ValaField* _tmp259_; + ValaCCodeFile* _tmp260_; + ValaField* _tmp261_; + gboolean _tmp262_ = FALSE; + ValaField* _tmp265_; + gboolean _tmp266_ = FALSE; + ValaField* _tmp269_; + gboolean _tmp270_; + gboolean _tmp271_; + _tmp259_ = f; + _tmp260_ = self->cfile; + vala_ccode_base_module_generate_field_declaration (self, _tmp259_, _tmp260_); + _tmp261_ = f; + _tmp262_ = vala_symbol_is_internal_symbol ((ValaSymbol*) _tmp261_); + if (!_tmp262_) { + ValaField* _tmp263_; + ValaCCodeFile* _tmp264_; + _tmp263_ = f; + _tmp264_ = self->header_file; + vala_ccode_base_module_generate_field_declaration (self, _tmp263_, _tmp264_); } - _tmp237_ = f; - _tmp238_ = vala_symbol_is_private_symbol ((ValaSymbol*) _tmp237_); - if (!_tmp238_) { - ValaField* _tmp239_; - ValaCCodeFile* _tmp240_; - _tmp239_ = f; - _tmp240_ = self->internal_header_file; - vala_ccode_base_module_generate_field_declaration (self, _tmp239_, _tmp240_); + _tmp265_ = f; + _tmp266_ = vala_symbol_is_private_symbol ((ValaSymbol*) _tmp265_); + if (!_tmp266_) { + ValaField* _tmp267_; + ValaCCodeFile* _tmp268_; + _tmp267_ = f; + _tmp268_ = self->internal_header_file; + vala_ccode_base_module_generate_field_declaration (self, _tmp267_, _tmp268_); } - _tmp241_ = f; - _tmp242_ = vala_symbol_get_external ((ValaSymbol*) _tmp241_); - _tmp243_ = _tmp242_; - if (!_tmp243_) { - ValaField* _tmp244_; - gchar* _tmp245_ = NULL; - gchar* _tmp246_; - ValaCCodeIdentifier* _tmp247_; - ValaField* _tmp248_; - gchar* _tmp249_ = NULL; - gchar* _tmp250_; - ValaField* _tmp251_; - ValaDataType* _tmp252_; - ValaDataType* _tmp253_; - gchar* _tmp254_ = NULL; - gchar* _tmp255_; - ValaCCodeVariableDeclarator* _tmp256_; - ValaCCodeVariableDeclarator* _tmp257_; + _tmp269_ = f; + _tmp270_ = vala_symbol_get_external ((ValaSymbol*) _tmp269_); + _tmp271_ = _tmp270_; + if (!_tmp271_) { + ValaField* _tmp272_; + gchar* _tmp273_ = NULL; + gchar* _tmp274_; + ValaCCodeIdentifier* _tmp275_; + ValaField* _tmp276_; + gchar* _tmp277_ = NULL; + gchar* _tmp278_; + ValaField* _tmp279_; + ValaDataType* _tmp280_; + ValaDataType* _tmp281_; + gchar* _tmp282_ = NULL; + gchar* _tmp283_; + ValaCCodeVariableDeclarator* _tmp284_; + ValaCCodeVariableDeclarator* _tmp285_; ValaCCodeVariableDeclarator* var_decl; - ValaCCodeVariableDeclarator* _tmp258_; - ValaField* _tmp259_; - ValaDataType* _tmp260_; - ValaDataType* _tmp261_; - ValaCCodeExpression* _tmp262_ = NULL; - ValaCCodeExpression* _tmp263_; - ValaCCodeBaseModuleEmitContext* _tmp264_; - ValaField* _tmp268_; - ValaExpression* _tmp269_; - ValaExpression* _tmp270_; - const gchar* _tmp282_; - ValaCCodeDeclaration* _tmp283_; + ValaCCodeVariableDeclarator* _tmp286_; + ValaField* _tmp287_; + ValaDataType* _tmp288_; + ValaDataType* _tmp289_; + ValaCCodeExpression* _tmp290_ = NULL; + ValaCCodeExpression* _tmp291_; + ValaCCodeBaseModuleEmitContext* _tmp292_; + ValaField* _tmp296_; + ValaExpression* _tmp297_; + ValaExpression* _tmp298_; + const gchar* _tmp310_; + ValaCCodeDeclaration* _tmp311_; ValaCCodeDeclaration* var_def; - ValaCCodeDeclaration* _tmp284_; - ValaCCodeVariableDeclarator* _tmp285_; - ValaField* _tmp286_; - gboolean _tmp287_ = FALSE; - ValaCCodeFile* _tmp290_; - ValaCCodeDeclaration* _tmp291_; - gboolean _tmp292_ = FALSE; - ValaField* _tmp293_; - ValaDataType* _tmp294_; - ValaDataType* _tmp295_; - gboolean _tmp298_; - ValaField* _tmp411_; - ValaExpression* _tmp412_; - ValaExpression* _tmp413_; - _tmp244_ = f; - _tmp245_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp244_); - _tmp246_ = _tmp245_; - _tmp247_ = vala_ccode_identifier_new (_tmp246_); + ValaCCodeDeclaration* _tmp312_; + ValaCCodeVariableDeclarator* _tmp313_; + ValaField* _tmp314_; + gboolean _tmp315_ = FALSE; + ValaCCodeFile* _tmp318_; + ValaCCodeDeclaration* _tmp319_; + gboolean _tmp320_ = FALSE; + ValaField* _tmp321_; + ValaDataType* _tmp322_; + ValaDataType* _tmp323_; + gboolean _tmp326_; + ValaField* _tmp439_; + ValaExpression* _tmp440_; + ValaExpression* _tmp441_; + _tmp272_ = f; + _tmp273_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp272_); + _tmp274_ = _tmp273_; + _tmp275_ = vala_ccode_identifier_new (_tmp274_); _vala_ccode_node_unref0 (lhs); - lhs = (ValaCCodeExpression*) _tmp247_; - _g_free0 (_tmp246_); - _tmp248_ = f; - _tmp249_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp248_); - _tmp250_ = _tmp249_; - _tmp251_ = f; - _tmp252_ = vala_variable_get_variable_type ((ValaVariable*) _tmp251_); - _tmp253_ = _tmp252_; - _tmp254_ = vala_ccode_base_module_get_ccode_declarator_suffix (_tmp253_); - _tmp255_ = _tmp254_; - _tmp256_ = vala_ccode_variable_declarator_new (_tmp250_, NULL, _tmp255_); - _tmp257_ = _tmp256_; - _g_free0 (_tmp255_); - _g_free0 (_tmp250_); - var_decl = _tmp257_; - _tmp258_ = var_decl; - _tmp259_ = f; - _tmp260_ = vala_variable_get_variable_type ((ValaVariable*) _tmp259_); - _tmp261_ = _tmp260_; - _tmp262_ = vala_ccode_base_module_default_value_for_type (self, _tmp261_, TRUE); - _tmp263_ = _tmp262_; - vala_ccode_variable_declarator_set_initializer (_tmp258_, _tmp263_); - _vala_ccode_node_unref0 (_tmp263_); - _tmp264_ = self->class_init_context; - if (_tmp264_ != NULL) { - ValaCCodeBaseModuleEmitContext* _tmp265_; - _tmp265_ = self->class_init_context; - vala_ccode_base_module_push_context (self, _tmp265_); + lhs = (ValaCCodeExpression*) _tmp275_; + _g_free0 (_tmp274_); + _tmp276_ = f; + _tmp277_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp276_); + _tmp278_ = _tmp277_; + _tmp279_ = f; + _tmp280_ = vala_variable_get_variable_type ((ValaVariable*) _tmp279_); + _tmp281_ = _tmp280_; + _tmp282_ = vala_ccode_base_module_get_ccode_declarator_suffix (_tmp281_); + _tmp283_ = _tmp282_; + _tmp284_ = vala_ccode_variable_declarator_new (_tmp278_, NULL, _tmp283_); + _tmp285_ = _tmp284_; + _g_free0 (_tmp283_); + _g_free0 (_tmp278_); + var_decl = _tmp285_; + _tmp286_ = var_decl; + _tmp287_ = f; + _tmp288_ = vala_variable_get_variable_type ((ValaVariable*) _tmp287_); + _tmp289_ = _tmp288_; + _tmp290_ = vala_ccode_base_module_default_value_for_type (self, _tmp289_, TRUE); + _tmp291_ = _tmp290_; + vala_ccode_variable_declarator_set_initializer (_tmp286_, _tmp291_); + _vala_ccode_node_unref0 (_tmp291_); + _tmp292_ = self->class_init_context; + if (_tmp292_ != NULL) { + ValaCCodeBaseModuleEmitContext* _tmp293_; + _tmp293_ = self->class_init_context; + vala_ccode_base_module_push_context (self, _tmp293_); } else { - ValaCCodeBaseModuleEmitContext* _tmp266_; - ValaCCodeBaseModuleEmitContext* _tmp267_; - _tmp266_ = vala_ccode_base_module_emit_context_new (NULL); - _tmp267_ = _tmp266_; - vala_ccode_base_module_push_context (self, _tmp267_); - _vala_ccode_base_module_emit_context_unref0 (_tmp267_); + ValaCCodeBaseModuleEmitContext* _tmp294_; + ValaCCodeBaseModuleEmitContext* _tmp295_; + _tmp294_ = vala_ccode_base_module_emit_context_new (NULL); + _tmp295_ = _tmp294_; + vala_ccode_base_module_push_context (self, _tmp295_); + _vala_ccode_base_module_emit_context_unref0 (_tmp295_); } - _tmp268_ = f; - _tmp269_ = vala_variable_get_initializer ((ValaVariable*) _tmp268_); - _tmp270_ = _tmp269_; - if (_tmp270_ != NULL) { - ValaField* _tmp271_; - ValaExpression* _tmp272_; - ValaExpression* _tmp273_; - ValaField* _tmp274_; - ValaExpression* _tmp275_; - ValaExpression* _tmp276_; - ValaCCodeExpression* _tmp277_ = NULL; + _tmp296_ = f; + _tmp297_ = vala_variable_get_initializer ((ValaVariable*) _tmp296_); + _tmp298_ = _tmp297_; + if (_tmp298_ != NULL) { + ValaField* _tmp299_; + ValaExpression* _tmp300_; + ValaExpression* _tmp301_; + ValaField* _tmp302_; + ValaExpression* _tmp303_; + ValaExpression* _tmp304_; + ValaCCodeExpression* _tmp305_ = NULL; ValaCCodeExpression* init; - ValaCCodeExpression* _tmp278_; - gboolean _tmp279_ = FALSE; - _tmp271_ = f; - _tmp272_ = vala_variable_get_initializer ((ValaVariable*) _tmp271_); - _tmp273_ = _tmp272_; - vala_code_node_emit ((ValaCodeNode*) _tmp273_, (ValaCodeGenerator*) self); - _tmp274_ = f; - _tmp275_ = vala_variable_get_initializer ((ValaVariable*) _tmp274_); - _tmp276_ = _tmp275_; - _tmp277_ = vala_ccode_base_module_get_cvalue (self, _tmp276_); - init = _tmp277_; - _tmp278_ = init; - _tmp279_ = vala_ccode_base_module_is_constant_ccode_expression (self, _tmp278_); - if (_tmp279_) { - ValaCCodeVariableDeclarator* _tmp280_; - ValaCCodeExpression* _tmp281_; - _tmp280_ = var_decl; - _tmp281_ = init; - vala_ccode_variable_declarator_set_initializer (_tmp280_, _tmp281_); + ValaCCodeExpression* _tmp306_; + gboolean _tmp307_ = FALSE; + _tmp299_ = f; + _tmp300_ = vala_variable_get_initializer ((ValaVariable*) _tmp299_); + _tmp301_ = _tmp300_; + vala_code_node_emit ((ValaCodeNode*) _tmp301_, (ValaCodeGenerator*) self); + _tmp302_ = f; + _tmp303_ = vala_variable_get_initializer ((ValaVariable*) _tmp302_); + _tmp304_ = _tmp303_; + _tmp305_ = vala_ccode_base_module_get_cvalue (self, _tmp304_); + init = _tmp305_; + _tmp306_ = init; + _tmp307_ = vala_ccode_base_module_is_constant_ccode_expression (self, _tmp306_); + if (_tmp307_) { + ValaCCodeVariableDeclarator* _tmp308_; + ValaCCodeExpression* _tmp309_; + _tmp308_ = var_decl; + _tmp309_ = init; + vala_ccode_variable_declarator_set_initializer (_tmp308_, _tmp309_); } _vala_ccode_node_unref0 (init); } - _tmp282_ = field_ctype; - _tmp283_ = vala_ccode_declaration_new (_tmp282_); - var_def = _tmp283_; - _tmp284_ = var_def; - _tmp285_ = var_decl; - vala_ccode_declaration_add_declarator (_tmp284_, (ValaCCodeDeclarator*) _tmp285_); - _tmp286_ = f; - _tmp287_ = vala_symbol_is_private_symbol ((ValaSymbol*) _tmp286_); - if (!_tmp287_) { - ValaCCodeDeclaration* _tmp288_; - _tmp288_ = var_def; - vala_ccode_declaration_set_modifiers (_tmp288_, VALA_CCODE_MODIFIERS_EXTERN); + _tmp310_ = field_ctype; + _tmp311_ = vala_ccode_declaration_new (_tmp310_); + var_def = _tmp311_; + _tmp312_ = var_def; + _tmp313_ = var_decl; + vala_ccode_declaration_add_declarator (_tmp312_, (ValaCCodeDeclarator*) _tmp313_); + _tmp314_ = f; + _tmp315_ = vala_symbol_is_private_symbol ((ValaSymbol*) _tmp314_); + if (!_tmp315_) { + ValaCCodeDeclaration* _tmp316_; + _tmp316_ = var_def; + vala_ccode_declaration_set_modifiers (_tmp316_, VALA_CCODE_MODIFIERS_EXTERN); } else { - ValaCCodeDeclaration* _tmp289_; - _tmp289_ = var_def; - vala_ccode_declaration_set_modifiers (_tmp289_, VALA_CCODE_MODIFIERS_STATIC); + ValaCCodeDeclaration* _tmp317_; + _tmp317_ = var_def; + vala_ccode_declaration_set_modifiers (_tmp317_, VALA_CCODE_MODIFIERS_STATIC); } - _tmp290_ = self->cfile; - _tmp291_ = var_def; - vala_ccode_file_add_type_member_declaration (_tmp290_, (ValaCCodeNode*) _tmp291_); - _tmp293_ = f; - _tmp294_ = vala_variable_get_variable_type ((ValaVariable*) _tmp293_); - _tmp295_ = _tmp294_; - if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp295_, VALA_TYPE_ARRAY_TYPE)) { - ValaField* _tmp296_; - gboolean _tmp297_ = FALSE; - _tmp296_ = f; - _tmp297_ = vala_ccode_base_module_get_ccode_array_length ((ValaCodeNode*) _tmp296_); - _tmp292_ = _tmp297_; + _tmp318_ = self->cfile; + _tmp319_ = var_def; + vala_ccode_file_add_type_member_declaration (_tmp318_, (ValaCCodeNode*) _tmp319_); + _tmp321_ = f; + _tmp322_ = vala_variable_get_variable_type ((ValaVariable*) _tmp321_); + _tmp323_ = _tmp322_; + if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp323_, VALA_TYPE_ARRAY_TYPE)) { + ValaField* _tmp324_; + gboolean _tmp325_ = FALSE; + _tmp324_ = f; + _tmp325_ = vala_ccode_base_module_get_ccode_array_length ((ValaCodeNode*) _tmp324_); + _tmp320_ = _tmp325_; } else { - _tmp292_ = FALSE; + _tmp320_ = FALSE; } - _tmp298_ = _tmp292_; - if (_tmp298_) { - ValaField* _tmp299_; - ValaDataType* _tmp300_; - ValaDataType* _tmp301_; - ValaArrayType* _tmp302_; + _tmp326_ = _tmp320_; + if (_tmp326_) { + ValaField* _tmp327_; + ValaDataType* _tmp328_; + ValaDataType* _tmp329_; + ValaArrayType* _tmp330_; ValaArrayType* array_type; - ValaArrayType* _tmp303_; - gboolean _tmp304_; - gboolean _tmp305_; - _tmp299_ = f; - _tmp300_ = vala_variable_get_variable_type ((ValaVariable*) _tmp299_); - _tmp301_ = _tmp300_; - _tmp302_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp301_, VALA_TYPE_ARRAY_TYPE, ValaArrayType)); - array_type = _tmp302_; - _tmp303_ = array_type; - _tmp304_ = vala_array_type_get_fixed_length (_tmp303_); - _tmp305_ = _tmp304_; - if (!_tmp305_) { - gboolean _tmp337_ = FALSE; - ValaArrayType* _tmp338_; - gint _tmp339_; - gint _tmp340_; - gboolean _tmp343_; + ValaArrayType* _tmp331_; + gboolean _tmp332_; + gboolean _tmp333_; + _tmp327_ = f; + _tmp328_ = vala_variable_get_variable_type ((ValaVariable*) _tmp327_); + _tmp329_ = _tmp328_; + _tmp330_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp329_, VALA_TYPE_ARRAY_TYPE, ValaArrayType)); + array_type = _tmp330_; + _tmp331_ = array_type; + _tmp332_ = vala_array_type_get_fixed_length (_tmp331_); + _tmp333_ = _tmp332_; + if (!_tmp333_) { + gboolean _tmp365_ = FALSE; + ValaArrayType* _tmp366_; + gint _tmp367_; + gint _tmp368_; + gboolean _tmp371_; { gint dim; dim = 1; { - gboolean _tmp306_; - _tmp306_ = TRUE; + gboolean _tmp334_; + _tmp334_ = TRUE; while (TRUE) { - gboolean _tmp307_; - gint _tmp309_; - ValaArrayType* _tmp310_; - gint _tmp311_; - gint _tmp312_; - ValaDataType* _tmp313_; - ValaDataType* _tmp314_ = NULL; + gboolean _tmp335_; + gint _tmp337_; + ValaArrayType* _tmp338_; + gint _tmp339_; + gint _tmp340_; + ValaDataType* _tmp341_; + ValaDataType* _tmp342_ = NULL; ValaDataType* len_type; - ValaDataType* _tmp315_; - gchar* _tmp316_ = NULL; - gchar* _tmp317_; - ValaCCodeDeclaration* _tmp318_; - ValaCCodeDeclaration* _tmp319_; + ValaDataType* _tmp343_; + gchar* _tmp344_ = NULL; + gchar* _tmp345_; + ValaCCodeDeclaration* _tmp346_; + ValaCCodeDeclaration* _tmp347_; ValaCCodeDeclaration* len_def; - ValaCCodeDeclaration* _tmp320_; - ValaField* _tmp321_; - gchar* _tmp322_ = NULL; - gchar* _tmp323_; - gint _tmp324_; - gchar* _tmp325_ = NULL; - gchar* _tmp326_; - ValaCCodeConstant* _tmp327_; - ValaCCodeConstant* _tmp328_; - ValaCCodeVariableDeclarator* _tmp329_; - ValaCCodeVariableDeclarator* _tmp330_; - ValaField* _tmp331_; - gboolean _tmp332_ = FALSE; - ValaCCodeFile* _tmp335_; - ValaCCodeDeclaration* _tmp336_; - _tmp307_ = _tmp306_; - if (!_tmp307_) { - gint _tmp308_; - _tmp308_ = dim; - dim = _tmp308_ + 1; + ValaCCodeDeclaration* _tmp348_; + ValaField* _tmp349_; + gchar* _tmp350_ = NULL; + gchar* _tmp351_; + gint _tmp352_; + gchar* _tmp353_ = NULL; + gchar* _tmp354_; + ValaCCodeConstant* _tmp355_; + ValaCCodeConstant* _tmp356_; + ValaCCodeVariableDeclarator* _tmp357_; + ValaCCodeVariableDeclarator* _tmp358_; + ValaField* _tmp359_; + gboolean _tmp360_ = FALSE; + ValaCCodeFile* _tmp363_; + ValaCCodeDeclaration* _tmp364_; + _tmp335_ = _tmp334_; + if (!_tmp335_) { + gint _tmp336_; + _tmp336_ = dim; + dim = _tmp336_ + 1; } - _tmp306_ = FALSE; - _tmp309_ = dim; - _tmp310_ = array_type; - _tmp311_ = vala_array_type_get_rank (_tmp310_); - _tmp312_ = _tmp311_; - if (!(_tmp309_ <= _tmp312_)) { + _tmp334_ = FALSE; + _tmp337_ = dim; + _tmp338_ = array_type; + _tmp339_ = vala_array_type_get_rank (_tmp338_); + _tmp340_ = _tmp339_; + if (!(_tmp337_ <= _tmp340_)) { break; } - _tmp313_ = self->int_type; - _tmp314_ = vala_data_type_copy (_tmp313_); - len_type = _tmp314_; - _tmp315_ = len_type; - _tmp316_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp315_); - _tmp317_ = _tmp316_; - _tmp318_ = vala_ccode_declaration_new (_tmp317_); - _tmp319_ = _tmp318_; - _g_free0 (_tmp317_); - len_def = _tmp319_; - _tmp320_ = len_def; - _tmp321_ = f; - _tmp322_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp321_); - _tmp323_ = _tmp322_; - _tmp324_ = dim; - _tmp325_ = vala_ccode_base_module_get_array_length_cname (self, _tmp323_, _tmp324_); - _tmp326_ = _tmp325_; - _tmp327_ = vala_ccode_constant_new ("0"); - _tmp328_ = _tmp327_; - _tmp329_ = vala_ccode_variable_declarator_new (_tmp326_, (ValaCCodeExpression*) _tmp328_, NULL); - _tmp330_ = _tmp329_; - vala_ccode_declaration_add_declarator (_tmp320_, (ValaCCodeDeclarator*) _tmp330_); - _vala_ccode_node_unref0 (_tmp330_); - _vala_ccode_node_unref0 (_tmp328_); - _g_free0 (_tmp326_); - _g_free0 (_tmp323_); - _tmp331_ = f; - _tmp332_ = vala_symbol_is_private_symbol ((ValaSymbol*) _tmp331_); - if (!_tmp332_) { - ValaCCodeDeclaration* _tmp333_; - _tmp333_ = len_def; - vala_ccode_declaration_set_modifiers (_tmp333_, VALA_CCODE_MODIFIERS_EXTERN); + _tmp341_ = self->int_type; + _tmp342_ = vala_data_type_copy (_tmp341_); + len_type = _tmp342_; + _tmp343_ = len_type; + _tmp344_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp343_); + _tmp345_ = _tmp344_; + _tmp346_ = vala_ccode_declaration_new (_tmp345_); + _tmp347_ = _tmp346_; + _g_free0 (_tmp345_); + len_def = _tmp347_; + _tmp348_ = len_def; + _tmp349_ = f; + _tmp350_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp349_); + _tmp351_ = _tmp350_; + _tmp352_ = dim; + _tmp353_ = vala_ccode_base_module_get_array_length_cname (self, _tmp351_, _tmp352_); + _tmp354_ = _tmp353_; + _tmp355_ = vala_ccode_constant_new ("0"); + _tmp356_ = _tmp355_; + _tmp357_ = vala_ccode_variable_declarator_new (_tmp354_, (ValaCCodeExpression*) _tmp356_, NULL); + _tmp358_ = _tmp357_; + vala_ccode_declaration_add_declarator (_tmp348_, (ValaCCodeDeclarator*) _tmp358_); + _vala_ccode_node_unref0 (_tmp358_); + _vala_ccode_node_unref0 (_tmp356_); + _g_free0 (_tmp354_); + _g_free0 (_tmp351_); + _tmp359_ = f; + _tmp360_ = vala_symbol_is_private_symbol ((ValaSymbol*) _tmp359_); + if (!_tmp360_) { + ValaCCodeDeclaration* _tmp361_; + _tmp361_ = len_def; + vala_ccode_declaration_set_modifiers (_tmp361_, VALA_CCODE_MODIFIERS_EXTERN); } else { - ValaCCodeDeclaration* _tmp334_; - _tmp334_ = len_def; - vala_ccode_declaration_set_modifiers (_tmp334_, VALA_CCODE_MODIFIERS_STATIC); + ValaCCodeDeclaration* _tmp362_; + _tmp362_ = len_def; + vala_ccode_declaration_set_modifiers (_tmp362_, VALA_CCODE_MODIFIERS_STATIC); } - _tmp335_ = self->cfile; - _tmp336_ = len_def; - vala_ccode_file_add_type_member_declaration (_tmp335_, (ValaCCodeNode*) _tmp336_); + _tmp363_ = self->cfile; + _tmp364_ = len_def; + vala_ccode_file_add_type_member_declaration (_tmp363_, (ValaCCodeNode*) _tmp364_); _vala_ccode_node_unref0 (len_def); _vala_code_node_unref0 (len_type); } } } - _tmp338_ = array_type; - _tmp339_ = vala_array_type_get_rank (_tmp338_); - _tmp340_ = _tmp339_; - if (_tmp340_ == 1) { - ValaField* _tmp341_; - gboolean _tmp342_ = FALSE; - _tmp341_ = f; - _tmp342_ = vala_symbol_is_internal_symbol ((ValaSymbol*) _tmp341_); - _tmp337_ = _tmp342_; + _tmp366_ = array_type; + _tmp367_ = vala_array_type_get_rank (_tmp366_); + _tmp368_ = _tmp367_; + if (_tmp368_ == 1) { + ValaField* _tmp369_; + gboolean _tmp370_ = FALSE; + _tmp369_ = f; + _tmp370_ = vala_symbol_is_internal_symbol ((ValaSymbol*) _tmp369_); + _tmp365_ = _tmp370_; } else { - _tmp337_ = FALSE; + _tmp365_ = FALSE; } - _tmp343_ = _tmp337_; - if (_tmp343_) { - ValaDataType* _tmp344_; - ValaDataType* _tmp345_ = NULL; + _tmp371_ = _tmp365_; + if (_tmp371_) { + ValaDataType* _tmp372_; + ValaDataType* _tmp373_ = NULL; ValaDataType* len_type; - ValaDataType* _tmp346_; - gchar* _tmp347_ = NULL; - gchar* _tmp348_; - ValaCCodeDeclaration* _tmp349_; - ValaCCodeDeclaration* _tmp350_; + ValaDataType* _tmp374_; + gchar* _tmp375_ = NULL; + gchar* _tmp376_; + ValaCCodeDeclaration* _tmp377_; + ValaCCodeDeclaration* _tmp378_; ValaCCodeDeclaration* _cdecl_; - ValaCCodeDeclaration* _tmp351_; - ValaField* _tmp352_; - gchar* _tmp353_ = NULL; - gchar* _tmp354_; - gchar* _tmp355_ = NULL; - gchar* _tmp356_; - ValaCCodeConstant* _tmp357_; - ValaCCodeConstant* _tmp358_; - ValaCCodeVariableDeclarator* _tmp359_; - ValaCCodeVariableDeclarator* _tmp360_; - ValaCCodeDeclaration* _tmp361_; - ValaCCodeFile* _tmp362_; - ValaCCodeDeclaration* _tmp363_; - _tmp344_ = self->int_type; - _tmp345_ = vala_data_type_copy (_tmp344_); - len_type = _tmp345_; - _tmp346_ = len_type; - _tmp347_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp346_); - _tmp348_ = _tmp347_; - _tmp349_ = vala_ccode_declaration_new (_tmp348_); - _tmp350_ = _tmp349_; - _g_free0 (_tmp348_); - _cdecl_ = _tmp350_; - _tmp351_ = _cdecl_; - _tmp352_ = f; - _tmp353_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp352_); - _tmp354_ = _tmp353_; - _tmp355_ = vala_ccode_base_module_get_array_size_cname (self, _tmp354_); - _tmp356_ = _tmp355_; - _tmp357_ = vala_ccode_constant_new ("0"); - _tmp358_ = _tmp357_; - _tmp359_ = vala_ccode_variable_declarator_new (_tmp356_, (ValaCCodeExpression*) _tmp358_, NULL); - _tmp360_ = _tmp359_; - vala_ccode_declaration_add_declarator (_tmp351_, (ValaCCodeDeclarator*) _tmp360_); - _vala_ccode_node_unref0 (_tmp360_); - _vala_ccode_node_unref0 (_tmp358_); - _g_free0 (_tmp356_); - _g_free0 (_tmp354_); - _tmp361_ = _cdecl_; - vala_ccode_declaration_set_modifiers (_tmp361_, VALA_CCODE_MODIFIERS_STATIC); - _tmp362_ = self->cfile; - _tmp363_ = _cdecl_; - vala_ccode_file_add_type_member_declaration (_tmp362_, (ValaCCodeNode*) _tmp363_); + ValaCCodeDeclaration* _tmp379_; + ValaField* _tmp380_; + gchar* _tmp381_ = NULL; + gchar* _tmp382_; + gchar* _tmp383_ = NULL; + gchar* _tmp384_; + ValaCCodeConstant* _tmp385_; + ValaCCodeConstant* _tmp386_; + ValaCCodeVariableDeclarator* _tmp387_; + ValaCCodeVariableDeclarator* _tmp388_; + ValaCCodeDeclaration* _tmp389_; + ValaCCodeFile* _tmp390_; + ValaCCodeDeclaration* _tmp391_; + _tmp372_ = self->int_type; + _tmp373_ = vala_data_type_copy (_tmp372_); + len_type = _tmp373_; + _tmp374_ = len_type; + _tmp375_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp374_); + _tmp376_ = _tmp375_; + _tmp377_ = vala_ccode_declaration_new (_tmp376_); + _tmp378_ = _tmp377_; + _g_free0 (_tmp376_); + _cdecl_ = _tmp378_; + _tmp379_ = _cdecl_; + _tmp380_ = f; + _tmp381_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp380_); + _tmp382_ = _tmp381_; + _tmp383_ = vala_ccode_base_module_get_array_size_cname (self, _tmp382_); + _tmp384_ = _tmp383_; + _tmp385_ = vala_ccode_constant_new ("0"); + _tmp386_ = _tmp385_; + _tmp387_ = vala_ccode_variable_declarator_new (_tmp384_, (ValaCCodeExpression*) _tmp386_, NULL); + _tmp388_ = _tmp387_; + vala_ccode_declaration_add_declarator (_tmp379_, (ValaCCodeDeclarator*) _tmp388_); + _vala_ccode_node_unref0 (_tmp388_); + _vala_ccode_node_unref0 (_tmp386_); + _g_free0 (_tmp384_); + _g_free0 (_tmp382_); + _tmp389_ = _cdecl_; + vala_ccode_declaration_set_modifiers (_tmp389_, VALA_CCODE_MODIFIERS_STATIC); + _tmp390_ = self->cfile; + _tmp391_ = _cdecl_; + vala_ccode_file_add_type_member_declaration (_tmp390_, (ValaCCodeNode*) _tmp391_); _vala_ccode_node_unref0 (_cdecl_); _vala_code_node_unref0 (len_type); } } _vala_code_node_unref0 (array_type); } else { - ValaField* _tmp364_; - ValaDataType* _tmp365_; - ValaDataType* _tmp366_; - _tmp364_ = f; - _tmp365_ = vala_variable_get_variable_type ((ValaVariable*) _tmp364_); - _tmp366_ = _tmp365_; - if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp366_, VALA_TYPE_DELEGATE_TYPE)) { - ValaField* _tmp367_; - ValaDataType* _tmp368_; - ValaDataType* _tmp369_; - ValaDelegateType* _tmp370_; + ValaField* _tmp392_; + ValaDataType* _tmp393_; + ValaDataType* _tmp394_; + _tmp392_ = f; + _tmp393_ = vala_variable_get_variable_type ((ValaVariable*) _tmp392_); + _tmp394_ = _tmp393_; + if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp394_, VALA_TYPE_DELEGATE_TYPE)) { + ValaField* _tmp395_; + ValaDataType* _tmp396_; + ValaDataType* _tmp397_; + ValaDelegateType* _tmp398_; ValaDelegateType* delegate_type; - ValaDelegateType* _tmp371_; - ValaDelegate* _tmp372_; - ValaDelegate* _tmp373_; - gboolean _tmp374_; - gboolean _tmp375_; - _tmp367_ = f; - _tmp368_ = vala_variable_get_variable_type ((ValaVariable*) _tmp367_); - _tmp369_ = _tmp368_; - _tmp370_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp369_, VALA_TYPE_DELEGATE_TYPE, ValaDelegateType)); - delegate_type = _tmp370_; - _tmp371_ = delegate_type; - _tmp372_ = vala_delegate_type_get_delegate_symbol (_tmp371_); - _tmp373_ = _tmp372_; - _tmp374_ = vala_delegate_get_has_target (_tmp373_); - _tmp375_ = _tmp374_; - if (_tmp375_) { - ValaCCodeDeclaration* _tmp376_; + ValaDelegateType* _tmp399_; + ValaDelegate* _tmp400_; + ValaDelegate* _tmp401_; + gboolean _tmp402_; + gboolean _tmp403_; + _tmp395_ = f; + _tmp396_ = vala_variable_get_variable_type ((ValaVariable*) _tmp395_); + _tmp397_ = _tmp396_; + _tmp398_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp397_, VALA_TYPE_DELEGATE_TYPE, ValaDelegateType)); + delegate_type = _tmp398_; + _tmp399_ = delegate_type; + _tmp400_ = vala_delegate_type_get_delegate_symbol (_tmp399_); + _tmp401_ = _tmp400_; + _tmp402_ = vala_delegate_get_has_target (_tmp401_); + _tmp403_ = _tmp402_; + if (_tmp403_) { + ValaCCodeDeclaration* _tmp404_; ValaCCodeDeclaration* target_def; - ValaCCodeDeclaration* _tmp377_; - ValaField* _tmp378_; - gchar* _tmp379_ = NULL; - gchar* _tmp380_; - ValaCCodeConstant* _tmp381_; - ValaCCodeConstant* _tmp382_; - ValaCCodeVariableDeclarator* _tmp383_; - ValaCCodeVariableDeclarator* _tmp384_; - ValaField* _tmp385_; - gboolean _tmp386_ = FALSE; - ValaCCodeFile* _tmp389_; - ValaCCodeDeclaration* _tmp390_; - ValaDelegateType* _tmp391_; - gboolean _tmp392_; - gboolean _tmp393_; - _tmp376_ = vala_ccode_declaration_new ("gpointer"); - target_def = _tmp376_; - _tmp377_ = target_def; - _tmp378_ = f; - _tmp379_ = vala_ccode_base_module_get_ccode_delegate_target_name ((ValaVariable*) _tmp378_); - _tmp380_ = _tmp379_; - _tmp381_ = vala_ccode_constant_new ("NULL"); - _tmp382_ = _tmp381_; - _tmp383_ = vala_ccode_variable_declarator_new (_tmp380_, (ValaCCodeExpression*) _tmp382_, NULL); - _tmp384_ = _tmp383_; - vala_ccode_declaration_add_declarator (_tmp377_, (ValaCCodeDeclarator*) _tmp384_); - _vala_ccode_node_unref0 (_tmp384_); - _vala_ccode_node_unref0 (_tmp382_); - _g_free0 (_tmp380_); - _tmp385_ = f; - _tmp386_ = vala_symbol_is_private_symbol ((ValaSymbol*) _tmp385_); - if (!_tmp386_) { - ValaCCodeDeclaration* _tmp387_; - _tmp387_ = target_def; - vala_ccode_declaration_set_modifiers (_tmp387_, VALA_CCODE_MODIFIERS_EXTERN); + ValaCCodeDeclaration* _tmp405_; + ValaField* _tmp406_; + gchar* _tmp407_ = NULL; + gchar* _tmp408_; + ValaCCodeConstant* _tmp409_; + ValaCCodeConstant* _tmp410_; + ValaCCodeVariableDeclarator* _tmp411_; + ValaCCodeVariableDeclarator* _tmp412_; + ValaField* _tmp413_; + gboolean _tmp414_ = FALSE; + ValaCCodeFile* _tmp417_; + ValaCCodeDeclaration* _tmp418_; + ValaDelegateType* _tmp419_; + gboolean _tmp420_; + gboolean _tmp421_; + _tmp404_ = vala_ccode_declaration_new ("gpointer"); + target_def = _tmp404_; + _tmp405_ = target_def; + _tmp406_ = f; + _tmp407_ = vala_ccode_base_module_get_ccode_delegate_target_name ((ValaVariable*) _tmp406_); + _tmp408_ = _tmp407_; + _tmp409_ = vala_ccode_constant_new ("NULL"); + _tmp410_ = _tmp409_; + _tmp411_ = vala_ccode_variable_declarator_new (_tmp408_, (ValaCCodeExpression*) _tmp410_, NULL); + _tmp412_ = _tmp411_; + vala_ccode_declaration_add_declarator (_tmp405_, (ValaCCodeDeclarator*) _tmp412_); + _vala_ccode_node_unref0 (_tmp412_); + _vala_ccode_node_unref0 (_tmp410_); + _g_free0 (_tmp408_); + _tmp413_ = f; + _tmp414_ = vala_symbol_is_private_symbol ((ValaSymbol*) _tmp413_); + if (!_tmp414_) { + ValaCCodeDeclaration* _tmp415_; + _tmp415_ = target_def; + vala_ccode_declaration_set_modifiers (_tmp415_, VALA_CCODE_MODIFIERS_EXTERN); } else { - ValaCCodeDeclaration* _tmp388_; - _tmp388_ = target_def; - vala_ccode_declaration_set_modifiers (_tmp388_, VALA_CCODE_MODIFIERS_STATIC); + ValaCCodeDeclaration* _tmp416_; + _tmp416_ = target_def; + vala_ccode_declaration_set_modifiers (_tmp416_, VALA_CCODE_MODIFIERS_STATIC); } - _tmp389_ = self->cfile; - _tmp390_ = target_def; - vala_ccode_file_add_type_member_declaration (_tmp389_, (ValaCCodeNode*) _tmp390_); - _tmp391_ = delegate_type; - _tmp392_ = vala_data_type_get_value_owned ((ValaDataType*) _tmp391_); - _tmp393_ = _tmp392_; - if (_tmp393_) { - ValaCCodeDeclaration* _tmp394_; + _tmp417_ = self->cfile; + _tmp418_ = target_def; + vala_ccode_file_add_type_member_declaration (_tmp417_, (ValaCCodeNode*) _tmp418_); + _tmp419_ = delegate_type; + _tmp420_ = vala_data_type_get_value_owned ((ValaDataType*) _tmp419_); + _tmp421_ = _tmp420_; + if (_tmp421_) { + ValaCCodeDeclaration* _tmp422_; ValaCCodeDeclaration* target_destroy_notify_def; - ValaCCodeDeclaration* _tmp395_; - ValaField* _tmp396_; - gchar* _tmp397_ = NULL; - gchar* _tmp398_; - gchar* _tmp399_ = NULL; - gchar* _tmp400_; - ValaCCodeConstant* _tmp401_; - ValaCCodeConstant* _tmp402_; - ValaCCodeVariableDeclarator* _tmp403_; - ValaCCodeVariableDeclarator* _tmp404_; - ValaField* _tmp405_; - gboolean _tmp406_ = FALSE; - ValaCCodeFile* _tmp409_; - ValaCCodeDeclaration* _tmp410_; - _tmp394_ = vala_ccode_declaration_new ("GDestroyNotify"); - target_destroy_notify_def = _tmp394_; - _tmp395_ = target_destroy_notify_def; - _tmp396_ = f; - _tmp397_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp396_); - _tmp398_ = _tmp397_; - _tmp399_ = vala_ccode_base_module_get_delegate_target_destroy_notify_cname (self, _tmp398_); - _tmp400_ = _tmp399_; - _tmp401_ = vala_ccode_constant_new ("NULL"); - _tmp402_ = _tmp401_; - _tmp403_ = vala_ccode_variable_declarator_new (_tmp400_, (ValaCCodeExpression*) _tmp402_, NULL); - _tmp404_ = _tmp403_; - vala_ccode_declaration_add_declarator (_tmp395_, (ValaCCodeDeclarator*) _tmp404_); - _vala_ccode_node_unref0 (_tmp404_); - _vala_ccode_node_unref0 (_tmp402_); - _g_free0 (_tmp400_); - _g_free0 (_tmp398_); - _tmp405_ = f; - _tmp406_ = vala_symbol_is_private_symbol ((ValaSymbol*) _tmp405_); - if (!_tmp406_) { - ValaCCodeDeclaration* _tmp407_; - _tmp407_ = target_destroy_notify_def; - vala_ccode_declaration_set_modifiers (_tmp407_, VALA_CCODE_MODIFIERS_EXTERN); + ValaCCodeDeclaration* _tmp423_; + ValaField* _tmp424_; + gchar* _tmp425_ = NULL; + gchar* _tmp426_; + gchar* _tmp427_ = NULL; + gchar* _tmp428_; + ValaCCodeConstant* _tmp429_; + ValaCCodeConstant* _tmp430_; + ValaCCodeVariableDeclarator* _tmp431_; + ValaCCodeVariableDeclarator* _tmp432_; + ValaField* _tmp433_; + gboolean _tmp434_ = FALSE; + ValaCCodeFile* _tmp437_; + ValaCCodeDeclaration* _tmp438_; + _tmp422_ = vala_ccode_declaration_new ("GDestroyNotify"); + target_destroy_notify_def = _tmp422_; + _tmp423_ = target_destroy_notify_def; + _tmp424_ = f; + _tmp425_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp424_); + _tmp426_ = _tmp425_; + _tmp427_ = vala_ccode_base_module_get_delegate_target_destroy_notify_cname (self, _tmp426_); + _tmp428_ = _tmp427_; + _tmp429_ = vala_ccode_constant_new ("NULL"); + _tmp430_ = _tmp429_; + _tmp431_ = vala_ccode_variable_declarator_new (_tmp428_, (ValaCCodeExpression*) _tmp430_, NULL); + _tmp432_ = _tmp431_; + vala_ccode_declaration_add_declarator (_tmp423_, (ValaCCodeDeclarator*) _tmp432_); + _vala_ccode_node_unref0 (_tmp432_); + _vala_ccode_node_unref0 (_tmp430_); + _g_free0 (_tmp428_); + _g_free0 (_tmp426_); + _tmp433_ = f; + _tmp434_ = vala_symbol_is_private_symbol ((ValaSymbol*) _tmp433_); + if (!_tmp434_) { + ValaCCodeDeclaration* _tmp435_; + _tmp435_ = target_destroy_notify_def; + vala_ccode_declaration_set_modifiers (_tmp435_, VALA_CCODE_MODIFIERS_EXTERN); } else { - ValaCCodeDeclaration* _tmp408_; - _tmp408_ = target_destroy_notify_def; - vala_ccode_declaration_set_modifiers (_tmp408_, VALA_CCODE_MODIFIERS_STATIC); + ValaCCodeDeclaration* _tmp436_; + _tmp436_ = target_destroy_notify_def; + vala_ccode_declaration_set_modifiers (_tmp436_, VALA_CCODE_MODIFIERS_STATIC); } - _tmp409_ = self->cfile; - _tmp410_ = target_destroy_notify_def; - vala_ccode_file_add_type_member_declaration (_tmp409_, (ValaCCodeNode*) _tmp410_); + _tmp437_ = self->cfile; + _tmp438_ = target_destroy_notify_def; + vala_ccode_file_add_type_member_declaration (_tmp437_, (ValaCCodeNode*) _tmp438_); _vala_ccode_node_unref0 (target_destroy_notify_def); } _vala_ccode_node_unref0 (target_def); @@ -5892,260 +5979,342 @@ static void vala_ccode_base_module_real_visit_field (ValaCodeVisitor* base, Vala _vala_code_node_unref0 (delegate_type); } } - _tmp411_ = f; - _tmp412_ = vala_variable_get_initializer ((ValaVariable*) _tmp411_); - _tmp413_ = _tmp412_; - if (_tmp413_ != NULL) { - ValaField* _tmp414_; - ValaExpression* _tmp415_; - ValaExpression* _tmp416_; - ValaCCodeExpression* _tmp417_ = NULL; + _tmp439_ = f; + _tmp440_ = vala_variable_get_initializer ((ValaVariable*) _tmp439_); + _tmp441_ = _tmp440_; + if (_tmp441_ != NULL) { + ValaField* _tmp442_; + ValaExpression* _tmp443_; + ValaExpression* _tmp444_; + ValaCCodeExpression* _tmp445_ = NULL; ValaCCodeExpression* rhs; - ValaCCodeExpression* _tmp418_; - gboolean _tmp419_ = FALSE; - _tmp414_ = f; - _tmp415_ = vala_variable_get_initializer ((ValaVariable*) _tmp414_); - _tmp416_ = _tmp415_; - _tmp417_ = vala_ccode_base_module_get_cvalue (self, _tmp416_); - rhs = _tmp417_; - _tmp418_ = rhs; - _tmp419_ = vala_ccode_base_module_is_constant_ccode_expression (self, _tmp418_); - if (!_tmp419_) { - gboolean _tmp420_; - _tmp420_ = is_gtypeinstance; - if (_tmp420_) { - ValaField* _tmp421_; - ValaExpression* _tmp422_; - ValaExpression* _tmp423_; - gboolean _tmp460_ = FALSE; - gboolean _tmp461_ = FALSE; - ValaField* _tmp462_; - ValaDataType* _tmp463_; - ValaDataType* _tmp464_; - gboolean _tmp467_; - gboolean _tmp471_; - _tmp421_ = f; - _tmp422_ = vala_variable_get_initializer ((ValaVariable*) _tmp421_); - _tmp423_ = _tmp422_; - if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp423_, VALA_TYPE_INITIALIZER_LIST)) { - ValaCCodeFunction* _tmp424_; - ValaCCodeFunction* _tmp425_; - ValaField* _tmp426_; - ValaDataType* _tmp427_; - ValaDataType* _tmp428_; - ValaLocalVariable* _tmp429_ = NULL; + ValaCCodeExpression* _tmp446_; + gboolean _tmp447_ = FALSE; + _tmp442_ = f; + _tmp443_ = vala_variable_get_initializer ((ValaVariable*) _tmp442_); + _tmp444_ = _tmp443_; + _tmp445_ = vala_ccode_base_module_get_cvalue (self, _tmp444_); + rhs = _tmp445_; + _tmp446_ = rhs; + _tmp447_ = vala_ccode_base_module_is_constant_ccode_expression (self, _tmp446_); + if (!_tmp447_) { + gboolean _tmp448_; + _tmp448_ = is_gtypeinstance; + if (_tmp448_) { + ValaField* _tmp449_; + ValaExpression* _tmp450_; + ValaExpression* _tmp451_; + gboolean _tmp488_ = FALSE; + ValaField* _tmp489_; + ValaDataType* _tmp490_; + ValaDataType* _tmp491_; + gboolean _tmp494_; + _tmp449_ = f; + _tmp450_ = vala_variable_get_initializer ((ValaVariable*) _tmp449_); + _tmp451_ = _tmp450_; + if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp451_, VALA_TYPE_INITIALIZER_LIST)) { + ValaCCodeFunction* _tmp452_; + ValaCCodeFunction* _tmp453_; + ValaField* _tmp454_; + ValaDataType* _tmp455_; + ValaDataType* _tmp456_; + ValaLocalVariable* _tmp457_ = NULL; ValaLocalVariable* temp_decl; - ValaLocalVariable* _tmp430_; - const gchar* _tmp431_; - const gchar* _tmp432_; - ValaCCodeExpression* _tmp433_; - ValaCCodeVariableDeclarator* _tmp434_; + ValaLocalVariable* _tmp458_; + const gchar* _tmp459_; + const gchar* _tmp460_; + ValaCCodeExpression* _tmp461_; + ValaCCodeVariableDeclarator* _tmp462_; ValaCCodeVariableDeclarator* vardecl; - ValaCCodeFunction* _tmp435_; - ValaCCodeFunction* _tmp436_; - ValaLocalVariable* _tmp437_; - ValaDataType* _tmp438_; - ValaDataType* _tmp439_; - gchar* _tmp440_ = NULL; - gchar* _tmp441_; - ValaCCodeVariableDeclarator* _tmp442_; - ValaLocalVariable* _tmp443_; - const gchar* _tmp444_; - const gchar* _tmp445_; - gchar* _tmp446_ = NULL; - gchar* _tmp447_; - ValaCCodeExpression* _tmp448_ = NULL; - ValaCCodeExpression* _tmp449_; + ValaCCodeFunction* _tmp463_; + ValaCCodeFunction* _tmp464_; + ValaLocalVariable* _tmp465_; + ValaDataType* _tmp466_; + ValaDataType* _tmp467_; + gchar* _tmp468_ = NULL; + gchar* _tmp469_; + ValaCCodeVariableDeclarator* _tmp470_; + ValaLocalVariable* _tmp471_; + const gchar* _tmp472_; + const gchar* _tmp473_; + gchar* _tmp474_ = NULL; + gchar* _tmp475_; + ValaCCodeExpression* _tmp476_ = NULL; + ValaCCodeExpression* _tmp477_; ValaCCodeExpression* tmp; - ValaCCodeFunction* _tmp450_; - ValaCCodeFunction* _tmp451_; - ValaCCodeExpression* _tmp452_; - ValaCCodeExpression* _tmp453_; - ValaCCodeFunction* _tmp454_; - ValaCCodeFunction* _tmp455_; - _tmp424_ = vala_ccode_base_module_get_ccode (self); - _tmp425_ = _tmp424_; - vala_ccode_function_open_block (_tmp425_); - _tmp426_ = f; - _tmp427_ = vala_variable_get_variable_type ((ValaVariable*) _tmp426_); - _tmp428_ = _tmp427_; - _tmp429_ = vala_ccode_base_module_get_temp_variable (self, _tmp428_, TRUE, NULL, TRUE); - temp_decl = _tmp429_; - _tmp430_ = temp_decl; - _tmp431_ = vala_symbol_get_name ((ValaSymbol*) _tmp430_); - _tmp432_ = _tmp431_; - _tmp433_ = rhs; - _tmp434_ = vala_ccode_variable_declarator_new_zero (_tmp432_, _tmp433_, NULL); - vardecl = _tmp434_; - _tmp435_ = vala_ccode_base_module_get_ccode (self); - _tmp436_ = _tmp435_; - _tmp437_ = temp_decl; - _tmp438_ = vala_variable_get_variable_type ((ValaVariable*) _tmp437_); - _tmp439_ = _tmp438_; - _tmp440_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp439_); - _tmp441_ = _tmp440_; - _tmp442_ = vardecl; - vala_ccode_function_add_declaration (_tmp436_, _tmp441_, (ValaCCodeDeclarator*) _tmp442_, 0); - _g_free0 (_tmp441_); - _tmp443_ = temp_decl; - _tmp444_ = vala_symbol_get_name ((ValaSymbol*) _tmp443_); - _tmp445_ = _tmp444_; - _tmp446_ = vala_ccode_base_module_get_variable_cname (self, _tmp445_); - _tmp447_ = _tmp446_; - _tmp448_ = vala_ccode_base_module_get_variable_cexpression (self, _tmp447_); - _tmp449_ = _tmp448_; - _g_free0 (_tmp447_); - tmp = _tmp449_; - _tmp450_ = vala_ccode_base_module_get_ccode (self); - _tmp451_ = _tmp450_; - _tmp452_ = lhs; - _tmp453_ = tmp; - vala_ccode_function_add_assignment (_tmp451_, _tmp452_, _tmp453_); - _tmp454_ = vala_ccode_base_module_get_ccode (self); - _tmp455_ = _tmp454_; - vala_ccode_function_close (_tmp455_); + ValaCCodeFunction* _tmp478_; + ValaCCodeFunction* _tmp479_; + ValaCCodeExpression* _tmp480_; + ValaCCodeExpression* _tmp481_; + ValaCCodeFunction* _tmp482_; + ValaCCodeFunction* _tmp483_; + _tmp452_ = vala_ccode_base_module_get_ccode (self); + _tmp453_ = _tmp452_; + vala_ccode_function_open_block (_tmp453_); + _tmp454_ = f; + _tmp455_ = vala_variable_get_variable_type ((ValaVariable*) _tmp454_); + _tmp456_ = _tmp455_; + _tmp457_ = vala_ccode_base_module_get_temp_variable (self, _tmp456_, TRUE, NULL, TRUE); + temp_decl = _tmp457_; + _tmp458_ = temp_decl; + _tmp459_ = vala_symbol_get_name ((ValaSymbol*) _tmp458_); + _tmp460_ = _tmp459_; + _tmp461_ = rhs; + _tmp462_ = vala_ccode_variable_declarator_new_zero (_tmp460_, _tmp461_, NULL); + vardecl = _tmp462_; + _tmp463_ = vala_ccode_base_module_get_ccode (self); + _tmp464_ = _tmp463_; + _tmp465_ = temp_decl; + _tmp466_ = vala_variable_get_variable_type ((ValaVariable*) _tmp465_); + _tmp467_ = _tmp466_; + _tmp468_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp467_); + _tmp469_ = _tmp468_; + _tmp470_ = vardecl; + vala_ccode_function_add_declaration (_tmp464_, _tmp469_, (ValaCCodeDeclarator*) _tmp470_, 0); + _g_free0 (_tmp469_); + _tmp471_ = temp_decl; + _tmp472_ = vala_symbol_get_name ((ValaSymbol*) _tmp471_); + _tmp473_ = _tmp472_; + _tmp474_ = vala_ccode_base_module_get_variable_cname (self, _tmp473_); + _tmp475_ = _tmp474_; + _tmp476_ = vala_ccode_base_module_get_variable_cexpression (self, _tmp475_); + _tmp477_ = _tmp476_; + _g_free0 (_tmp475_); + tmp = _tmp477_; + _tmp478_ = vala_ccode_base_module_get_ccode (self); + _tmp479_ = _tmp478_; + _tmp480_ = lhs; + _tmp481_ = tmp; + vala_ccode_function_add_assignment (_tmp479_, _tmp480_, _tmp481_); + _tmp482_ = vala_ccode_base_module_get_ccode (self); + _tmp483_ = _tmp482_; + vala_ccode_function_close (_tmp483_); _vala_ccode_node_unref0 (tmp); _vala_ccode_node_unref0 (vardecl); _vala_code_node_unref0 (temp_decl); } else { - ValaCCodeFunction* _tmp456_; - ValaCCodeFunction* _tmp457_; - ValaCCodeExpression* _tmp458_; - ValaCCodeExpression* _tmp459_; - _tmp456_ = vala_ccode_base_module_get_ccode (self); - _tmp457_ = _tmp456_; - _tmp458_ = lhs; - _tmp459_ = rhs; - vala_ccode_function_add_assignment (_tmp457_, _tmp458_, _tmp459_); + ValaCCodeFunction* _tmp484_; + ValaCCodeFunction* _tmp485_; + ValaCCodeExpression* _tmp486_; + ValaCCodeExpression* _tmp487_; + _tmp484_ = vala_ccode_base_module_get_ccode (self); + _tmp485_ = _tmp484_; + _tmp486_ = lhs; + _tmp487_ = rhs; + vala_ccode_function_add_assignment (_tmp485_, _tmp486_, _tmp487_); } - _tmp462_ = f; - _tmp463_ = vala_variable_get_variable_type ((ValaVariable*) _tmp462_); - _tmp464_ = _tmp463_; - if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp464_, VALA_TYPE_ARRAY_TYPE)) { - ValaField* _tmp465_; - gboolean _tmp466_ = FALSE; - _tmp465_ = f; - _tmp466_ = vala_ccode_base_module_get_ccode_array_length ((ValaCodeNode*) _tmp465_); - _tmp461_ = _tmp466_; + _tmp489_ = f; + _tmp490_ = vala_variable_get_variable_type ((ValaVariable*) _tmp489_); + _tmp491_ = _tmp490_; + if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp491_, VALA_TYPE_ARRAY_TYPE)) { + ValaField* _tmp492_; + gboolean _tmp493_ = FALSE; + _tmp492_ = f; + _tmp493_ = vala_ccode_base_module_get_ccode_array_length ((ValaCodeNode*) _tmp492_); + _tmp488_ = _tmp493_; } else { - _tmp461_ = FALSE; + _tmp488_ = FALSE; } - _tmp467_ = _tmp461_; - if (_tmp467_) { - ValaField* _tmp468_; - ValaExpression* _tmp469_; - ValaExpression* _tmp470_; - _tmp468_ = f; - _tmp469_ = vala_variable_get_initializer ((ValaVariable*) _tmp468_); - _tmp470_ = _tmp469_; - _tmp460_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp470_, VALA_TYPE_ARRAY_CREATION_EXPRESSION); - } else { - _tmp460_ = FALSE; - } - _tmp471_ = _tmp460_; - if (_tmp471_) { - ValaField* _tmp472_; - ValaDataType* _tmp473_; - ValaDataType* _tmp474_; - ValaArrayType* _tmp475_; + _tmp494_ = _tmp488_; + if (_tmp494_) { + ValaField* _tmp495_; + ValaDataType* _tmp496_; + ValaDataType* _tmp497_; + ValaArrayType* _tmp498_; ValaArrayType* array_type; - ValaField* _tmp476_; - ValaTargetValue* _tmp477_ = NULL; + ValaField* _tmp499_; + ValaTargetValue* _tmp500_ = NULL; ValaTargetValue* field_value; - ValaField* _tmp478_; - ValaExpression* _tmp479_; - ValaExpression* _tmp480_; - ValaList* _tmp481_ = NULL; - ValaList* sizes; - _tmp472_ = f; - _tmp473_ = vala_variable_get_variable_type ((ValaVariable*) _tmp472_); - _tmp474_ = _tmp473_; - _tmp475_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp474_, VALA_TYPE_ARRAY_TYPE, ValaArrayType)); - array_type = _tmp475_; - _tmp476_ = f; - _tmp477_ = vala_ccode_base_module_get_field_cvalue (self, _tmp476_, NULL); - field_value = _tmp477_; - _tmp478_ = f; - _tmp479_ = vala_variable_get_initializer ((ValaVariable*) _tmp478_); - _tmp480_ = _tmp479_; - _tmp481_ = vala_array_creation_expression_get_sizes (G_TYPE_CHECK_INSTANCE_CAST (_tmp480_, VALA_TYPE_ARRAY_CREATION_EXPRESSION, ValaArrayCreationExpression)); - sizes = _tmp481_; - { - gint dim; - dim = 1; + ValaField* _tmp501_; + ValaExpression* _tmp502_; + ValaExpression* _tmp503_; + ValaTargetValue* _tmp504_; + ValaTargetValue* _tmp505_; + ValaGLibValue* _tmp506_; + ValaGLibValue* glib_value; + ValaGLibValue* _tmp507_; + ValaList* _tmp508_; + _tmp495_ = f; + _tmp496_ = vala_variable_get_variable_type ((ValaVariable*) _tmp495_); + _tmp497_ = _tmp496_; + _tmp498_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp497_, VALA_TYPE_ARRAY_TYPE, ValaArrayType)); + array_type = _tmp498_; + _tmp499_ = f; + _tmp500_ = vala_ccode_base_module_get_field_cvalue (self, _tmp499_, NULL); + field_value = _tmp500_; + _tmp501_ = f; + _tmp502_ = vala_variable_get_initializer ((ValaVariable*) _tmp501_); + _tmp503_ = _tmp502_; + _tmp504_ = vala_expression_get_target_value (_tmp503_); + _tmp505_ = _tmp504_; + _tmp506_ = _vala_target_value_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp505_, VALA_TYPE_GLIB_VALUE, ValaGLibValue)); + glib_value = _tmp506_; + _tmp507_ = glib_value; + _tmp508_ = _tmp507_->array_length_cvalues; + if (_tmp508_ != NULL) { { - gboolean _tmp482_; - _tmp482_ = TRUE; - while (TRUE) { - gboolean _tmp483_; - gint _tmp485_; - ValaArrayType* _tmp486_; - gint _tmp487_; - gint _tmp488_; - ValaTargetValue* _tmp489_; - gint _tmp490_; - ValaCCodeExpression* _tmp491_ = NULL; - ValaCCodeExpression* array_len_lhs; - ValaList* _tmp492_; - gint _tmp493_; - gpointer _tmp494_ = NULL; - ValaExpression* size; - ValaCCodeFunction* _tmp495_; - ValaCCodeFunction* _tmp496_; - ValaCCodeExpression* _tmp497_; - ValaExpression* _tmp498_; - ValaCCodeExpression* _tmp499_ = NULL; - ValaCCodeExpression* _tmp500_; - _tmp483_ = _tmp482_; - if (!_tmp483_) { - gint _tmp484_; - _tmp484_ = dim; - dim = _tmp484_ + 1; + gint dim; + dim = 1; + { + gboolean _tmp509_; + _tmp509_ = TRUE; + while (TRUE) { + gboolean _tmp510_; + gint _tmp512_; + ValaArrayType* _tmp513_; + gint _tmp514_; + gint _tmp515_; + ValaTargetValue* _tmp516_; + gint _tmp517_; + ValaCCodeExpression* _tmp518_ = NULL; + ValaCCodeExpression* array_len_lhs; + ValaCCodeFunction* _tmp519_; + ValaCCodeFunction* _tmp520_; + ValaCCodeExpression* _tmp521_; + ValaGLibValue* _tmp522_; + gint _tmp523_; + ValaCCodeExpression* _tmp524_ = NULL; + ValaCCodeExpression* _tmp525_; + _tmp510_ = _tmp509_; + if (!_tmp510_) { + gint _tmp511_; + _tmp511_ = dim; + dim = _tmp511_ + 1; + } + _tmp509_ = FALSE; + _tmp512_ = dim; + _tmp513_ = array_type; + _tmp514_ = vala_array_type_get_rank (_tmp513_); + _tmp515_ = _tmp514_; + if (!(_tmp512_ <= _tmp515_)) { + break; + } + _tmp516_ = field_value; + _tmp517_ = dim; + _tmp518_ = vala_ccode_base_module_get_array_length_cvalue (self, _tmp516_, _tmp517_); + array_len_lhs = _tmp518_; + _tmp519_ = vala_ccode_base_module_get_ccode (self); + _tmp520_ = _tmp519_; + _tmp521_ = array_len_lhs; + _tmp522_ = glib_value; + _tmp523_ = dim; + _tmp524_ = vala_ccode_base_module_get_array_length_cvalue (self, (ValaTargetValue*) _tmp522_, _tmp523_); + _tmp525_ = _tmp524_; + vala_ccode_function_add_assignment (_tmp520_, _tmp521_, _tmp525_); + _vala_ccode_node_unref0 (_tmp525_); + _vala_ccode_node_unref0 (array_len_lhs); } - _tmp482_ = FALSE; - _tmp485_ = dim; - _tmp486_ = array_type; - _tmp487_ = vala_array_type_get_rank (_tmp486_); - _tmp488_ = _tmp487_; - if (!(_tmp485_ <= _tmp488_)) { - break; + } + } + } else { + ValaGLibValue* _tmp526_; + gboolean _tmp527_; + _tmp526_ = glib_value; + _tmp527_ = _tmp526_->array_null_terminated; + if (_tmp527_) { + ValaCCodeIdentifier* _tmp528_; + ValaCCodeIdentifier* _tmp529_; + ValaCCodeFunctionCall* _tmp530_; + ValaCCodeFunctionCall* _tmp531_; + ValaCCodeFunctionCall* len_call; + ValaCCodeFunctionCall* _tmp532_; + ValaGLibValue* _tmp533_; + ValaCCodeExpression* _tmp534_ = NULL; + ValaCCodeExpression* _tmp535_; + ValaCCodeFunction* _tmp536_; + ValaCCodeFunction* _tmp537_; + ValaTargetValue* _tmp538_; + ValaCCodeExpression* _tmp539_ = NULL; + ValaCCodeExpression* _tmp540_; + ValaCCodeFunctionCall* _tmp541_; + self->requires_array_length = TRUE; + _tmp528_ = vala_ccode_identifier_new ("_vala_array_length"); + _tmp529_ = _tmp528_; + _tmp530_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp529_); + _tmp531_ = _tmp530_; + _vala_ccode_node_unref0 (_tmp529_); + len_call = _tmp531_; + _tmp532_ = len_call; + _tmp533_ = glib_value; + _tmp534_ = vala_ccode_base_module_get_cvalue_ (self, (ValaTargetValue*) _tmp533_); + _tmp535_ = _tmp534_; + vala_ccode_function_call_add_argument (_tmp532_, _tmp535_); + _vala_ccode_node_unref0 (_tmp535_); + _tmp536_ = vala_ccode_base_module_get_ccode (self); + _tmp537_ = _tmp536_; + _tmp538_ = field_value; + _tmp539_ = vala_ccode_base_module_get_array_length_cvalue (self, _tmp538_, 1); + _tmp540_ = _tmp539_; + _tmp541_ = len_call; + vala_ccode_function_add_assignment (_tmp537_, _tmp540_, (ValaCCodeExpression*) _tmp541_); + _vala_ccode_node_unref0 (_tmp540_); + _vala_ccode_node_unref0 (len_call); + } else { + { + gint dim; + dim = 1; + { + gboolean _tmp542_; + _tmp542_ = TRUE; + while (TRUE) { + gboolean _tmp543_; + gint _tmp545_; + ValaArrayType* _tmp546_; + gint _tmp547_; + gint _tmp548_; + ValaCCodeFunction* _tmp549_; + ValaCCodeFunction* _tmp550_; + ValaTargetValue* _tmp551_; + gint _tmp552_; + ValaCCodeExpression* _tmp553_ = NULL; + ValaCCodeExpression* _tmp554_; + ValaCCodeConstant* _tmp555_; + ValaCCodeConstant* _tmp556_; + _tmp543_ = _tmp542_; + if (!_tmp543_) { + gint _tmp544_; + _tmp544_ = dim; + dim = _tmp544_ + 1; + } + _tmp542_ = FALSE; + _tmp545_ = dim; + _tmp546_ = array_type; + _tmp547_ = vala_array_type_get_rank (_tmp546_); + _tmp548_ = _tmp547_; + if (!(_tmp545_ <= _tmp548_)) { + break; + } + _tmp549_ = vala_ccode_base_module_get_ccode (self); + _tmp550_ = _tmp549_; + _tmp551_ = field_value; + _tmp552_ = dim; + _tmp553_ = vala_ccode_base_module_get_array_length_cvalue (self, _tmp551_, _tmp552_); + _tmp554_ = _tmp553_; + _tmp555_ = vala_ccode_constant_new ("-1"); + _tmp556_ = _tmp555_; + vala_ccode_function_add_assignment (_tmp550_, _tmp554_, (ValaCCodeExpression*) _tmp556_); + _vala_ccode_node_unref0 (_tmp556_); + _vala_ccode_node_unref0 (_tmp554_); + } } - _tmp489_ = field_value; - _tmp490_ = dim; - _tmp491_ = vala_ccode_base_module_get_array_length_cvalue (self, _tmp489_, _tmp490_); - array_len_lhs = _tmp491_; - _tmp492_ = sizes; - _tmp493_ = dim; - _tmp494_ = vala_list_get (_tmp492_, _tmp493_ - 1); - size = (ValaExpression*) _tmp494_; - _tmp495_ = vala_ccode_base_module_get_ccode (self); - _tmp496_ = _tmp495_; - _tmp497_ = array_len_lhs; - _tmp498_ = size; - _tmp499_ = vala_ccode_base_module_get_cvalue (self, _tmp498_); - _tmp500_ = _tmp499_; - vala_ccode_function_add_assignment (_tmp496_, _tmp497_, _tmp500_); - _vala_ccode_node_unref0 (_tmp500_); - _vala_code_node_unref0 (size); - _vala_ccode_node_unref0 (array_len_lhs); } } } - _vala_iterable_unref0 (sizes); + _vala_target_value_unref0 (glib_value); _vala_target_value_unref0 (field_value); _vala_code_node_unref0 (array_type); } } else { - ValaField* _tmp501_; - ValaField* _tmp502_; - ValaSourceReference* _tmp503_; - ValaSourceReference* _tmp504_; - _tmp501_ = f; - vala_code_node_set_error ((ValaCodeNode*) _tmp501_, TRUE); - _tmp502_ = f; - _tmp503_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp502_); - _tmp504_ = _tmp503_; - vala_report_error (_tmp504_, "Non-constant field initializers not supported in this context"); + ValaField* _tmp557_; + ValaField* _tmp558_; + ValaSourceReference* _tmp559_; + ValaSourceReference* _tmp560_; + _tmp557_ = f; + vala_code_node_set_error ((ValaCodeNode*) _tmp557_, TRUE); + _tmp558_ = f; + _tmp559_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp558_); + _tmp560_ = _tmp559_; + vala_report_error (_tmp560_, "Non-constant field initializers not supported in this context"); _vala_ccode_node_unref0 (rhs); _vala_ccode_node_unref0 (var_def); _vala_ccode_node_unref0 (var_decl); @@ -29380,11 +29549,6 @@ static void vala_ccode_base_module_real_visit_typeof_expression (ValaCodeVisitor } -static gpointer _vala_target_value_ref0 (gpointer self) { - return self ? vala_target_value_ref (self) : NULL; -} - - static void vala_ccode_base_module_real_visit_unary_expression (ValaCodeVisitor* base, ValaUnaryExpression* expr) { ValaCCodeBaseModule * self; gboolean _tmp0_ = FALSE; @@ -30609,34 +30773,34 @@ static void vala_ccode_base_module_real_visit_cast_expression (ValaCodeVisitor* gboolean _tmp108_ = FALSE; ValaArrayType* _tmp109_; gboolean _tmp115_; - ValaCastExpression* _tmp175_; - ValaExpression* _tmp176_; - ValaExpression* _tmp177_; - ValaCCodeExpression* _tmp178_ = NULL; + ValaCastExpression* _tmp201_; + ValaExpression* _tmp202_; + ValaExpression* _tmp203_; + ValaCCodeExpression* _tmp204_ = NULL; ValaCCodeExpression* innercexpr; - gboolean _tmp179_ = FALSE; - gboolean _tmp180_ = FALSE; - gboolean _tmp181_ = FALSE; - ValaCastExpression* _tmp182_; - ValaDataType* _tmp183_; - ValaDataType* _tmp184_; - ValaTypeSymbol* _tmp185_; - ValaTypeSymbol* _tmp186_; - gboolean _tmp192_; - gboolean _tmp200_; - gboolean _tmp208_; - ValaCastExpression* _tmp211_; - ValaCCodeExpression* _tmp212_; - ValaCastExpression* _tmp213_; - ValaDataType* _tmp214_; - ValaDataType* _tmp215_; - gchar* _tmp216_ = NULL; - gchar* _tmp217_; - ValaCCodeCastExpression* _tmp218_; - ValaCCodeCastExpression* _tmp219_; - ValaCastExpression* _tmp220_; - ValaDataType* _tmp221_; - ValaDataType* _tmp222_; + gboolean _tmp205_ = FALSE; + gboolean _tmp206_ = FALSE; + gboolean _tmp207_ = FALSE; + ValaCastExpression* _tmp208_; + ValaDataType* _tmp209_; + ValaDataType* _tmp210_; + ValaTypeSymbol* _tmp211_; + ValaTypeSymbol* _tmp212_; + gboolean _tmp218_; + gboolean _tmp226_; + gboolean _tmp234_; + ValaCastExpression* _tmp237_; + ValaCCodeExpression* _tmp238_; + ValaCastExpression* _tmp239_; + ValaDataType* _tmp240_; + ValaDataType* _tmp241_; + gchar* _tmp242_ = NULL; + gchar* _tmp243_; + ValaCCodeCastExpression* _tmp244_; + ValaCCodeCastExpression* _tmp245_; + ValaCastExpression* _tmp246_; + ValaDataType* _tmp247_; + ValaDataType* _tmp248_; _tmp97_ = expr; _tmp98_ = vala_cast_expression_get_is_silent_cast (_tmp97_); _tmp99_ = _tmp98_; @@ -30680,343 +30844,419 @@ static void vala_ccode_base_module_real_visit_cast_expression (ValaCodeVisitor* } _tmp115_ = _tmp108_; if (_tmp115_) { - ValaCCodeIdentifier* _tmp116_; - ValaCCodeIdentifier* _tmp117_; - ValaCCodeFunctionCall* _tmp118_; - ValaCCodeFunctionCall* _tmp119_; - ValaCCodeFunctionCall* sizeof_to; - ValaCCodeFunctionCall* _tmp120_; - ValaArrayType* _tmp121_; - ValaDataType* _tmp122_; - ValaDataType* _tmp123_; - gchar* _tmp124_ = NULL; - gchar* _tmp125_; - ValaCCodeConstant* _tmp126_; - ValaCCodeConstant* _tmp127_; - ValaCCodeIdentifier* _tmp128_; - ValaCCodeIdentifier* _tmp129_; - ValaCCodeFunctionCall* _tmp130_; - ValaCCodeFunctionCall* _tmp131_; - ValaCCodeFunctionCall* sizeof_from; - ValaCCodeFunctionCall* _tmp132_; - ValaCastExpression* _tmp133_; - ValaExpression* _tmp134_; - ValaExpression* _tmp135_; - ValaDataType* _tmp136_; - ValaDataType* _tmp137_; - ValaDataType* _tmp138_; - ValaDataType* _tmp139_; - gchar* _tmp140_ = NULL; - gchar* _tmp141_; - ValaCCodeConstant* _tmp142_; - ValaCCodeConstant* _tmp143_; - _tmp116_ = vala_ccode_identifier_new ("sizeof"); - _tmp117_ = _tmp116_; - _tmp118_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp117_); + gboolean _tmp116_ = FALSE; + ValaArrayType* _tmp117_; + ValaDataType* _tmp118_; + ValaDataType* _tmp119_; + gboolean _tmp127_; + _tmp117_ = array_type; + _tmp118_ = vala_array_type_get_element_type (_tmp117_); _tmp119_ = _tmp118_; - _vala_ccode_node_unref0 (_tmp117_); - sizeof_to = _tmp119_; - _tmp120_ = sizeof_to; - _tmp121_ = array_type; - _tmp122_ = vala_array_type_get_element_type (_tmp121_); - _tmp123_ = _tmp122_; - _tmp124_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp123_); - _tmp125_ = _tmp124_; - _tmp126_ = vala_ccode_constant_new (_tmp125_); - _tmp127_ = _tmp126_; - vala_ccode_function_call_add_argument (_tmp120_, (ValaCCodeExpression*) _tmp127_); - _vala_ccode_node_unref0 (_tmp127_); - _g_free0 (_tmp125_); - _tmp128_ = vala_ccode_identifier_new ("sizeof"); - _tmp129_ = _tmp128_; - _tmp130_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp129_); - _tmp131_ = _tmp130_; - _vala_ccode_node_unref0 (_tmp129_); - sizeof_from = _tmp131_; - _tmp132_ = sizeof_from; - _tmp133_ = expr; - _tmp134_ = vala_cast_expression_get_inner (_tmp133_); - _tmp135_ = _tmp134_; - _tmp136_ = vala_expression_get_value_type (_tmp135_); - _tmp137_ = _tmp136_; - _tmp138_ = vala_array_type_get_element_type (G_TYPE_CHECK_INSTANCE_CAST (_tmp137_, VALA_TYPE_ARRAY_TYPE, ValaArrayType)); - _tmp139_ = _tmp138_; - _tmp140_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp139_); - _tmp141_ = _tmp140_; - _tmp142_ = vala_ccode_constant_new (_tmp141_); - _tmp143_ = _tmp142_; - vala_ccode_function_call_add_argument (_tmp132_, (ValaCCodeExpression*) _tmp143_); - _vala_ccode_node_unref0 (_tmp143_); - _g_free0 (_tmp141_); - { - gint dim; - dim = 1; + if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp119_, VALA_TYPE_GENERIC_TYPE)) { + _tmp116_ = TRUE; + } else { + ValaCastExpression* _tmp120_; + ValaExpression* _tmp121_; + ValaExpression* _tmp122_; + ValaDataType* _tmp123_; + ValaDataType* _tmp124_; + ValaDataType* _tmp125_; + ValaDataType* _tmp126_; + _tmp120_ = expr; + _tmp121_ = vala_cast_expression_get_inner (_tmp120_); + _tmp122_ = _tmp121_; + _tmp123_ = vala_expression_get_value_type (_tmp122_); + _tmp124_ = _tmp123_; + _tmp125_ = vala_array_type_get_element_type (G_TYPE_CHECK_INSTANCE_CAST (_tmp124_, VALA_TYPE_ARRAY_TYPE, ValaArrayType)); + _tmp126_ = _tmp125_; + _tmp116_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp126_, VALA_TYPE_GENERIC_TYPE); + } + _tmp127_ = _tmp116_; + if (_tmp127_) { { - gboolean _tmp144_; - _tmp144_ = TRUE; - while (TRUE) { - gboolean _tmp145_; - gint _tmp147_; - ValaArrayType* _tmp148_; - gint _tmp149_; - gint _tmp150_; - ValaCastExpression* _tmp151_; - ValaCastExpression* _tmp152_; - ValaExpression* _tmp153_; - ValaExpression* _tmp154_; - gint _tmp155_; - ValaCCodeExpression* _tmp156_ = NULL; - ValaCCodeExpression* _tmp157_; - ValaCCodeFunctionCall* _tmp158_; - ValaCCodeBinaryExpression* _tmp159_; - ValaCCodeBinaryExpression* _tmp160_; - ValaCCodeFunctionCall* _tmp161_; - ValaCCodeBinaryExpression* _tmp162_; - ValaCCodeBinaryExpression* _tmp163_; - _tmp145_ = _tmp144_; - if (!_tmp145_) { - gint _tmp146_; - _tmp146_ = dim; - dim = _tmp146_ + 1; + gint dim; + dim = 1; + { + gboolean _tmp128_; + _tmp128_ = TRUE; + while (TRUE) { + gboolean _tmp129_; + gint _tmp131_; + ValaArrayType* _tmp132_; + gint _tmp133_; + gint _tmp134_; + ValaCastExpression* _tmp135_; + ValaCastExpression* _tmp136_; + ValaExpression* _tmp137_; + ValaExpression* _tmp138_; + gint _tmp139_; + ValaCCodeExpression* _tmp140_ = NULL; + ValaCCodeExpression* _tmp141_; + _tmp129_ = _tmp128_; + if (!_tmp129_) { + gint _tmp130_; + _tmp130_ = dim; + dim = _tmp130_ + 1; + } + _tmp128_ = FALSE; + _tmp131_ = dim; + _tmp132_ = array_type; + _tmp133_ = vala_array_type_get_rank (_tmp132_); + _tmp134_ = _tmp133_; + if (!(_tmp131_ <= _tmp134_)) { + break; + } + _tmp135_ = expr; + _tmp136_ = expr; + _tmp137_ = vala_cast_expression_get_inner (_tmp136_); + _tmp138_ = _tmp137_; + _tmp139_ = dim; + _tmp140_ = vala_ccode_base_module_get_array_length_cexpression (self, _tmp138_, _tmp139_); + _tmp141_ = _tmp140_; + vala_ccode_base_module_append_array_length (self, (ValaExpression*) _tmp135_, _tmp141_); + _vala_ccode_node_unref0 (_tmp141_); } - _tmp144_ = FALSE; - _tmp147_ = dim; - _tmp148_ = array_type; - _tmp149_ = vala_array_type_get_rank (_tmp148_); - _tmp150_ = _tmp149_; - if (!(_tmp147_ <= _tmp150_)) { - break; + } + } + } else { + ValaCCodeIdentifier* _tmp142_; + ValaCCodeIdentifier* _tmp143_; + ValaCCodeFunctionCall* _tmp144_; + ValaCCodeFunctionCall* _tmp145_; + ValaCCodeFunctionCall* sizeof_to; + ValaCCodeFunctionCall* _tmp146_; + ValaArrayType* _tmp147_; + ValaDataType* _tmp148_; + ValaDataType* _tmp149_; + gchar* _tmp150_ = NULL; + gchar* _tmp151_; + ValaCCodeConstant* _tmp152_; + ValaCCodeConstant* _tmp153_; + ValaCCodeIdentifier* _tmp154_; + ValaCCodeIdentifier* _tmp155_; + ValaCCodeFunctionCall* _tmp156_; + ValaCCodeFunctionCall* _tmp157_; + ValaCCodeFunctionCall* sizeof_from; + ValaCCodeFunctionCall* _tmp158_; + ValaCastExpression* _tmp159_; + ValaExpression* _tmp160_; + ValaExpression* _tmp161_; + ValaDataType* _tmp162_; + ValaDataType* _tmp163_; + ValaDataType* _tmp164_; + ValaDataType* _tmp165_; + gchar* _tmp166_ = NULL; + gchar* _tmp167_; + ValaCCodeConstant* _tmp168_; + ValaCCodeConstant* _tmp169_; + _tmp142_ = vala_ccode_identifier_new ("sizeof"); + _tmp143_ = _tmp142_; + _tmp144_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp143_); + _tmp145_ = _tmp144_; + _vala_ccode_node_unref0 (_tmp143_); + sizeof_to = _tmp145_; + _tmp146_ = sizeof_to; + _tmp147_ = array_type; + _tmp148_ = vala_array_type_get_element_type (_tmp147_); + _tmp149_ = _tmp148_; + _tmp150_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp149_); + _tmp151_ = _tmp150_; + _tmp152_ = vala_ccode_constant_new (_tmp151_); + _tmp153_ = _tmp152_; + vala_ccode_function_call_add_argument (_tmp146_, (ValaCCodeExpression*) _tmp153_); + _vala_ccode_node_unref0 (_tmp153_); + _g_free0 (_tmp151_); + _tmp154_ = vala_ccode_identifier_new ("sizeof"); + _tmp155_ = _tmp154_; + _tmp156_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp155_); + _tmp157_ = _tmp156_; + _vala_ccode_node_unref0 (_tmp155_); + sizeof_from = _tmp157_; + _tmp158_ = sizeof_from; + _tmp159_ = expr; + _tmp160_ = vala_cast_expression_get_inner (_tmp159_); + _tmp161_ = _tmp160_; + _tmp162_ = vala_expression_get_value_type (_tmp161_); + _tmp163_ = _tmp162_; + _tmp164_ = vala_array_type_get_element_type (G_TYPE_CHECK_INSTANCE_CAST (_tmp163_, VALA_TYPE_ARRAY_TYPE, ValaArrayType)); + _tmp165_ = _tmp164_; + _tmp166_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp165_); + _tmp167_ = _tmp166_; + _tmp168_ = vala_ccode_constant_new (_tmp167_); + _tmp169_ = _tmp168_; + vala_ccode_function_call_add_argument (_tmp158_, (ValaCCodeExpression*) _tmp169_); + _vala_ccode_node_unref0 (_tmp169_); + _g_free0 (_tmp167_); + { + gint dim; + dim = 1; + { + gboolean _tmp170_; + _tmp170_ = TRUE; + while (TRUE) { + gboolean _tmp171_; + gint _tmp173_; + ValaArrayType* _tmp174_; + gint _tmp175_; + gint _tmp176_; + ValaCastExpression* _tmp177_; + ValaCastExpression* _tmp178_; + ValaExpression* _tmp179_; + ValaExpression* _tmp180_; + gint _tmp181_; + ValaCCodeExpression* _tmp182_ = NULL; + ValaCCodeExpression* _tmp183_; + ValaCCodeFunctionCall* _tmp184_; + ValaCCodeBinaryExpression* _tmp185_; + ValaCCodeBinaryExpression* _tmp186_; + ValaCCodeFunctionCall* _tmp187_; + ValaCCodeBinaryExpression* _tmp188_; + ValaCCodeBinaryExpression* _tmp189_; + _tmp171_ = _tmp170_; + if (!_tmp171_) { + gint _tmp172_; + _tmp172_ = dim; + dim = _tmp172_ + 1; + } + _tmp170_ = FALSE; + _tmp173_ = dim; + _tmp174_ = array_type; + _tmp175_ = vala_array_type_get_rank (_tmp174_); + _tmp176_ = _tmp175_; + if (!(_tmp173_ <= _tmp176_)) { + break; + } + _tmp177_ = expr; + _tmp178_ = expr; + _tmp179_ = vala_cast_expression_get_inner (_tmp178_); + _tmp180_ = _tmp179_; + _tmp181_ = dim; + _tmp182_ = vala_ccode_base_module_get_array_length_cexpression (self, _tmp180_, _tmp181_); + _tmp183_ = _tmp182_; + _tmp184_ = sizeof_from; + _tmp185_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_MUL, _tmp183_, (ValaCCodeExpression*) _tmp184_); + _tmp186_ = _tmp185_; + _tmp187_ = sizeof_to; + _tmp188_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_DIV, (ValaCCodeExpression*) _tmp186_, (ValaCCodeExpression*) _tmp187_); + _tmp189_ = _tmp188_; + vala_ccode_base_module_append_array_length (self, (ValaExpression*) _tmp177_, (ValaCCodeExpression*) _tmp189_); + _vala_ccode_node_unref0 (_tmp189_); + _vala_ccode_node_unref0 (_tmp186_); + _vala_ccode_node_unref0 (_tmp183_); } - _tmp151_ = expr; - _tmp152_ = expr; - _tmp153_ = vala_cast_expression_get_inner (_tmp152_); - _tmp154_ = _tmp153_; - _tmp155_ = dim; - _tmp156_ = vala_ccode_base_module_get_array_length_cexpression (self, _tmp154_, _tmp155_); - _tmp157_ = _tmp156_; - _tmp158_ = sizeof_from; - _tmp159_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_MUL, _tmp157_, (ValaCCodeExpression*) _tmp158_); - _tmp160_ = _tmp159_; - _tmp161_ = sizeof_to; - _tmp162_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_DIV, (ValaCCodeExpression*) _tmp160_, (ValaCCodeExpression*) _tmp161_); - _tmp163_ = _tmp162_; - vala_ccode_base_module_append_array_length (self, (ValaExpression*) _tmp151_, (ValaCCodeExpression*) _tmp163_); - _vala_ccode_node_unref0 (_tmp163_); - _vala_ccode_node_unref0 (_tmp160_); - _vala_ccode_node_unref0 (_tmp157_); } } + _vala_ccode_node_unref0 (sizeof_from); + _vala_ccode_node_unref0 (sizeof_to); } - _vala_ccode_node_unref0 (sizeof_from); - _vala_ccode_node_unref0 (sizeof_to); } else { - ValaArrayType* _tmp164_; - _tmp164_ = array_type; - if (_tmp164_ != NULL) { + ValaArrayType* _tmp190_; + _tmp190_ = array_type; + if (_tmp190_ != NULL) { { gint dim; dim = 1; { - gboolean _tmp165_; - _tmp165_ = TRUE; + gboolean _tmp191_; + _tmp191_ = TRUE; while (TRUE) { - gboolean _tmp166_; - gint _tmp168_; - ValaArrayType* _tmp169_; - gint _tmp170_; - gint _tmp171_; - ValaCastExpression* _tmp172_; - ValaCCodeConstant* _tmp173_; - ValaCCodeConstant* _tmp174_; - _tmp166_ = _tmp165_; - if (!_tmp166_) { - gint _tmp167_; - _tmp167_ = dim; - dim = _tmp167_ + 1; + gboolean _tmp192_; + gint _tmp194_; + ValaArrayType* _tmp195_; + gint _tmp196_; + gint _tmp197_; + ValaCastExpression* _tmp198_; + ValaCCodeConstant* _tmp199_; + ValaCCodeConstant* _tmp200_; + _tmp192_ = _tmp191_; + if (!_tmp192_) { + gint _tmp193_; + _tmp193_ = dim; + dim = _tmp193_ + 1; } - _tmp165_ = FALSE; - _tmp168_ = dim; - _tmp169_ = array_type; - _tmp170_ = vala_array_type_get_rank (_tmp169_); - _tmp171_ = _tmp170_; - if (!(_tmp168_ <= _tmp171_)) { + _tmp191_ = FALSE; + _tmp194_ = dim; + _tmp195_ = array_type; + _tmp196_ = vala_array_type_get_rank (_tmp195_); + _tmp197_ = _tmp196_; + if (!(_tmp194_ <= _tmp197_)) { break; } - _tmp172_ = expr; - _tmp173_ = vala_ccode_constant_new ("-1"); - _tmp174_ = _tmp173_; - vala_ccode_base_module_append_array_length (self, (ValaExpression*) _tmp172_, (ValaCCodeExpression*) _tmp174_); - _vala_ccode_node_unref0 (_tmp174_); + _tmp198_ = expr; + _tmp199_ = vala_ccode_constant_new ("-1"); + _tmp200_ = _tmp199_; + vala_ccode_base_module_append_array_length (self, (ValaExpression*) _tmp198_, (ValaCCodeExpression*) _tmp200_); + _vala_ccode_node_unref0 (_tmp200_); } } } } } - _tmp175_ = expr; - _tmp176_ = vala_cast_expression_get_inner (_tmp175_); - _tmp177_ = _tmp176_; - _tmp178_ = vala_ccode_base_module_get_cvalue (self, _tmp177_); - innercexpr = _tmp178_; - _tmp182_ = expr; - _tmp183_ = vala_cast_expression_get_type_reference (_tmp182_); - _tmp184_ = _tmp183_; - _tmp185_ = vala_data_type_get_data_type (_tmp184_); - _tmp186_ = _tmp185_; - if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp186_, VALA_TYPE_STRUCT)) { - ValaCastExpression* _tmp187_; - ValaDataType* _tmp188_; - ValaDataType* _tmp189_; - gboolean _tmp190_; - gboolean _tmp191_; - _tmp187_ = expr; - _tmp188_ = vala_cast_expression_get_type_reference (_tmp187_); - _tmp189_ = _tmp188_; - _tmp190_ = vala_data_type_get_nullable (_tmp189_); - _tmp191_ = _tmp190_; - _tmp181_ = !_tmp191_; + _tmp201_ = expr; + _tmp202_ = vala_cast_expression_get_inner (_tmp201_); + _tmp203_ = _tmp202_; + _tmp204_ = vala_ccode_base_module_get_cvalue (self, _tmp203_); + innercexpr = _tmp204_; + _tmp208_ = expr; + _tmp209_ = vala_cast_expression_get_type_reference (_tmp208_); + _tmp210_ = _tmp209_; + _tmp211_ = vala_data_type_get_data_type (_tmp210_); + _tmp212_ = _tmp211_; + if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp212_, VALA_TYPE_STRUCT)) { + ValaCastExpression* _tmp213_; + ValaDataType* _tmp214_; + ValaDataType* _tmp215_; + gboolean _tmp216_; + gboolean _tmp217_; + _tmp213_ = expr; + _tmp214_ = vala_cast_expression_get_type_reference (_tmp213_); + _tmp215_ = _tmp214_; + _tmp216_ = vala_data_type_get_nullable (_tmp215_); + _tmp217_ = _tmp216_; + _tmp207_ = !_tmp217_; } else { - _tmp181_ = FALSE; - } - _tmp192_ = _tmp181_; - if (_tmp192_) { - ValaCastExpression* _tmp193_; - ValaExpression* _tmp194_; - ValaExpression* _tmp195_; - ValaDataType* _tmp196_; - ValaDataType* _tmp197_; - ValaTypeSymbol* _tmp198_; - ValaTypeSymbol* _tmp199_; - _tmp193_ = expr; - _tmp194_ = vala_cast_expression_get_inner (_tmp193_); - _tmp195_ = _tmp194_; - _tmp196_ = vala_expression_get_value_type (_tmp195_); - _tmp197_ = _tmp196_; - _tmp198_ = vala_data_type_get_data_type (_tmp197_); - _tmp199_ = _tmp198_; - _tmp180_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp199_, VALA_TYPE_STRUCT); + _tmp207_ = FALSE; + } + _tmp218_ = _tmp207_; + if (_tmp218_) { + ValaCastExpression* _tmp219_; + ValaExpression* _tmp220_; + ValaExpression* _tmp221_; + ValaDataType* _tmp222_; + ValaDataType* _tmp223_; + ValaTypeSymbol* _tmp224_; + ValaTypeSymbol* _tmp225_; + _tmp219_ = expr; + _tmp220_ = vala_cast_expression_get_inner (_tmp219_); + _tmp221_ = _tmp220_; + _tmp222_ = vala_expression_get_value_type (_tmp221_); + _tmp223_ = _tmp222_; + _tmp224_ = vala_data_type_get_data_type (_tmp223_); + _tmp225_ = _tmp224_; + _tmp206_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp225_, VALA_TYPE_STRUCT); } else { - _tmp180_ = FALSE; - } - _tmp200_ = _tmp180_; - if (_tmp200_) { - ValaCastExpression* _tmp201_; - ValaExpression* _tmp202_; - ValaExpression* _tmp203_; - ValaDataType* _tmp204_; - ValaDataType* _tmp205_; - gboolean _tmp206_; - gboolean _tmp207_; - _tmp201_ = expr; - _tmp202_ = vala_cast_expression_get_inner (_tmp201_); - _tmp203_ = _tmp202_; - _tmp204_ = vala_expression_get_value_type (_tmp203_); - _tmp205_ = _tmp204_; - _tmp206_ = vala_data_type_get_nullable (_tmp205_); - _tmp207_ = _tmp206_; - _tmp179_ = _tmp207_; + _tmp206_ = FALSE; + } + _tmp226_ = _tmp206_; + if (_tmp226_) { + ValaCastExpression* _tmp227_; + ValaExpression* _tmp228_; + ValaExpression* _tmp229_; + ValaDataType* _tmp230_; + ValaDataType* _tmp231_; + gboolean _tmp232_; + gboolean _tmp233_; + _tmp227_ = expr; + _tmp228_ = vala_cast_expression_get_inner (_tmp227_); + _tmp229_ = _tmp228_; + _tmp230_ = vala_expression_get_value_type (_tmp229_); + _tmp231_ = _tmp230_; + _tmp232_ = vala_data_type_get_nullable (_tmp231_); + _tmp233_ = _tmp232_; + _tmp205_ = _tmp233_; } else { - _tmp179_ = FALSE; + _tmp205_ = FALSE; } - _tmp208_ = _tmp179_; - if (_tmp208_) { - ValaCCodeExpression* _tmp209_; - ValaCCodeUnaryExpression* _tmp210_; - _tmp209_ = innercexpr; - _tmp210_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_POINTER_INDIRECTION, _tmp209_); + _tmp234_ = _tmp205_; + if (_tmp234_) { + ValaCCodeExpression* _tmp235_; + ValaCCodeUnaryExpression* _tmp236_; + _tmp235_ = innercexpr; + _tmp236_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_POINTER_INDIRECTION, _tmp235_); _vala_ccode_node_unref0 (innercexpr); - innercexpr = (ValaCCodeExpression*) _tmp210_; - } - _tmp211_ = expr; - _tmp212_ = innercexpr; - _tmp213_ = expr; - _tmp214_ = vala_cast_expression_get_type_reference (_tmp213_); - _tmp215_ = _tmp214_; - _tmp216_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp215_); - _tmp217_ = _tmp216_; - _tmp218_ = vala_ccode_cast_expression_new (_tmp212_, _tmp217_); - _tmp219_ = _tmp218_; - vala_ccode_base_module_set_cvalue (self, (ValaExpression*) _tmp211_, (ValaCCodeExpression*) _tmp219_); - _vala_ccode_node_unref0 (_tmp219_); - _g_free0 (_tmp217_); - _tmp220_ = expr; - _tmp221_ = vala_cast_expression_get_type_reference (_tmp220_); - _tmp222_ = _tmp221_; - if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp222_, VALA_TYPE_DELEGATE_TYPE)) { - ValaCastExpression* _tmp223_; - ValaExpression* _tmp224_; - ValaExpression* _tmp225_; - ValaCCodeExpression* _tmp226_ = NULL; - ValaCCodeExpression* _tmp227_; - gboolean _tmp228_; - ValaCastExpression* _tmp238_; - ValaExpression* _tmp239_; - ValaExpression* _tmp240_; - ValaCCodeExpression* _tmp241_ = NULL; - ValaCCodeExpression* _tmp242_; - gboolean _tmp243_; - _tmp223_ = expr; - _tmp224_ = vala_cast_expression_get_inner (_tmp223_); - _tmp225_ = _tmp224_; - _tmp226_ = vala_ccode_base_module_get_delegate_target (self, _tmp225_); - _tmp227_ = _tmp226_; - _tmp228_ = _tmp227_ != NULL; - _vala_ccode_node_unref0 (_tmp227_); - if (_tmp228_) { - ValaCastExpression* _tmp229_; - ValaCastExpression* _tmp230_; - ValaExpression* _tmp231_; - ValaExpression* _tmp232_; - ValaCCodeExpression* _tmp233_ = NULL; - ValaCCodeExpression* _tmp234_; - _tmp229_ = expr; - _tmp230_ = expr; - _tmp231_ = vala_cast_expression_get_inner (_tmp230_); - _tmp232_ = _tmp231_; - _tmp233_ = vala_ccode_base_module_get_delegate_target (self, _tmp232_); - _tmp234_ = _tmp233_; - vala_ccode_base_module_set_delegate_target (self, (ValaExpression*) _tmp229_, _tmp234_); - _vala_ccode_node_unref0 (_tmp234_); + innercexpr = (ValaCCodeExpression*) _tmp236_; + } + _tmp237_ = expr; + _tmp238_ = innercexpr; + _tmp239_ = expr; + _tmp240_ = vala_cast_expression_get_type_reference (_tmp239_); + _tmp241_ = _tmp240_; + _tmp242_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp241_); + _tmp243_ = _tmp242_; + _tmp244_ = vala_ccode_cast_expression_new (_tmp238_, _tmp243_); + _tmp245_ = _tmp244_; + vala_ccode_base_module_set_cvalue (self, (ValaExpression*) _tmp237_, (ValaCCodeExpression*) _tmp245_); + _vala_ccode_node_unref0 (_tmp245_); + _g_free0 (_tmp243_); + _tmp246_ = expr; + _tmp247_ = vala_cast_expression_get_type_reference (_tmp246_); + _tmp248_ = _tmp247_; + if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp248_, VALA_TYPE_DELEGATE_TYPE)) { + ValaCastExpression* _tmp249_; + ValaExpression* _tmp250_; + ValaExpression* _tmp251_; + ValaCCodeExpression* _tmp252_ = NULL; + ValaCCodeExpression* _tmp253_; + gboolean _tmp254_; + ValaCastExpression* _tmp264_; + ValaExpression* _tmp265_; + ValaExpression* _tmp266_; + ValaCCodeExpression* _tmp267_ = NULL; + ValaCCodeExpression* _tmp268_; + gboolean _tmp269_; + _tmp249_ = expr; + _tmp250_ = vala_cast_expression_get_inner (_tmp249_); + _tmp251_ = _tmp250_; + _tmp252_ = vala_ccode_base_module_get_delegate_target (self, _tmp251_); + _tmp253_ = _tmp252_; + _tmp254_ = _tmp253_ != NULL; + _vala_ccode_node_unref0 (_tmp253_); + if (_tmp254_) { + ValaCastExpression* _tmp255_; + ValaCastExpression* _tmp256_; + ValaExpression* _tmp257_; + ValaExpression* _tmp258_; + ValaCCodeExpression* _tmp259_ = NULL; + ValaCCodeExpression* _tmp260_; + _tmp255_ = expr; + _tmp256_ = expr; + _tmp257_ = vala_cast_expression_get_inner (_tmp256_); + _tmp258_ = _tmp257_; + _tmp259_ = vala_ccode_base_module_get_delegate_target (self, _tmp258_); + _tmp260_ = _tmp259_; + vala_ccode_base_module_set_delegate_target (self, (ValaExpression*) _tmp255_, _tmp260_); + _vala_ccode_node_unref0 (_tmp260_); } else { - ValaCastExpression* _tmp235_; - ValaCCodeConstant* _tmp236_; - ValaCCodeConstant* _tmp237_; - _tmp235_ = expr; - _tmp236_ = vala_ccode_constant_new ("NULL"); - _tmp237_ = _tmp236_; - vala_ccode_base_module_set_delegate_target (self, (ValaExpression*) _tmp235_, (ValaCCodeExpression*) _tmp237_); - _vala_ccode_node_unref0 (_tmp237_); + ValaCastExpression* _tmp261_; + ValaCCodeConstant* _tmp262_; + ValaCCodeConstant* _tmp263_; + _tmp261_ = expr; + _tmp262_ = vala_ccode_constant_new ("NULL"); + _tmp263_ = _tmp262_; + vala_ccode_base_module_set_delegate_target (self, (ValaExpression*) _tmp261_, (ValaCCodeExpression*) _tmp263_); + _vala_ccode_node_unref0 (_tmp263_); } - _tmp238_ = expr; - _tmp239_ = vala_cast_expression_get_inner (_tmp238_); - _tmp240_ = _tmp239_; - _tmp241_ = vala_ccode_base_module_get_delegate_target_destroy_notify (self, _tmp240_); - _tmp242_ = _tmp241_; - _tmp243_ = _tmp242_ != NULL; - _vala_ccode_node_unref0 (_tmp242_); - if (_tmp243_) { - ValaCastExpression* _tmp244_; - ValaCastExpression* _tmp245_; - ValaExpression* _tmp246_; - ValaExpression* _tmp247_; - ValaCCodeExpression* _tmp248_ = NULL; - ValaCCodeExpression* _tmp249_; - _tmp244_ = expr; - _tmp245_ = expr; - _tmp246_ = vala_cast_expression_get_inner (_tmp245_); - _tmp247_ = _tmp246_; - _tmp248_ = vala_ccode_base_module_get_delegate_target_destroy_notify (self, _tmp247_); - _tmp249_ = _tmp248_; - vala_ccode_base_module_set_delegate_target_destroy_notify (self, (ValaExpression*) _tmp244_, _tmp249_); - _vala_ccode_node_unref0 (_tmp249_); + _tmp264_ = expr; + _tmp265_ = vala_cast_expression_get_inner (_tmp264_); + _tmp266_ = _tmp265_; + _tmp267_ = vala_ccode_base_module_get_delegate_target_destroy_notify (self, _tmp266_); + _tmp268_ = _tmp267_; + _tmp269_ = _tmp268_ != NULL; + _vala_ccode_node_unref0 (_tmp268_); + if (_tmp269_) { + ValaCastExpression* _tmp270_; + ValaCastExpression* _tmp271_; + ValaExpression* _tmp272_; + ValaExpression* _tmp273_; + ValaCCodeExpression* _tmp274_ = NULL; + ValaCCodeExpression* _tmp275_; + _tmp270_ = expr; + _tmp271_ = expr; + _tmp272_ = vala_cast_expression_get_inner (_tmp271_); + _tmp273_ = _tmp272_; + _tmp274_ = vala_ccode_base_module_get_delegate_target_destroy_notify (self, _tmp273_); + _tmp275_ = _tmp274_; + vala_ccode_base_module_set_delegate_target_destroy_notify (self, (ValaExpression*) _tmp270_, _tmp275_); + _vala_ccode_node_unref0 (_tmp275_); } else { - ValaCastExpression* _tmp250_; - ValaCCodeConstant* _tmp251_; - ValaCCodeConstant* _tmp252_; - _tmp250_ = expr; - _tmp251_ = vala_ccode_constant_new ("NULL"); - _tmp252_ = _tmp251_; - vala_ccode_base_module_set_delegate_target_destroy_notify (self, (ValaExpression*) _tmp250_, (ValaCCodeExpression*) _tmp252_); - _vala_ccode_node_unref0 (_tmp252_); + ValaCastExpression* _tmp276_; + ValaCCodeConstant* _tmp277_; + ValaCCodeConstant* _tmp278_; + _tmp276_ = expr; + _tmp277_ = vala_ccode_constant_new ("NULL"); + _tmp278_ = _tmp277_; + vala_ccode_base_module_set_delegate_target_destroy_notify (self, (ValaExpression*) _tmp276_, (ValaCCodeExpression*) _tmp278_); + _vala_ccode_node_unref0 (_tmp278_); } } _vala_ccode_node_unref0 (innercexpr); diff --git a/codegen/valaccodebasemodule.vala b/codegen/valaccodebasemodule.vala index 8b2a359..03f801a 100644 --- a/codegen/valaccodebasemodule.vala +++ b/codegen/valaccodebasemodule.vala @@ -1088,16 +1088,26 @@ public abstract class Vala.CCodeBaseModule : CodeGenerator { ccode.add_assignment (lhs, rhs); - if (f.variable_type is ArrayType && get_ccode_array_length (f) && - f.initializer is ArrayCreationExpression) { + if (f.variable_type is ArrayType && get_ccode_array_length (f)) { var array_type = (ArrayType) f.variable_type; var field_value = get_field_cvalue (f, load_this_parameter ((TypeSymbol) f.parent_symbol)); - List sizes = ((ArrayCreationExpression) f.initializer).get_sizes (); - for (int dim = 1; dim <= array_type.rank; dim++) { - var array_len_lhs = get_array_length_cvalue (field_value, dim); - var size = sizes[dim - 1]; - ccode.add_assignment (array_len_lhs, get_cvalue (size)); + var glib_value = (GLibValue) f.initializer.target_value; + if (glib_value.array_length_cvalues != null) { + for (int dim = 1; dim <= array_type.rank; dim++) { + var array_len_lhs = get_array_length_cvalue (field_value, dim); + ccode.add_assignment (array_len_lhs, get_array_length_cvalue (glib_value, dim)); + } + } else if (glib_value.array_null_terminated) { + requires_array_length = true; + var len_call = new CCodeFunctionCall (new CCodeIdentifier ("_vala_array_length")); + len_call.add_argument (get_cvalue_ (glib_value)); + + ccode.add_assignment (get_array_length_cvalue (field_value, 1), len_call); + } else { + for (int dim = 1; dim <= array_type.rank; dim++) { + ccode.add_assignment (get_array_length_cvalue (field_value, dim), new CCodeConstant ("-1")); + } } if (array_type.rank == 1 && f.is_internal_symbol ()) { @@ -1267,16 +1277,26 @@ public abstract class Vala.CCodeBaseModule : CodeGenerator { ccode.add_assignment (lhs, rhs); } - if (f.variable_type is ArrayType && get_ccode_array_length (f) && - f.initializer is ArrayCreationExpression) { + if (f.variable_type is ArrayType && get_ccode_array_length (f)) { var array_type = (ArrayType) f.variable_type; var field_value = get_field_cvalue (f, null); - List sizes = ((ArrayCreationExpression) f.initializer).get_sizes (); - for (int dim = 1; dim <= array_type.rank; dim++) { - var array_len_lhs = get_array_length_cvalue (field_value, dim); - var size = sizes[dim - 1]; - ccode.add_assignment (array_len_lhs, get_cvalue (size)); + var glib_value = (GLibValue) f.initializer.target_value; + if (glib_value.array_length_cvalues != null) { + for (int dim = 1; dim <= array_type.rank; dim++) { + var array_len_lhs = get_array_length_cvalue (field_value, dim); + ccode.add_assignment (array_len_lhs, get_array_length_cvalue (glib_value, dim)); + } + } else if (glib_value.array_null_terminated) { + requires_array_length = true; + var len_call = new CCodeFunctionCall (new CCodeIdentifier ("_vala_array_length")); + len_call.add_argument (get_cvalue_ (glib_value)); + + ccode.add_assignment (get_array_length_cvalue (field_value, 1), len_call); + } else { + for (int dim = 1; dim <= array_type.rank; dim++) { + ccode.add_assignment (get_array_length_cvalue (field_value, dim), new CCodeConstant ("-1")); + } } } } else { @@ -5005,14 +5025,21 @@ public abstract class Vala.CCodeBaseModule : CodeGenerator { // recompute array length when casting to other array type var array_type = expr.type_reference as ArrayType; if (array_type != null && expr.inner.value_type is ArrayType) { - var sizeof_to = new CCodeFunctionCall (new CCodeIdentifier ("sizeof")); - sizeof_to.add_argument (new CCodeConstant (get_ccode_name (array_type.element_type))); + if (array_type.element_type is GenericType || ((ArrayType) expr.inner.value_type).element_type is GenericType) { + // element size unknown for generic arrays, retain array length as is + for (int dim = 1; dim <= array_type.rank; dim++) { + append_array_length (expr, get_array_length_cexpression (expr.inner, dim)); + } + } else { + var sizeof_to = new CCodeFunctionCall (new CCodeIdentifier ("sizeof")); + sizeof_to.add_argument (new CCodeConstant (get_ccode_name (array_type.element_type))); - var sizeof_from = new CCodeFunctionCall (new CCodeIdentifier ("sizeof")); - sizeof_from.add_argument (new CCodeConstant (get_ccode_name (((ArrayType) expr.inner.value_type).element_type))); + var sizeof_from = new CCodeFunctionCall (new CCodeIdentifier ("sizeof")); + sizeof_from.add_argument (new CCodeConstant (get_ccode_name (((ArrayType) expr.inner.value_type).element_type))); - for (int dim = 1; dim <= array_type.rank; dim++) { - append_array_length (expr, new CCodeBinaryExpression (CCodeBinaryOperator.DIV, new CCodeBinaryExpression (CCodeBinaryOperator.MUL, get_array_length_cexpression (expr.inner, dim), sizeof_from), sizeof_to)); + for (int dim = 1; dim <= array_type.rank; dim++) { + append_array_length (expr, new CCodeBinaryExpression (CCodeBinaryOperator.DIV, new CCodeBinaryExpression (CCodeBinaryOperator.MUL, get_array_length_cexpression (expr.inner, dim), sizeof_from), sizeof_to)); + } } } else if (array_type != null) { // cast from non-array to array, set invalid length diff --git a/codegen/valaccodemethodmodule.c b/codegen/valaccodemethodmodule.c index 8d7e203..1ec4ac3 100644 --- a/codegen/valaccodemethodmodule.c +++ b/codegen/valaccodemethodmodule.c @@ -2068,33 +2068,33 @@ static void vala_ccode_method_module_real_visit_method (ValaCodeVisitor* base, V gboolean _tmp323_; gboolean _tmp324_; gboolean _tmp332_; - gboolean _tmp1059_; - ValaMethod* _tmp1100_; - ValaBlock* _tmp1101_; - ValaBlock* _tmp1102_; - gboolean _tmp1106_; - gboolean _tmp1137_ = FALSE; - ValaMethod* _tmp1138_; - gboolean _tmp1139_; - gboolean _tmp1140_; - gboolean _tmp1148_; - gboolean _tmp1292_ = FALSE; - ValaMethod* _tmp1293_; - gboolean _tmp1294_; - gboolean _tmp1295_; - gboolean _tmp1298_; - gboolean _tmp1334_ = FALSE; - gboolean _tmp1335_ = FALSE; - gboolean _tmp1336_ = FALSE; - ValaMethod* _tmp1337_; - gboolean _tmp1338_; - gboolean _tmp1339_; + gboolean _tmp1064_; + ValaMethod* _tmp1105_; + ValaBlock* _tmp1106_; + ValaBlock* _tmp1107_; + gboolean _tmp1111_; + gboolean _tmp1142_ = FALSE; + ValaMethod* _tmp1143_; + gboolean _tmp1144_; + gboolean _tmp1145_; + gboolean _tmp1153_; + gboolean _tmp1297_ = FALSE; + ValaMethod* _tmp1298_; + gboolean _tmp1299_; + gboolean _tmp1300_; + gboolean _tmp1303_; + gboolean _tmp1339_ = FALSE; + gboolean _tmp1340_ = FALSE; + gboolean _tmp1341_ = FALSE; + ValaMethod* _tmp1342_; gboolean _tmp1343_; - gboolean _tmp1347_; - gboolean _tmp1351_; - ValaMethod* _tmp1364_; - gboolean _tmp1365_; - gboolean _tmp1366_; + gboolean _tmp1344_; + gboolean _tmp1348_; + gboolean _tmp1352_; + gboolean _tmp1356_; + ValaMethod* _tmp1369_; + gboolean _tmp1370_; + gboolean _tmp1371_; self = (ValaCCodeMethodModule*) base; g_return_if_fail (m != NULL); _tmp0_ = m; @@ -2959,13 +2959,13 @@ static void vala_ccode_method_module_real_visit_method (ValaCodeVisitor* base, V gboolean _tmp800_; gboolean _tmp804_; ValaMethod* _tmp821_; - gboolean _tmp1029_ = FALSE; - ValaCodeContext* _tmp1030_; - ValaCodeContext* _tmp1031_; - ValaMethod* _tmp1032_; - ValaMethod* _tmp1033_; - ValaMethod* _tmp1034_; - gboolean _tmp1036_; + gboolean _tmp1034_ = FALSE; + ValaCodeContext* _tmp1035_; + ValaCodeContext* _tmp1036_; + ValaMethod* _tmp1037_; + ValaMethod* _tmp1038_; + ValaMethod* _tmp1039_; + gboolean _tmp1041_; _tmp336_ = m; _tmp337_ = vala_method_get_coroutine (_tmp336_); _tmp338_ = _tmp337_; @@ -4320,8 +4320,10 @@ static void vala_ccode_method_module_real_visit_method (ValaCodeVisitor* base, V ValaCCodeConstant* _tmp852_; ValaCCodeVariableDeclarator* _tmp853_; ValaCCodeVariableDeclarator* _tmp854_; - ValaClass* _tmp855_; - gboolean _tmp856_ = FALSE; + gboolean _tmp855_ = FALSE; + ValaClass* _tmp856_; + gboolean _tmp857_ = FALSE; + gboolean _tmp861_; _tmp840_ = m; _tmp841_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp840_); _tmp842_ = _tmp841_; @@ -4343,246 +4345,258 @@ static void vala_ccode_method_module_real_visit_method (ValaCodeVisitor* base, V _vala_ccode_node_unref0 (_tmp852_); _g_free0 (_tmp850_); _g_free0 (_tmp848_); - _tmp855_ = cl; - _tmp856_ = vala_class_is_fundamental (_tmp855_); - if (_tmp856_) { - ValaCCodeIdentifier* _tmp857_; - ValaCCodeIdentifier* _tmp858_; - ValaCCodeFunctionCall* _tmp859_; - ValaCCodeFunctionCall* _tmp860_; - ValaCCodeFunctionCall* ccall; - ValaCCodeFunctionCall* _tmp861_; - ValaCCodeExpression* _tmp862_ = NULL; - ValaCCodeExpression* _tmp863_; - ValaCCodeFunction* _tmp864_; - ValaCCodeFunction* _tmp865_; - ValaCCodeExpression* _tmp866_ = NULL; - ValaCCodeExpression* _tmp867_; - ValaCCodeFunctionCall* _tmp868_; - ValaClass* _tmp869_; - gchar* _tmp870_ = NULL; - gchar* _tmp871_; - gchar* _tmp872_; - gchar* _tmp873_; - ValaCCodeCastExpression* _tmp874_; - ValaCCodeCastExpression* _tmp875_; - _tmp857_ = vala_ccode_identifier_new ("g_type_create_instance"); - _tmp858_ = _tmp857_; - _tmp859_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp858_); + _tmp856_ = cl; + _tmp857_ = vala_class_is_fundamental (_tmp856_); + if (_tmp857_) { + ValaMethod* _tmp858_; + gboolean _tmp859_; + gboolean _tmp860_; + _tmp858_ = m; + _tmp859_ = vala_creation_method_get_chain_up (G_TYPE_CHECK_INSTANCE_CAST (_tmp858_, VALA_TYPE_CREATION_METHOD, ValaCreationMethod)); _tmp860_ = _tmp859_; - _vala_ccode_node_unref0 (_tmp858_); - ccall = _tmp860_; - _tmp861_ = ccall; - _tmp862_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, "object_type"); + _tmp855_ = !_tmp860_; + } else { + _tmp855_ = FALSE; + } + _tmp861_ = _tmp855_; + if (_tmp861_) { + ValaCCodeIdentifier* _tmp862_; + ValaCCodeIdentifier* _tmp863_; + ValaCCodeFunctionCall* _tmp864_; + ValaCCodeFunctionCall* _tmp865_; + ValaCCodeFunctionCall* ccall; + ValaCCodeFunctionCall* _tmp866_; + ValaCCodeExpression* _tmp867_ = NULL; + ValaCCodeExpression* _tmp868_; + ValaCCodeFunction* _tmp869_; + ValaCCodeFunction* _tmp870_; + ValaCCodeExpression* _tmp871_ = NULL; + ValaCCodeExpression* _tmp872_; + ValaCCodeFunctionCall* _tmp873_; + ValaClass* _tmp874_; + gchar* _tmp875_ = NULL; + gchar* _tmp876_; + gchar* _tmp877_; + gchar* _tmp878_; + ValaCCodeCastExpression* _tmp879_; + ValaCCodeCastExpression* _tmp880_; + _tmp862_ = vala_ccode_identifier_new ("g_type_create_instance"); _tmp863_ = _tmp862_; - vala_ccode_function_call_add_argument (_tmp861_, _tmp863_); - _vala_ccode_node_unref0 (_tmp863_); - _tmp864_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp864_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp863_); _tmp865_ = _tmp864_; - _tmp866_ = vala_ccode_base_module_get_this_cexpression ((ValaCCodeBaseModule*) self); - _tmp867_ = _tmp866_; - _tmp868_ = ccall; - _tmp869_ = cl; - _tmp870_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp869_); - _tmp871_ = _tmp870_; - _tmp872_ = g_strconcat (_tmp871_, "*", NULL); - _tmp873_ = _tmp872_; - _tmp874_ = vala_ccode_cast_expression_new ((ValaCCodeExpression*) _tmp868_, _tmp873_); - _tmp875_ = _tmp874_; - vala_ccode_function_add_assignment (_tmp865_, _tmp867_, (ValaCCodeExpression*) _tmp875_); - _vala_ccode_node_unref0 (_tmp875_); - _g_free0 (_tmp873_); - _g_free0 (_tmp871_); - _vala_ccode_node_unref0 (_tmp867_); + _vala_ccode_node_unref0 (_tmp863_); + ccall = _tmp865_; + _tmp866_ = ccall; + _tmp867_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, "object_type"); + _tmp868_ = _tmp867_; + vala_ccode_function_call_add_argument (_tmp866_, _tmp868_); + _vala_ccode_node_unref0 (_tmp868_); + _tmp869_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp870_ = _tmp869_; + _tmp871_ = vala_ccode_base_module_get_this_cexpression ((ValaCCodeBaseModule*) self); + _tmp872_ = _tmp871_; + _tmp873_ = ccall; + _tmp874_ = cl; + _tmp875_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp874_); + _tmp876_ = _tmp875_; + _tmp877_ = g_strconcat (_tmp876_, "*", NULL); + _tmp878_ = _tmp877_; + _tmp879_ = vala_ccode_cast_expression_new ((ValaCCodeExpression*) _tmp873_, _tmp878_); + _tmp880_ = _tmp879_; + vala_ccode_function_add_assignment (_tmp870_, _tmp872_, (ValaCCodeExpression*) _tmp880_); + _vala_ccode_node_unref0 (_tmp880_); + _g_free0 (_tmp878_); + _g_free0 (_tmp876_); + _vala_ccode_node_unref0 (_tmp872_); { - ValaClass* _tmp876_; - ValaClass* _tmp877_; - ValaList* _tmp878_ = NULL; + ValaClass* _tmp881_; + ValaClass* _tmp882_; + ValaList* _tmp883_ = NULL; ValaList* _type_param_list; - ValaList* _tmp879_; - gint _tmp880_; - gint _tmp881_; + ValaList* _tmp884_; + gint _tmp885_; + gint _tmp886_; gint _type_param_size; gint _type_param_index; - _tmp876_ = vala_ccode_base_module_get_current_class ((ValaCCodeBaseModule*) self); - _tmp877_ = _tmp876_; - _tmp878_ = vala_object_type_symbol_get_type_parameters ((ValaObjectTypeSymbol*) _tmp877_); - _type_param_list = _tmp878_; - _tmp879_ = _type_param_list; - _tmp880_ = vala_collection_get_size ((ValaCollection*) _tmp879_); - _tmp881_ = _tmp880_; - _type_param_size = _tmp881_; + _tmp881_ = vala_ccode_base_module_get_current_class ((ValaCCodeBaseModule*) self); + _tmp882_ = _tmp881_; + _tmp883_ = vala_object_type_symbol_get_type_parameters ((ValaObjectTypeSymbol*) _tmp882_); + _type_param_list = _tmp883_; + _tmp884_ = _type_param_list; + _tmp885_ = vala_collection_get_size ((ValaCollection*) _tmp884_); + _tmp886_ = _tmp885_; + _type_param_size = _tmp886_; _type_param_index = -1; while (TRUE) { - gint _tmp882_; - gint _tmp883_; - gint _tmp884_; - ValaList* _tmp885_; - gint _tmp886_; - gpointer _tmp887_ = NULL; + gint _tmp887_; + gint _tmp888_; + gint _tmp889_; + ValaList* _tmp890_; + gint _tmp891_; + gpointer _tmp892_ = NULL; ValaTypeParameter* type_param; ValaCCodeIdentifier* param_name = NULL; ValaCCodeAssignment* assign = NULL; - ValaCCodeIdentifier* _tmp888_; - ValaCCodeIdentifier* _tmp889_; - ValaCCodeMemberAccess* _tmp890_; - ValaCCodeMemberAccess* _tmp891_; + ValaCCodeIdentifier* _tmp893_; + ValaCCodeIdentifier* _tmp894_; + ValaCCodeMemberAccess* _tmp895_; + ValaCCodeMemberAccess* _tmp896_; ValaCCodeMemberAccess* priv_access; - ValaTypeParameter* _tmp892_; - const gchar* _tmp893_; - const gchar* _tmp894_; - gchar* _tmp895_ = NULL; - gchar* _tmp896_; - gchar* _tmp897_ = NULL; - gchar* _tmp898_; - ValaCCodeIdentifier* _tmp899_; - ValaCCodeMemberAccess* _tmp900_; - ValaCCodeIdentifier* _tmp901_; - const gchar* _tmp902_; - const gchar* _tmp903_; - ValaCCodeMemberAccess* _tmp904_; + ValaTypeParameter* _tmp897_; + const gchar* _tmp898_; + const gchar* _tmp899_; + gchar* _tmp900_ = NULL; + gchar* _tmp901_; + gchar* _tmp902_ = NULL; + gchar* _tmp903_; + ValaCCodeIdentifier* _tmp904_; ValaCCodeMemberAccess* _tmp905_; ValaCCodeIdentifier* _tmp906_; - ValaCCodeAssignment* _tmp907_; - ValaCCodeFunction* _tmp908_; - ValaCCodeFunction* _tmp909_; - ValaCCodeAssignment* _tmp910_; - ValaTypeParameter* _tmp911_; - const gchar* _tmp912_; - const gchar* _tmp913_; - gchar* _tmp914_ = NULL; - gchar* _tmp915_; - gchar* _tmp916_ = NULL; - gchar* _tmp917_; - ValaCCodeIdentifier* _tmp918_; - ValaCCodeMemberAccess* _tmp919_; - ValaCCodeIdentifier* _tmp920_; - const gchar* _tmp921_; - const gchar* _tmp922_; - ValaCCodeMemberAccess* _tmp923_; + const gchar* _tmp907_; + const gchar* _tmp908_; + ValaCCodeMemberAccess* _tmp909_; + ValaCCodeMemberAccess* _tmp910_; + ValaCCodeIdentifier* _tmp911_; + ValaCCodeAssignment* _tmp912_; + ValaCCodeFunction* _tmp913_; + ValaCCodeFunction* _tmp914_; + ValaCCodeAssignment* _tmp915_; + ValaTypeParameter* _tmp916_; + const gchar* _tmp917_; + const gchar* _tmp918_; + gchar* _tmp919_ = NULL; + gchar* _tmp920_; + gchar* _tmp921_ = NULL; + gchar* _tmp922_; + ValaCCodeIdentifier* _tmp923_; ValaCCodeMemberAccess* _tmp924_; ValaCCodeIdentifier* _tmp925_; - ValaCCodeAssignment* _tmp926_; - ValaCCodeFunction* _tmp927_; - ValaCCodeFunction* _tmp928_; - ValaCCodeAssignment* _tmp929_; - ValaTypeParameter* _tmp930_; - const gchar* _tmp931_; - const gchar* _tmp932_; - gchar* _tmp933_ = NULL; - gchar* _tmp934_; - gchar* _tmp935_ = NULL; - gchar* _tmp936_; - ValaCCodeIdentifier* _tmp937_; - ValaCCodeMemberAccess* _tmp938_; - ValaCCodeIdentifier* _tmp939_; - const gchar* _tmp940_; - const gchar* _tmp941_; - ValaCCodeMemberAccess* _tmp942_; + const gchar* _tmp926_; + const gchar* _tmp927_; + ValaCCodeMemberAccess* _tmp928_; + ValaCCodeMemberAccess* _tmp929_; + ValaCCodeIdentifier* _tmp930_; + ValaCCodeAssignment* _tmp931_; + ValaCCodeFunction* _tmp932_; + ValaCCodeFunction* _tmp933_; + ValaCCodeAssignment* _tmp934_; + ValaTypeParameter* _tmp935_; + const gchar* _tmp936_; + const gchar* _tmp937_; + gchar* _tmp938_ = NULL; + gchar* _tmp939_; + gchar* _tmp940_ = NULL; + gchar* _tmp941_; + ValaCCodeIdentifier* _tmp942_; ValaCCodeMemberAccess* _tmp943_; ValaCCodeIdentifier* _tmp944_; - ValaCCodeAssignment* _tmp945_; - ValaCCodeFunction* _tmp946_; - ValaCCodeFunction* _tmp947_; - ValaCCodeAssignment* _tmp948_; - _tmp882_ = _type_param_index; - _type_param_index = _tmp882_ + 1; - _tmp883_ = _type_param_index; - _tmp884_ = _type_param_size; - if (!(_tmp883_ < _tmp884_)) { + const gchar* _tmp945_; + const gchar* _tmp946_; + ValaCCodeMemberAccess* _tmp947_; + ValaCCodeMemberAccess* _tmp948_; + ValaCCodeIdentifier* _tmp949_; + ValaCCodeAssignment* _tmp950_; + ValaCCodeFunction* _tmp951_; + ValaCCodeFunction* _tmp952_; + ValaCCodeAssignment* _tmp953_; + _tmp887_ = _type_param_index; + _type_param_index = _tmp887_ + 1; + _tmp888_ = _type_param_index; + _tmp889_ = _type_param_size; + if (!(_tmp888_ < _tmp889_)) { break; } - _tmp885_ = _type_param_list; - _tmp886_ = _type_param_index; - _tmp887_ = vala_list_get (_tmp885_, _tmp886_); - type_param = (ValaTypeParameter*) _tmp887_; - _tmp888_ = vala_ccode_identifier_new ("self"); - _tmp889_ = _tmp888_; - _tmp890_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp889_, "priv"); - _tmp891_ = _tmp890_; - _vala_ccode_node_unref0 (_tmp889_); - priv_access = _tmp891_; - _tmp892_ = type_param; - _tmp893_ = vala_symbol_get_name ((ValaSymbol*) _tmp892_); + _tmp890_ = _type_param_list; + _tmp891_ = _type_param_index; + _tmp892_ = vala_list_get (_tmp890_, _tmp891_); + type_param = (ValaTypeParameter*) _tmp892_; + _tmp893_ = vala_ccode_identifier_new ("self"); _tmp894_ = _tmp893_; - _tmp895_ = g_utf8_strdown (_tmp894_, (gssize) (-1)); + _tmp895_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp894_, "priv"); _tmp896_ = _tmp895_; - _tmp897_ = g_strdup_printf ("%s_type", _tmp896_); - _tmp898_ = _tmp897_; - _tmp899_ = vala_ccode_identifier_new (_tmp898_); - _vala_ccode_node_unref0 (param_name); - param_name = _tmp899_; - _g_free0 (_tmp898_); - _g_free0 (_tmp896_); - _tmp900_ = priv_access; - _tmp901_ = param_name; - _tmp902_ = vala_ccode_identifier_get_name (_tmp901_); + _vala_ccode_node_unref0 (_tmp894_); + priv_access = _tmp896_; + _tmp897_ = type_param; + _tmp898_ = vala_symbol_get_name ((ValaSymbol*) _tmp897_); + _tmp899_ = _tmp898_; + _tmp900_ = g_utf8_strdown (_tmp899_, (gssize) (-1)); + _tmp901_ = _tmp900_; + _tmp902_ = g_strdup_printf ("%s_type", _tmp901_); _tmp903_ = _tmp902_; - _tmp904_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp900_, _tmp903_); - _tmp905_ = _tmp904_; + _tmp904_ = vala_ccode_identifier_new (_tmp903_); + _vala_ccode_node_unref0 (param_name); + param_name = _tmp904_; + _g_free0 (_tmp903_); + _g_free0 (_tmp901_); + _tmp905_ = priv_access; _tmp906_ = param_name; - _tmp907_ = vala_ccode_assignment_new ((ValaCCodeExpression*) _tmp905_, (ValaCCodeExpression*) _tmp906_, VALA_CCODE_ASSIGNMENT_OPERATOR_SIMPLE); + _tmp907_ = vala_ccode_identifier_get_name (_tmp906_); + _tmp908_ = _tmp907_; + _tmp909_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp905_, _tmp908_); + _tmp910_ = _tmp909_; + _tmp911_ = param_name; + _tmp912_ = vala_ccode_assignment_new ((ValaCCodeExpression*) _tmp910_, (ValaCCodeExpression*) _tmp911_, VALA_CCODE_ASSIGNMENT_OPERATOR_SIMPLE); _vala_ccode_node_unref0 (assign); - assign = _tmp907_; - _vala_ccode_node_unref0 (_tmp905_); - _tmp908_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); - _tmp909_ = _tmp908_; - _tmp910_ = assign; - vala_ccode_function_add_expression (_tmp909_, (ValaCCodeExpression*) _tmp910_); - _tmp911_ = type_param; - _tmp912_ = vala_symbol_get_name ((ValaSymbol*) _tmp911_); - _tmp913_ = _tmp912_; - _tmp914_ = g_utf8_strdown (_tmp913_, (gssize) (-1)); - _tmp915_ = _tmp914_; - _tmp916_ = g_strdup_printf ("%s_dup_func", _tmp915_); - _tmp917_ = _tmp916_; - _tmp918_ = vala_ccode_identifier_new (_tmp917_); - _vala_ccode_node_unref0 (param_name); - param_name = _tmp918_; - _g_free0 (_tmp917_); - _g_free0 (_tmp915_); - _tmp919_ = priv_access; - _tmp920_ = param_name; - _tmp921_ = vala_ccode_identifier_get_name (_tmp920_); + assign = _tmp912_; + _vala_ccode_node_unref0 (_tmp910_); + _tmp913_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp914_ = _tmp913_; + _tmp915_ = assign; + vala_ccode_function_add_expression (_tmp914_, (ValaCCodeExpression*) _tmp915_); + _tmp916_ = type_param; + _tmp917_ = vala_symbol_get_name ((ValaSymbol*) _tmp916_); + _tmp918_ = _tmp917_; + _tmp919_ = g_utf8_strdown (_tmp918_, (gssize) (-1)); + _tmp920_ = _tmp919_; + _tmp921_ = g_strdup_printf ("%s_dup_func", _tmp920_); _tmp922_ = _tmp921_; - _tmp923_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp919_, _tmp922_); - _tmp924_ = _tmp923_; + _tmp923_ = vala_ccode_identifier_new (_tmp922_); + _vala_ccode_node_unref0 (param_name); + param_name = _tmp923_; + _g_free0 (_tmp922_); + _g_free0 (_tmp920_); + _tmp924_ = priv_access; _tmp925_ = param_name; - _tmp926_ = vala_ccode_assignment_new ((ValaCCodeExpression*) _tmp924_, (ValaCCodeExpression*) _tmp925_, VALA_CCODE_ASSIGNMENT_OPERATOR_SIMPLE); + _tmp926_ = vala_ccode_identifier_get_name (_tmp925_); + _tmp927_ = _tmp926_; + _tmp928_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp924_, _tmp927_); + _tmp929_ = _tmp928_; + _tmp930_ = param_name; + _tmp931_ = vala_ccode_assignment_new ((ValaCCodeExpression*) _tmp929_, (ValaCCodeExpression*) _tmp930_, VALA_CCODE_ASSIGNMENT_OPERATOR_SIMPLE); _vala_ccode_node_unref0 (assign); - assign = _tmp926_; - _vala_ccode_node_unref0 (_tmp924_); - _tmp927_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); - _tmp928_ = _tmp927_; - _tmp929_ = assign; - vala_ccode_function_add_expression (_tmp928_, (ValaCCodeExpression*) _tmp929_); - _tmp930_ = type_param; - _tmp931_ = vala_symbol_get_name ((ValaSymbol*) _tmp930_); - _tmp932_ = _tmp931_; - _tmp933_ = g_utf8_strdown (_tmp932_, (gssize) (-1)); - _tmp934_ = _tmp933_; - _tmp935_ = g_strdup_printf ("%s_destroy_func", _tmp934_); - _tmp936_ = _tmp935_; - _tmp937_ = vala_ccode_identifier_new (_tmp936_); - _vala_ccode_node_unref0 (param_name); - param_name = _tmp937_; - _g_free0 (_tmp936_); - _g_free0 (_tmp934_); - _tmp938_ = priv_access; - _tmp939_ = param_name; - _tmp940_ = vala_ccode_identifier_get_name (_tmp939_); + assign = _tmp931_; + _vala_ccode_node_unref0 (_tmp929_); + _tmp932_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp933_ = _tmp932_; + _tmp934_ = assign; + vala_ccode_function_add_expression (_tmp933_, (ValaCCodeExpression*) _tmp934_); + _tmp935_ = type_param; + _tmp936_ = vala_symbol_get_name ((ValaSymbol*) _tmp935_); + _tmp937_ = _tmp936_; + _tmp938_ = g_utf8_strdown (_tmp937_, (gssize) (-1)); + _tmp939_ = _tmp938_; + _tmp940_ = g_strdup_printf ("%s_destroy_func", _tmp939_); _tmp941_ = _tmp940_; - _tmp942_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp938_, _tmp941_); - _tmp943_ = _tmp942_; + _tmp942_ = vala_ccode_identifier_new (_tmp941_); + _vala_ccode_node_unref0 (param_name); + param_name = _tmp942_; + _g_free0 (_tmp941_); + _g_free0 (_tmp939_); + _tmp943_ = priv_access; _tmp944_ = param_name; - _tmp945_ = vala_ccode_assignment_new ((ValaCCodeExpression*) _tmp943_, (ValaCCodeExpression*) _tmp944_, VALA_CCODE_ASSIGNMENT_OPERATOR_SIMPLE); + _tmp945_ = vala_ccode_identifier_get_name (_tmp944_); + _tmp946_ = _tmp945_; + _tmp947_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp943_, _tmp946_); + _tmp948_ = _tmp947_; + _tmp949_ = param_name; + _tmp950_ = vala_ccode_assignment_new ((ValaCCodeExpression*) _tmp948_, (ValaCCodeExpression*) _tmp949_, VALA_CCODE_ASSIGNMENT_OPERATOR_SIMPLE); _vala_ccode_node_unref0 (assign); - assign = _tmp945_; - _vala_ccode_node_unref0 (_tmp943_); - _tmp946_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); - _tmp947_ = _tmp946_; - _tmp948_ = assign; - vala_ccode_function_add_expression (_tmp947_, (ValaCCodeExpression*) _tmp948_); + assign = _tmp950_; + _vala_ccode_node_unref0 (_tmp948_); + _tmp951_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp952_ = _tmp951_; + _tmp953_ = assign; + vala_ccode_function_add_expression (_tmp952_, (ValaCCodeExpression*) _tmp953_); _vala_ccode_node_unref0 (priv_access); _vala_ccode_node_unref0 (assign); _vala_ccode_node_unref0 (param_name); @@ -4594,1339 +4608,1353 @@ static void vala_ccode_method_module_real_visit_method (ValaCodeVisitor* base, V } _vala_code_node_unref0 (cl); } else { - ValaTypeSymbol* _tmp949_; - ValaTypeSymbol* _tmp950_; - _tmp949_ = vala_ccode_base_module_get_current_type_symbol ((ValaCCodeBaseModule*) self); - _tmp950_ = _tmp949_; - if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp950_, VALA_TYPE_CLASS)) { - ValaMethod* _tmp951_; - ValaSymbol* _tmp952_; - ValaSymbol* _tmp953_; - ValaClass* _tmp954_; + ValaTypeSymbol* _tmp954_; + ValaTypeSymbol* _tmp955_; + _tmp954_ = vala_ccode_base_module_get_current_type_symbol ((ValaCCodeBaseModule*) self); + _tmp955_ = _tmp954_; + if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp955_, VALA_TYPE_CLASS)) { + ValaMethod* _tmp956_; + ValaSymbol* _tmp957_; + ValaSymbol* _tmp958_; + ValaClass* _tmp959_; ValaClass* cl; - ValaMethod* _tmp955_; - gboolean _tmp956_; - gboolean _tmp957_; - ValaMethod* _tmp967_; - gboolean _tmp968_; - gboolean _tmp969_; - ValaClass* _tmp985_; - ValaClass* _tmp986_; - ValaClass* _tmp987_; - _tmp951_ = m; - _tmp952_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp951_); - _tmp953_ = _tmp952_; - _tmp954_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp953_, VALA_TYPE_CLASS, ValaClass)); - cl = _tmp954_; - _tmp955_ = m; - _tmp956_ = vala_method_get_coroutine (_tmp955_); - _tmp957_ = _tmp956_; - if (!_tmp957_) { - ValaCCodeFunction* _tmp958_; - ValaCCodeFunction* _tmp959_; - ValaClass* _tmp960_; - gchar* _tmp961_ = NULL; - gchar* _tmp962_; - gchar* _tmp963_; - gchar* _tmp964_; - ValaCCodeVariableDeclarator* _tmp965_; - ValaCCodeVariableDeclarator* _tmp966_; - _tmp958_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); - _tmp959_ = _tmp958_; - _tmp960_ = cl; - _tmp961_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp960_); - _tmp962_ = _tmp961_; - _tmp963_ = g_strconcat (_tmp962_, "*", NULL); + ValaMethod* _tmp960_; + gboolean _tmp961_; + gboolean _tmp962_; + ValaMethod* _tmp972_; + gboolean _tmp973_; + gboolean _tmp974_; + ValaClass* _tmp990_; + ValaClass* _tmp991_; + ValaClass* _tmp992_; + _tmp956_ = m; + _tmp957_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp956_); + _tmp958_ = _tmp957_; + _tmp959_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp958_, VALA_TYPE_CLASS, ValaClass)); + cl = _tmp959_; + _tmp960_ = m; + _tmp961_ = vala_method_get_coroutine (_tmp960_); + _tmp962_ = _tmp961_; + if (!_tmp962_) { + ValaCCodeFunction* _tmp963_; + ValaCCodeFunction* _tmp964_; + ValaClass* _tmp965_; + gchar* _tmp966_ = NULL; + gchar* _tmp967_; + gchar* _tmp968_; + gchar* _tmp969_; + ValaCCodeVariableDeclarator* _tmp970_; + ValaCCodeVariableDeclarator* _tmp971_; + _tmp963_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); _tmp964_ = _tmp963_; - _tmp965_ = vala_ccode_variable_declarator_new ("self", NULL, NULL); - _tmp966_ = _tmp965_; - vala_ccode_function_add_declaration (_tmp959_, _tmp964_, (ValaCCodeDeclarator*) _tmp966_, 0); - _vala_ccode_node_unref0 (_tmp966_); - _g_free0 (_tmp964_); - _g_free0 (_tmp962_); - } - _tmp967_ = m; - _tmp968_ = vala_creation_method_get_chain_up (G_TYPE_CHECK_INSTANCE_CAST (_tmp967_, VALA_TYPE_CREATION_METHOD, ValaCreationMethod)); - _tmp969_ = _tmp968_; - if (!_tmp969_) { - ValaCCodeIdentifier* _tmp970_; - ValaCCodeIdentifier* _tmp971_; - ValaCCodeFunctionCall* _tmp972_; - ValaCCodeFunctionCall* _tmp973_; - ValaCCodeFunctionCall* ccall; - ValaCCodeFunctionCall* _tmp974_; - ValaClass* _tmp975_; - gchar* _tmp976_ = NULL; - gchar* _tmp977_; - ValaCCodeIdentifier* _tmp978_; - ValaCCodeIdentifier* _tmp979_; - ValaCCodeFunction* _tmp980_; - ValaCCodeFunction* _tmp981_; - ValaCCodeExpression* _tmp982_ = NULL; - ValaCCodeExpression* _tmp983_; - ValaCCodeFunctionCall* _tmp984_; - _tmp970_ = vala_ccode_identifier_new ("g_slice_new0"); + _tmp965_ = cl; + _tmp966_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp965_); + _tmp967_ = _tmp966_; + _tmp968_ = g_strconcat (_tmp967_, "*", NULL); + _tmp969_ = _tmp968_; + _tmp970_ = vala_ccode_variable_declarator_new ("self", NULL, NULL); _tmp971_ = _tmp970_; - _tmp972_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp971_); - _tmp973_ = _tmp972_; + vala_ccode_function_add_declaration (_tmp964_, _tmp969_, (ValaCCodeDeclarator*) _tmp971_, 0); _vala_ccode_node_unref0 (_tmp971_); - ccall = _tmp973_; - _tmp974_ = ccall; - _tmp975_ = cl; - _tmp976_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp975_); - _tmp977_ = _tmp976_; - _tmp978_ = vala_ccode_identifier_new (_tmp977_); - _tmp979_ = _tmp978_; - vala_ccode_function_call_add_argument (_tmp974_, (ValaCCodeExpression*) _tmp979_); - _vala_ccode_node_unref0 (_tmp979_); - _g_free0 (_tmp977_); - _tmp980_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); - _tmp981_ = _tmp980_; - _tmp982_ = vala_ccode_base_module_get_this_cexpression ((ValaCCodeBaseModule*) self); - _tmp983_ = _tmp982_; - _tmp984_ = ccall; - vala_ccode_function_add_assignment (_tmp981_, _tmp983_, (ValaCCodeExpression*) _tmp984_); - _vala_ccode_node_unref0 (_tmp983_); + _g_free0 (_tmp969_); + _g_free0 (_tmp967_); + } + _tmp972_ = m; + _tmp973_ = vala_creation_method_get_chain_up (G_TYPE_CHECK_INSTANCE_CAST (_tmp972_, VALA_TYPE_CREATION_METHOD, ValaCreationMethod)); + _tmp974_ = _tmp973_; + if (!_tmp974_) { + ValaCCodeIdentifier* _tmp975_; + ValaCCodeIdentifier* _tmp976_; + ValaCCodeFunctionCall* _tmp977_; + ValaCCodeFunctionCall* _tmp978_; + ValaCCodeFunctionCall* ccall; + ValaCCodeFunctionCall* _tmp979_; + ValaClass* _tmp980_; + gchar* _tmp981_ = NULL; + gchar* _tmp982_; + ValaCCodeIdentifier* _tmp983_; + ValaCCodeIdentifier* _tmp984_; + ValaCCodeFunction* _tmp985_; + ValaCCodeFunction* _tmp986_; + ValaCCodeExpression* _tmp987_ = NULL; + ValaCCodeExpression* _tmp988_; + ValaCCodeFunctionCall* _tmp989_; + _tmp975_ = vala_ccode_identifier_new ("g_slice_new0"); + _tmp976_ = _tmp975_; + _tmp977_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp976_); + _tmp978_ = _tmp977_; + _vala_ccode_node_unref0 (_tmp976_); + ccall = _tmp978_; + _tmp979_ = ccall; + _tmp980_ = cl; + _tmp981_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp980_); + _tmp982_ = _tmp981_; + _tmp983_ = vala_ccode_identifier_new (_tmp982_); + _tmp984_ = _tmp983_; + vala_ccode_function_call_add_argument (_tmp979_, (ValaCCodeExpression*) _tmp984_); + _vala_ccode_node_unref0 (_tmp984_); + _g_free0 (_tmp982_); + _tmp985_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp986_ = _tmp985_; + _tmp987_ = vala_ccode_base_module_get_this_cexpression ((ValaCCodeBaseModule*) self); + _tmp988_ = _tmp987_; + _tmp989_ = ccall; + vala_ccode_function_add_assignment (_tmp986_, _tmp988_, (ValaCCodeExpression*) _tmp989_); + _vala_ccode_node_unref0 (_tmp988_); _vala_ccode_node_unref0 (ccall); } - _tmp985_ = cl; - _tmp986_ = vala_class_get_base_class (_tmp985_); - _tmp987_ = _tmp986_; - if (_tmp987_ == NULL) { - ValaClass* _tmp988_; - gchar* _tmp989_ = NULL; - gchar* _tmp990_; - gchar* _tmp991_ = NULL; - gchar* _tmp992_; - ValaCCodeIdentifier* _tmp993_; - ValaCCodeIdentifier* _tmp994_; - ValaCCodeFunctionCall* _tmp995_; - ValaCCodeFunctionCall* _tmp996_; + _tmp990_ = cl; + _tmp991_ = vala_class_get_base_class (_tmp990_); + _tmp992_ = _tmp991_; + if (_tmp992_ == NULL) { + ValaClass* _tmp993_; + gchar* _tmp994_ = NULL; + gchar* _tmp995_; + gchar* _tmp996_ = NULL; + gchar* _tmp997_; + ValaCCodeIdentifier* _tmp998_; + ValaCCodeIdentifier* _tmp999_; + ValaCCodeFunctionCall* _tmp1000_; + ValaCCodeFunctionCall* _tmp1001_; ValaCCodeFunctionCall* cinitcall; - ValaCCodeFunctionCall* _tmp997_; - ValaCCodeExpression* _tmp998_ = NULL; - ValaCCodeExpression* _tmp999_; - ValaCCodeFunction* _tmp1000_; - ValaCCodeFunction* _tmp1001_; ValaCCodeFunctionCall* _tmp1002_; - _tmp988_ = cl; - _tmp989_ = vala_ccode_base_module_get_ccode_lower_case_name ((ValaCodeNode*) _tmp988_, NULL); - _tmp990_ = _tmp989_; - _tmp991_ = g_strdup_printf ("%s_instance_init", _tmp990_); - _tmp992_ = _tmp991_; - _tmp993_ = vala_ccode_identifier_new (_tmp992_); - _tmp994_ = _tmp993_; - _tmp995_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp994_); - _tmp996_ = _tmp995_; - _vala_ccode_node_unref0 (_tmp994_); - _g_free0 (_tmp992_); - _g_free0 (_tmp990_); - cinitcall = _tmp996_; - _tmp997_ = cinitcall; - _tmp998_ = vala_ccode_base_module_get_this_cexpression ((ValaCCodeBaseModule*) self); + ValaCCodeExpression* _tmp1003_ = NULL; + ValaCCodeExpression* _tmp1004_; + ValaCCodeFunction* _tmp1005_; + ValaCCodeFunction* _tmp1006_; + ValaCCodeFunctionCall* _tmp1007_; + _tmp993_ = cl; + _tmp994_ = vala_ccode_base_module_get_ccode_lower_case_name ((ValaCodeNode*) _tmp993_, NULL); + _tmp995_ = _tmp994_; + _tmp996_ = g_strdup_printf ("%s_instance_init", _tmp995_); + _tmp997_ = _tmp996_; + _tmp998_ = vala_ccode_identifier_new (_tmp997_); _tmp999_ = _tmp998_; - vala_ccode_function_call_add_argument (_tmp997_, _tmp999_); - _vala_ccode_node_unref0 (_tmp999_); - _tmp1000_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp1000_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp999_); _tmp1001_ = _tmp1000_; + _vala_ccode_node_unref0 (_tmp999_); + _g_free0 (_tmp997_); + _g_free0 (_tmp995_); + cinitcall = _tmp1001_; _tmp1002_ = cinitcall; - vala_ccode_function_add_expression (_tmp1001_, (ValaCCodeExpression*) _tmp1002_); + _tmp1003_ = vala_ccode_base_module_get_this_cexpression ((ValaCCodeBaseModule*) self); + _tmp1004_ = _tmp1003_; + vala_ccode_function_call_add_argument (_tmp1002_, _tmp1004_); + _vala_ccode_node_unref0 (_tmp1004_); + _tmp1005_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp1006_ = _tmp1005_; + _tmp1007_ = cinitcall; + vala_ccode_function_add_expression (_tmp1006_, (ValaCCodeExpression*) _tmp1007_); _vala_ccode_node_unref0 (cinitcall); } _vala_code_node_unref0 (cl); } else { - ValaMethod* _tmp1003_; - ValaSymbol* _tmp1004_; - ValaSymbol* _tmp1005_; - ValaStruct* _tmp1006_; + ValaMethod* _tmp1008_; + ValaSymbol* _tmp1009_; + ValaSymbol* _tmp1010_; + ValaStruct* _tmp1011_; ValaStruct* st; - ValaCCodeFile* _tmp1007_; - ValaCCodeIdentifier* _tmp1008_; - ValaCCodeIdentifier* _tmp1009_; - ValaCCodeFunctionCall* _tmp1010_; - ValaCCodeFunctionCall* _tmp1011_; - ValaCCodeFunctionCall* czero; - ValaCCodeFunctionCall* _tmp1012_; + ValaCCodeFile* _tmp1012_; ValaCCodeIdentifier* _tmp1013_; ValaCCodeIdentifier* _tmp1014_; ValaCCodeFunctionCall* _tmp1015_; - ValaCCodeConstant* _tmp1016_; - ValaCCodeConstant* _tmp1017_; - ValaCCodeFunctionCall* _tmp1018_; - ValaStruct* _tmp1019_; - gchar* _tmp1020_ = NULL; - gchar* _tmp1021_; - gchar* _tmp1022_ = NULL; - gchar* _tmp1023_; - ValaCCodeIdentifier* _tmp1024_; - ValaCCodeIdentifier* _tmp1025_; - ValaCCodeFunction* _tmp1026_; - ValaCCodeFunction* _tmp1027_; - ValaCCodeFunctionCall* _tmp1028_; - _tmp1003_ = m; - _tmp1004_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp1003_); - _tmp1005_ = _tmp1004_; - _tmp1006_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp1005_, VALA_TYPE_STRUCT, ValaStruct)); - st = _tmp1006_; - _tmp1007_ = ((ValaCCodeBaseModule*) self)->cfile; - vala_ccode_file_add_include (_tmp1007_, "string.h", FALSE); - _tmp1008_ = vala_ccode_identifier_new ("memset"); - _tmp1009_ = _tmp1008_; - _tmp1010_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp1009_); - _tmp1011_ = _tmp1010_; - _vala_ccode_node_unref0 (_tmp1009_); - czero = _tmp1011_; - _tmp1012_ = czero; - _tmp1013_ = vala_ccode_identifier_new ("self"); + ValaCCodeFunctionCall* _tmp1016_; + ValaCCodeFunctionCall* czero; + ValaCCodeFunctionCall* _tmp1017_; + ValaCCodeIdentifier* _tmp1018_; + ValaCCodeIdentifier* _tmp1019_; + ValaCCodeFunctionCall* _tmp1020_; + ValaCCodeConstant* _tmp1021_; + ValaCCodeConstant* _tmp1022_; + ValaCCodeFunctionCall* _tmp1023_; + ValaStruct* _tmp1024_; + gchar* _tmp1025_ = NULL; + gchar* _tmp1026_; + gchar* _tmp1027_ = NULL; + gchar* _tmp1028_; + ValaCCodeIdentifier* _tmp1029_; + ValaCCodeIdentifier* _tmp1030_; + ValaCCodeFunction* _tmp1031_; + ValaCCodeFunction* _tmp1032_; + ValaCCodeFunctionCall* _tmp1033_; + _tmp1008_ = m; + _tmp1009_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp1008_); + _tmp1010_ = _tmp1009_; + _tmp1011_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp1010_, VALA_TYPE_STRUCT, ValaStruct)); + st = _tmp1011_; + _tmp1012_ = ((ValaCCodeBaseModule*) self)->cfile; + vala_ccode_file_add_include (_tmp1012_, "string.h", FALSE); + _tmp1013_ = vala_ccode_identifier_new ("memset"); _tmp1014_ = _tmp1013_; - vala_ccode_function_call_add_argument (_tmp1012_, (ValaCCodeExpression*) _tmp1014_); + _tmp1015_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp1014_); + _tmp1016_ = _tmp1015_; _vala_ccode_node_unref0 (_tmp1014_); - _tmp1015_ = czero; - _tmp1016_ = vala_ccode_constant_new ("0"); - _tmp1017_ = _tmp1016_; - vala_ccode_function_call_add_argument (_tmp1015_, (ValaCCodeExpression*) _tmp1017_); - _vala_ccode_node_unref0 (_tmp1017_); - _tmp1018_ = czero; - _tmp1019_ = st; - _tmp1020_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp1019_); - _tmp1021_ = _tmp1020_; - _tmp1022_ = g_strdup_printf ("sizeof (%s)", _tmp1021_); - _tmp1023_ = _tmp1022_; - _tmp1024_ = vala_ccode_identifier_new (_tmp1023_); - _tmp1025_ = _tmp1024_; - vala_ccode_function_call_add_argument (_tmp1018_, (ValaCCodeExpression*) _tmp1025_); - _vala_ccode_node_unref0 (_tmp1025_); - _g_free0 (_tmp1023_); - _g_free0 (_tmp1021_); - _tmp1026_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); - _tmp1027_ = _tmp1026_; - _tmp1028_ = czero; - vala_ccode_function_add_expression (_tmp1027_, (ValaCCodeExpression*) _tmp1028_); + czero = _tmp1016_; + _tmp1017_ = czero; + _tmp1018_ = vala_ccode_identifier_new ("self"); + _tmp1019_ = _tmp1018_; + vala_ccode_function_call_add_argument (_tmp1017_, (ValaCCodeExpression*) _tmp1019_); + _vala_ccode_node_unref0 (_tmp1019_); + _tmp1020_ = czero; + _tmp1021_ = vala_ccode_constant_new ("0"); + _tmp1022_ = _tmp1021_; + vala_ccode_function_call_add_argument (_tmp1020_, (ValaCCodeExpression*) _tmp1022_); + _vala_ccode_node_unref0 (_tmp1022_); + _tmp1023_ = czero; + _tmp1024_ = st; + _tmp1025_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp1024_); + _tmp1026_ = _tmp1025_; + _tmp1027_ = g_strdup_printf ("sizeof (%s)", _tmp1026_); + _tmp1028_ = _tmp1027_; + _tmp1029_ = vala_ccode_identifier_new (_tmp1028_); + _tmp1030_ = _tmp1029_; + vala_ccode_function_call_add_argument (_tmp1023_, (ValaCCodeExpression*) _tmp1030_); + _vala_ccode_node_unref0 (_tmp1030_); + _g_free0 (_tmp1028_); + _g_free0 (_tmp1026_); + _tmp1031_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp1032_ = _tmp1031_; + _tmp1033_ = czero; + vala_ccode_function_add_expression (_tmp1032_, (ValaCCodeExpression*) _tmp1033_); _vala_ccode_node_unref0 (czero); _vala_code_node_unref0 (st); } } } } - _tmp1030_ = vala_ccode_base_module_get_context ((ValaCCodeBaseModule*) self); - _tmp1031_ = _tmp1030_; - _tmp1032_ = vala_code_context_get_module_init_method (_tmp1031_); - _tmp1033_ = _tmp1032_; - _tmp1034_ = m; - if (_tmp1033_ == _tmp1034_) { - gboolean _tmp1035_; - _tmp1035_ = ((ValaCCodeBaseModule*) self)->in_plugin; - _tmp1029_ = _tmp1035_; + _tmp1035_ = vala_ccode_base_module_get_context ((ValaCCodeBaseModule*) self); + _tmp1036_ = _tmp1035_; + _tmp1037_ = vala_code_context_get_module_init_method (_tmp1036_); + _tmp1038_ = _tmp1037_; + _tmp1039_ = m; + if (_tmp1038_ == _tmp1039_) { + gboolean _tmp1040_; + _tmp1040_ = ((ValaCCodeBaseModule*) self)->in_plugin; + _tmp1034_ = _tmp1040_; } else { - _tmp1029_ = FALSE; + _tmp1034_ = FALSE; } - _tmp1036_ = _tmp1029_; - if (_tmp1036_) { - ValaCodeContext* _tmp1037_; - ValaCodeContext* _tmp1038_; - ValaNamespace* _tmp1039_; - ValaNamespace* _tmp1040_; - GHashFunc _tmp1041_; - GEqualFunc _tmp1042_; - ValaHashSet* _tmp1043_; - ValaHashSet* _tmp1044_; - _tmp1037_ = vala_ccode_base_module_get_context ((ValaCCodeBaseModule*) self); - _tmp1038_ = _tmp1037_; - _tmp1039_ = vala_code_context_get_root (_tmp1038_); - _tmp1040_ = _tmp1039_; - _tmp1041_ = g_direct_hash; - _tmp1042_ = g_direct_equal; - _tmp1043_ = vala_hash_set_new (VALA_TYPE_SYMBOL, (GBoxedCopyFunc) vala_code_node_ref, vala_code_node_unref, _tmp1041_, _tmp1042_); - _tmp1044_ = _tmp1043_; - vala_ccode_method_module_register_plugin_types (self, (ValaSymbol*) _tmp1040_, (ValaSet*) _tmp1044_); - _vala_iterable_unref0 (_tmp1044_); + _tmp1041_ = _tmp1034_; + if (_tmp1041_) { + ValaCodeContext* _tmp1042_; + ValaCodeContext* _tmp1043_; + ValaNamespace* _tmp1044_; + ValaNamespace* _tmp1045_; + GHashFunc _tmp1046_; + GEqualFunc _tmp1047_; + ValaHashSet* _tmp1048_; + ValaHashSet* _tmp1049_; + _tmp1042_ = vala_ccode_base_module_get_context ((ValaCCodeBaseModule*) self); + _tmp1043_ = _tmp1042_; + _tmp1044_ = vala_code_context_get_root (_tmp1043_); + _tmp1045_ = _tmp1044_; + _tmp1046_ = g_direct_hash; + _tmp1047_ = g_direct_equal; + _tmp1048_ = vala_hash_set_new (VALA_TYPE_SYMBOL, (GBoxedCopyFunc) vala_code_node_ref, vala_code_node_unref, _tmp1046_, _tmp1047_); + _tmp1049_ = _tmp1048_; + vala_ccode_method_module_register_plugin_types (self, (ValaSymbol*) _tmp1045_, (ValaSet*) _tmp1049_); + _vala_iterable_unref0 (_tmp1049_); } { - ValaMethod* _tmp1045_; - ValaList* _tmp1046_ = NULL; + ValaMethod* _tmp1050_; + ValaList* _tmp1051_ = NULL; ValaList* _precondition_list; - ValaList* _tmp1047_; - gint _tmp1048_; - gint _tmp1049_; + ValaList* _tmp1052_; + gint _tmp1053_; + gint _tmp1054_; gint _precondition_size; gint _precondition_index; - _tmp1045_ = m; - _tmp1046_ = vala_method_get_preconditions (_tmp1045_); - _precondition_list = _tmp1046_; - _tmp1047_ = _precondition_list; - _tmp1048_ = vala_collection_get_size ((ValaCollection*) _tmp1047_); - _tmp1049_ = _tmp1048_; - _precondition_size = _tmp1049_; + _tmp1050_ = m; + _tmp1051_ = vala_method_get_preconditions (_tmp1050_); + _precondition_list = _tmp1051_; + _tmp1052_ = _precondition_list; + _tmp1053_ = vala_collection_get_size ((ValaCollection*) _tmp1052_); + _tmp1054_ = _tmp1053_; + _precondition_size = _tmp1054_; _precondition_index = -1; while (TRUE) { - gint _tmp1050_; - gint _tmp1051_; - gint _tmp1052_; - ValaList* _tmp1053_; - gint _tmp1054_; - gpointer _tmp1055_ = NULL; + gint _tmp1055_; + gint _tmp1056_; + gint _tmp1057_; + ValaList* _tmp1058_; + gint _tmp1059_; + gpointer _tmp1060_ = NULL; ValaExpression* precondition; - ValaMethod* _tmp1056_; - ValaDataType* _tmp1057_; - ValaExpression* _tmp1058_; - _tmp1050_ = _precondition_index; - _precondition_index = _tmp1050_ + 1; - _tmp1051_ = _precondition_index; - _tmp1052_ = _precondition_size; - if (!(_tmp1051_ < _tmp1052_)) { + ValaMethod* _tmp1061_; + ValaDataType* _tmp1062_; + ValaExpression* _tmp1063_; + _tmp1055_ = _precondition_index; + _precondition_index = _tmp1055_ + 1; + _tmp1056_ = _precondition_index; + _tmp1057_ = _precondition_size; + if (!(_tmp1056_ < _tmp1057_)) { break; } - _tmp1053_ = _precondition_list; - _tmp1054_ = _precondition_index; - _tmp1055_ = vala_list_get (_tmp1053_, _tmp1054_); - precondition = (ValaExpression*) _tmp1055_; - _tmp1056_ = m; - _tmp1057_ = creturn_type; - _tmp1058_ = precondition; - vala_ccode_method_module_create_precondition_statement (self, (ValaCodeNode*) _tmp1056_, _tmp1057_, _tmp1058_); + _tmp1058_ = _precondition_list; + _tmp1059_ = _precondition_index; + _tmp1060_ = vala_list_get (_tmp1058_, _tmp1059_); + precondition = (ValaExpression*) _tmp1060_; + _tmp1061_ = m; + _tmp1062_ = creturn_type; + _tmp1063_ = precondition; + vala_ccode_method_module_create_precondition_statement (self, (ValaCodeNode*) _tmp1061_, _tmp1062_, _tmp1063_); _vala_code_node_unref0 (precondition); } _vala_iterable_unref0 (_precondition_list); } } } - _tmp1059_ = profile; - if (_tmp1059_) { - const gchar* _tmp1060_; - gchar* _tmp1061_ = NULL; + _tmp1064_ = profile; + if (_tmp1064_) { + const gchar* _tmp1065_; + gchar* _tmp1066_ = NULL; gchar* prefix; - const gchar* _tmp1062_; - gchar* _tmp1063_; - gchar* _tmp1064_; - ValaCCodeIdentifier* _tmp1065_; - ValaCCodeIdentifier* _tmp1066_; + const gchar* _tmp1067_; + gchar* _tmp1068_; + gchar* _tmp1069_; + ValaCCodeIdentifier* _tmp1070_; + ValaCCodeIdentifier* _tmp1071_; ValaCCodeIdentifier* level; - ValaCCodeFunction* _tmp1067_; - ValaCCodeFunction* _tmp1068_; - ValaCCodeIdentifier* _tmp1069_; - ValaCCodeUnaryExpression* _tmp1070_; - ValaCCodeUnaryExpression* _tmp1071_; - ValaCCodeUnaryExpression* _tmp1072_; - ValaCCodeUnaryExpression* _tmp1073_; - const gchar* _tmp1074_; - gchar* _tmp1075_; - gchar* _tmp1076_; - ValaCCodeIdentifier* _tmp1077_; - ValaCCodeIdentifier* _tmp1078_; + ValaCCodeFunction* _tmp1072_; + ValaCCodeFunction* _tmp1073_; + ValaCCodeIdentifier* _tmp1074_; + ValaCCodeUnaryExpression* _tmp1075_; + ValaCCodeUnaryExpression* _tmp1076_; + ValaCCodeUnaryExpression* _tmp1077_; + ValaCCodeUnaryExpression* _tmp1078_; + const gchar* _tmp1079_; + gchar* _tmp1080_; + gchar* _tmp1081_; + ValaCCodeIdentifier* _tmp1082_; + ValaCCodeIdentifier* _tmp1083_; ValaCCodeIdentifier* counter; - ValaCCodeFunction* _tmp1079_; - ValaCCodeFunction* _tmp1080_; - ValaCCodeIdentifier* _tmp1081_; - ValaCCodeUnaryExpression* _tmp1082_; - ValaCCodeUnaryExpression* _tmp1083_; - const gchar* _tmp1084_; - gchar* _tmp1085_; - gchar* _tmp1086_; - ValaCCodeIdentifier* _tmp1087_; - ValaCCodeIdentifier* _tmp1088_; + ValaCCodeFunction* _tmp1084_; + ValaCCodeFunction* _tmp1085_; + ValaCCodeIdentifier* _tmp1086_; + ValaCCodeUnaryExpression* _tmp1087_; + ValaCCodeUnaryExpression* _tmp1088_; + const gchar* _tmp1089_; + gchar* _tmp1090_; + gchar* _tmp1091_; + ValaCCodeIdentifier* _tmp1092_; + ValaCCodeIdentifier* _tmp1093_; ValaCCodeIdentifier* timer; - ValaCCodeIdentifier* _tmp1089_; - ValaCCodeIdentifier* _tmp1090_; - ValaCCodeFunctionCall* _tmp1091_; - ValaCCodeFunctionCall* _tmp1092_; - ValaCCodeFunctionCall* cont_call; - ValaCCodeFunctionCall* _tmp1093_; ValaCCodeIdentifier* _tmp1094_; - ValaCCodeFunction* _tmp1095_; - ValaCCodeFunction* _tmp1096_; + ValaCCodeIdentifier* _tmp1095_; + ValaCCodeFunctionCall* _tmp1096_; ValaCCodeFunctionCall* _tmp1097_; - ValaCCodeFunction* _tmp1098_; - ValaCCodeFunction* _tmp1099_; - _tmp1060_ = real_name; - _tmp1061_ = g_strdup_printf ("_vala_prof_%s", _tmp1060_); - prefix = _tmp1061_; - _tmp1062_ = prefix; - _tmp1063_ = g_strconcat (_tmp1062_, "_level", NULL); - _tmp1064_ = _tmp1063_; - _tmp1065_ = vala_ccode_identifier_new (_tmp1064_); - _tmp1066_ = _tmp1065_; - _g_free0 (_tmp1064_); - level = _tmp1066_; - _tmp1067_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); - _tmp1068_ = _tmp1067_; - _tmp1069_ = level; - _tmp1070_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_POSTFIX_INCREMENT, (ValaCCodeExpression*) _tmp1069_); + ValaCCodeFunctionCall* cont_call; + ValaCCodeFunctionCall* _tmp1098_; + ValaCCodeIdentifier* _tmp1099_; + ValaCCodeFunction* _tmp1100_; + ValaCCodeFunction* _tmp1101_; + ValaCCodeFunctionCall* _tmp1102_; + ValaCCodeFunction* _tmp1103_; + ValaCCodeFunction* _tmp1104_; + _tmp1065_ = real_name; + _tmp1066_ = g_strdup_printf ("_vala_prof_%s", _tmp1065_); + prefix = _tmp1066_; + _tmp1067_ = prefix; + _tmp1068_ = g_strconcat (_tmp1067_, "_level", NULL); + _tmp1069_ = _tmp1068_; + _tmp1070_ = vala_ccode_identifier_new (_tmp1069_); _tmp1071_ = _tmp1070_; - _tmp1072_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_LOGICAL_NEGATION, (ValaCCodeExpression*) _tmp1071_); + _g_free0 (_tmp1069_); + level = _tmp1071_; + _tmp1072_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); _tmp1073_ = _tmp1072_; - vala_ccode_function_open_if (_tmp1068_, (ValaCCodeExpression*) _tmp1073_); - _vala_ccode_node_unref0 (_tmp1073_); - _vala_ccode_node_unref0 (_tmp1071_); - _tmp1074_ = prefix; - _tmp1075_ = g_strconcat (_tmp1074_, "_counter", NULL); + _tmp1074_ = level; + _tmp1075_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_POSTFIX_INCREMENT, (ValaCCodeExpression*) _tmp1074_); _tmp1076_ = _tmp1075_; - _tmp1077_ = vala_ccode_identifier_new (_tmp1076_); + _tmp1077_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_LOGICAL_NEGATION, (ValaCCodeExpression*) _tmp1076_); _tmp1078_ = _tmp1077_; - _g_free0 (_tmp1076_); - counter = _tmp1078_; - _tmp1079_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); - _tmp1080_ = _tmp1079_; - _tmp1081_ = counter; - _tmp1082_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_POSTFIX_INCREMENT, (ValaCCodeExpression*) _tmp1081_); + vala_ccode_function_open_if (_tmp1073_, (ValaCCodeExpression*) _tmp1078_); + _vala_ccode_node_unref0 (_tmp1078_); + _vala_ccode_node_unref0 (_tmp1076_); + _tmp1079_ = prefix; + _tmp1080_ = g_strconcat (_tmp1079_, "_counter", NULL); + _tmp1081_ = _tmp1080_; + _tmp1082_ = vala_ccode_identifier_new (_tmp1081_); _tmp1083_ = _tmp1082_; - vala_ccode_function_add_expression (_tmp1080_, (ValaCCodeExpression*) _tmp1083_); - _vala_ccode_node_unref0 (_tmp1083_); - _tmp1084_ = prefix; - _tmp1085_ = g_strconcat (_tmp1084_, "_timer", NULL); - _tmp1086_ = _tmp1085_; - _tmp1087_ = vala_ccode_identifier_new (_tmp1086_); + _g_free0 (_tmp1081_); + counter = _tmp1083_; + _tmp1084_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp1085_ = _tmp1084_; + _tmp1086_ = counter; + _tmp1087_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_POSTFIX_INCREMENT, (ValaCCodeExpression*) _tmp1086_); _tmp1088_ = _tmp1087_; - _g_free0 (_tmp1086_); - timer = _tmp1088_; - _tmp1089_ = vala_ccode_identifier_new ("g_timer_continue"); - _tmp1090_ = _tmp1089_; - _tmp1091_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp1090_); - _tmp1092_ = _tmp1091_; - _vala_ccode_node_unref0 (_tmp1090_); - cont_call = _tmp1092_; - _tmp1093_ = cont_call; - _tmp1094_ = timer; - vala_ccode_function_call_add_argument (_tmp1093_, (ValaCCodeExpression*) _tmp1094_); - _tmp1095_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); - _tmp1096_ = _tmp1095_; - _tmp1097_ = cont_call; - vala_ccode_function_add_expression (_tmp1096_, (ValaCCodeExpression*) _tmp1097_); - _tmp1098_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); - _tmp1099_ = _tmp1098_; - vala_ccode_function_close (_tmp1099_); + vala_ccode_function_add_expression (_tmp1085_, (ValaCCodeExpression*) _tmp1088_); + _vala_ccode_node_unref0 (_tmp1088_); + _tmp1089_ = prefix; + _tmp1090_ = g_strconcat (_tmp1089_, "_timer", NULL); + _tmp1091_ = _tmp1090_; + _tmp1092_ = vala_ccode_identifier_new (_tmp1091_); + _tmp1093_ = _tmp1092_; + _g_free0 (_tmp1091_); + timer = _tmp1093_; + _tmp1094_ = vala_ccode_identifier_new ("g_timer_continue"); + _tmp1095_ = _tmp1094_; + _tmp1096_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp1095_); + _tmp1097_ = _tmp1096_; + _vala_ccode_node_unref0 (_tmp1095_); + cont_call = _tmp1097_; + _tmp1098_ = cont_call; + _tmp1099_ = timer; + vala_ccode_function_call_add_argument (_tmp1098_, (ValaCCodeExpression*) _tmp1099_); + _tmp1100_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp1101_ = _tmp1100_; + _tmp1102_ = cont_call; + vala_ccode_function_add_expression (_tmp1101_, (ValaCCodeExpression*) _tmp1102_); + _tmp1103_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp1104_ = _tmp1103_; + vala_ccode_function_close (_tmp1104_); _vala_ccode_node_unref0 (cont_call); _vala_ccode_node_unref0 (timer); _vala_ccode_node_unref0 (counter); _vala_ccode_node_unref0 (level); _g_free0 (prefix); } - _tmp1100_ = m; - _tmp1101_ = vala_subroutine_get_body ((ValaSubroutine*) _tmp1100_); - _tmp1102_ = _tmp1101_; - if (_tmp1102_ != NULL) { - ValaMethod* _tmp1103_; - ValaBlock* _tmp1104_; - ValaBlock* _tmp1105_; - _tmp1103_ = m; - _tmp1104_ = vala_subroutine_get_body ((ValaSubroutine*) _tmp1103_); - _tmp1105_ = _tmp1104_; - vala_code_node_emit ((ValaCodeNode*) _tmp1105_, (ValaCodeGenerator*) self); + _tmp1105_ = m; + _tmp1106_ = vala_subroutine_get_body ((ValaSubroutine*) _tmp1105_); + _tmp1107_ = _tmp1106_; + if (_tmp1107_ != NULL) { + ValaMethod* _tmp1108_; + ValaBlock* _tmp1109_; + ValaBlock* _tmp1110_; + _tmp1108_ = m; + _tmp1109_ = vala_subroutine_get_body ((ValaSubroutine*) _tmp1108_); + _tmp1110_ = _tmp1109_; + vala_code_node_emit ((ValaCodeNode*) _tmp1110_, (ValaCodeGenerator*) self); } - _tmp1106_ = profile; - if (_tmp1106_) { - const gchar* _tmp1107_; - gchar* _tmp1108_ = NULL; + _tmp1111_ = profile; + if (_tmp1111_) { + const gchar* _tmp1112_; + gchar* _tmp1113_ = NULL; gchar* prefix; - const gchar* _tmp1109_; - gchar* _tmp1110_; - gchar* _tmp1111_; - ValaCCodeIdentifier* _tmp1112_; - ValaCCodeIdentifier* _tmp1113_; + const gchar* _tmp1114_; + gchar* _tmp1115_; + gchar* _tmp1116_; + ValaCCodeIdentifier* _tmp1117_; + ValaCCodeIdentifier* _tmp1118_; ValaCCodeIdentifier* level; - ValaCCodeFunction* _tmp1114_; - ValaCCodeFunction* _tmp1115_; - ValaCCodeIdentifier* _tmp1116_; - ValaCCodeUnaryExpression* _tmp1117_; - ValaCCodeUnaryExpression* _tmp1118_; - ValaCCodeUnaryExpression* _tmp1119_; - ValaCCodeUnaryExpression* _tmp1120_; - const gchar* _tmp1121_; - gchar* _tmp1122_; - gchar* _tmp1123_; - ValaCCodeIdentifier* _tmp1124_; - ValaCCodeIdentifier* _tmp1125_; + ValaCCodeFunction* _tmp1119_; + ValaCCodeFunction* _tmp1120_; + ValaCCodeIdentifier* _tmp1121_; + ValaCCodeUnaryExpression* _tmp1122_; + ValaCCodeUnaryExpression* _tmp1123_; + ValaCCodeUnaryExpression* _tmp1124_; + ValaCCodeUnaryExpression* _tmp1125_; + const gchar* _tmp1126_; + gchar* _tmp1127_; + gchar* _tmp1128_; + ValaCCodeIdentifier* _tmp1129_; + ValaCCodeIdentifier* _tmp1130_; ValaCCodeIdentifier* timer; - ValaCCodeIdentifier* _tmp1126_; - ValaCCodeIdentifier* _tmp1127_; - ValaCCodeFunctionCall* _tmp1128_; - ValaCCodeFunctionCall* _tmp1129_; - ValaCCodeFunctionCall* stop_call; - ValaCCodeFunctionCall* _tmp1130_; ValaCCodeIdentifier* _tmp1131_; - ValaCCodeFunction* _tmp1132_; - ValaCCodeFunction* _tmp1133_; + ValaCCodeIdentifier* _tmp1132_; + ValaCCodeFunctionCall* _tmp1133_; ValaCCodeFunctionCall* _tmp1134_; - ValaCCodeFunction* _tmp1135_; - ValaCCodeFunction* _tmp1136_; - _tmp1107_ = real_name; - _tmp1108_ = g_strdup_printf ("_vala_prof_%s", _tmp1107_); - prefix = _tmp1108_; - _tmp1109_ = prefix; - _tmp1110_ = g_strconcat (_tmp1109_, "_level", NULL); - _tmp1111_ = _tmp1110_; - _tmp1112_ = vala_ccode_identifier_new (_tmp1111_); - _tmp1113_ = _tmp1112_; - _g_free0 (_tmp1111_); - level = _tmp1113_; - _tmp1114_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); - _tmp1115_ = _tmp1114_; - _tmp1116_ = level; - _tmp1117_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_PREFIX_DECREMENT, (ValaCCodeExpression*) _tmp1116_); + ValaCCodeFunctionCall* stop_call; + ValaCCodeFunctionCall* _tmp1135_; + ValaCCodeIdentifier* _tmp1136_; + ValaCCodeFunction* _tmp1137_; + ValaCCodeFunction* _tmp1138_; + ValaCCodeFunctionCall* _tmp1139_; + ValaCCodeFunction* _tmp1140_; + ValaCCodeFunction* _tmp1141_; + _tmp1112_ = real_name; + _tmp1113_ = g_strdup_printf ("_vala_prof_%s", _tmp1112_); + prefix = _tmp1113_; + _tmp1114_ = prefix; + _tmp1115_ = g_strconcat (_tmp1114_, "_level", NULL); + _tmp1116_ = _tmp1115_; + _tmp1117_ = vala_ccode_identifier_new (_tmp1116_); _tmp1118_ = _tmp1117_; - _tmp1119_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_LOGICAL_NEGATION, (ValaCCodeExpression*) _tmp1118_); + _g_free0 (_tmp1116_); + level = _tmp1118_; + _tmp1119_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); _tmp1120_ = _tmp1119_; - vala_ccode_function_open_if (_tmp1115_, (ValaCCodeExpression*) _tmp1120_); - _vala_ccode_node_unref0 (_tmp1120_); - _vala_ccode_node_unref0 (_tmp1118_); - _tmp1121_ = prefix; - _tmp1122_ = g_strconcat (_tmp1121_, "_timer", NULL); + _tmp1121_ = level; + _tmp1122_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_PREFIX_DECREMENT, (ValaCCodeExpression*) _tmp1121_); _tmp1123_ = _tmp1122_; - _tmp1124_ = vala_ccode_identifier_new (_tmp1123_); + _tmp1124_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_LOGICAL_NEGATION, (ValaCCodeExpression*) _tmp1123_); _tmp1125_ = _tmp1124_; - _g_free0 (_tmp1123_); - timer = _tmp1125_; - _tmp1126_ = vala_ccode_identifier_new ("g_timer_stop"); - _tmp1127_ = _tmp1126_; - _tmp1128_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp1127_); - _tmp1129_ = _tmp1128_; - _vala_ccode_node_unref0 (_tmp1127_); - stop_call = _tmp1129_; - _tmp1130_ = stop_call; - _tmp1131_ = timer; - vala_ccode_function_call_add_argument (_tmp1130_, (ValaCCodeExpression*) _tmp1131_); - _tmp1132_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); - _tmp1133_ = _tmp1132_; - _tmp1134_ = stop_call; - vala_ccode_function_add_expression (_tmp1133_, (ValaCCodeExpression*) _tmp1134_); - _tmp1135_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); - _tmp1136_ = _tmp1135_; - vala_ccode_function_close (_tmp1136_); + vala_ccode_function_open_if (_tmp1120_, (ValaCCodeExpression*) _tmp1125_); + _vala_ccode_node_unref0 (_tmp1125_); + _vala_ccode_node_unref0 (_tmp1123_); + _tmp1126_ = prefix; + _tmp1127_ = g_strconcat (_tmp1126_, "_timer", NULL); + _tmp1128_ = _tmp1127_; + _tmp1129_ = vala_ccode_identifier_new (_tmp1128_); + _tmp1130_ = _tmp1129_; + _g_free0 (_tmp1128_); + timer = _tmp1130_; + _tmp1131_ = vala_ccode_identifier_new ("g_timer_stop"); + _tmp1132_ = _tmp1131_; + _tmp1133_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp1132_); + _tmp1134_ = _tmp1133_; + _vala_ccode_node_unref0 (_tmp1132_); + stop_call = _tmp1134_; + _tmp1135_ = stop_call; + _tmp1136_ = timer; + vala_ccode_function_call_add_argument (_tmp1135_, (ValaCCodeExpression*) _tmp1136_); + _tmp1137_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp1138_ = _tmp1137_; + _tmp1139_ = stop_call; + vala_ccode_function_add_expression (_tmp1138_, (ValaCCodeExpression*) _tmp1139_); + _tmp1140_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp1141_ = _tmp1140_; + vala_ccode_function_close (_tmp1141_); _vala_ccode_node_unref0 (stop_call); _vala_ccode_node_unref0 (timer); _vala_ccode_node_unref0 (level); _g_free0 (prefix); } - _tmp1138_ = m; - _tmp1139_ = vala_method_get_is_abstract (_tmp1138_); - _tmp1140_ = _tmp1139_; - if (!_tmp1140_) { - _tmp1137_ = TRUE; + _tmp1143_ = m; + _tmp1144_ = vala_method_get_is_abstract (_tmp1143_); + _tmp1145_ = _tmp1144_; + if (!_tmp1145_) { + _tmp1142_ = TRUE; } else { - gboolean _tmp1141_ = FALSE; - ValaMethod* _tmp1142_; - gboolean _tmp1143_; - gboolean _tmp1144_; - gboolean _tmp1147_; - _tmp1142_ = m; - _tmp1143_ = vala_method_get_is_abstract (_tmp1142_); - _tmp1144_ = _tmp1143_; - if (_tmp1144_) { - ValaTypeSymbol* _tmp1145_; - ValaTypeSymbol* _tmp1146_; - _tmp1145_ = vala_ccode_base_module_get_current_type_symbol ((ValaCCodeBaseModule*) self); - _tmp1146_ = _tmp1145_; - _tmp1141_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp1146_, VALA_TYPE_CLASS); + gboolean _tmp1146_ = FALSE; + ValaMethod* _tmp1147_; + gboolean _tmp1148_; + gboolean _tmp1149_; + gboolean _tmp1152_; + _tmp1147_ = m; + _tmp1148_ = vala_method_get_is_abstract (_tmp1147_); + _tmp1149_ = _tmp1148_; + if (_tmp1149_) { + ValaTypeSymbol* _tmp1150_; + ValaTypeSymbol* _tmp1151_; + _tmp1150_ = vala_ccode_base_module_get_current_type_symbol ((ValaCCodeBaseModule*) self); + _tmp1151_ = _tmp1150_; + _tmp1146_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp1151_, VALA_TYPE_CLASS); } else { - _tmp1141_ = FALSE; + _tmp1146_ = FALSE; } - _tmp1147_ = _tmp1141_; - _tmp1137_ = _tmp1147_; + _tmp1152_ = _tmp1146_; + _tmp1142_ = _tmp1152_; } - _tmp1148_ = _tmp1137_; - if (_tmp1148_) { - ValaMethod* _tmp1149_; - ValaBlock* _tmp1150_; - ValaBlock* _tmp1151_; - _tmp1149_ = m; - _tmp1150_ = vala_subroutine_get_body ((ValaSubroutine*) _tmp1149_); - _tmp1151_ = _tmp1150_; - if (_tmp1151_ != NULL) { - gboolean _tmp1152_; - gboolean _tmp1153_; - ValaMethod* _tmp1164_; - gboolean _tmp1165_; - gboolean _tmp1166_; - gboolean _tmp1167_ = FALSE; - gboolean _tmp1168_ = FALSE; + _tmp1153_ = _tmp1142_; + if (_tmp1153_) { + ValaMethod* _tmp1154_; + ValaBlock* _tmp1155_; + ValaBlock* _tmp1156_; + _tmp1154_ = m; + _tmp1155_ = vala_subroutine_get_body ((ValaSubroutine*) _tmp1154_); + _tmp1156_ = _tmp1155_; + if (_tmp1156_ != NULL) { + gboolean _tmp1157_; + gboolean _tmp1158_; ValaMethod* _tmp1169_; - ValaDataType* _tmp1170_; - ValaDataType* _tmp1171_; - gboolean _tmp1176_; - gboolean _tmp1180_; - ValaMethod* _tmp1197_; - ValaCCodeFile* _tmp1289_; - ValaCCodeFunction* _tmp1290_; - ValaCCodeFunction* _tmp1291_; - _tmp1152_ = vala_ccode_base_module_get_current_method_inner_error ((ValaCCodeBaseModule*) self); - _tmp1153_ = _tmp1152_; - if (_tmp1153_) { - ValaMethod* _tmp1154_; - gboolean _tmp1155_; - gboolean _tmp1156_; - _tmp1154_ = m; - _tmp1155_ = vala_method_get_coroutine (_tmp1154_); - _tmp1156_ = _tmp1155_; - if (_tmp1156_) { - ValaCCodeStruct* _tmp1157_; - _tmp1157_ = ((ValaCCodeBaseModule*) self)->closure_struct; - vala_ccode_struct_add_field (_tmp1157_, "GError *", "_inner_error_", NULL); + gboolean _tmp1170_; + gboolean _tmp1171_; + gboolean _tmp1172_ = FALSE; + gboolean _tmp1173_ = FALSE; + ValaMethod* _tmp1174_; + ValaDataType* _tmp1175_; + ValaDataType* _tmp1176_; + gboolean _tmp1181_; + gboolean _tmp1185_; + ValaMethod* _tmp1202_; + ValaCCodeFile* _tmp1294_; + ValaCCodeFunction* _tmp1295_; + ValaCCodeFunction* _tmp1296_; + _tmp1157_ = vala_ccode_base_module_get_current_method_inner_error ((ValaCCodeBaseModule*) self); + _tmp1158_ = _tmp1157_; + if (_tmp1158_) { + ValaMethod* _tmp1159_; + gboolean _tmp1160_; + gboolean _tmp1161_; + _tmp1159_ = m; + _tmp1160_ = vala_method_get_coroutine (_tmp1159_); + _tmp1161_ = _tmp1160_; + if (_tmp1161_) { + ValaCCodeStruct* _tmp1162_; + _tmp1162_ = ((ValaCCodeBaseModule*) self)->closure_struct; + vala_ccode_struct_add_field (_tmp1162_, "GError *", "_inner_error_", NULL); } else { - ValaCCodeFunction* _tmp1158_; - ValaCCodeFunction* _tmp1159_; - ValaCCodeConstant* _tmp1160_; - ValaCCodeConstant* _tmp1161_; - ValaCCodeVariableDeclarator* _tmp1162_; - ValaCCodeVariableDeclarator* _tmp1163_; - _tmp1158_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); - _tmp1159_ = _tmp1158_; - _tmp1160_ = vala_ccode_constant_new ("NULL"); - _tmp1161_ = _tmp1160_; - _tmp1162_ = vala_ccode_variable_declarator_new_zero ("_inner_error_", (ValaCCodeExpression*) _tmp1161_, NULL); - _tmp1163_ = _tmp1162_; - vala_ccode_function_add_declaration (_tmp1159_, "GError *", (ValaCCodeDeclarator*) _tmp1163_, 0); - _vala_ccode_node_unref0 (_tmp1163_); - _vala_ccode_node_unref0 (_tmp1161_); + ValaCCodeFunction* _tmp1163_; + ValaCCodeFunction* _tmp1164_; + ValaCCodeConstant* _tmp1165_; + ValaCCodeConstant* _tmp1166_; + ValaCCodeVariableDeclarator* _tmp1167_; + ValaCCodeVariableDeclarator* _tmp1168_; + _tmp1163_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp1164_ = _tmp1163_; + _tmp1165_ = vala_ccode_constant_new ("NULL"); + _tmp1166_ = _tmp1165_; + _tmp1167_ = vala_ccode_variable_declarator_new_zero ("_inner_error_", (ValaCCodeExpression*) _tmp1166_, NULL); + _tmp1168_ = _tmp1167_; + vala_ccode_function_add_declaration (_tmp1164_, "GError *", (ValaCCodeDeclarator*) _tmp1168_, 0); + _vala_ccode_node_unref0 (_tmp1168_); + _vala_ccode_node_unref0 (_tmp1166_); } } - _tmp1164_ = m; - _tmp1165_ = vala_method_get_coroutine (_tmp1164_); - _tmp1166_ = _tmp1165_; - if (_tmp1166_) { - vala_ccode_method_module_complete_async (self); - } _tmp1169_ = m; - _tmp1170_ = vala_method_get_return_type (_tmp1169_); + _tmp1170_ = vala_method_get_coroutine (_tmp1169_); _tmp1171_ = _tmp1170_; - if (!G_TYPE_CHECK_INSTANCE_TYPE (_tmp1171_, VALA_TYPE_VOID_TYPE)) { - ValaMethod* _tmp1172_; - ValaDataType* _tmp1173_; - ValaDataType* _tmp1174_; - gboolean _tmp1175_ = FALSE; - _tmp1172_ = m; - _tmp1173_ = vala_method_get_return_type (_tmp1172_); - _tmp1174_ = _tmp1173_; - _tmp1175_ = vala_data_type_is_real_non_null_struct_type (_tmp1174_); - _tmp1168_ = !_tmp1175_; - } else { - _tmp1168_ = FALSE; + if (_tmp1171_) { + vala_ccode_method_module_complete_async (self); } - _tmp1176_ = _tmp1168_; - if (_tmp1176_) { + _tmp1174_ = m; + _tmp1175_ = vala_method_get_return_type (_tmp1174_); + _tmp1176_ = _tmp1175_; + if (!G_TYPE_CHECK_INSTANCE_TYPE (_tmp1176_, VALA_TYPE_VOID_TYPE)) { ValaMethod* _tmp1177_; - gboolean _tmp1178_; - gboolean _tmp1179_; + ValaDataType* _tmp1178_; + ValaDataType* _tmp1179_; + gboolean _tmp1180_ = FALSE; _tmp1177_ = m; - _tmp1178_ = vala_method_get_coroutine (_tmp1177_); + _tmp1178_ = vala_method_get_return_type (_tmp1177_); _tmp1179_ = _tmp1178_; - _tmp1167_ = !_tmp1179_; + _tmp1180_ = vala_data_type_is_real_non_null_struct_type (_tmp1179_); + _tmp1173_ = !_tmp1180_; } else { - _tmp1167_ = FALSE; + _tmp1173_ = FALSE; } - _tmp1180_ = _tmp1167_; - if (_tmp1180_) { - gboolean _tmp1181_ = FALSE; + _tmp1181_ = _tmp1173_; + if (_tmp1181_) { ValaMethod* _tmp1182_; - ValaBasicBlock* _tmp1183_; - ValaBasicBlock* _tmp1184_; - gboolean _tmp1192_; + gboolean _tmp1183_; + gboolean _tmp1184_; _tmp1182_ = m; - _tmp1183_ = vala_subroutine_get_return_block ((ValaSubroutine*) _tmp1182_); + _tmp1183_ = vala_method_get_coroutine (_tmp1182_); _tmp1184_ = _tmp1183_; - if (_tmp1184_ != NULL) { - ValaMethod* _tmp1185_; - ValaBasicBlock* _tmp1186_; - ValaBasicBlock* _tmp1187_; - ValaList* _tmp1188_ = NULL; - ValaList* _tmp1189_; - gint _tmp1190_; - gint _tmp1191_; - _tmp1185_ = m; - _tmp1186_ = vala_subroutine_get_return_block ((ValaSubroutine*) _tmp1185_); - _tmp1187_ = _tmp1186_; - _tmp1188_ = vala_basic_block_get_predecessors (_tmp1187_); - _tmp1189_ = _tmp1188_; - _tmp1190_ = vala_collection_get_size ((ValaCollection*) _tmp1189_); - _tmp1191_ = _tmp1190_; - _tmp1181_ = _tmp1191_ == 0; - _vala_iterable_unref0 (_tmp1189_); - } else { - _tmp1181_ = FALSE; - } - _tmp1192_ = _tmp1181_; - if (_tmp1192_) { - ValaCCodeFunction* _tmp1193_; - ValaCCodeFunction* _tmp1194_; - ValaCCodeIdentifier* _tmp1195_; - ValaCCodeIdentifier* _tmp1196_; - _tmp1193_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp1172_ = !_tmp1184_; + } else { + _tmp1172_ = FALSE; + } + _tmp1185_ = _tmp1172_; + if (_tmp1185_) { + gboolean _tmp1186_ = FALSE; + ValaMethod* _tmp1187_; + ValaBasicBlock* _tmp1188_; + ValaBasicBlock* _tmp1189_; + gboolean _tmp1197_; + _tmp1187_ = m; + _tmp1188_ = vala_subroutine_get_return_block ((ValaSubroutine*) _tmp1187_); + _tmp1189_ = _tmp1188_; + if (_tmp1189_ != NULL) { + ValaMethod* _tmp1190_; + ValaBasicBlock* _tmp1191_; + ValaBasicBlock* _tmp1192_; + ValaList* _tmp1193_ = NULL; + ValaList* _tmp1194_; + gint _tmp1195_; + gint _tmp1196_; + _tmp1190_ = m; + _tmp1191_ = vala_subroutine_get_return_block ((ValaSubroutine*) _tmp1190_); + _tmp1192_ = _tmp1191_; + _tmp1193_ = vala_basic_block_get_predecessors (_tmp1192_); _tmp1194_ = _tmp1193_; - _tmp1195_ = vala_ccode_identifier_new ("result"); + _tmp1195_ = vala_collection_get_size ((ValaCollection*) _tmp1194_); _tmp1196_ = _tmp1195_; - vala_ccode_function_add_return (_tmp1194_, (ValaCCodeExpression*) _tmp1196_); - _vala_ccode_node_unref0 (_tmp1196_); + _tmp1186_ = _tmp1196_ == 0; + _vala_iterable_unref0 (_tmp1194_); + } else { + _tmp1186_ = FALSE; + } + _tmp1197_ = _tmp1186_; + if (_tmp1197_) { + ValaCCodeFunction* _tmp1198_; + ValaCCodeFunction* _tmp1199_; + ValaCCodeIdentifier* _tmp1200_; + ValaCCodeIdentifier* _tmp1201_; + _tmp1198_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp1199_ = _tmp1198_; + _tmp1200_ = vala_ccode_identifier_new ("result"); + _tmp1201_ = _tmp1200_; + vala_ccode_function_add_return (_tmp1199_, (ValaCCodeExpression*) _tmp1201_); + _vala_ccode_node_unref0 (_tmp1201_); } } - _tmp1197_ = m; - if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp1197_, VALA_TYPE_CREATION_METHOD)) { - ValaTypeSymbol* _tmp1198_; - ValaTypeSymbol* _tmp1199_; - gboolean _tmp1204_ = FALSE; - gboolean _tmp1205_ = FALSE; - gboolean _tmp1206_ = FALSE; - gboolean _tmp1207_ = FALSE; - ValaTypeSymbol* _tmp1208_; - ValaTypeSymbol* _tmp1209_; - gboolean _tmp1211_; + _tmp1202_ = m; + if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp1202_, VALA_TYPE_CREATION_METHOD)) { + ValaTypeSymbol* _tmp1203_; + ValaTypeSymbol* _tmp1204_; + gboolean _tmp1209_ = FALSE; + gboolean _tmp1210_ = FALSE; + gboolean _tmp1211_ = FALSE; + gboolean _tmp1212_ = FALSE; + ValaTypeSymbol* _tmp1213_; + ValaTypeSymbol* _tmp1214_; gboolean _tmp1216_; - gboolean _tmp1223_; - gboolean _tmp1227_; - gboolean _tmp1269_ = FALSE; - ValaTypeSymbol* _tmp1270_; - ValaTypeSymbol* _tmp1271_; - gboolean _tmp1275_; - _tmp1198_ = vala_ccode_base_module_get_current_type_symbol ((ValaCCodeBaseModule*) self); - _tmp1199_ = _tmp1198_; - if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp1199_, VALA_TYPE_CLASS)) { - ValaClass* _tmp1200_; - ValaClass* _tmp1201_; - ValaObjectType* _tmp1202_; - _tmp1200_ = vala_ccode_base_module_get_current_class ((ValaCCodeBaseModule*) self); - _tmp1201_ = _tmp1200_; - _tmp1202_ = vala_object_type_new ((ValaObjectTypeSymbol*) _tmp1201_); + gboolean _tmp1221_; + gboolean _tmp1228_; + gboolean _tmp1232_; + gboolean _tmp1274_ = FALSE; + ValaTypeSymbol* _tmp1275_; + ValaTypeSymbol* _tmp1276_; + gboolean _tmp1280_; + _tmp1203_ = vala_ccode_base_module_get_current_type_symbol ((ValaCCodeBaseModule*) self); + _tmp1204_ = _tmp1203_; + if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp1204_, VALA_TYPE_CLASS)) { + ValaClass* _tmp1205_; + ValaClass* _tmp1206_; + ValaObjectType* _tmp1207_; + _tmp1205_ = vala_ccode_base_module_get_current_class ((ValaCCodeBaseModule*) self); + _tmp1206_ = _tmp1205_; + _tmp1207_ = vala_object_type_new ((ValaObjectTypeSymbol*) _tmp1206_); _vala_code_node_unref0 (creturn_type); - creturn_type = (ValaDataType*) _tmp1202_; + creturn_type = (ValaDataType*) _tmp1207_; } else { - ValaVoidType* _tmp1203_; - _tmp1203_ = vala_void_type_new (NULL); + ValaVoidType* _tmp1208_; + _tmp1208_ = vala_void_type_new (NULL); _vala_code_node_unref0 (creturn_type); - creturn_type = (ValaDataType*) _tmp1203_; - } - _tmp1208_ = vala_ccode_base_module_get_current_type_symbol ((ValaCCodeBaseModule*) self); - _tmp1209_ = _tmp1208_; - if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp1209_, VALA_TYPE_CLASS)) { - ValaTypeSymbol* _tmp1210_; - _tmp1210_ = ((ValaCCodeBaseModule*) self)->gobject_type; - _tmp1207_ = _tmp1210_ != NULL; - } else { - _tmp1207_ = FALSE; + creturn_type = (ValaDataType*) _tmp1208_; } - _tmp1211_ = _tmp1207_; - if (_tmp1211_) { - ValaClass* _tmp1212_; - ValaClass* _tmp1213_; - ValaTypeSymbol* _tmp1214_; - gboolean _tmp1215_ = FALSE; - _tmp1212_ = vala_ccode_base_module_get_current_class ((ValaCCodeBaseModule*) self); - _tmp1213_ = _tmp1212_; - _tmp1214_ = ((ValaCCodeBaseModule*) self)->gobject_type; - _tmp1215_ = vala_typesymbol_is_subtype_of ((ValaTypeSymbol*) _tmp1213_, _tmp1214_); - _tmp1206_ = _tmp1215_; + _tmp1213_ = vala_ccode_base_module_get_current_type_symbol ((ValaCCodeBaseModule*) self); + _tmp1214_ = _tmp1213_; + if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp1214_, VALA_TYPE_CLASS)) { + ValaTypeSymbol* _tmp1215_; + _tmp1215_ = ((ValaCCodeBaseModule*) self)->gobject_type; + _tmp1212_ = _tmp1215_ != NULL; } else { - _tmp1206_ = FALSE; + _tmp1212_ = FALSE; } - _tmp1216_ = _tmp1206_; + _tmp1216_ = _tmp1212_; if (_tmp1216_) { ValaClass* _tmp1217_; ValaClass* _tmp1218_; - ValaList* _tmp1219_ = NULL; - ValaList* _tmp1220_; - gint _tmp1221_; - gint _tmp1222_; + ValaTypeSymbol* _tmp1219_; + gboolean _tmp1220_ = FALSE; _tmp1217_ = vala_ccode_base_module_get_current_class ((ValaCCodeBaseModule*) self); _tmp1218_ = _tmp1217_; - _tmp1219_ = vala_object_type_symbol_get_type_parameters ((ValaObjectTypeSymbol*) _tmp1218_); - _tmp1220_ = _tmp1219_; - _tmp1221_ = vala_collection_get_size ((ValaCollection*) _tmp1220_); - _tmp1222_ = _tmp1221_; - _tmp1205_ = _tmp1222_ > 0; - _vala_iterable_unref0 (_tmp1220_); + _tmp1219_ = ((ValaCCodeBaseModule*) self)->gobject_type; + _tmp1220_ = vala_typesymbol_is_subtype_of ((ValaTypeSymbol*) _tmp1218_, _tmp1219_); + _tmp1211_ = _tmp1220_; } else { - _tmp1205_ = FALSE; + _tmp1211_ = FALSE; } - _tmp1223_ = _tmp1205_; - if (_tmp1223_) { - ValaMethod* _tmp1224_; - gboolean _tmp1225_; - gboolean _tmp1226_; - _tmp1224_ = m; - _tmp1225_ = vala_creation_method_get_chain_up (G_TYPE_CHECK_INSTANCE_CAST (_tmp1224_, VALA_TYPE_CREATION_METHOD, ValaCreationMethod)); - _tmp1226_ = _tmp1225_; - _tmp1204_ = !_tmp1226_; + _tmp1221_ = _tmp1211_; + if (_tmp1221_) { + ValaClass* _tmp1222_; + ValaClass* _tmp1223_; + ValaList* _tmp1224_ = NULL; + ValaList* _tmp1225_; + gint _tmp1226_; + gint _tmp1227_; + _tmp1222_ = vala_ccode_base_module_get_current_class ((ValaCCodeBaseModule*) self); + _tmp1223_ = _tmp1222_; + _tmp1224_ = vala_object_type_symbol_get_type_parameters ((ValaObjectTypeSymbol*) _tmp1223_); + _tmp1225_ = _tmp1224_; + _tmp1226_ = vala_collection_get_size ((ValaCollection*) _tmp1225_); + _tmp1227_ = _tmp1226_; + _tmp1210_ = _tmp1227_ > 0; + _vala_iterable_unref0 (_tmp1225_); } else { - _tmp1204_ = FALSE; + _tmp1210_ = FALSE; } - _tmp1227_ = _tmp1204_; - if (_tmp1227_) { - ValaCCodeIdentifier* _tmp1228_; - ValaCCodeIdentifier* _tmp1229_; - ValaCCodeIdentifier* _tmp1230_; - ValaCCodeIdentifier* _tmp1231_; - ValaCCodeBinaryExpression* _tmp1232_; - ValaCCodeBinaryExpression* _tmp1233_; + _tmp1228_ = _tmp1210_; + if (_tmp1228_) { + ValaMethod* _tmp1229_; + gboolean _tmp1230_; + gboolean _tmp1231_; + _tmp1229_ = m; + _tmp1230_ = vala_creation_method_get_chain_up (G_TYPE_CHECK_INSTANCE_CAST (_tmp1229_, VALA_TYPE_CREATION_METHOD, ValaCreationMethod)); + _tmp1231_ = _tmp1230_; + _tmp1209_ = !_tmp1231_; + } else { + _tmp1209_ = FALSE; + } + _tmp1232_ = _tmp1209_; + if (_tmp1232_) { + ValaCCodeIdentifier* _tmp1233_; + ValaCCodeIdentifier* _tmp1234_; + ValaCCodeIdentifier* _tmp1235_; + ValaCCodeIdentifier* _tmp1236_; + ValaCCodeBinaryExpression* _tmp1237_; + ValaCCodeBinaryExpression* _tmp1238_; ValaCCodeBinaryExpression* ccond; - ValaCCodeFunction* _tmp1234_; - ValaCCodeFunction* _tmp1235_; - ValaCCodeBinaryExpression* _tmp1236_; - ValaCCodeFunction* _tmp1237_; - ValaCCodeFunction* _tmp1238_; - ValaCCodeIdentifier* _tmp1239_; - ValaCCodeIdentifier* _tmp1240_; - ValaCCodeUnaryExpression* _tmp1241_; - ValaCCodeUnaryExpression* _tmp1242_; - ValaCCodeIdentifier* _tmp1243_; + ValaCCodeFunction* _tmp1239_; + ValaCCodeFunction* _tmp1240_; + ValaCCodeBinaryExpression* _tmp1241_; + ValaCCodeFunction* _tmp1242_; + ValaCCodeFunction* _tmp1243_; ValaCCodeIdentifier* _tmp1244_; - ValaCCodeFunctionCall* _tmp1245_; - ValaCCodeFunctionCall* _tmp1246_; - ValaCCodeFunctionCall* cunsetcall; - ValaCCodeFunctionCall* _tmp1247_; + ValaCCodeIdentifier* _tmp1245_; + ValaCCodeUnaryExpression* _tmp1246_; + ValaCCodeUnaryExpression* _tmp1247_; ValaCCodeIdentifier* _tmp1248_; ValaCCodeIdentifier* _tmp1249_; - ValaCCodeMemberAccess* _tmp1250_; - ValaCCodeMemberAccess* _tmp1251_; - ValaCCodeUnaryExpression* _tmp1252_; - ValaCCodeUnaryExpression* _tmp1253_; - ValaCCodeFunction* _tmp1254_; - ValaCCodeFunction* _tmp1255_; - ValaCCodeFunctionCall* _tmp1256_; - ValaCCodeFunction* _tmp1257_; - ValaCCodeFunction* _tmp1258_; - ValaCCodeIdentifier* _tmp1259_; - ValaCCodeIdentifier* _tmp1260_; + ValaCCodeFunctionCall* _tmp1250_; + ValaCCodeFunctionCall* _tmp1251_; + ValaCCodeFunctionCall* cunsetcall; + ValaCCodeFunctionCall* _tmp1252_; + ValaCCodeIdentifier* _tmp1253_; + ValaCCodeIdentifier* _tmp1254_; + ValaCCodeMemberAccess* _tmp1255_; + ValaCCodeMemberAccess* _tmp1256_; + ValaCCodeUnaryExpression* _tmp1257_; + ValaCCodeUnaryExpression* _tmp1258_; + ValaCCodeFunction* _tmp1259_; + ValaCCodeFunction* _tmp1260_; ValaCCodeFunctionCall* _tmp1261_; - ValaCCodeFunctionCall* _tmp1262_; - ValaCCodeFunctionCall* cfreeparams; - ValaCCodeFunctionCall* _tmp1263_; + ValaCCodeFunction* _tmp1262_; + ValaCCodeFunction* _tmp1263_; ValaCCodeIdentifier* _tmp1264_; ValaCCodeIdentifier* _tmp1265_; - ValaCCodeFunction* _tmp1266_; - ValaCCodeFunction* _tmp1267_; + ValaCCodeFunctionCall* _tmp1266_; + ValaCCodeFunctionCall* _tmp1267_; + ValaCCodeFunctionCall* cfreeparams; ValaCCodeFunctionCall* _tmp1268_; - _tmp1228_ = vala_ccode_identifier_new ("__params_it"); - _tmp1229_ = _tmp1228_; - _tmp1230_ = vala_ccode_identifier_new ("__params"); - _tmp1231_ = _tmp1230_; - _tmp1232_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_GREATER_THAN, (ValaCCodeExpression*) _tmp1229_, (ValaCCodeExpression*) _tmp1231_); - _tmp1233_ = _tmp1232_; - _vala_ccode_node_unref0 (_tmp1231_); - _vala_ccode_node_unref0 (_tmp1229_); - ccond = _tmp1233_; - _tmp1234_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); - _tmp1235_ = _tmp1234_; - _tmp1236_ = ccond; - vala_ccode_function_open_while (_tmp1235_, (ValaCCodeExpression*) _tmp1236_); - _tmp1237_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + ValaCCodeIdentifier* _tmp1269_; + ValaCCodeIdentifier* _tmp1270_; + ValaCCodeFunction* _tmp1271_; + ValaCCodeFunction* _tmp1272_; + ValaCCodeFunctionCall* _tmp1273_; + _tmp1233_ = vala_ccode_identifier_new ("__params_it"); + _tmp1234_ = _tmp1233_; + _tmp1235_ = vala_ccode_identifier_new ("__params"); + _tmp1236_ = _tmp1235_; + _tmp1237_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_GREATER_THAN, (ValaCCodeExpression*) _tmp1234_, (ValaCCodeExpression*) _tmp1236_); _tmp1238_ = _tmp1237_; - _tmp1239_ = vala_ccode_identifier_new ("__params_it"); + _vala_ccode_node_unref0 (_tmp1236_); + _vala_ccode_node_unref0 (_tmp1234_); + ccond = _tmp1238_; + _tmp1239_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); _tmp1240_ = _tmp1239_; - _tmp1241_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_PREFIX_DECREMENT, (ValaCCodeExpression*) _tmp1240_); - _tmp1242_ = _tmp1241_; - vala_ccode_function_add_expression (_tmp1238_, (ValaCCodeExpression*) _tmp1242_); - _vala_ccode_node_unref0 (_tmp1242_); - _vala_ccode_node_unref0 (_tmp1240_); - _tmp1243_ = vala_ccode_identifier_new ("g_value_unset"); - _tmp1244_ = _tmp1243_; - _tmp1245_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp1244_); - _tmp1246_ = _tmp1245_; - _vala_ccode_node_unref0 (_tmp1244_); - cunsetcall = _tmp1246_; - _tmp1247_ = cunsetcall; - _tmp1248_ = vala_ccode_identifier_new ("__params_it"); + _tmp1241_ = ccond; + vala_ccode_function_open_while (_tmp1240_, (ValaCCodeExpression*) _tmp1241_); + _tmp1242_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp1243_ = _tmp1242_; + _tmp1244_ = vala_ccode_identifier_new ("__params_it"); + _tmp1245_ = _tmp1244_; + _tmp1246_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_PREFIX_DECREMENT, (ValaCCodeExpression*) _tmp1245_); + _tmp1247_ = _tmp1246_; + vala_ccode_function_add_expression (_tmp1243_, (ValaCCodeExpression*) _tmp1247_); + _vala_ccode_node_unref0 (_tmp1247_); + _vala_ccode_node_unref0 (_tmp1245_); + _tmp1248_ = vala_ccode_identifier_new ("g_value_unset"); _tmp1249_ = _tmp1248_; - _tmp1250_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp1249_, "value"); + _tmp1250_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp1249_); _tmp1251_ = _tmp1250_; - _tmp1252_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, (ValaCCodeExpression*) _tmp1251_); - _tmp1253_ = _tmp1252_; - vala_ccode_function_call_add_argument (_tmp1247_, (ValaCCodeExpression*) _tmp1253_); - _vala_ccode_node_unref0 (_tmp1253_); - _vala_ccode_node_unref0 (_tmp1251_); _vala_ccode_node_unref0 (_tmp1249_); - _tmp1254_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); - _tmp1255_ = _tmp1254_; - _tmp1256_ = cunsetcall; - vala_ccode_function_add_expression (_tmp1255_, (ValaCCodeExpression*) _tmp1256_); - _tmp1257_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + cunsetcall = _tmp1251_; + _tmp1252_ = cunsetcall; + _tmp1253_ = vala_ccode_identifier_new ("__params_it"); + _tmp1254_ = _tmp1253_; + _tmp1255_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp1254_, "value"); + _tmp1256_ = _tmp1255_; + _tmp1257_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, (ValaCCodeExpression*) _tmp1256_); _tmp1258_ = _tmp1257_; - vala_ccode_function_close (_tmp1258_); - _tmp1259_ = vala_ccode_identifier_new ("g_free"); + vala_ccode_function_call_add_argument (_tmp1252_, (ValaCCodeExpression*) _tmp1258_); + _vala_ccode_node_unref0 (_tmp1258_); + _vala_ccode_node_unref0 (_tmp1256_); + _vala_ccode_node_unref0 (_tmp1254_); + _tmp1259_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); _tmp1260_ = _tmp1259_; - _tmp1261_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp1260_); - _tmp1262_ = _tmp1261_; - _vala_ccode_node_unref0 (_tmp1260_); - cfreeparams = _tmp1262_; - _tmp1263_ = cfreeparams; - _tmp1264_ = vala_ccode_identifier_new ("__params"); + _tmp1261_ = cunsetcall; + vala_ccode_function_add_expression (_tmp1260_, (ValaCCodeExpression*) _tmp1261_); + _tmp1262_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp1263_ = _tmp1262_; + vala_ccode_function_close (_tmp1263_); + _tmp1264_ = vala_ccode_identifier_new ("g_free"); _tmp1265_ = _tmp1264_; - vala_ccode_function_call_add_argument (_tmp1263_, (ValaCCodeExpression*) _tmp1265_); - _vala_ccode_node_unref0 (_tmp1265_); - _tmp1266_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp1266_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp1265_); _tmp1267_ = _tmp1266_; + _vala_ccode_node_unref0 (_tmp1265_); + cfreeparams = _tmp1267_; _tmp1268_ = cfreeparams; - vala_ccode_function_add_expression (_tmp1267_, (ValaCCodeExpression*) _tmp1268_); + _tmp1269_ = vala_ccode_identifier_new ("__params"); + _tmp1270_ = _tmp1269_; + vala_ccode_function_call_add_argument (_tmp1268_, (ValaCCodeExpression*) _tmp1270_); + _vala_ccode_node_unref0 (_tmp1270_); + _tmp1271_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp1272_ = _tmp1271_; + _tmp1273_ = cfreeparams; + vala_ccode_function_add_expression (_tmp1272_, (ValaCCodeExpression*) _tmp1273_); _vala_ccode_node_unref0 (cfreeparams); _vala_ccode_node_unref0 (cunsetcall); _vala_ccode_node_unref0 (ccond); } - _tmp1270_ = vala_ccode_base_module_get_current_type_symbol ((ValaCCodeBaseModule*) self); - _tmp1271_ = _tmp1270_; - if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp1271_, VALA_TYPE_CLASS)) { - ValaMethod* _tmp1272_; - gboolean _tmp1273_; - gboolean _tmp1274_; - _tmp1272_ = m; - _tmp1273_ = vala_method_get_coroutine (_tmp1272_); - _tmp1274_ = _tmp1273_; - _tmp1269_ = !_tmp1274_; - } else { - _tmp1269_ = FALSE; - } - _tmp1275_ = _tmp1269_; - if (_tmp1275_) { - ValaCCodeIdentifier* _tmp1276_; - ValaCCodeExpression* cresult; + _tmp1275_ = vala_ccode_base_module_get_current_type_symbol ((ValaCCodeBaseModule*) self); + _tmp1276_ = _tmp1275_; + if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp1276_, VALA_TYPE_CLASS)) { ValaMethod* _tmp1277_; - gchar* _tmp1278_ = NULL; - gchar* _tmp1279_; - gboolean _tmp1280_; - ValaCCodeFunction* _tmp1286_; - ValaCCodeFunction* _tmp1287_; - ValaCCodeExpression* _tmp1288_; - _tmp1276_ = vala_ccode_identifier_new ("self"); - cresult = (ValaCCodeExpression*) _tmp1276_; + gboolean _tmp1278_; + gboolean _tmp1279_; _tmp1277_ = m; - _tmp1278_ = vala_ccode_base_module_get_ccode_type ((ValaCodeNode*) _tmp1277_); + _tmp1278_ = vala_method_get_coroutine (_tmp1277_); _tmp1279_ = _tmp1278_; - _tmp1280_ = _tmp1279_ != NULL; - _g_free0 (_tmp1279_); - if (_tmp1280_) { - ValaCCodeExpression* _tmp1281_; - ValaMethod* _tmp1282_; - gchar* _tmp1283_ = NULL; - gchar* _tmp1284_; - ValaCCodeCastExpression* _tmp1285_; - _tmp1281_ = cresult; - _tmp1282_ = m; - _tmp1283_ = vala_ccode_base_module_get_ccode_type ((ValaCodeNode*) _tmp1282_); - _tmp1284_ = _tmp1283_; - _tmp1285_ = vala_ccode_cast_expression_new (_tmp1281_, _tmp1284_); + _tmp1274_ = !_tmp1279_; + } else { + _tmp1274_ = FALSE; + } + _tmp1280_ = _tmp1274_; + if (_tmp1280_) { + ValaCCodeIdentifier* _tmp1281_; + ValaCCodeExpression* cresult; + ValaMethod* _tmp1282_; + gchar* _tmp1283_ = NULL; + gchar* _tmp1284_; + gboolean _tmp1285_; + ValaCCodeFunction* _tmp1291_; + ValaCCodeFunction* _tmp1292_; + ValaCCodeExpression* _tmp1293_; + _tmp1281_ = vala_ccode_identifier_new ("self"); + cresult = (ValaCCodeExpression*) _tmp1281_; + _tmp1282_ = m; + _tmp1283_ = vala_ccode_base_module_get_ccode_type ((ValaCodeNode*) _tmp1282_); + _tmp1284_ = _tmp1283_; + _tmp1285_ = _tmp1284_ != NULL; + _g_free0 (_tmp1284_); + if (_tmp1285_) { + ValaCCodeExpression* _tmp1286_; + ValaMethod* _tmp1287_; + gchar* _tmp1288_ = NULL; + gchar* _tmp1289_; + ValaCCodeCastExpression* _tmp1290_; + _tmp1286_ = cresult; + _tmp1287_ = m; + _tmp1288_ = vala_ccode_base_module_get_ccode_type ((ValaCodeNode*) _tmp1287_); + _tmp1289_ = _tmp1288_; + _tmp1290_ = vala_ccode_cast_expression_new (_tmp1286_, _tmp1289_); _vala_ccode_node_unref0 (cresult); - cresult = (ValaCCodeExpression*) _tmp1285_; - _g_free0 (_tmp1284_); + cresult = (ValaCCodeExpression*) _tmp1290_; + _g_free0 (_tmp1289_); } - _tmp1286_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); - _tmp1287_ = _tmp1286_; - _tmp1288_ = cresult; - vala_ccode_function_add_return (_tmp1287_, _tmp1288_); + _tmp1291_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp1292_ = _tmp1291_; + _tmp1293_ = cresult; + vala_ccode_function_add_return (_tmp1292_, _tmp1293_); _vala_ccode_node_unref0 (cresult); } } - _tmp1289_ = ((ValaCCodeBaseModule*) self)->cfile; - _tmp1290_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); - _tmp1291_ = _tmp1290_; - vala_ccode_file_add_function (_tmp1289_, _tmp1291_); + _tmp1294_ = ((ValaCCodeBaseModule*) self)->cfile; + _tmp1295_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp1296_ = _tmp1295_; + vala_ccode_file_add_function (_tmp1294_, _tmp1296_); } } - _tmp1293_ = m; - _tmp1294_ = vala_method_get_is_abstract (_tmp1293_); - _tmp1295_ = _tmp1294_; - if (_tmp1295_) { - ValaTypeSymbol* _tmp1296_; - ValaTypeSymbol* _tmp1297_; - _tmp1296_ = vala_ccode_base_module_get_current_type_symbol ((ValaCCodeBaseModule*) self); - _tmp1297_ = _tmp1296_; - _tmp1292_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp1297_, VALA_TYPE_CLASS); + _tmp1298_ = m; + _tmp1299_ = vala_method_get_is_abstract (_tmp1298_); + _tmp1300_ = _tmp1299_; + if (_tmp1300_) { + ValaTypeSymbol* _tmp1301_; + ValaTypeSymbol* _tmp1302_; + _tmp1301_ = vala_ccode_base_module_get_current_type_symbol ((ValaCCodeBaseModule*) self); + _tmp1302_ = _tmp1301_; + _tmp1297_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp1302_, VALA_TYPE_CLASS); } else { - _tmp1292_ = FALSE; + _tmp1297_ = FALSE; } - _tmp1298_ = _tmp1292_; - if (_tmp1298_) { - ValaCCodeIdentifier* _tmp1299_; - ValaCCodeIdentifier* _tmp1300_; - ValaCCodeFunctionCall* _tmp1301_; - ValaCCodeFunctionCall* _tmp1302_; - ValaCCodeFunctionCall* type_from_instance_call; - ValaCCodeFunctionCall* _tmp1303_; + _tmp1303_ = _tmp1297_; + if (_tmp1303_) { ValaCCodeIdentifier* _tmp1304_; ValaCCodeIdentifier* _tmp1305_; - ValaCCodeIdentifier* _tmp1306_; - ValaCCodeIdentifier* _tmp1307_; + ValaCCodeFunctionCall* _tmp1306_; + ValaCCodeFunctionCall* _tmp1307_; + ValaCCodeFunctionCall* type_from_instance_call; ValaCCodeFunctionCall* _tmp1308_; - ValaCCodeFunctionCall* _tmp1309_; + ValaCCodeIdentifier* _tmp1309_; + ValaCCodeIdentifier* _tmp1310_; + ValaCCodeIdentifier* _tmp1311_; + ValaCCodeIdentifier* _tmp1312_; + ValaCCodeFunctionCall* _tmp1313_; + ValaCCodeFunctionCall* _tmp1314_; ValaCCodeFunctionCall* type_name_call; - ValaCCodeFunctionCall* _tmp1310_; - ValaCCodeFunctionCall* _tmp1311_; - ValaMethod* _tmp1312_; - gchar* _tmp1313_ = NULL; - gchar* _tmp1314_; - gchar* _tmp1315_ = NULL; - gchar* _tmp1316_; + ValaCCodeFunctionCall* _tmp1315_; + ValaCCodeFunctionCall* _tmp1316_; + ValaMethod* _tmp1317_; + gchar* _tmp1318_ = NULL; + gchar* _tmp1319_; + gchar* _tmp1320_ = NULL; + gchar* _tmp1321_; gchar* error_string; - ValaCCodeIdentifier* _tmp1317_; - ValaCCodeIdentifier* _tmp1318_; - ValaCCodeFunctionCall* _tmp1319_; - ValaCCodeFunctionCall* _tmp1320_; - ValaCCodeFunctionCall* cerrorcall; - ValaCCodeFunctionCall* _tmp1321_; - const gchar* _tmp1322_; - ValaCCodeConstant* _tmp1323_; - ValaCCodeConstant* _tmp1324_; + ValaCCodeIdentifier* _tmp1322_; + ValaCCodeIdentifier* _tmp1323_; + ValaCCodeFunctionCall* _tmp1324_; ValaCCodeFunctionCall* _tmp1325_; + ValaCCodeFunctionCall* cerrorcall; ValaCCodeFunctionCall* _tmp1326_; - ValaCCodeFunction* _tmp1327_; - ValaCCodeFunction* _tmp1328_; - ValaCCodeFunctionCall* _tmp1329_; - ValaDataType* _tmp1330_; - ValaCCodeFile* _tmp1331_; + const gchar* _tmp1327_; + ValaCCodeConstant* _tmp1328_; + ValaCCodeConstant* _tmp1329_; + ValaCCodeFunctionCall* _tmp1330_; + ValaCCodeFunctionCall* _tmp1331_; ValaCCodeFunction* _tmp1332_; ValaCCodeFunction* _tmp1333_; - _tmp1299_ = vala_ccode_identifier_new ("G_TYPE_FROM_INSTANCE"); - _tmp1300_ = _tmp1299_; - _tmp1301_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp1300_); - _tmp1302_ = _tmp1301_; - _vala_ccode_node_unref0 (_tmp1300_); - type_from_instance_call = _tmp1302_; - _tmp1303_ = type_from_instance_call; - _tmp1304_ = vala_ccode_identifier_new ("self"); + ValaCCodeFunctionCall* _tmp1334_; + ValaDataType* _tmp1335_; + ValaCCodeFile* _tmp1336_; + ValaCCodeFunction* _tmp1337_; + ValaCCodeFunction* _tmp1338_; + _tmp1304_ = vala_ccode_identifier_new ("G_TYPE_FROM_INSTANCE"); _tmp1305_ = _tmp1304_; - vala_ccode_function_call_add_argument (_tmp1303_, (ValaCCodeExpression*) _tmp1305_); - _vala_ccode_node_unref0 (_tmp1305_); - _tmp1306_ = vala_ccode_identifier_new ("g_type_name"); + _tmp1306_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp1305_); _tmp1307_ = _tmp1306_; - _tmp1308_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp1307_); - _tmp1309_ = _tmp1308_; - _vala_ccode_node_unref0 (_tmp1307_); - type_name_call = _tmp1309_; - _tmp1310_ = type_name_call; - _tmp1311_ = type_from_instance_call; - vala_ccode_function_call_add_argument (_tmp1310_, (ValaCCodeExpression*) _tmp1311_); - _tmp1312_ = m; - _tmp1313_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp1312_); + _vala_ccode_node_unref0 (_tmp1305_); + type_from_instance_call = _tmp1307_; + _tmp1308_ = type_from_instance_call; + _tmp1309_ = vala_ccode_identifier_new ("self"); + _tmp1310_ = _tmp1309_; + vala_ccode_function_call_add_argument (_tmp1308_, (ValaCCodeExpression*) _tmp1310_); + _vala_ccode_node_unref0 (_tmp1310_); + _tmp1311_ = vala_ccode_identifier_new ("g_type_name"); + _tmp1312_ = _tmp1311_; + _tmp1313_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp1312_); _tmp1314_ = _tmp1313_; - _tmp1315_ = g_strdup_printf ("\"Type `%%s' does not implement abstract method `%s'\"", _tmp1314_); - _tmp1316_ = _tmp1315_; - _g_free0 (_tmp1314_); - error_string = _tmp1316_; - _tmp1317_ = vala_ccode_identifier_new ("g_critical"); - _tmp1318_ = _tmp1317_; - _tmp1319_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp1318_); - _tmp1320_ = _tmp1319_; - _vala_ccode_node_unref0 (_tmp1318_); - cerrorcall = _tmp1320_; - _tmp1321_ = cerrorcall; - _tmp1322_ = error_string; - _tmp1323_ = vala_ccode_constant_new (_tmp1322_); - _tmp1324_ = _tmp1323_; - vala_ccode_function_call_add_argument (_tmp1321_, (ValaCCodeExpression*) _tmp1324_); - _vala_ccode_node_unref0 (_tmp1324_); - _tmp1325_ = cerrorcall; - _tmp1326_ = type_name_call; - vala_ccode_function_call_add_argument (_tmp1325_, (ValaCCodeExpression*) _tmp1326_); - _tmp1327_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); - _tmp1328_ = _tmp1327_; - _tmp1329_ = cerrorcall; - vala_ccode_function_add_expression (_tmp1328_, (ValaCCodeExpression*) _tmp1329_); - _tmp1330_ = creturn_type; - vala_ccode_base_module_return_default_value ((ValaCCodeBaseModule*) self, _tmp1330_); - _tmp1331_ = ((ValaCCodeBaseModule*) self)->cfile; + _vala_ccode_node_unref0 (_tmp1312_); + type_name_call = _tmp1314_; + _tmp1315_ = type_name_call; + _tmp1316_ = type_from_instance_call; + vala_ccode_function_call_add_argument (_tmp1315_, (ValaCCodeExpression*) _tmp1316_); + _tmp1317_ = m; + _tmp1318_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp1317_); + _tmp1319_ = _tmp1318_; + _tmp1320_ = g_strdup_printf ("\"Type `%%s' does not implement abstract method `%s'\"", _tmp1319_); + _tmp1321_ = _tmp1320_; + _g_free0 (_tmp1319_); + error_string = _tmp1321_; + _tmp1322_ = vala_ccode_identifier_new ("g_critical"); + _tmp1323_ = _tmp1322_; + _tmp1324_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp1323_); + _tmp1325_ = _tmp1324_; + _vala_ccode_node_unref0 (_tmp1323_); + cerrorcall = _tmp1325_; + _tmp1326_ = cerrorcall; + _tmp1327_ = error_string; + _tmp1328_ = vala_ccode_constant_new (_tmp1327_); + _tmp1329_ = _tmp1328_; + vala_ccode_function_call_add_argument (_tmp1326_, (ValaCCodeExpression*) _tmp1329_); + _vala_ccode_node_unref0 (_tmp1329_); + _tmp1330_ = cerrorcall; + _tmp1331_ = type_name_call; + vala_ccode_function_call_add_argument (_tmp1330_, (ValaCCodeExpression*) _tmp1331_); _tmp1332_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); _tmp1333_ = _tmp1332_; - vala_ccode_file_add_function (_tmp1331_, _tmp1333_); + _tmp1334_ = cerrorcall; + vala_ccode_function_add_expression (_tmp1333_, (ValaCCodeExpression*) _tmp1334_); + _tmp1335_ = creturn_type; + vala_ccode_base_module_return_default_value ((ValaCCodeBaseModule*) self, _tmp1335_); + _tmp1336_ = ((ValaCCodeBaseModule*) self)->cfile; + _tmp1337_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp1338_ = _tmp1337_; + vala_ccode_file_add_function (_tmp1336_, _tmp1338_); _vala_ccode_node_unref0 (cerrorcall); _g_free0 (error_string); _vala_ccode_node_unref0 (type_name_call); _vala_ccode_node_unref0 (type_from_instance_call); } vala_ccode_base_module_pop_context ((ValaCCodeBaseModule*) self); - _tmp1337_ = m; - _tmp1338_ = vala_method_get_is_abstract (_tmp1337_); - _tmp1339_ = _tmp1338_; - if (_tmp1339_) { - _tmp1336_ = TRUE; + _tmp1342_ = m; + _tmp1343_ = vala_method_get_is_abstract (_tmp1342_); + _tmp1344_ = _tmp1343_; + if (_tmp1344_) { + _tmp1341_ = TRUE; } else { - ValaMethod* _tmp1340_; - gboolean _tmp1341_; - gboolean _tmp1342_; - _tmp1340_ = m; - _tmp1341_ = vala_method_get_is_virtual (_tmp1340_); - _tmp1342_ = _tmp1341_; - _tmp1336_ = _tmp1342_; - } - _tmp1343_ = _tmp1336_; - if (_tmp1343_) { - ValaMethod* _tmp1344_; - gboolean _tmp1345_; + ValaMethod* _tmp1345_; gboolean _tmp1346_; - _tmp1344_ = m; - _tmp1345_ = vala_method_get_coroutine (_tmp1344_); - _tmp1346_ = _tmp1345_; - _tmp1335_ = !_tmp1346_; + gboolean _tmp1347_; + _tmp1345_ = m; + _tmp1346_ = vala_method_get_is_virtual (_tmp1345_); + _tmp1347_ = _tmp1346_; + _tmp1341_ = _tmp1347_; + } + _tmp1348_ = _tmp1341_; + if (_tmp1348_) { + ValaMethod* _tmp1349_; + gboolean _tmp1350_; + gboolean _tmp1351_; + _tmp1349_ = m; + _tmp1350_ = vala_method_get_coroutine (_tmp1349_); + _tmp1351_ = _tmp1350_; + _tmp1340_ = !_tmp1351_; } else { - _tmp1335_ = FALSE; + _tmp1340_ = FALSE; } - _tmp1347_ = _tmp1335_; - if (_tmp1347_) { - ValaMethod* _tmp1348_; - ValaSignal* _tmp1349_; - ValaSignal* _tmp1350_; - _tmp1348_ = m; - _tmp1349_ = vala_method_get_signal_reference (_tmp1348_); - _tmp1350_ = _tmp1349_; - _tmp1334_ = _tmp1350_ == NULL; + _tmp1352_ = _tmp1340_; + if (_tmp1352_) { + ValaMethod* _tmp1353_; + ValaSignal* _tmp1354_; + ValaSignal* _tmp1355_; + _tmp1353_ = m; + _tmp1354_ = vala_method_get_signal_reference (_tmp1353_); + _tmp1355_ = _tmp1354_; + _tmp1339_ = _tmp1355_ == NULL; } else { - _tmp1334_ = FALSE; + _tmp1339_ = FALSE; } - _tmp1351_ = _tmp1334_; - if (_tmp1351_) { - GHashFunc _tmp1352_; - GEqualFunc _tmp1353_; - GEqualFunc _tmp1354_; - ValaHashMap* _tmp1355_; - GHashFunc _tmp1356_; - GEqualFunc _tmp1357_; + _tmp1356_ = _tmp1339_; + if (_tmp1356_) { + GHashFunc _tmp1357_; GEqualFunc _tmp1358_; - ValaHashMap* _tmp1359_; + GEqualFunc _tmp1359_; + ValaHashMap* _tmp1360_; + GHashFunc _tmp1361_; + GEqualFunc _tmp1362_; + GEqualFunc _tmp1363_; + ValaHashMap* _tmp1364_; ValaHashMap* carg_map; - ValaMethod* _tmp1360_; - ValaDataType* _tmp1361_; - ValaHashMap* _tmp1362_; - ValaHashMap* _tmp1363_; - _tmp1352_ = g_direct_hash; - _tmp1353_ = g_direct_equal; - _tmp1354_ = g_direct_equal; - _tmp1355_ = vala_hash_map_new (G_TYPE_INT, NULL, NULL, VALA_TYPE_CCODE_PARAMETER, (GBoxedCopyFunc) vala_ccode_node_ref, vala_ccode_node_unref, _tmp1352_, _tmp1353_, _tmp1354_); - _vala_map_unref0 (cparam_map); - cparam_map = _tmp1355_; - _tmp1356_ = g_direct_hash; - _tmp1357_ = g_direct_equal; + ValaMethod* _tmp1365_; + ValaDataType* _tmp1366_; + ValaHashMap* _tmp1367_; + ValaHashMap* _tmp1368_; + _tmp1357_ = g_direct_hash; _tmp1358_ = g_direct_equal; - _tmp1359_ = vala_hash_map_new (G_TYPE_INT, NULL, NULL, VALA_TYPE_CCODE_EXPRESSION, (GBoxedCopyFunc) vala_ccode_node_ref, vala_ccode_node_unref, _tmp1356_, _tmp1357_, _tmp1358_); - carg_map = _tmp1359_; - _tmp1360_ = m; - _tmp1361_ = creturn_type; - _tmp1362_ = cparam_map; - _tmp1363_ = carg_map; - vala_ccode_method_module_generate_vfunc (self, _tmp1360_, _tmp1361_, (ValaMap*) _tmp1362_, (ValaMap*) _tmp1363_, "", 3); + _tmp1359_ = g_direct_equal; + _tmp1360_ = vala_hash_map_new (G_TYPE_INT, NULL, NULL, VALA_TYPE_CCODE_PARAMETER, (GBoxedCopyFunc) vala_ccode_node_ref, vala_ccode_node_unref, _tmp1357_, _tmp1358_, _tmp1359_); + _vala_map_unref0 (cparam_map); + cparam_map = _tmp1360_; + _tmp1361_ = g_direct_hash; + _tmp1362_ = g_direct_equal; + _tmp1363_ = g_direct_equal; + _tmp1364_ = vala_hash_map_new (G_TYPE_INT, NULL, NULL, VALA_TYPE_CCODE_EXPRESSION, (GBoxedCopyFunc) vala_ccode_node_ref, vala_ccode_node_unref, _tmp1361_, _tmp1362_, _tmp1363_); + carg_map = _tmp1364_; + _tmp1365_ = m; + _tmp1366_ = creturn_type; + _tmp1367_ = cparam_map; + _tmp1368_ = carg_map; + vala_ccode_method_module_generate_vfunc (self, _tmp1365_, _tmp1366_, (ValaMap*) _tmp1367_, (ValaMap*) _tmp1368_, "", 3); _vala_map_unref0 (carg_map); } - _tmp1364_ = m; - _tmp1365_ = vala_method_get_entry_point (_tmp1364_); - _tmp1366_ = _tmp1365_; - if (_tmp1366_) { - ValaCCodeFunction* _tmp1367_; - ValaCCodeFunction* cmain; - ValaCCodeFunction* _tmp1368_; - ValaCCodeFunction* _tmp1369_; - ValaCCodeLineDirective* _tmp1370_; - ValaCCodeLineDirective* _tmp1371_; + _tmp1369_ = m; + _tmp1370_ = vala_method_get_entry_point (_tmp1369_); + _tmp1371_ = _tmp1370_; + if (_tmp1371_) { ValaCCodeFunction* _tmp1372_; - ValaCCodeParameter* _tmp1373_; - ValaCCodeParameter* _tmp1374_; - ValaCCodeFunction* _tmp1375_; - ValaCCodeParameter* _tmp1376_; - ValaCCodeParameter* _tmp1377_; - ValaCCodeFunction* _tmp1378_; - ValaCodeContext* _tmp1379_; - ValaCodeContext* _tmp1380_; - gboolean _tmp1381_; - gboolean _tmp1382_; - ValaCodeContext* _tmp1397_; - ValaCodeContext* _tmp1398_; - gboolean _tmp1399_; - gboolean _tmp1400_; - ValaCCodeFunction* _tmp1415_; - ValaCCodeFunction* _tmp1416_; - ValaCCodeIdentifier* _tmp1417_; - ValaCCodeIdentifier* _tmp1418_; - ValaCCodeFunctionCall* _tmp1419_; - ValaCCodeFunctionCall* _tmp1420_; - ValaCCodeFunction* _tmp1421_; - const gchar* _tmp1422_; - const gchar* _tmp1423_; - ValaCCodeIdentifier* _tmp1424_; - ValaCCodeIdentifier* _tmp1425_; - ValaCCodeFunctionCall* _tmp1426_; - ValaCCodeFunctionCall* _tmp1427_; + ValaCCodeFunction* cmain; + ValaCCodeFunction* _tmp1373_; + ValaCCodeFunction* _tmp1374_; + ValaCCodeLineDirective* _tmp1375_; + ValaCCodeLineDirective* _tmp1376_; + ValaCCodeFunction* _tmp1377_; + ValaCCodeParameter* _tmp1378_; + ValaCCodeParameter* _tmp1379_; + ValaCCodeFunction* _tmp1380_; + ValaCCodeParameter* _tmp1381_; + ValaCCodeParameter* _tmp1382_; + ValaCCodeFunction* _tmp1383_; + ValaCodeContext* _tmp1384_; + ValaCodeContext* _tmp1385_; + gboolean _tmp1386_; + gboolean _tmp1387_; + gboolean _tmp1402_ = FALSE; + ValaCodeContext* _tmp1403_; + ValaCodeContext* _tmp1404_; + gboolean _tmp1405_; + gboolean _tmp1406_; + gboolean _tmp1410_; + ValaCCodeFunction* _tmp1425_; + ValaCCodeFunction* _tmp1426_; + ValaCCodeIdentifier* _tmp1427_; + ValaCCodeIdentifier* _tmp1428_; + ValaCCodeFunctionCall* _tmp1429_; + ValaCCodeFunctionCall* _tmp1430_; + ValaCCodeFunction* _tmp1431_; + const gchar* _tmp1432_; + const gchar* _tmp1433_; + ValaCCodeIdentifier* _tmp1434_; + ValaCCodeIdentifier* _tmp1435_; + ValaCCodeFunctionCall* _tmp1436_; + ValaCCodeFunctionCall* _tmp1437_; ValaCCodeFunctionCall* main_call; - ValaMethod* _tmp1428_; - ValaList* _tmp1429_ = NULL; - ValaList* _tmp1430_; - gint _tmp1431_; - gint _tmp1432_; - gboolean _tmp1433_; - ValaMethod* _tmp1440_; - ValaDataType* _tmp1441_; - ValaDataType* _tmp1442_; - ValaCCodeFile* _tmp1453_; - ValaCCodeFunction* _tmp1454_; - _tmp1367_ = vala_ccode_function_new ("main", "int"); - cmain = _tmp1367_; - _tmp1368_ = cmain; - _tmp1369_ = function; - _tmp1370_ = vala_ccode_node_get_line ((ValaCCodeNode*) _tmp1369_); - _tmp1371_ = _tmp1370_; - vala_ccode_node_set_line ((ValaCCodeNode*) _tmp1368_, _tmp1371_); - _tmp1372_ = cmain; - _tmp1373_ = vala_ccode_parameter_new ("argc", "int"); - _tmp1374_ = _tmp1373_; - vala_ccode_function_add_parameter (_tmp1372_, _tmp1374_); - _vala_ccode_node_unref0 (_tmp1374_); - _tmp1375_ = cmain; - _tmp1376_ = vala_ccode_parameter_new ("argv", "char **"); - _tmp1377_ = _tmp1376_; - vala_ccode_function_add_parameter (_tmp1375_, _tmp1377_); - _vala_ccode_node_unref0 (_tmp1377_); - _tmp1378_ = cmain; - vala_ccode_base_module_push_function ((ValaCCodeBaseModule*) self, _tmp1378_); - _tmp1379_ = vala_ccode_base_module_get_context ((ValaCCodeBaseModule*) self); - _tmp1380_ = _tmp1379_; - _tmp1381_ = vala_code_context_get_mem_profiler (_tmp1380_); + ValaMethod* _tmp1438_; + ValaList* _tmp1439_ = NULL; + ValaList* _tmp1440_; + gint _tmp1441_; + gint _tmp1442_; + gboolean _tmp1443_; + ValaMethod* _tmp1450_; + ValaDataType* _tmp1451_; + ValaDataType* _tmp1452_; + ValaCCodeFile* _tmp1463_; + ValaCCodeFunction* _tmp1464_; + _tmp1372_ = vala_ccode_function_new ("main", "int"); + cmain = _tmp1372_; + _tmp1373_ = cmain; + _tmp1374_ = function; + _tmp1375_ = vala_ccode_node_get_line ((ValaCCodeNode*) _tmp1374_); + _tmp1376_ = _tmp1375_; + vala_ccode_node_set_line ((ValaCCodeNode*) _tmp1373_, _tmp1376_); + _tmp1377_ = cmain; + _tmp1378_ = vala_ccode_parameter_new ("argc", "int"); + _tmp1379_ = _tmp1378_; + vala_ccode_function_add_parameter (_tmp1377_, _tmp1379_); + _vala_ccode_node_unref0 (_tmp1379_); + _tmp1380_ = cmain; + _tmp1381_ = vala_ccode_parameter_new ("argv", "char **"); _tmp1382_ = _tmp1381_; - if (_tmp1382_) { - ValaCCodeIdentifier* _tmp1383_; - ValaCCodeIdentifier* _tmp1384_; - ValaCCodeFunctionCall* _tmp1385_; - ValaCCodeFunctionCall* _tmp1386_; - ValaCCodeFunctionCall* mem_profiler_init_call; - ValaCCodeFunctionCall* _tmp1387_; - ValaCCodeFunction* _tmp1388_; - ValaCCodeLineDirective* _tmp1389_; - ValaCCodeLineDirective* _tmp1390_; + vala_ccode_function_add_parameter (_tmp1380_, _tmp1382_); + _vala_ccode_node_unref0 (_tmp1382_); + _tmp1383_ = cmain; + vala_ccode_base_module_push_function ((ValaCCodeBaseModule*) self, _tmp1383_); + _tmp1384_ = vala_ccode_base_module_get_context ((ValaCCodeBaseModule*) self); + _tmp1385_ = _tmp1384_; + _tmp1386_ = vala_code_context_get_mem_profiler (_tmp1385_); + _tmp1387_ = _tmp1386_; + if (_tmp1387_) { + ValaCCodeIdentifier* _tmp1388_; + ValaCCodeIdentifier* _tmp1389_; + ValaCCodeFunctionCall* _tmp1390_; ValaCCodeFunctionCall* _tmp1391_; - ValaCCodeConstant* _tmp1392_; - ValaCCodeConstant* _tmp1393_; - ValaCCodeFunction* _tmp1394_; - ValaCCodeFunction* _tmp1395_; + ValaCCodeFunctionCall* mem_profiler_init_call; + ValaCCodeFunctionCall* _tmp1392_; + ValaCCodeFunction* _tmp1393_; + ValaCCodeLineDirective* _tmp1394_; + ValaCCodeLineDirective* _tmp1395_; ValaCCodeFunctionCall* _tmp1396_; - _tmp1383_ = vala_ccode_identifier_new ("g_mem_set_vtable"); - _tmp1384_ = _tmp1383_; - _tmp1385_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp1384_); - _tmp1386_ = _tmp1385_; - _vala_ccode_node_unref0 (_tmp1384_); - mem_profiler_init_call = _tmp1386_; - _tmp1387_ = mem_profiler_init_call; - _tmp1388_ = cmain; - _tmp1389_ = vala_ccode_node_get_line ((ValaCCodeNode*) _tmp1388_); - _tmp1390_ = _tmp1389_; - vala_ccode_node_set_line ((ValaCCodeNode*) _tmp1387_, _tmp1390_); - _tmp1391_ = mem_profiler_init_call; - _tmp1392_ = vala_ccode_constant_new ("glib_mem_profiler_table"); - _tmp1393_ = _tmp1392_; - vala_ccode_function_call_add_argument (_tmp1391_, (ValaCCodeExpression*) _tmp1393_); - _vala_ccode_node_unref0 (_tmp1393_); - _tmp1394_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + ValaCCodeConstant* _tmp1397_; + ValaCCodeConstant* _tmp1398_; + ValaCCodeFunction* _tmp1399_; + ValaCCodeFunction* _tmp1400_; + ValaCCodeFunctionCall* _tmp1401_; + _tmp1388_ = vala_ccode_identifier_new ("g_mem_set_vtable"); + _tmp1389_ = _tmp1388_; + _tmp1390_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp1389_); + _tmp1391_ = _tmp1390_; + _vala_ccode_node_unref0 (_tmp1389_); + mem_profiler_init_call = _tmp1391_; + _tmp1392_ = mem_profiler_init_call; + _tmp1393_ = cmain; + _tmp1394_ = vala_ccode_node_get_line ((ValaCCodeNode*) _tmp1393_); _tmp1395_ = _tmp1394_; + vala_ccode_node_set_line ((ValaCCodeNode*) _tmp1392_, _tmp1395_); _tmp1396_ = mem_profiler_init_call; - vala_ccode_function_add_expression (_tmp1395_, (ValaCCodeExpression*) _tmp1396_); + _tmp1397_ = vala_ccode_constant_new ("glib_mem_profiler_table"); + _tmp1398_ = _tmp1397_; + vala_ccode_function_call_add_argument (_tmp1396_, (ValaCCodeExpression*) _tmp1398_); + _vala_ccode_node_unref0 (_tmp1398_); + _tmp1399_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp1400_ = _tmp1399_; + _tmp1401_ = mem_profiler_init_call; + vala_ccode_function_add_expression (_tmp1400_, (ValaCCodeExpression*) _tmp1401_); _vala_ccode_node_unref0 (mem_profiler_init_call); } - _tmp1397_ = vala_ccode_base_module_get_context ((ValaCCodeBaseModule*) self); - _tmp1398_ = _tmp1397_; - _tmp1399_ = vala_code_context_get_thread (_tmp1398_); - _tmp1400_ = _tmp1399_; - if (_tmp1400_) { - ValaCCodeIdentifier* _tmp1401_; - ValaCCodeIdentifier* _tmp1402_; - ValaCCodeFunctionCall* _tmp1403_; - ValaCCodeFunctionCall* _tmp1404_; - ValaCCodeFunctionCall* thread_init_call; - ValaCCodeFunctionCall* _tmp1405_; - ValaCCodeFunction* _tmp1406_; - ValaCCodeLineDirective* _tmp1407_; - ValaCCodeLineDirective* _tmp1408_; - ValaCCodeFunctionCall* _tmp1409_; - ValaCCodeConstant* _tmp1410_; - ValaCCodeConstant* _tmp1411_; - ValaCCodeFunction* _tmp1412_; - ValaCCodeFunction* _tmp1413_; - ValaCCodeFunctionCall* _tmp1414_; - _tmp1401_ = vala_ccode_identifier_new ("g_thread_init"); - _tmp1402_ = _tmp1401_; - _tmp1403_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp1402_); - _tmp1404_ = _tmp1403_; - _vala_ccode_node_unref0 (_tmp1402_); - thread_init_call = _tmp1404_; - _tmp1405_ = thread_init_call; - _tmp1406_ = cmain; - _tmp1407_ = vala_ccode_node_get_line ((ValaCCodeNode*) _tmp1406_); + _tmp1403_ = vala_ccode_base_module_get_context ((ValaCCodeBaseModule*) self); + _tmp1404_ = _tmp1403_; + _tmp1405_ = vala_code_context_get_thread (_tmp1404_); + _tmp1406_ = _tmp1405_; + if (_tmp1406_) { + ValaCodeContext* _tmp1407_; + ValaCodeContext* _tmp1408_; + gboolean _tmp1409_ = FALSE; + _tmp1407_ = vala_ccode_base_module_get_context ((ValaCCodeBaseModule*) self); _tmp1408_ = _tmp1407_; - vala_ccode_node_set_line ((ValaCCodeNode*) _tmp1405_, _tmp1408_); - _tmp1409_ = thread_init_call; - _tmp1410_ = vala_ccode_constant_new ("NULL"); - _tmp1411_ = _tmp1410_; - vala_ccode_function_call_add_argument (_tmp1409_, (ValaCCodeExpression*) _tmp1411_); - _vala_ccode_node_unref0 (_tmp1411_); - _tmp1412_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); - _tmp1413_ = _tmp1412_; - _tmp1414_ = thread_init_call; - vala_ccode_function_add_expression (_tmp1413_, (ValaCCodeExpression*) _tmp1414_); + _tmp1409_ = vala_code_context_require_glib_version (_tmp1408_, 2, 32); + _tmp1402_ = !_tmp1409_; + } else { + _tmp1402_ = FALSE; + } + _tmp1410_ = _tmp1402_; + if (_tmp1410_) { + ValaCCodeIdentifier* _tmp1411_; + ValaCCodeIdentifier* _tmp1412_; + ValaCCodeFunctionCall* _tmp1413_; + ValaCCodeFunctionCall* _tmp1414_; + ValaCCodeFunctionCall* thread_init_call; + ValaCCodeFunctionCall* _tmp1415_; + ValaCCodeFunction* _tmp1416_; + ValaCCodeLineDirective* _tmp1417_; + ValaCCodeLineDirective* _tmp1418_; + ValaCCodeFunctionCall* _tmp1419_; + ValaCCodeConstant* _tmp1420_; + ValaCCodeConstant* _tmp1421_; + ValaCCodeFunction* _tmp1422_; + ValaCCodeFunction* _tmp1423_; + ValaCCodeFunctionCall* _tmp1424_; + _tmp1411_ = vala_ccode_identifier_new ("g_thread_init"); + _tmp1412_ = _tmp1411_; + _tmp1413_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp1412_); + _tmp1414_ = _tmp1413_; + _vala_ccode_node_unref0 (_tmp1412_); + thread_init_call = _tmp1414_; + _tmp1415_ = thread_init_call; + _tmp1416_ = cmain; + _tmp1417_ = vala_ccode_node_get_line ((ValaCCodeNode*) _tmp1416_); + _tmp1418_ = _tmp1417_; + vala_ccode_node_set_line ((ValaCCodeNode*) _tmp1415_, _tmp1418_); + _tmp1419_ = thread_init_call; + _tmp1420_ = vala_ccode_constant_new ("NULL"); + _tmp1421_ = _tmp1420_; + vala_ccode_function_call_add_argument (_tmp1419_, (ValaCCodeExpression*) _tmp1421_); + _vala_ccode_node_unref0 (_tmp1421_); + _tmp1422_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp1423_ = _tmp1422_; + _tmp1424_ = thread_init_call; + vala_ccode_function_add_expression (_tmp1423_, (ValaCCodeExpression*) _tmp1424_); _vala_ccode_node_unref0 (thread_init_call); } - _tmp1415_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); - _tmp1416_ = _tmp1415_; - _tmp1417_ = vala_ccode_identifier_new ("g_type_init"); - _tmp1418_ = _tmp1417_; - _tmp1419_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp1418_); - _tmp1420_ = _tmp1419_; - vala_ccode_function_add_expression (_tmp1416_, (ValaCCodeExpression*) _tmp1420_); - _vala_ccode_node_unref0 (_tmp1420_); - _vala_ccode_node_unref0 (_tmp1418_); - _tmp1421_ = function; - _tmp1422_ = vala_ccode_function_get_name (_tmp1421_); - _tmp1423_ = _tmp1422_; - _tmp1424_ = vala_ccode_identifier_new (_tmp1423_); - _tmp1425_ = _tmp1424_; - _tmp1426_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp1425_); - _tmp1427_ = _tmp1426_; - _vala_ccode_node_unref0 (_tmp1425_); - main_call = _tmp1427_; - _tmp1428_ = m; - _tmp1429_ = vala_method_get_parameters (_tmp1428_); + _tmp1425_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp1426_ = _tmp1425_; + _tmp1427_ = vala_ccode_identifier_new ("g_type_init"); + _tmp1428_ = _tmp1427_; + _tmp1429_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp1428_); _tmp1430_ = _tmp1429_; - _tmp1431_ = vala_collection_get_size ((ValaCollection*) _tmp1430_); - _tmp1432_ = _tmp1431_; - _tmp1433_ = _tmp1432_ == 1; - _vala_iterable_unref0 (_tmp1430_); - if (_tmp1433_) { - ValaCCodeFunctionCall* _tmp1434_; - ValaCCodeIdentifier* _tmp1435_; - ValaCCodeIdentifier* _tmp1436_; - ValaCCodeFunctionCall* _tmp1437_; - ValaCCodeIdentifier* _tmp1438_; - ValaCCodeIdentifier* _tmp1439_; - _tmp1434_ = main_call; - _tmp1435_ = vala_ccode_identifier_new ("argv"); - _tmp1436_ = _tmp1435_; - vala_ccode_function_call_add_argument (_tmp1434_, (ValaCCodeExpression*) _tmp1436_); - _vala_ccode_node_unref0 (_tmp1436_); - _tmp1437_ = main_call; - _tmp1438_ = vala_ccode_identifier_new ("argc"); - _tmp1439_ = _tmp1438_; - vala_ccode_function_call_add_argument (_tmp1437_, (ValaCCodeExpression*) _tmp1439_); - _vala_ccode_node_unref0 (_tmp1439_); - } - _tmp1440_ = m; - _tmp1441_ = vala_method_get_return_type (_tmp1440_); + vala_ccode_function_add_expression (_tmp1426_, (ValaCCodeExpression*) _tmp1430_); + _vala_ccode_node_unref0 (_tmp1430_); + _vala_ccode_node_unref0 (_tmp1428_); + _tmp1431_ = function; + _tmp1432_ = vala_ccode_function_get_name (_tmp1431_); + _tmp1433_ = _tmp1432_; + _tmp1434_ = vala_ccode_identifier_new (_tmp1433_); + _tmp1435_ = _tmp1434_; + _tmp1436_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp1435_); + _tmp1437_ = _tmp1436_; + _vala_ccode_node_unref0 (_tmp1435_); + main_call = _tmp1437_; + _tmp1438_ = m; + _tmp1439_ = vala_method_get_parameters (_tmp1438_); + _tmp1440_ = _tmp1439_; + _tmp1441_ = vala_collection_get_size ((ValaCollection*) _tmp1440_); _tmp1442_ = _tmp1441_; - if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp1442_, VALA_TYPE_VOID_TYPE)) { - ValaCCodeFunction* _tmp1443_; - ValaCCodeFunction* _tmp1444_; - ValaCCodeFunctionCall* _tmp1445_; - ValaCCodeFunction* _tmp1446_; - ValaCCodeFunction* _tmp1447_; - ValaCCodeConstant* _tmp1448_; - ValaCCodeConstant* _tmp1449_; - _tmp1443_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); - _tmp1444_ = _tmp1443_; - _tmp1445_ = main_call; - vala_ccode_function_add_expression (_tmp1444_, (ValaCCodeExpression*) _tmp1445_); - _tmp1446_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); - _tmp1447_ = _tmp1446_; - _tmp1448_ = vala_ccode_constant_new ("0"); + _tmp1443_ = _tmp1442_ == 1; + _vala_iterable_unref0 (_tmp1440_); + if (_tmp1443_) { + ValaCCodeFunctionCall* _tmp1444_; + ValaCCodeIdentifier* _tmp1445_; + ValaCCodeIdentifier* _tmp1446_; + ValaCCodeFunctionCall* _tmp1447_; + ValaCCodeIdentifier* _tmp1448_; + ValaCCodeIdentifier* _tmp1449_; + _tmp1444_ = main_call; + _tmp1445_ = vala_ccode_identifier_new ("argv"); + _tmp1446_ = _tmp1445_; + vala_ccode_function_call_add_argument (_tmp1444_, (ValaCCodeExpression*) _tmp1446_); + _vala_ccode_node_unref0 (_tmp1446_); + _tmp1447_ = main_call; + _tmp1448_ = vala_ccode_identifier_new ("argc"); _tmp1449_ = _tmp1448_; - vala_ccode_function_add_return (_tmp1447_, (ValaCCodeExpression*) _tmp1449_); + vala_ccode_function_call_add_argument (_tmp1447_, (ValaCCodeExpression*) _tmp1449_); _vala_ccode_node_unref0 (_tmp1449_); + } + _tmp1450_ = m; + _tmp1451_ = vala_method_get_return_type (_tmp1450_); + _tmp1452_ = _tmp1451_; + if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp1452_, VALA_TYPE_VOID_TYPE)) { + ValaCCodeFunction* _tmp1453_; + ValaCCodeFunction* _tmp1454_; + ValaCCodeFunctionCall* _tmp1455_; + ValaCCodeFunction* _tmp1456_; + ValaCCodeFunction* _tmp1457_; + ValaCCodeConstant* _tmp1458_; + ValaCCodeConstant* _tmp1459_; + _tmp1453_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp1454_ = _tmp1453_; + _tmp1455_ = main_call; + vala_ccode_function_add_expression (_tmp1454_, (ValaCCodeExpression*) _tmp1455_); + _tmp1456_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp1457_ = _tmp1456_; + _tmp1458_ = vala_ccode_constant_new ("0"); + _tmp1459_ = _tmp1458_; + vala_ccode_function_add_return (_tmp1457_, (ValaCCodeExpression*) _tmp1459_); + _vala_ccode_node_unref0 (_tmp1459_); } else { - ValaCCodeFunction* _tmp1450_; - ValaCCodeFunction* _tmp1451_; - ValaCCodeFunctionCall* _tmp1452_; - _tmp1450_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); - _tmp1451_ = _tmp1450_; - _tmp1452_ = main_call; - vala_ccode_function_add_return (_tmp1451_, (ValaCCodeExpression*) _tmp1452_); + ValaCCodeFunction* _tmp1460_; + ValaCCodeFunction* _tmp1461_; + ValaCCodeFunctionCall* _tmp1462_; + _tmp1460_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp1461_ = _tmp1460_; + _tmp1462_ = main_call; + vala_ccode_function_add_return (_tmp1461_, (ValaCCodeExpression*) _tmp1462_); } vala_ccode_base_module_pop_function ((ValaCCodeBaseModule*) self); - _tmp1453_ = ((ValaCCodeBaseModule*) self)->cfile; - _tmp1454_ = cmain; - vala_ccode_file_add_function (_tmp1453_, _tmp1454_); + _tmp1463_ = ((ValaCCodeBaseModule*) self)->cfile; + _tmp1464_ = cmain; + vala_ccode_file_add_function (_tmp1463_, _tmp1464_); _vala_ccode_node_unref0 (main_call); _vala_ccode_node_unref0 (cmain); } diff --git a/codegen/valaccodemethodmodule.vala b/codegen/valaccodemethodmodule.vala index a425490..f26ed71 100644 --- a/codegen/valaccodemethodmodule.vala +++ b/codegen/valaccodemethodmodule.vala @@ -606,7 +606,7 @@ public abstract class Vala.CCodeMethodModule : CCodeStructModule { var cl = (Class) m.parent_symbol; ccode.add_declaration (get_ccode_name (cl) + "*", new CCodeVariableDeclarator.zero ("self", new CCodeConstant ("NULL"))); - if (cl.is_fundamental ()) { + if (cl.is_fundamental () && !((CreationMethod) m).chain_up) { var ccall = new CCodeFunctionCall (new CCodeIdentifier ("g_type_create_instance")); ccall.add_argument (get_variable_cexpression ("object_type")); ccode.add_assignment (get_this_cexpression (), new CCodeCastExpression (ccall, get_ccode_name (cl) + "*")); @@ -834,7 +834,7 @@ public abstract class Vala.CCodeMethodModule : CCodeStructModule { ccode.add_expression (mem_profiler_init_call); } - if (context.thread) { + if (context.thread && !context.require_glib_version (2, 32)) { var thread_init_call = new CCodeFunctionCall (new CCodeIdentifier ("g_thread_init")); thread_init_call.line = cmain.line; thread_init_call.add_argument (new CCodeConstant ("NULL")); diff --git a/codegen/valagasyncmodule.c b/codegen/valagasyncmodule.c index d621ad0..05786b2 100644 --- a/codegen/valagasyncmodule.c +++ b/codegen/valagasyncmodule.c @@ -1551,8 +1551,8 @@ static void vala_gasync_module_generate_async_function (ValaGAsyncModule* self, ValaMethod* _tmp139_; ValaSymbol* _tmp140_; ValaSymbol* _tmp141_; - ValaClass* _tmp142_; - ValaClass* cl; + ValaTypeSymbol* _tmp142_; + ValaTypeSymbol* t; gboolean _tmp143_ = FALSE; gboolean _tmp144_ = FALSE; gboolean _tmp145_ = FALSE; @@ -1918,8 +1918,8 @@ static void vala_gasync_module_generate_async_function (ValaGAsyncModule* self, _tmp139_ = m; _tmp140_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp139_); _tmp141_ = _tmp140_; - _tmp142_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp141_, VALA_TYPE_CLASS) ? ((ValaClass*) _tmp141_) : NULL); - cl = _tmp142_; + _tmp142_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp141_, VALA_TYPE_TYPESYMBOL) ? ((ValaTypeSymbol*) _tmp141_) : NULL); + t = _tmp142_; _tmp146_ = m; if (!G_TYPE_CHECK_INSTANCE_TYPE (_tmp146_, VALA_TYPE_CREATION_METHOD)) { ValaMethod* _tmp147_; @@ -1934,20 +1934,20 @@ static void vala_gasync_module_generate_async_function (ValaGAsyncModule* self, } _tmp150_ = _tmp145_; if (_tmp150_) { - ValaClass* _tmp151_; - _tmp151_ = cl; + ValaTypeSymbol* _tmp151_; + _tmp151_ = t; _tmp144_ = _tmp151_ != NULL; } else { _tmp144_ = FALSE; } _tmp152_ = _tmp144_; if (_tmp152_) { - ValaClass* _tmp153_; + ValaTypeSymbol* _tmp153_; ValaTypeSymbol* _tmp154_; gboolean _tmp155_ = FALSE; - _tmp153_ = cl; + _tmp153_ = t; _tmp154_ = ((ValaCCodeBaseModule*) self)->gobject_type; - _tmp155_ = vala_typesymbol_is_subtype_of ((ValaTypeSymbol*) _tmp153_, _tmp154_); + _tmp155_ = vala_typesymbol_is_subtype_of (_tmp153_, _tmp154_); _tmp143_ = _tmp155_; } else { _tmp143_ = FALSE; @@ -2505,7 +2505,7 @@ static void vala_gasync_module_generate_async_function (ValaGAsyncModule* self, vala_ccode_base_module_pop_context ((ValaCCodeBaseModule*) self); _vala_ccode_node_unref0 (ccall); _vala_ccode_node_unref0 (set_op_res_call); - _vala_code_node_unref0 (cl); + _vala_code_node_unref0 (t); _vala_ccode_node_unref0 (create_result); _vala_ccode_node_unref0 (data_var); _vala_ccode_node_unref0 (dataalloc); diff --git a/codegen/valagasyncmodule.vala b/codegen/valagasyncmodule.vala index 9e2a1b4..b40965c 100644 --- a/codegen/valagasyncmodule.vala +++ b/codegen/valagasyncmodule.vala @@ -202,9 +202,9 @@ public class Vala.GAsyncModule : GSignalModule { var create_result = new CCodeFunctionCall (new CCodeIdentifier ("g_simple_async_result_new")); - var cl = m.parent_symbol as Class; + var t = m.parent_symbol as TypeSymbol; if (!(m is CreationMethod) && m.binding == MemberBinding.INSTANCE && - cl != null && cl.is_subtype_of (gobject_type)) { + t != null && t.is_subtype_of (gobject_type)) { var gobject_cast = new CCodeFunctionCall (new CCodeIdentifier ("G_OBJECT")); gobject_cast.add_argument (new CCodeIdentifier ("self")); diff --git a/codegen/valagdbusservermodule.c b/codegen/valagdbusservermodule.c index 8935db3..8cdc6b5 100644 --- a/codegen/valagdbusservermodule.c +++ b/codegen/valagdbusservermodule.c @@ -3942,39 +3942,39 @@ static gchar* vala_gd_bus_server_module_generate_dbus_property_get_wrapper (Vala ValaDataType* _tmp34_; ValaDataType* _tmp35_; gboolean _tmp36_ = FALSE; - ValaProperty* _tmp106_; - ValaPropertyAccessor* _tmp107_; - ValaPropertyAccessor* _tmp108_; - ValaDataType* _tmp109_; - ValaDataType* _tmp110_; - ValaCCodeIdentifier* _tmp111_; - ValaCCodeIdentifier* _tmp112_; - ValaCCodeExpression* _tmp113_ = NULL; - ValaCCodeExpression* _tmp114_; + ValaProperty* _tmp108_; + ValaPropertyAccessor* _tmp109_; + ValaPropertyAccessor* _tmp110_; + ValaDataType* _tmp111_; + ValaDataType* _tmp112_; + ValaCCodeIdentifier* _tmp113_; + ValaCCodeIdentifier* _tmp114_; + ValaCCodeExpression* _tmp115_ = NULL; + ValaCCodeExpression* _tmp116_; ValaCCodeExpression* reply_expr; - ValaCCodeFunction* _tmp115_; - ValaCCodeFunction* _tmp116_; - ValaCCodeVariableDeclarator* _tmp117_; - ValaCCodeVariableDeclarator* _tmp118_; - ValaCCodeFunction* _tmp119_; - ValaCCodeFunction* _tmp120_; - ValaCCodeIdentifier* _tmp121_; - ValaCCodeIdentifier* _tmp122_; - ValaCCodeExpression* _tmp123_; - ValaProperty* _tmp124_; - ValaPropertyAccessor* _tmp125_; - ValaPropertyAccessor* _tmp126_; - ValaDataType* _tmp127_; - ValaDataType* _tmp128_; - gboolean _tmp129_ = FALSE; - ValaCCodeFunction* _tmp141_; - ValaCCodeFunction* _tmp142_; - ValaCCodeIdentifier* _tmp143_; - ValaCCodeIdentifier* _tmp144_; - ValaCCodeFile* _tmp145_; - ValaCCodeFunction* _tmp146_; + ValaCCodeFunction* _tmp117_; + ValaCCodeFunction* _tmp118_; + ValaCCodeVariableDeclarator* _tmp119_; + ValaCCodeVariableDeclarator* _tmp120_; + ValaCCodeFunction* _tmp121_; + ValaCCodeFunction* _tmp122_; + ValaCCodeIdentifier* _tmp123_; + ValaCCodeIdentifier* _tmp124_; + ValaCCodeExpression* _tmp125_; + ValaProperty* _tmp126_; + ValaPropertyAccessor* _tmp127_; + ValaPropertyAccessor* _tmp128_; + ValaDataType* _tmp129_; + ValaDataType* _tmp130_; + gboolean _tmp131_ = FALSE; + ValaCCodeFunction* _tmp143_; + ValaCCodeFunction* _tmp144_; + ValaCCodeIdentifier* _tmp145_; + ValaCCodeIdentifier* _tmp146_; ValaCCodeFile* _tmp147_; ValaCCodeFunction* _tmp148_; + ValaCCodeFile* _tmp149_; + ValaCCodeFunction* _tmp150_; g_return_val_if_fail (self != NULL, NULL); g_return_val_if_fail (prop != NULL, NULL); g_return_val_if_fail (sym != NULL, NULL); @@ -4163,14 +4163,16 @@ static gchar* vala_gd_bus_server_module_generate_dbus_property_get_wrapper (Vala ValaCCodeFunction* _tmp95_; ValaCCodeFunction* _tmp96_; const gchar* _tmp97_; - ValaCCodeVariableDeclarator* _tmp98_; - ValaCCodeVariableDeclarator* _tmp99_; - ValaCCodeFunctionCall* _tmp100_; - const gchar* _tmp101_; - ValaCCodeIdentifier* _tmp102_; - ValaCCodeIdentifier* _tmp103_; - ValaCCodeUnaryExpression* _tmp104_; - ValaCCodeUnaryExpression* _tmp105_; + ValaCCodeConstant* _tmp98_; + ValaCCodeConstant* _tmp99_; + ValaCCodeVariableDeclarator* _tmp100_; + ValaCCodeVariableDeclarator* _tmp101_; + ValaCCodeFunctionCall* _tmp102_; + const gchar* _tmp103_; + ValaCCodeIdentifier* _tmp104_; + ValaCCodeIdentifier* _tmp105_; + ValaCCodeUnaryExpression* _tmp106_; + ValaCCodeUnaryExpression* _tmp107_; _tmp87_ = _tmp86_; if (!_tmp87_) { gint _tmp88_; @@ -4191,19 +4193,22 @@ static gchar* vala_gd_bus_server_module_generate_dbus_property_get_wrapper (Vala _tmp95_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); _tmp96_ = _tmp95_; _tmp97_ = length_cname; - _tmp98_ = vala_ccode_variable_declarator_new (_tmp97_, NULL, NULL); + _tmp98_ = vala_ccode_constant_new ("0"); _tmp99_ = _tmp98_; - vala_ccode_function_add_declaration (_tmp96_, "int", (ValaCCodeDeclarator*) _tmp99_, 0); + _tmp100_ = vala_ccode_variable_declarator_new_zero (_tmp97_, (ValaCCodeExpression*) _tmp99_, NULL); + _tmp101_ = _tmp100_; + vala_ccode_function_add_declaration (_tmp96_, "int", (ValaCCodeDeclarator*) _tmp101_, 0); + _vala_ccode_node_unref0 (_tmp101_); _vala_ccode_node_unref0 (_tmp99_); - _tmp100_ = ccall; - _tmp101_ = length_cname; - _tmp102_ = vala_ccode_identifier_new (_tmp101_); - _tmp103_ = _tmp102_; - _tmp104_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, (ValaCCodeExpression*) _tmp103_); + _tmp102_ = ccall; + _tmp103_ = length_cname; + _tmp104_ = vala_ccode_identifier_new (_tmp103_); _tmp105_ = _tmp104_; - vala_ccode_function_call_add_argument (_tmp100_, (ValaCCodeExpression*) _tmp105_); + _tmp106_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, (ValaCCodeExpression*) _tmp105_); + _tmp107_ = _tmp106_; + vala_ccode_function_call_add_argument (_tmp102_, (ValaCCodeExpression*) _tmp107_); + _vala_ccode_node_unref0 (_tmp107_); _vala_ccode_node_unref0 (_tmp105_); - _vala_ccode_node_unref0 (_tmp103_); _g_free0 (length_cname); } } @@ -4211,78 +4216,78 @@ static gchar* vala_gd_bus_server_module_generate_dbus_property_get_wrapper (Vala } _vala_code_node_unref0 (array_type); } - _tmp106_ = prop; - _tmp107_ = vala_property_get_get_accessor (_tmp106_); - _tmp108_ = _tmp107_; - _tmp109_ = vala_property_accessor_get_value_type (_tmp108_); + _tmp108_ = prop; + _tmp109_ = vala_property_get_get_accessor (_tmp108_); _tmp110_ = _tmp109_; - _tmp111_ = vala_ccode_identifier_new ("result"); + _tmp111_ = vala_property_accessor_get_value_type (_tmp110_); _tmp112_ = _tmp111_; - _tmp113_ = vala_ccode_base_module_serialize_expression ((ValaCCodeBaseModule*) self, _tmp110_, (ValaCCodeExpression*) _tmp112_); + _tmp113_ = vala_ccode_identifier_new ("result"); _tmp114_ = _tmp113_; - _vala_ccode_node_unref0 (_tmp112_); - reply_expr = _tmp114_; - _tmp115_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp115_ = vala_ccode_base_module_serialize_expression ((ValaCCodeBaseModule*) self, _tmp112_, (ValaCCodeExpression*) _tmp114_); _tmp116_ = _tmp115_; - _tmp117_ = vala_ccode_variable_declarator_new ("_reply", NULL, NULL); + _vala_ccode_node_unref0 (_tmp114_); + reply_expr = _tmp116_; + _tmp117_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); _tmp118_ = _tmp117_; - vala_ccode_function_add_declaration (_tmp116_, "GVariant*", (ValaCCodeDeclarator*) _tmp118_, 0); - _vala_ccode_node_unref0 (_tmp118_); - _tmp119_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp119_ = vala_ccode_variable_declarator_new ("_reply", NULL, NULL); _tmp120_ = _tmp119_; - _tmp121_ = vala_ccode_identifier_new ("_reply"); + vala_ccode_function_add_declaration (_tmp118_, "GVariant*", (ValaCCodeDeclarator*) _tmp120_, 0); + _vala_ccode_node_unref0 (_tmp120_); + _tmp121_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); _tmp122_ = _tmp121_; - _tmp123_ = reply_expr; - vala_ccode_function_add_assignment (_tmp120_, (ValaCCodeExpression*) _tmp122_, _tmp123_); - _vala_ccode_node_unref0 (_tmp122_); - _tmp124_ = prop; - _tmp125_ = vala_property_get_get_accessor (_tmp124_); - _tmp126_ = _tmp125_; - _tmp127_ = vala_property_accessor_get_value_type (_tmp126_); + _tmp123_ = vala_ccode_identifier_new ("_reply"); + _tmp124_ = _tmp123_; + _tmp125_ = reply_expr; + vala_ccode_function_add_assignment (_tmp122_, (ValaCCodeExpression*) _tmp124_, _tmp125_); + _vala_ccode_node_unref0 (_tmp124_); + _tmp126_ = prop; + _tmp127_ = vala_property_get_get_accessor (_tmp126_); _tmp128_ = _tmp127_; - _tmp129_ = vala_ccode_base_module_requires_destroy ((ValaCCodeBaseModule*) self, _tmp128_); - if (_tmp129_) { - ValaProperty* _tmp130_; - ValaPropertyAccessor* _tmp131_; - ValaPropertyAccessor* _tmp132_; - ValaDataType* _tmp133_; - ValaDataType* _tmp134_; - ValaLocalVariable* _tmp135_; + _tmp129_ = vala_property_accessor_get_value_type (_tmp128_); + _tmp130_ = _tmp129_; + _tmp131_ = vala_ccode_base_module_requires_destroy ((ValaCCodeBaseModule*) self, _tmp130_); + if (_tmp131_) { + ValaProperty* _tmp132_; + ValaPropertyAccessor* _tmp133_; + ValaPropertyAccessor* _tmp134_; + ValaDataType* _tmp135_; + ValaDataType* _tmp136_; + ValaLocalVariable* _tmp137_; ValaLocalVariable* local; - ValaCCodeFunction* _tmp136_; - ValaCCodeFunction* _tmp137_; - ValaLocalVariable* _tmp138_; - ValaCCodeExpression* _tmp139_ = NULL; - ValaCCodeExpression* _tmp140_; - _tmp130_ = prop; - _tmp131_ = vala_property_get_get_accessor (_tmp130_); - _tmp132_ = _tmp131_; - _tmp133_ = vala_property_accessor_get_value_type (_tmp132_); + ValaCCodeFunction* _tmp138_; + ValaCCodeFunction* _tmp139_; + ValaLocalVariable* _tmp140_; + ValaCCodeExpression* _tmp141_ = NULL; + ValaCCodeExpression* _tmp142_; + _tmp132_ = prop; + _tmp133_ = vala_property_get_get_accessor (_tmp132_); _tmp134_ = _tmp133_; - _tmp135_ = vala_local_variable_new (_tmp134_, ".result", NULL, NULL); - local = _tmp135_; - _tmp136_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); - _tmp137_ = _tmp136_; - _tmp138_ = local; - _tmp139_ = vala_ccode_base_module_destroy_local ((ValaCCodeBaseModule*) self, _tmp138_); - _tmp140_ = _tmp139_; - vala_ccode_function_add_expression (_tmp137_, _tmp140_); - _vala_ccode_node_unref0 (_tmp140_); + _tmp135_ = vala_property_accessor_get_value_type (_tmp134_); + _tmp136_ = _tmp135_; + _tmp137_ = vala_local_variable_new (_tmp136_, ".result", NULL, NULL); + local = _tmp137_; + _tmp138_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp139_ = _tmp138_; + _tmp140_ = local; + _tmp141_ = vala_ccode_base_module_destroy_local ((ValaCCodeBaseModule*) self, _tmp140_); + _tmp142_ = _tmp141_; + vala_ccode_function_add_expression (_tmp139_, _tmp142_); + _vala_ccode_node_unref0 (_tmp142_); _vala_code_node_unref0 (local); } - _tmp141_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); - _tmp142_ = _tmp141_; - _tmp143_ = vala_ccode_identifier_new ("_reply"); + _tmp143_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); _tmp144_ = _tmp143_; - vala_ccode_function_add_return (_tmp142_, (ValaCCodeExpression*) _tmp144_); - _vala_ccode_node_unref0 (_tmp144_); + _tmp145_ = vala_ccode_identifier_new ("_reply"); + _tmp146_ = _tmp145_; + vala_ccode_function_add_return (_tmp144_, (ValaCCodeExpression*) _tmp146_); + _vala_ccode_node_unref0 (_tmp146_); vala_ccode_base_module_pop_function ((ValaCCodeBaseModule*) self); - _tmp145_ = ((ValaCCodeBaseModule*) self)->cfile; - _tmp146_ = function; - vala_ccode_file_add_function_declaration (_tmp145_, _tmp146_); _tmp147_ = ((ValaCCodeBaseModule*) self)->cfile; _tmp148_ = function; - vala_ccode_file_add_function (_tmp147_, _tmp148_); + vala_ccode_file_add_function_declaration (_tmp147_, _tmp148_); + _tmp149_ = ((ValaCCodeBaseModule*) self)->cfile; + _tmp150_ = function; + vala_ccode_file_add_function (_tmp149_, _tmp150_); result = wrapper_name; _vala_ccode_node_unref0 (reply_expr); _vala_ccode_node_unref0 (ccall); diff --git a/codegen/valagdbusservermodule.vala b/codegen/valagdbusservermodule.vala index c92a444..9da2bb8 100644 --- a/codegen/valagdbusservermodule.vala +++ b/codegen/valagdbusservermodule.vala @@ -505,7 +505,7 @@ public class Vala.GDBusServerModule : GDBusClientModule { for (int dim = 1; dim <= array_type.rank; dim++) { string length_cname = get_array_length_cname ("result", dim); - ccode.add_declaration ("int", new CCodeVariableDeclarator (length_cname)); + ccode.add_declaration ("int", new CCodeVariableDeclarator.zero (length_cname, new CCodeConstant ("0"))); ccall.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, new CCodeIdentifier (length_cname))); } } diff --git a/configure b/configure index 9be90d5..ea315d2 100755 --- a/configure +++ b/configure @@ -1,6 +1,6 @@ #! /bin/sh # Guess values for system-dependent variables and create Makefiles. -# Generated by GNU Autoconf 2.69 for vala 0.18.0. +# Generated by GNU Autoconf 2.69 for vala 0.18.1. # # Report bugs to . # @@ -589,8 +589,8 @@ MAKEFLAGS= # Identity of this package. PACKAGE_NAME='vala' PACKAGE_TARNAME='vala' -PACKAGE_VERSION='0.18.0' -PACKAGE_STRING='vala 0.18.0' +PACKAGE_VERSION='0.18.1' +PACKAGE_STRING='vala 0.18.1' PACKAGE_BUGREPORT='j@bitron.ch' PACKAGE_URL='' @@ -1357,7 +1357,7 @@ if test "$ac_init_help" = "long"; then # 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.18.0 to adapt to many kinds of systems. +\`configure' configures vala 0.18.1 to adapt to many kinds of systems. Usage: $0 [OPTION]... [VAR=VALUE]... @@ -1427,7 +1427,7 @@ fi if test -n "$ac_init_help"; then case $ac_init_help in - short | recursive ) echo "Configuration of vala 0.18.0:";; + short | recursive ) echo "Configuration of vala 0.18.1:";; esac cat <<\_ACEOF @@ -1553,7 +1553,7 @@ fi test -n "$ac_init_help" && exit $ac_status if $ac_init_version; then cat <<\_ACEOF -vala configure 0.18.0 +vala configure 0.18.1 generated by GNU Autoconf 2.69 Copyright (C) 2012 Free Software Foundation, Inc. @@ -1831,7 +1831,7 @@ cat >config.log <<_ACEOF 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.18.0, which was +It was created by vala $as_me 0.18.1, which was generated by GNU Autoconf 2.69. Invocation command line was $ $0 $@ @@ -2659,7 +2659,7 @@ fi # Define the identity of the package. PACKAGE='vala' - VERSION='0.18.0' + VERSION='0.18.1' cat >>confdefs.h <<_ACEOF @@ -12831,7 +12831,7 @@ cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 # 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.18.0, which was +This file was extended by vala $as_me 0.18.1, which was generated by GNU Autoconf 2.69. Invocation command line was CONFIG_FILES = $CONFIG_FILES @@ -12897,7 +12897,7 @@ _ACEOF cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 ac_cs_config="`$as_echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`" ac_cs_version="\\ -vala config.status 0.18.0 +vala config.status 0.18.1 configured by $0, generated by GNU Autoconf 2.69, with options \\"\$ac_cs_config\\" diff --git a/gobject-introspection/scanner.c b/gobject-introspection/scanner.c index dcaa01c..ced13f4 100644 --- a/gobject-introspection/scanner.c +++ b/gobject-introspection/scanner.c @@ -31,7 +31,6 @@ #include #include #include -#include /* waitpid */ #include #include "scanner.h" #include "gidlparser.h" @@ -40,6 +39,10 @@ #include "gidlwriter.h" #include "grealpath.h" +#ifndef _WIN32 +#include /* waitpid */ +#endif + typedef GType (*TypeFunction) (void); @@ -1600,12 +1603,28 @@ g_igenerator_start_preprocessor (GIGenerator *igenerator, close (cpp_out); +#ifndef _WIN32 if (waitpid (pid, &status, 0) > 0) +#else + /* We don't want to include as it clashes horribly + * with token names from scannerparser.h. So just declare + * WaitForSingleObject, GetExitCodeProcess and INFINITE here. + */ + extern unsigned long __stdcall WaitForSingleObject(void*, int); + extern int __stdcall GetExitCodeProcess(void*, int*); +#define INFINITE 0xffffffff + + WaitForSingleObject (pid, INFINITE); + + if (GetExitCodeProcess (pid, &status)) +#endif { if (status != 0) { g_spawn_close_pid (pid); +#ifndef _WIN32 kill (pid, SIGKILL); +#endif g_error ("cpp returned error code: %d\n", status); unlink (tmpname); diff --git a/gobject-introspection/scannerparser.c b/gobject-introspection/scannerparser.c index 015d8da..934f6fc 100644 --- a/gobject-introspection/scannerparser.c +++ b/gobject-introspection/scannerparser.c @@ -1,4 +1,4 @@ -/* A Bison parser, made by GNU Bison 2.6. */ +/* A Bison parser, made by GNU Bison 2.6.5. */ /* Bison implementation for Yacc-like parsers in C @@ -44,7 +44,7 @@ #define YYBISON 1 /* Bison version. */ -#define YYBISON_VERSION "2.6" +#define YYBISON_VERSION "2.6.5" /* Skeleton name. */ #define YYSKELETON_NAME "yacc.c" @@ -62,8 +62,7 @@ /* Copy the first part of user declarations. */ - -/* Line 336 of yacc.c */ +/* Line 360 of yacc.c */ #line 29 "scannerparser.y" #include @@ -224,9 +223,8 @@ cdirective_free (CDirective *directive) } - -/* Line 336 of yacc.c */ -#line 230 "scannerparser.c" +/* Line 360 of yacc.c */ +#line 228 "scannerparser.c" # ifndef YY_NULL # if defined __cplusplus && 201103L <= __cplusplus @@ -246,8 +244,8 @@ cdirective_free (CDirective *directive) /* In a future release of Bison, this section will be replaced by #include "y.tab.h". */ -#ifndef YY_Y_TAB_H -# define YY_Y_TAB_H +#ifndef YY_YY_Y_TAB_H_INCLUDED +# define YY_YY_Y_TAB_H_INCLUDED /* Enabling traces. */ #ifndef YYDEBUG # define YYDEBUG 0 @@ -401,8 +399,7 @@ extern int yydebug; #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED typedef union YYSTYPE { - -/* Line 350 of yacc.c */ +/* Line 376 of yacc.c */ #line 190 "scannerparser.y" char *str; @@ -415,9 +412,8 @@ typedef union YYSTYPE UnaryOperator unary_operator; - -/* Line 350 of yacc.c */ -#line 421 "scannerparser.c" +/* Line 376 of yacc.c */ +#line 417 "scannerparser.c" } YYSTYPE; # define YYSTYPE_IS_TRIVIAL 1 # define yystype YYSTYPE /* obsolescent; will be withdrawn */ @@ -440,13 +436,12 @@ int yyparse (); #endif #endif /* ! YYPARSE_PARAM */ -#endif /* !YY_Y_TAB_H */ +#endif /* !YY_YY_Y_TAB_H_INCLUDED */ /* Copy the second part of user declarations. */ - -/* Line 353 of yacc.c */ -#line 450 "scannerparser.c" +/* Line 379 of yacc.c */ +#line 445 "scannerparser.c" #ifdef short # undef short @@ -499,24 +494,24 @@ typedef short int yytype_int16; # if defined YYENABLE_NLS && YYENABLE_NLS # if ENABLE_NLS # include /* INFRINGES ON USER NAME SPACE */ -# define YY_(msgid) dgettext ("bison-runtime", msgid) +# define YY_(Msgid) dgettext ("bison-runtime", Msgid) # endif # endif # ifndef YY_ -# define YY_(msgid) msgid +# define YY_(Msgid) Msgid # endif #endif /* Suppress unused-variable warnings by "using" E. */ #if ! defined lint || defined __GNUC__ -# define YYUSE(e) ((void) (e)) +# define YYUSE(E) ((void) (E)) #else -# define YYUSE(e) /* empty */ +# define YYUSE(E) /* empty */ #endif /* Identity function, used to suppress warnings about constant conditions. */ #ifndef lint -# define YYID(n) (n) +# define YYID(N) (N) #else #if (defined __STDC__ || defined __C99__FUNC__ \ || defined __cplusplus || defined _MSC_VER) @@ -1300,10 +1295,10 @@ static const yytype_int16 yytable[] = 0, 0, 21, 22, 23, 24 }; -#define yypact_value_is_default(yystate) \ - ((yystate) == (-199)) +#define yypact_value_is_default(Yystate) \ + (!!((Yystate) == (-199))) -#define yytable_value_is_error(yytable_value) \ +#define yytable_value_is_error(Yytable_value) \ YYID (0) static const yytype_int16 yycheck[] = @@ -1582,47 +1577,18 @@ do \ } \ while (YYID (0)) - +/* Error token number */ #define YYTERROR 1 #define YYERRCODE 256 -/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N]. - If N is 0, then set CURRENT to the empty location which ends - the previous symbol: RHS[0] (always defined). */ - -#ifndef YYLLOC_DEFAULT -# define YYLLOC_DEFAULT(Current, Rhs, N) \ - do \ - if (YYID (N)) \ - { \ - (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \ - (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \ - (Current).last_line = YYRHSLOC (Rhs, N).last_line; \ - (Current).last_column = YYRHSLOC (Rhs, N).last_column; \ - } \ - else \ - { \ - (Current).first_line = (Current).last_line = \ - YYRHSLOC (Rhs, 0).last_line; \ - (Current).first_column = (Current).last_column = \ - YYRHSLOC (Rhs, 0).last_column; \ - } \ - while (YYID (0)) -#endif - -#define YYRHSLOC(Rhs, K) ((Rhs)[K]) - - /* This macro is provided for backward compatibility. */ - #ifndef YY_LOCATION_PRINT # define YY_LOCATION_PRINT(File, Loc) ((void) 0) #endif /* YYLEX -- calling `yylex' with the right arguments. */ - #ifdef YYLEX_PARAM # define YYLEX yylex (YYLEX_PARAM) #else @@ -2093,8 +2059,17 @@ yydestruct (yymsg, yytype, yyvaluep, igenerator) /* The lookahead symbol. */ int yychar; + +#ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN +# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN +# define YY_IGNORE_MAYBE_UNINITIALIZED_END +#endif +#ifndef YY_INITIAL_VALUE +# define YY_INITIAL_VALUE(Value) /* Nothing. */ +#endif + /* The semantic value of the lookahead symbol. */ -YYSTYPE yylval; +YYSTYPE yylval YY_INITIAL_VALUE(yyval_default); /* Number of syntax errors so far. */ int yynerrs; @@ -2152,7 +2127,7 @@ yyparse (igenerator) int yyn; int yyresult; /* Lookahead token as an internal (translated) token number. */ - int yytoken; + int yytoken = 0; /* The variables used to return semantic value and location from the action routines. */ YYSTYPE yyval; @@ -2170,9 +2145,8 @@ yyparse (igenerator) Keep to zero when no symbol should be popped. */ int yylen = 0; - yytoken = 0; - yyss = yyssa; - yyvs = yyvsa; + yyssp = yyss = yyssa; + yyvsp = yyvs = yyvsa; yystacksize = YYINITDEPTH; YYDPRINTF ((stderr, "Starting parse\n")); @@ -2181,14 +2155,6 @@ yyparse (igenerator) yyerrstatus = 0; yynerrs = 0; yychar = YYEMPTY; /* Cause a token to be read. */ - - /* Initialize stack pointers. - Waste one element of value and location stack - so that they stay on the same level as the state stack. - The wasted elements are never initialized. */ - yyssp = yyss; - yyvsp = yyvs; - goto yysetstate; /*------------------------------------------------------------. @@ -2329,7 +2295,9 @@ yybackup: yychar = YYEMPTY; yystate = yyn; + YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN *++yyvsp = yylval; + YY_IGNORE_MAYBE_UNINITIALIZED_END goto yynewstate; @@ -2366,8 +2334,7 @@ yyreduce: switch (yyn) { case 2: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 280 "scannerparser.y" { (yyval.symbol) = g_hash_table_lookup (const_table, (yyvsp[(1) - (1)].str)); @@ -2378,8 +2345,7 @@ yyreduce: break; case 3: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 287 "scannerparser.y" { (yyval.symbol) = csymbol_new (CSYMBOL_TYPE_CONST); @@ -2395,8 +2361,7 @@ yyreduce: break; case 4: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 299 "scannerparser.y" { (yyval.symbol) = csymbol_new (CSYMBOL_TYPE_INVALID); @@ -2404,8 +2369,7 @@ yyreduce: break; case 5: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 303 "scannerparser.y" { (yyval.symbol) = csymbol_new (CSYMBOL_TYPE_INVALID); @@ -2413,8 +2377,7 @@ yyreduce: break; case 7: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 308 "scannerparser.y" { (yyval.symbol) = (yyvsp[(2) - (3)].symbol); @@ -2422,8 +2385,7 @@ yyreduce: break; case 8: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 316 "scannerparser.y" { (yyval.symbol) = csymbol_new (CSYMBOL_TYPE_CONST); @@ -2433,8 +2395,7 @@ yyreduce: break; case 9: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 322 "scannerparser.y" { char *strings, *string2; @@ -2449,8 +2410,7 @@ yyreduce: break; case 10: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 336 "scannerparser.y" { (yyval.str) = g_strdup (yytext); @@ -2458,8 +2418,7 @@ yyreduce: break; case 14: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 349 "scannerparser.y" { (yyval.symbol) = csymbol_new (CSYMBOL_TYPE_INVALID); @@ -2467,8 +2426,7 @@ yyreduce: break; case 15: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 353 "scannerparser.y" { (yyval.symbol) = csymbol_new (CSYMBOL_TYPE_INVALID); @@ -2476,8 +2434,7 @@ yyreduce: break; case 16: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 357 "scannerparser.y" { (yyval.symbol) = csymbol_new (CSYMBOL_TYPE_INVALID); @@ -2485,8 +2442,7 @@ yyreduce: break; case 17: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 361 "scannerparser.y" { (yyval.symbol) = csymbol_new (CSYMBOL_TYPE_INVALID); @@ -2494,8 +2450,7 @@ yyreduce: break; case 18: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 365 "scannerparser.y" { (yyval.symbol) = csymbol_new (CSYMBOL_TYPE_INVALID); @@ -2503,8 +2458,7 @@ yyreduce: break; case 19: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 369 "scannerparser.y" { (yyval.symbol) = csymbol_new (CSYMBOL_TYPE_INVALID); @@ -2512,8 +2466,7 @@ yyreduce: break; case 20: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 373 "scannerparser.y" { (yyval.symbol) = csymbol_new (CSYMBOL_TYPE_INVALID); @@ -2521,8 +2474,7 @@ yyreduce: break; case 24: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 386 "scannerparser.y" { (yyval.symbol) = csymbol_new (CSYMBOL_TYPE_INVALID); @@ -2530,8 +2482,7 @@ yyreduce: break; case 25: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 390 "scannerparser.y" { (yyval.symbol) = csymbol_new (CSYMBOL_TYPE_INVALID); @@ -2539,8 +2490,7 @@ yyreduce: break; case 26: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 394 "scannerparser.y" { switch ((yyvsp[(1) - (2)].unary_operator)) { @@ -2567,8 +2517,7 @@ yyreduce: break; case 27: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 417 "scannerparser.y" { (yyval.symbol) = csymbol_new (CSYMBOL_TYPE_INVALID); @@ -2576,8 +2525,7 @@ yyreduce: break; case 28: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 421 "scannerparser.y" { (yyval.symbol) = csymbol_new (CSYMBOL_TYPE_INVALID); @@ -2585,8 +2533,7 @@ yyreduce: break; case 29: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 428 "scannerparser.y" { (yyval.unary_operator) = UNARY_ADDRESS_OF; @@ -2594,8 +2541,7 @@ yyreduce: break; case 30: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 432 "scannerparser.y" { (yyval.unary_operator) = UNARY_POINTER_INDIRECTION; @@ -2603,8 +2549,7 @@ yyreduce: break; case 31: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 436 "scannerparser.y" { (yyval.unary_operator) = UNARY_PLUS; @@ -2612,8 +2557,7 @@ yyreduce: break; case 32: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 440 "scannerparser.y" { (yyval.unary_operator) = UNARY_MINUS; @@ -2621,8 +2565,7 @@ yyreduce: break; case 33: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 444 "scannerparser.y" { (yyval.unary_operator) = UNARY_BITWISE_COMPLEMENT; @@ -2630,8 +2573,7 @@ yyreduce: break; case 34: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 448 "scannerparser.y" { (yyval.unary_operator) = UNARY_LOGICAL_NEGATION; @@ -2639,8 +2581,7 @@ yyreduce: break; case 36: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 456 "scannerparser.y" { (yyval.symbol) = (yyvsp[(4) - (4)].symbol); @@ -2648,8 +2589,7 @@ yyreduce: break; case 38: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 464 "scannerparser.y" { (yyval.symbol) = csymbol_new (CSYMBOL_TYPE_CONST); @@ -2659,8 +2599,7 @@ yyreduce: break; case 39: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 470 "scannerparser.y" { (yyval.symbol) = csymbol_new (CSYMBOL_TYPE_CONST); @@ -2672,8 +2611,7 @@ yyreduce: break; case 40: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 478 "scannerparser.y" { (yyval.symbol) = csymbol_new (CSYMBOL_TYPE_CONST); @@ -2683,8 +2621,7 @@ yyreduce: break; case 42: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 488 "scannerparser.y" { (yyval.symbol) = csymbol_new (CSYMBOL_TYPE_CONST); @@ -2694,8 +2631,7 @@ yyreduce: break; case 43: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 494 "scannerparser.y" { (yyval.symbol) = csymbol_new (CSYMBOL_TYPE_CONST); @@ -2705,8 +2641,7 @@ yyreduce: break; case 45: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 504 "scannerparser.y" { (yyval.symbol) = csymbol_new (CSYMBOL_TYPE_CONST); @@ -2716,8 +2651,7 @@ yyreduce: break; case 46: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 510 "scannerparser.y" { (yyval.symbol) = csymbol_new (CSYMBOL_TYPE_CONST); @@ -2727,8 +2661,7 @@ yyreduce: break; case 48: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 520 "scannerparser.y" { (yyval.symbol) = csymbol_new (CSYMBOL_TYPE_CONST); @@ -2738,8 +2671,7 @@ yyreduce: break; case 49: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 526 "scannerparser.y" { (yyval.symbol) = csymbol_new (CSYMBOL_TYPE_CONST); @@ -2749,8 +2681,7 @@ yyreduce: break; case 50: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 532 "scannerparser.y" { (yyval.symbol) = csymbol_new (CSYMBOL_TYPE_CONST); @@ -2760,8 +2691,7 @@ yyreduce: break; case 51: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 538 "scannerparser.y" { (yyval.symbol) = csymbol_new (CSYMBOL_TYPE_CONST); @@ -2771,8 +2701,7 @@ yyreduce: break; case 53: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 548 "scannerparser.y" { (yyval.symbol) = csymbol_new (CSYMBOL_TYPE_CONST); @@ -2782,8 +2711,7 @@ yyreduce: break; case 54: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 554 "scannerparser.y" { (yyval.symbol) = csymbol_new (CSYMBOL_TYPE_CONST); @@ -2793,8 +2721,7 @@ yyreduce: break; case 56: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 564 "scannerparser.y" { (yyval.symbol) = csymbol_new (CSYMBOL_TYPE_CONST); @@ -2804,8 +2731,7 @@ yyreduce: break; case 58: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 574 "scannerparser.y" { (yyval.symbol) = csymbol_new (CSYMBOL_TYPE_CONST); @@ -2815,8 +2741,7 @@ yyreduce: break; case 60: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 584 "scannerparser.y" { (yyval.symbol) = csymbol_new (CSYMBOL_TYPE_CONST); @@ -2826,8 +2751,7 @@ yyreduce: break; case 62: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 594 "scannerparser.y" { (yyval.symbol) = csymbol_new (CSYMBOL_TYPE_CONST); @@ -2837,8 +2761,7 @@ yyreduce: break; case 64: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 604 "scannerparser.y" { (yyval.symbol) = csymbol_new (CSYMBOL_TYPE_CONST); @@ -2848,8 +2771,7 @@ yyreduce: break; case 66: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 614 "scannerparser.y" { (yyval.symbol) = csymbol_get_const_boolean ((yyvsp[(1) - (5)].symbol)) ? (yyvsp[(3) - (5)].symbol) : (yyvsp[(5) - (5)].symbol); @@ -2857,8 +2779,7 @@ yyreduce: break; case 68: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 622 "scannerparser.y" { (yyval.symbol) = csymbol_new (CSYMBOL_TYPE_INVALID); @@ -2866,8 +2787,7 @@ yyreduce: break; case 81: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 644 "scannerparser.y" { (yyval.symbol) = csymbol_new (CSYMBOL_TYPE_INVALID); @@ -2875,8 +2795,7 @@ yyreduce: break; case 83: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 657 "scannerparser.y" { GList *l; @@ -2896,8 +2815,7 @@ yyreduce: break; case 85: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 677 "scannerparser.y" { (yyval.ctype) = (yyvsp[(2) - (2)].ctype); @@ -2906,8 +2824,7 @@ yyreduce: break; case 86: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 682 "scannerparser.y" { (yyval.ctype) = ctype_new (CTYPE_INVALID); @@ -2916,8 +2833,7 @@ yyreduce: break; case 87: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 687 "scannerparser.y" { (yyval.ctype) = (yyvsp[(1) - (2)].ctype); @@ -2926,8 +2842,7 @@ yyreduce: break; case 89: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 693 "scannerparser.y" { (yyval.ctype) = (yyvsp[(2) - (2)].ctype); @@ -2936,8 +2851,7 @@ yyreduce: break; case 90: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 698 "scannerparser.y" { (yyval.ctype) = ctype_new (CTYPE_INVALID); @@ -2946,8 +2860,7 @@ yyreduce: break; case 91: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 703 "scannerparser.y" { (yyval.ctype) = (yyvsp[(2) - (2)].ctype); @@ -2956,8 +2869,7 @@ yyreduce: break; case 92: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 708 "scannerparser.y" { (yyval.ctype) = ctype_new (CTYPE_INVALID); @@ -2966,8 +2878,7 @@ yyreduce: break; case 93: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 716 "scannerparser.y" { (yyval.list) = g_list_append (NULL, (yyvsp[(1) - (1)].symbol)); @@ -2975,8 +2886,7 @@ yyreduce: break; case 94: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 720 "scannerparser.y" { (yyval.list) = g_list_append ((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].symbol)); @@ -2984,8 +2894,7 @@ yyreduce: break; case 97: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 732 "scannerparser.y" { (yyval.storage_class_specifier) = STORAGE_CLASS_TYPEDEF; @@ -2993,8 +2902,7 @@ yyreduce: break; case 98: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 736 "scannerparser.y" { (yyval.storage_class_specifier) = STORAGE_CLASS_EXTERN; @@ -3002,8 +2910,7 @@ yyreduce: break; case 99: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 740 "scannerparser.y" { (yyval.storage_class_specifier) = STORAGE_CLASS_STATIC; @@ -3011,8 +2918,7 @@ yyreduce: break; case 100: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 744 "scannerparser.y" { (yyval.storage_class_specifier) = STORAGE_CLASS_AUTO; @@ -3020,8 +2926,7 @@ yyreduce: break; case 101: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 748 "scannerparser.y" { (yyval.storage_class_specifier) = STORAGE_CLASS_REGISTER; @@ -3029,8 +2934,7 @@ yyreduce: break; case 102: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 755 "scannerparser.y" { (yyval.ctype) = ctype_new (CTYPE_VOID); @@ -3038,8 +2942,7 @@ yyreduce: break; case 103: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 759 "scannerparser.y" { (yyval.ctype) = cbasic_type_new ("char"); @@ -3047,8 +2950,7 @@ yyreduce: break; case 104: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 763 "scannerparser.y" { (yyval.ctype) = cbasic_type_new ("short"); @@ -3056,8 +2958,7 @@ yyreduce: break; case 105: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 767 "scannerparser.y" { (yyval.ctype) = cbasic_type_new ("int"); @@ -3065,8 +2966,7 @@ yyreduce: break; case 106: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 771 "scannerparser.y" { (yyval.ctype) = cbasic_type_new ("long"); @@ -3074,8 +2974,7 @@ yyreduce: break; case 107: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 775 "scannerparser.y" { (yyval.ctype) = cbasic_type_new ("float"); @@ -3083,8 +2982,7 @@ yyreduce: break; case 108: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 779 "scannerparser.y" { (yyval.ctype) = cbasic_type_new ("double"); @@ -3092,8 +2990,7 @@ yyreduce: break; case 109: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 783 "scannerparser.y" { (yyval.ctype) = cbasic_type_new ("signed"); @@ -3101,8 +2998,7 @@ yyreduce: break; case 110: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 787 "scannerparser.y" { (yyval.ctype) = cbasic_type_new ("unsigned"); @@ -3110,8 +3006,7 @@ yyreduce: break; case 111: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 791 "scannerparser.y" { (yyval.ctype) = cbasic_type_new ("bool"); @@ -3119,8 +3014,7 @@ yyreduce: break; case 114: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 797 "scannerparser.y" { (yyval.ctype) = ctypedef_new ((yyvsp[(1) - (1)].str)); @@ -3128,8 +3022,7 @@ yyreduce: break; case 115: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 804 "scannerparser.y" { (yyval.ctype) = (yyvsp[(1) - (5)].ctype); @@ -3151,8 +3044,7 @@ yyreduce: break; case 116: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 822 "scannerparser.y" { (yyval.ctype) = (yyvsp[(1) - (4)].ctype); @@ -3161,8 +3053,7 @@ yyreduce: break; case 117: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 827 "scannerparser.y" { (yyval.ctype) = (yyvsp[(1) - (2)].ctype); @@ -3171,8 +3062,7 @@ yyreduce: break; case 118: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 835 "scannerparser.y" { (yyval.ctype) = cstruct_new (NULL); @@ -3180,8 +3070,7 @@ yyreduce: break; case 119: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 839 "scannerparser.y" { (yyval.ctype) = cunion_new (NULL); @@ -3189,8 +3078,7 @@ yyreduce: break; case 121: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 847 "scannerparser.y" { (yyval.list) = g_list_concat ((yyvsp[(1) - (2)].list), (yyvsp[(2) - (2)].list)); @@ -3198,8 +3086,7 @@ yyreduce: break; case 122: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 854 "scannerparser.y" { GList *l; @@ -3216,8 +3103,7 @@ yyreduce: break; case 123: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 870 "scannerparser.y" { (yyval.ctype) = (yyvsp[(1) - (2)].ctype); @@ -3226,8 +3112,7 @@ yyreduce: break; case 125: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 876 "scannerparser.y" { (yyval.ctype) = (yyvsp[(2) - (2)].ctype); @@ -3236,8 +3121,7 @@ yyreduce: break; case 126: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 881 "scannerparser.y" { (yyval.ctype) = ctype_new (CTYPE_INVALID); @@ -3246,8 +3130,7 @@ yyreduce: break; case 127: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 889 "scannerparser.y" { (yyval.list) = g_list_append (NULL, (yyvsp[(1) - (1)].symbol)); @@ -3255,8 +3138,7 @@ yyreduce: break; case 128: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 893 "scannerparser.y" { (yyval.list) = g_list_append ((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].symbol)); @@ -3264,8 +3146,7 @@ yyreduce: break; case 129: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 900 "scannerparser.y" { (yyval.symbol) = csymbol_new (CSYMBOL_TYPE_INVALID); @@ -3273,8 +3154,7 @@ yyreduce: break; case 131: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 905 "scannerparser.y" { (yyval.symbol) = csymbol_new (CSYMBOL_TYPE_INVALID); @@ -3282,8 +3162,7 @@ yyreduce: break; case 133: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 913 "scannerparser.y" { (yyval.ctype) = cenum_new ((yyvsp[(2) - (5)].str)); @@ -3293,8 +3172,7 @@ yyreduce: break; case 134: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 919 "scannerparser.y" { (yyval.ctype) = cenum_new (NULL); @@ -3304,8 +3182,7 @@ yyreduce: break; case 135: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 925 "scannerparser.y" { (yyval.ctype) = cenum_new ((yyvsp[(2) - (6)].str)); @@ -3315,8 +3192,7 @@ yyreduce: break; case 136: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 931 "scannerparser.y" { (yyval.ctype) = cenum_new (NULL); @@ -3326,8 +3202,7 @@ yyreduce: break; case 137: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 937 "scannerparser.y" { (yyval.ctype) = cenum_new ((yyvsp[(2) - (2)].str)); @@ -3335,8 +3210,7 @@ yyreduce: break; case 138: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 944 "scannerparser.y" { (yyval.list) = g_list_append (NULL, (yyvsp[(1) - (1)].symbol)); @@ -3344,8 +3218,7 @@ yyreduce: break; case 139: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 948 "scannerparser.y" { (yyval.list) = g_list_append ((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].symbol)); @@ -3353,8 +3226,7 @@ yyreduce: break; case 140: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 955 "scannerparser.y" { (yyval.symbol) = csymbol_new (CSYMBOL_TYPE_OBJECT); @@ -3366,8 +3238,7 @@ yyreduce: break; case 141: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 963 "scannerparser.y" { (yyval.symbol) = csymbol_new (CSYMBOL_TYPE_OBJECT); @@ -3380,8 +3251,7 @@ yyreduce: break; case 142: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 975 "scannerparser.y" { (yyval.type_qualifier) = TYPE_QUALIFIER_CONST; @@ -3389,8 +3259,7 @@ yyreduce: break; case 143: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 979 "scannerparser.y" { (yyval.type_qualifier) = TYPE_QUALIFIER_RESTRICT; @@ -3398,8 +3267,7 @@ yyreduce: break; case 144: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 983 "scannerparser.y" { (yyval.type_qualifier) = TYPE_QUALIFIER_VOLATILE; @@ -3407,8 +3275,7 @@ yyreduce: break; case 145: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 990 "scannerparser.y" { (yyval.function_specifier) = FUNCTION_INLINE; @@ -3416,8 +3283,7 @@ yyreduce: break; case 146: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 997 "scannerparser.y" { (yyval.symbol) = (yyvsp[(2) - (2)].symbol); @@ -3426,8 +3292,7 @@ yyreduce: break; case 148: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 1006 "scannerparser.y" { (yyval.symbol) = csymbol_new (CSYMBOL_TYPE_INVALID); @@ -3436,8 +3301,7 @@ yyreduce: break; case 149: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 1011 "scannerparser.y" { (yyval.symbol) = (yyvsp[(2) - (3)].symbol); @@ -3445,8 +3309,7 @@ yyreduce: break; case 150: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 1015 "scannerparser.y" { (yyval.symbol) = (yyvsp[(1) - (4)].symbol); @@ -3455,8 +3318,7 @@ yyreduce: break; case 151: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 1020 "scannerparser.y" { (yyval.symbol) = (yyvsp[(1) - (3)].symbol); @@ -3465,8 +3327,7 @@ yyreduce: break; case 152: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 1025 "scannerparser.y" { CType *func = cfunction_new (); @@ -3480,8 +3341,7 @@ yyreduce: break; case 153: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 1035 "scannerparser.y" { CType *func = cfunction_new (); @@ -3492,8 +3352,7 @@ yyreduce: break; case 154: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 1042 "scannerparser.y" { CType *func = cfunction_new (); @@ -3503,8 +3362,7 @@ yyreduce: break; case 155: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 1051 "scannerparser.y" { (yyval.ctype) = cpointer_new (NULL); @@ -3513,8 +3371,7 @@ yyreduce: break; case 156: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 1056 "scannerparser.y" { (yyval.ctype) = cpointer_new (NULL); @@ -3522,8 +3379,7 @@ yyreduce: break; case 157: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 1060 "scannerparser.y" { (yyval.ctype) = cpointer_new ((yyvsp[(3) - (3)].ctype)); @@ -3532,8 +3388,7 @@ yyreduce: break; case 158: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 1065 "scannerparser.y" { (yyval.ctype) = cpointer_new ((yyvsp[(2) - (2)].ctype)); @@ -3541,8 +3396,7 @@ yyreduce: break; case 160: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 1073 "scannerparser.y" { (yyval.type_qualifier) = (yyvsp[(1) - (2)].type_qualifier) | (yyvsp[(2) - (2)].type_qualifier); @@ -3550,8 +3404,7 @@ yyreduce: break; case 163: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 1085 "scannerparser.y" { (yyval.list) = g_list_append (NULL, (yyvsp[(1) - (1)].symbol)); @@ -3559,8 +3412,7 @@ yyreduce: break; case 164: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 1089 "scannerparser.y" { (yyval.list) = g_list_append ((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].symbol)); @@ -3568,8 +3420,7 @@ yyreduce: break; case 165: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 1096 "scannerparser.y" { (yyval.symbol) = (yyvsp[(2) - (2)].symbol); @@ -3578,8 +3429,7 @@ yyreduce: break; case 166: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 1101 "scannerparser.y" { (yyval.symbol) = (yyvsp[(2) - (2)].symbol); @@ -3588,8 +3438,7 @@ yyreduce: break; case 167: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 1106 "scannerparser.y" { (yyval.symbol) = csymbol_new (CSYMBOL_TYPE_INVALID); @@ -3598,8 +3447,7 @@ yyreduce: break; case 168: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 1114 "scannerparser.y" { CSymbol *sym = csymbol_new (CSYMBOL_TYPE_INVALID); @@ -3609,8 +3457,7 @@ yyreduce: break; case 169: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 1120 "scannerparser.y" { CSymbol *sym = csymbol_new (CSYMBOL_TYPE_INVALID); @@ -3620,8 +3467,7 @@ yyreduce: break; case 172: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 1134 "scannerparser.y" { (yyval.symbol) = csymbol_new (CSYMBOL_TYPE_INVALID); @@ -3630,8 +3476,7 @@ yyreduce: break; case 174: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 1140 "scannerparser.y" { (yyval.symbol) = (yyvsp[(2) - (2)].symbol); @@ -3640,8 +3485,7 @@ yyreduce: break; case 175: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 1148 "scannerparser.y" { (yyval.symbol) = (yyvsp[(2) - (3)].symbol); @@ -3649,8 +3493,7 @@ yyreduce: break; case 176: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 1152 "scannerparser.y" { (yyval.symbol) = csymbol_new (CSYMBOL_TYPE_INVALID); @@ -3659,8 +3502,7 @@ yyreduce: break; case 177: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 1157 "scannerparser.y" { (yyval.symbol) = csymbol_new (CSYMBOL_TYPE_INVALID); @@ -3669,8 +3511,7 @@ yyreduce: break; case 178: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 1162 "scannerparser.y" { (yyval.symbol) = (yyvsp[(1) - (3)].symbol); @@ -3679,8 +3520,7 @@ yyreduce: break; case 179: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 1167 "scannerparser.y" { (yyval.symbol) = (yyvsp[(1) - (4)].symbol); @@ -3689,8 +3529,7 @@ yyreduce: break; case 180: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 1172 "scannerparser.y" { CType *func = cfunction_new (); @@ -3700,8 +3539,7 @@ yyreduce: break; case 181: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 1178 "scannerparser.y" { CType *func = cfunction_new (); @@ -3715,8 +3553,7 @@ yyreduce: break; case 182: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 1188 "scannerparser.y" { CType *func = cfunction_new (); @@ -3726,8 +3563,7 @@ yyreduce: break; case 183: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 1194 "scannerparser.y" { CType *func = cfunction_new (); @@ -3741,8 +3577,7 @@ yyreduce: break; case 184: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 1207 "scannerparser.y" { (yyval.str) = g_strdup (yytext); @@ -3750,8 +3585,7 @@ yyreduce: break; case 234: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 1314 "scannerparser.y" { (yyval.str) = g_strdup (yytext + strlen ("#define ")); @@ -3759,8 +3593,7 @@ yyreduce: break; case 235: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 1321 "scannerparser.y" { (yyval.str) = g_strdup (yytext + strlen ("#define ")); @@ -3768,8 +3601,7 @@ yyreduce: break; case 237: - -/* Line 1788 of yacc.c */ +/* Line 1778 of yacc.c */ #line 1332 "scannerparser.y" { if ((yyvsp[(2) - (2)].symbol)->const_int_set || (yyvsp[(2) - (2)].symbol)->const_string != NULL) { @@ -3780,9 +3612,8 @@ yyreduce: break; - -/* Line 1788 of yacc.c */ -#line 3786 "scannerparser.c" +/* Line 1778 of yacc.c */ +#line 3617 "scannerparser.c" default: break; } /* User semantic actions sometimes alter yychar, and that requires @@ -3945,7 +3776,9 @@ yyerrlab1: YY_STACK_PRINT (yyss, yyssp); } + YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN *++yyvsp = yylval; + YY_IGNORE_MAYBE_UNINITIALIZED_END /* Shift the error token. */ @@ -4011,8 +3844,7 @@ yyreturn: } - -/* Line 2049 of yacc.c */ +/* Line 2041 of yacc.c */ #line 1346 "scannerparser.y" @@ -4049,4 +3881,3 @@ g_igenerator_parse_file (GIGenerator *igenerator, FILE *file) } - diff --git a/gobject-introspection/scannerparser.h b/gobject-introspection/scannerparser.h index 53c04a3..15d7d40 100644 --- a/gobject-introspection/scannerparser.h +++ b/gobject-introspection/scannerparser.h @@ -1,4 +1,4 @@ -/* A Bison parser, made by GNU Bison 2.6. */ +/* A Bison parser, made by GNU Bison 2.6.5. */ /* Bison interface for Yacc-like parsers in C @@ -30,8 +30,8 @@ This special exception was added by the Free Software Foundation in version 2.2 of Bison. */ -#ifndef YY_SCANNERPARSER_H -# define YY_SCANNERPARSER_H +#ifndef YY_YY_SCANNERPARSER_H_INCLUDED +# define YY_YY_SCANNERPARSER_H_INCLUDED /* Enabling traces. */ #ifndef YYDEBUG # define YYDEBUG 0 @@ -185,8 +185,7 @@ extern int yydebug; #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED typedef union YYSTYPE { - -/* Line 2050 of yacc.c */ +/* Line 2042 of yacc.c */ #line 190 "scannerparser.y" char *str; @@ -199,9 +198,8 @@ typedef union YYSTYPE UnaryOperator unary_operator; - -/* Line 2050 of yacc.c */ -#line 205 "scannerparser.h" +/* Line 2042 of yacc.c */ +#line 203 "scannerparser.h" } YYSTYPE; # define YYSTYPE_IS_TRIVIAL 1 # define yystype YYSTYPE /* obsolescent; will be withdrawn */ @@ -224,4 +222,4 @@ int yyparse (); #endif #endif /* ! YYPARSE_PARAM */ -#endif /* !YY_SCANNERPARSER_H */ +#endif /* !YY_YY_SCANNERPARSER_H_INCLUDED */ diff --git a/tests/Makefile.am b/tests/Makefile.am index c1a8296..3d2bc4a 100644 --- a/tests/Makefile.am +++ b/tests/Makefile.am @@ -32,6 +32,7 @@ TESTS = \ basic-types/bug652380.vala \ basic-types/bug655908.vala \ basic-types/bug659975.vala \ + basic-types/bug686336.vala \ namespaces.vala \ methods/lambda.vala \ methods/closures.vala \ @@ -166,6 +167,7 @@ TESTS = \ dbus/async-errors.test \ dbus/signals.test \ dbus/filedescriptor.test \ + dbus/dicts.test \ dbus/bug596862.vala \ dbus/bug602003.test \ gir/bug651773.test \ diff --git a/tests/Makefile.in b/tests/Makefile.in index 46a5928..5ca0203 100644 --- a/tests/Makefile.in +++ b/tests/Makefile.in @@ -58,17 +58,18 @@ TESTS = basic-types/integers.vala basic-types/floats.vala \ basic-types/bug632322.vala basic-types/bug647222.vala \ basic-types/bug648364.vala basic-types/bug650993.vala \ basic-types/bug652380.vala basic-types/bug655908.vala \ - basic-types/bug659975.vala namespaces.vala methods/lambda.vala \ - methods/closures.vala methods/symbolresolution.vala \ - methods/bug595538.vala methods/bug596726.vala \ - methods/bug597426.vala methods/bug598738.vala \ - methods/bug599892.vala methods/bug613483.vala \ - methods/bug620673.vala methods/bug622570.vala \ - methods/bug639054.vala methods/bug642899.vala \ - methods/bug646345.vala methods/bug648320.vala \ - methods/bug649562.vala methods/bug653391.vala \ - methods/bug653908.vala methods/bug663210.vala \ - methods/generics.vala control-flow/break.vala \ + basic-types/bug659975.vala basic-types/bug686336.vala \ + namespaces.vala methods/lambda.vala methods/closures.vala \ + methods/symbolresolution.vala methods/bug595538.vala \ + methods/bug596726.vala methods/bug597426.vala \ + methods/bug598738.vala methods/bug599892.vala \ + methods/bug613483.vala methods/bug620673.vala \ + methods/bug622570.vala methods/bug639054.vala \ + methods/bug642899.vala methods/bug646345.vala \ + methods/bug648320.vala methods/bug649562.vala \ + methods/bug653391.vala methods/bug653908.vala \ + methods/bug663210.vala methods/generics.vala \ + control-flow/break.vala \ control-flow/expressions-conditional.vala \ control-flow/for.vala control-flow/foreach.vala \ control-flow/switch.vala control-flow/sideeffects.vala \ @@ -123,7 +124,7 @@ TESTS = basic-types/integers.vala basic-types/floats.vala \ asynchronous/closures.vala dbus/basic-types.test \ dbus/arrays.test dbus/structs.test dbus/errors.test \ dbus/async.test dbus/async-errors.test dbus/signals.test \ - dbus/filedescriptor.test dbus/bug596862.vala \ + dbus/filedescriptor.test dbus/dicts.test dbus/bug596862.vala \ dbus/bug602003.test gir/bug651773.test $(am__EXEEXT_1) subdir = tests DIST_COMMON = $(srcdir)/Makefile.am $(srcdir)/Makefile.in diff --git a/tests/basic-types/bug686336.vala b/tests/basic-types/bug686336.vala new file mode 100644 index 0000000..3aceef8 --- /dev/null +++ b/tests/basic-types/bug686336.vala @@ -0,0 +1,25 @@ +class Foo { + static int[] static_bar = { 1, 2, 3 }; + static int[] static_baz = create_array (); + + int[] bar = { 1, 2, 3 }; + int[] baz = create_array (); + + static int[] create_array () { + return { 1, 2, 3 }; + } + + public void test () { + assert (static_bar.length == 3); + assert (static_baz.length == 3); + + assert (bar.length == 3); + assert (baz.length == 3); + } +} + +void main () { + var foo = new Foo (); + foo.test (); +} + diff --git a/tests/dbus/dicts.test b/tests/dbus/dicts.test new file mode 100644 index 0000000..c67c515 --- /dev/null +++ b/tests/dbus/dicts.test @@ -0,0 +1,59 @@ +Packages: gio-2.0 +D-Bus + +Program: client + +[DBus (name = "org.example.Test")] +interface Test : Object { + public abstract HashTable test_dict () throws IOError; +} + +void main () { + // client + Test test = Bus.get_proxy_sync (BusType.SESSION, "org.example.Test", "/org/example/test"); + + HashTable dict = test.test_dict (); + assert (dict.size () == 1); + Variant v = dict.lookup ("hello"); + assert (v != null); + string[] s = (string[]) v; + assert (s.length == 1 && s[0] == "hello"); +} + +Program: server + +[DBus (name = "org.example.Test")] +class Test : Object { + public HashTable test_dict () { + string[] s = { "hello" }; + HashTable dict = new HashTable (str_hash, null); + dict.insert ("hello", s); + return dict; + } +} + +MainLoop main_loop; + +void client_exit (Pid pid, int status) { + // client finished, terminate server + assert (status == 0); + main_loop.quit (); +} + +void main () { + var conn = Bus.get_sync (BusType.SESSION); + conn.register_object ("/org/example/test", new Test ()); + + // try to register service in session bus + var request_result = conn.call_sync ("org.freedesktop.DBus", "/org/freedesktop/DBus", "org.freedesktop.DBus", "RequestName", + new Variant ("(su)", "org.example.Test", 0x4), null, 0, -1); + assert ((uint) request_result.get_child_value (0) == 1); + + // server ready, spawn client + Pid client_pid; + Process.spawn_async (null, { "test", "/dbus/dicts/client" }, null, SpawnFlags.DO_NOT_REAP_CHILD, null, out client_pid); + ChildWatch.add (client_pid, client_exit); + + main_loop = new MainLoop (); + main_loop.run (); +} diff --git a/tests/testrunner.sh b/tests/testrunner.sh index 02948c1..8d47808 100755 --- a/tests/testrunner.sh +++ b/tests/testrunner.sh @@ -28,9 +28,9 @@ vapidir=$topsrcdir/vapi export G_DEBUG=fatal_warnings -VALAC=$topbuilddir/compiler/valac +VALAC=$topbuilddir/compiler/valac$EXEEXT VALAFLAGS="--vapidir $vapidir --disable-warnings --main main --save-temps -X -g -X -O0 -X -pipe -X -lm -X -Werror=return-type -X -Werror=init-self -X -Werror=implicit -X -Werror=sequence-point -X -Werror=return-type -X -Werror=uninitialized -X -Werror=pointer-arith -X -Werror=int-to-pointer-cast -X -Werror=pointer-to-int-cast" -VAPIGEN=$topbuilddir/vapigen/vapigen +VAPIGEN=$topbuilddir/vapigen/vapigen$EXEEXT VAPIGENFLAGS="--vapidir $vapidir" # Incorporate the user's CFLAGS. Matters if the user decided to insert diff --git a/vala/valaarraytype.c b/vala/valaarraytype.c index b2bf929..347e449 100644 --- a/vala/valaarraytype.c +++ b/vala/valaarraytype.c @@ -1374,6 +1374,7 @@ void vala_code_node_set_source_reference (ValaCodeNode* self, ValaSourceReferenc static ValaSymbol* vala_array_type_real_get_member (ValaDataType* base, const gchar* member_name); static ValaArrayLengthField* vala_array_type_get_length_field (ValaArrayType* self); static ValaArrayMoveMethod* vala_array_type_get_move_method (ValaArrayType* self); +gint vala_array_type_get_rank (ValaArrayType* self); static ValaArrayResizeMethod* vala_array_type_get_resize_method (ValaArrayType* self); ValaSourceReference* vala_code_node_get_source_reference (ValaCodeNode* self); ValaArrayLengthField* vala_array_length_field_new (ValaSourceReference* source_reference); @@ -1391,7 +1392,6 @@ ValaSourceFile* vala_source_reference_get_file (ValaSourceReference* self); ValaCodeContext* vala_source_file_get_context (ValaSourceFile* self); GType vala_namespace_get_type (void) G_GNUC_CONST; ValaNamespace* vala_code_context_get_root (ValaCodeContext* self); -gint vala_array_type_get_rank (ValaArrayType* self); ValaScope* vala_symbol_get_scope (ValaSymbol* self); ValaSymbol* vala_scope_lookup (ValaScope* self, const gchar* name); GType vala_typesymbol_get_type (void) G_GNUC_CONST; @@ -1584,9 +1584,15 @@ static ValaSymbol* vala_array_type_real_get_member (ValaDataType* base, const gc const gchar* _tmp4_; _tmp4_ = member_name; if (g_strcmp0 (_tmp4_, "resize") == 0) { - ValaArrayResizeMethod* _tmp5_ = NULL; - _tmp5_ = vala_array_type_get_resize_method (self); - result = (ValaSymbol*) _tmp5_; + gint _tmp5_; + ValaArrayResizeMethod* _tmp6_ = NULL; + _tmp5_ = self->priv->_rank; + if (_tmp5_ > 1) { + result = NULL; + return result; + } + _tmp6_ = vala_array_type_get_resize_method (self); + result = (ValaSymbol*) _tmp6_; return result; } } diff --git a/vala/valaarraytype.vala b/vala/valaarraytype.vala index f1bcba1..b376723 100644 --- a/vala/valaarraytype.vala +++ b/vala/valaarraytype.vala @@ -71,6 +71,9 @@ public class Vala.ArrayType : ReferenceType { } else if (member_name == "move") { return get_move_method (); } else if (member_name == "resize") { + if (rank > 1) { + return null; + } return get_resize_method (); } return null; diff --git a/vapi/Makefile.am b/vapi/Makefile.am index 8c09365..d474ac3 100644 --- a/vapi/Makefile.am +++ b/vapi/Makefile.am @@ -394,7 +394,7 @@ GIR_BINDINGS = \ BINDINGS = $(GIR_BINDINGS) $(GIDL_BINDINGS) -VAPIGEN = $(top_builddir)/vapigen/vapigen +VAPIGEN = $(top_builddir)/vapigen/vapigen$(EXEEXT) VAPIGENFLAGS = --vapidir $(srcdir) GENVAPI = $(VAPIGEN) $(VAPIGENFLAGS) METADATADIR = $(srcdir)/metadata diff --git a/vapi/Makefile.in b/vapi/Makefile.in index 7912664..b09a14d 100644 --- a/vapi/Makefile.in +++ b/vapi/Makefile.in @@ -641,7 +641,7 @@ GIR_BINDINGS = \ $(NULL) BINDINGS = $(GIR_BINDINGS) $(GIDL_BINDINGS) -VAPIGEN = $(top_builddir)/vapigen/vapigen +VAPIGEN = $(top_builddir)/vapigen/vapigen$(EXEEXT) VAPIGENFLAGS = --vapidir $(srcdir) GENVAPI = $(VAPIGEN) $(VAPIGENFLAGS) METADATADIR = $(srcdir)/metadata diff --git a/vapi/glib-2.0.vapi b/vapi/glib-2.0.vapi index 6479249..f509c9a 100644 --- a/vapi/glib-2.0.vapi +++ b/vapi/glib-2.0.vapi @@ -661,6 +661,10 @@ public struct uint64 { [CCode (cname = "gfloat", cheader_filename = "glib.h,float.h,math.h", type_id = "G_TYPE_FLOAT", marshaller_type_name = "FLOAT", get_value_function = "g_value_get_float", set_value_function = "g_value_set_float", default_value = "0.0F")] [FloatingType (rank = 1)] public struct float { + [CCode (cname = "FLT_ROUNDS")] + public static int ROUNDS; + [CCode (cname = "FLT_RADIX")] + public static int RADIX; [CCode (cname = "FLT_MANT_DIG")] public static int MANT_DIG; [CCode (cname = "FLT_DIG")] @@ -1830,6 +1834,7 @@ namespace GLib { [Compact] [CCode (ref_function = "g_async_queue_ref", unref_function = "g_async_queue_unref")] public class AsyncQueue { + [CCode (cname = "g_async_queue_new_full", simple_generics = true)] public AsyncQueue (); public void push (owned G data); public void push_sorted (owned G data, CompareDataFunc func); @@ -2563,11 +2568,11 @@ namespace GLib { [CCode (cname = "g_get_environ", array_length = false, array_null_terminated = true)] public static string[] get (); [CCode (cname = "g_environ_getenv")] - public static string? get_variable ([CCode (array_length = false, array_null_terminated = true)] string[] envp, string variable); + public static string? get_variable ([CCode (array_length = false, array_null_terminated = true)] string[]? envp, string variable); [CCode (cname = "g_environ_setenv", array_length = false, array_null_terminated = true)] - public static string[] set_variable ([CCode (array_length = false, array_null_terminated = true)] owned string[] envp, string variable, string value, bool overwrite = true); + public static string[] set_variable ([CCode (array_length = false, array_null_terminated = true)] owned string[]? envp, string variable, string value, bool overwrite = true); [CCode (cname = "g_environ_unsetenv", array_length = false, array_null_terminated = true)] - public static string[] unset_variable ([CCode (array_length = false, array_null_terminated = true)] owned string[] envp, string variable); + public static string[] unset_variable ([CCode (array_length = false, array_null_terminated = true)] owned string[]? envp, string variable); } [CCode (has_type_id = false)] @@ -2872,6 +2877,8 @@ namespace GLib { public static bool spawn_command_line_sync (string command_line, out string standard_output = null, out string standard_error = null, out int exit_status = null) throws SpawnError; [CCode (cname = "g_spawn_close_pid")] public static void close_pid (Pid pid); + [CCode (cname = "g_spawn_check_exit_status")] + public static bool check_exit_status (int exit_status) throws GLib.Error; /* these macros are required to examine the exit status of a process */ [CCode (cname = "WIFEXITED", cheader_filename = "sys/wait.h")] @@ -3615,7 +3622,7 @@ namespace GLib { public static int32 rand_int (); public static int32 rand_int_range (int32 begin, int32 end); public static double rand_double (); - public static double rand_double_range (); + public static double rand_double_range (double begin, double end); public static void log_set_fatal_handler (LogFatalFunc log_func); } diff --git a/vapi/gstreamer-1.0.vapi b/vapi/gstreamer-1.0.vapi index 378302e..a0c0734 100644 --- a/vapi/gstreamer-1.0.vapi +++ b/vapi/gstreamer-1.0.vapi @@ -1983,6 +1983,10 @@ namespace Gst { public void* data; public uint64 offset; public uint size; + public unowned Gst.Buffer get_buffer (); + public Gst.BufferList get_buffer_list (); + public unowned Gst.Event get_event (); + public unowned Gst.Query get_query (); } [CCode (cheader_filename = "gst/gst.h", has_type_id = false)] public struct ParamSpecFraction { @@ -2849,7 +2853,7 @@ namespace Gst { [CCode (cheader_filename = "gst/gst.h", has_target = false)] public delegate Gst.Iterator PadIterIntLinkFunction (Gst.Pad pad, Gst.Object parent); [CCode (cheader_filename = "gst/gst.h", has_target = false)] - public delegate Gst.PadLinkReturn PadLinkFunction (Gst.Pad pad, Gst.Pad peer); + public delegate Gst.PadLinkReturn PadLinkFunction (Gst.Pad pad, Gst.Object parent, Gst.Pad peer); [CCode (cheader_filename = "gst/gst.h", instance_pos = 2.9)] public delegate Gst.PadProbeReturn PadProbeCallback (Gst.Pad pad, Gst.PadProbeInfo info); [CCode (cheader_filename = "gst/gst.h", has_target = false)] @@ -2857,7 +2861,7 @@ namespace Gst { [CCode (cheader_filename = "gst/gst.h", instance_pos = 2.9)] public delegate bool PadStickyEventsForeachFunction (Gst.Pad pad, Gst.Event event); [CCode (cheader_filename = "gst/gst.h", has_target = false)] - public delegate void PadUnlinkFunction (Gst.Pad pad); + public delegate void PadUnlinkFunction (Gst.Pad pad, Gst.Object parent); [CCode (cheader_filename = "gst/gst.h", instance_pos = 1.9)] public delegate bool PluginFeatureFilter (Gst.PluginFeature feature); [CCode (cheader_filename = "gst/gst.h", instance_pos = 1.9)] diff --git a/vapi/gstreamer-audio-1.0.vapi b/vapi/gstreamer-audio-1.0.vapi index b67cd5e..2920c25 100644 --- a/vapi/gstreamer-audio-1.0.vapi +++ b/vapi/gstreamer-audio-1.0.vapi @@ -649,7 +649,7 @@ namespace Gst { [CCode (cheader_filename = "gst/audio/audio-channels.h,gst/audio/audio-enumtypes.h,gst/audio/audio-format.h,gst/audio/audio-info.h,gst/audio/audio.h,gst/audio/gstaudiobasesink.h,gst/audio/gstaudiobasesrc.h,gst/audio/gstaudiocdsrc.h,gst/audio/gstaudioclock.h,gst/audio/gstaudiodecoder.h,gst/audio/gstaudioencoder.h,gst/audio/gstaudiofilter.h,gst/audio/gstaudioiec61937.h,gst/audio/gstaudiometa.h,gst/audio/gstaudioringbuffer.h,gst/audio/gstaudiosink.h,gst/audio/gstaudiosrc.h,gst/audio/streamvolume.h", cname = "gst_audio_iec61937_frame_size")] public static uint audio_iec61937_frame_size (Gst.Audio.RingBufferSpec spec); [CCode (cheader_filename = "gst/audio/audio-channels.h,gst/audio/audio-enumtypes.h,gst/audio/audio-format.h,gst/audio/audio-info.h,gst/audio/audio.h,gst/audio/gstaudiobasesink.h,gst/audio/gstaudiobasesrc.h,gst/audio/gstaudiocdsrc.h,gst/audio/gstaudioclock.h,gst/audio/gstaudiodecoder.h,gst/audio/gstaudioencoder.h,gst/audio/gstaudiofilter.h,gst/audio/gstaudioiec61937.h,gst/audio/gstaudiometa.h,gst/audio/gstaudioringbuffer.h,gst/audio/gstaudiosink.h,gst/audio/gstaudiosrc.h,gst/audio/streamvolume.h", cname = "gst_audio_iec61937_payload")] - public static bool audio_iec61937_payload ([CCode (array_length_cname = "src_n", array_length_pos = 1.5, array_length_type = "guint")] uint8[] src, [CCode (array_length_cname = "dst_n", array_length_pos = 2.5, array_length_type = "guint")] uint8[] dst, Gst.Audio.RingBufferSpec spec); + public static bool audio_iec61937_payload ([CCode (array_length_cname = "src_n", array_length_pos = 1.5, array_length_type = "guint")] uint8[] src, [CCode (array_length_cname = "dst_n", array_length_pos = 2.5, array_length_type = "guint")] uint8[] dst, Gst.Audio.RingBufferSpec spec, int endianness); [CCode (cheader_filename = "gst/audio/audio-channels.h,gst/audio/audio-enumtypes.h,gst/audio/audio-format.h,gst/audio/audio-info.h,gst/audio/audio.h,gst/audio/gstaudiobasesink.h,gst/audio/gstaudiobasesrc.h,gst/audio/gstaudiocdsrc.h,gst/audio/gstaudioclock.h,gst/audio/gstaudiodecoder.h,gst/audio/gstaudioencoder.h,gst/audio/gstaudiofilter.h,gst/audio/gstaudioiec61937.h,gst/audio/gstaudiometa.h,gst/audio/gstaudioringbuffer.h,gst/audio/gstaudiosink.h,gst/audio/gstaudiosrc.h,gst/audio/streamvolume.h", cname = "gst_audio_reorder_channels")] public static bool audio_reorder_channels ([CCode (array_length_cname = "size", array_length_pos = 1.5, array_length_type = "gsize")] uint8[] data, Gst.Audio.Format format, int channels, [CCode (array_length = false)] Gst.Audio.ChannelPosition[] from, [CCode (array_length = false)] Gst.Audio.ChannelPosition[] to); [CCode (cheader_filename = "gst/audio/audio-channels.h,gst/audio/audio-enumtypes.h,gst/audio/audio-format.h,gst/audio/audio-info.h,gst/audio/audio.h,gst/audio/gstaudiobasesink.h,gst/audio/gstaudiobasesrc.h,gst/audio/gstaudiocdsrc.h,gst/audio/gstaudioclock.h,gst/audio/gstaudiodecoder.h,gst/audio/gstaudioencoder.h,gst/audio/gstaudiofilter.h,gst/audio/gstaudioiec61937.h,gst/audio/gstaudiometa.h,gst/audio/gstaudioringbuffer.h,gst/audio/gstaudiosink.h,gst/audio/gstaudiosrc.h,gst/audio/streamvolume.h", cname = "gst_buffer_add_audio_downmix_meta")] diff --git a/vapi/gtk+-2.0.vapi b/vapi/gtk+-2.0.vapi index 74b75b3..755d0d2 100644 --- a/vapi/gtk+-2.0.vapi +++ b/vapi/gtk+-2.0.vapi @@ -1223,7 +1223,7 @@ namespace Gtk { public weak Gtk.Widget colorsel; [CCode (has_construct_function = false, type = "GtkWidget*")] public ColorSelectionDialog (string title); - public unowned Gtk.Widget get_color_selection (); + public unowned Gtk.ColorSelection get_color_selection (); [NoAccessorMethod] public Gtk.Widget cancel_button { owned get; } public Gtk.Widget color_selection { get; } @@ -1912,8 +1912,8 @@ namespace Gtk { public class HSV : Gtk.Widget, Atk.Implementor, Gtk.Buildable { [CCode (has_construct_function = false, type = "GtkWidget*")] public HSV (); - public void get_color (double h, double s, double v); - public void get_metrics (int size, int ring_width); + public void get_color (out double h, out double s, out double v); + public void get_metrics (out int size, out int ring_width); public bool is_adjusting (); public void set_color (double h, double s, double v); public void set_metrics (int size, int ring_width); @@ -2328,10 +2328,10 @@ namespace Gtk { [CCode (has_construct_function = false, type = "GtkWidget*")] public InfoBar (); public void add_action_widget (Gtk.Widget child, int response_id); - public unowned Gtk.Widget add_button (string button_text, int response_id); + public unowned Gtk.Button add_button (string button_text, int response_id); public void add_buttons (...); public unowned Gtk.Widget get_action_area (); - public unowned Gtk.Widget get_content_area (); + public unowned Gtk.Container get_content_area (); public Gtk.MessageType get_message_type (); public void set_default_response (int response_id); public void set_message_type (Gtk.MessageType message_type); @@ -2674,7 +2674,7 @@ namespace Gtk { public virtual signal void toggle_size_request (void* requisition); } [CCode (cheader_filename = "gtk/gtk.h")] - public class MenuShell : Gtk.Container, Atk.Implementor, Gtk.Buildable { + public abstract class MenuShell : Gtk.Container, Atk.Implementor, Gtk.Buildable { public uint32 activate_time; public uint active; public weak Gtk.Widget active_menu_item; @@ -3261,17 +3261,17 @@ namespace Gtk { [CCode (has_construct_function = false, type = "GtkWidget*")] public RadioButton (GLib.SList? group); [CCode (has_construct_function = false, type = "GtkWidget*")] - public RadioButton.from_widget (Gtk.RadioButton radio_group_member); + public RadioButton.from_widget (Gtk.RadioButton? radio_group_member); public unowned GLib.SList get_group (); public void set_group (GLib.SList group); [CCode (has_construct_function = false, type = "GtkWidget*")] public RadioButton.with_label (GLib.SList? group, string label); [CCode (has_construct_function = false, type = "GtkWidget*")] - public RadioButton.with_label_from_widget (Gtk.RadioButton radio_group_member, string label); + public RadioButton.with_label_from_widget (Gtk.RadioButton? radio_group_member, string label); [CCode (has_construct_function = false, type = "GtkWidget*")] public RadioButton.with_mnemonic (GLib.SList? group, string label); [CCode (has_construct_function = false, type = "GtkWidget*")] - public RadioButton.with_mnemonic_from_widget (Gtk.RadioButton radio_group_member, string label); + public RadioButton.with_mnemonic_from_widget (Gtk.RadioButton? radio_group_member, string label); [NoAccessorMethod] public Gtk.RadioButton group { set; } public virtual signal void group_changed (); @@ -3279,17 +3279,17 @@ namespace Gtk { [CCode (cheader_filename = "gtk/gtk.h")] public class RadioMenuItem : Gtk.CheckMenuItem, Atk.Implementor, Gtk.Buildable, Gtk.Activatable { [CCode (has_construct_function = false, type = "GtkWidget*")] - public RadioMenuItem (GLib.SList group); + public RadioMenuItem (GLib.SList? group); [CCode (has_construct_function = false, type = "GtkWidget*")] public RadioMenuItem.from_widget (Gtk.RadioMenuItem group); - public unowned GLib.SList get_group (); - public void set_group (GLib.SList group); + public unowned GLib.SList? get_group (); + public void set_group (GLib.SList? group); [CCode (has_construct_function = false, type = "GtkWidget*")] - public RadioMenuItem.with_label (GLib.SList group, string label); + public RadioMenuItem.with_label (GLib.SList? group, string label); [CCode (has_construct_function = false, type = "GtkWidget*")] public RadioMenuItem.with_label_from_widget (Gtk.RadioMenuItem group, string label); [CCode (has_construct_function = false, type = "GtkWidget*")] - public RadioMenuItem.with_mnemonic (GLib.SList group, string label); + public RadioMenuItem.with_mnemonic (GLib.SList? group, string label); [CCode (has_construct_function = false, type = "GtkWidget*")] public RadioMenuItem.with_mnemonic_from_widget (Gtk.RadioMenuItem group, string label); public Gtk.RadioMenuItem group { set; } @@ -3615,7 +3615,7 @@ namespace Gtk { public weak Gtk.Widget minus_button; public weak Gtk.Widget plus_button; [CCode (has_construct_function = false, type = "GtkWidget*")] - public ScaleButton (Gtk.IconSize size, double min, double max, double step, [CCode (array_length = false)] string[] icons); + public ScaleButton (Gtk.IconSize size, double min = 0.0, double max = 100.0, double step = 2.0, [CCode (array_length = false)] string[]? icons = null); public unowned Gtk.Adjustment get_adjustment (); public unowned Gtk.Widget get_minus_button (); public unowned Gtk.Widget get_plus_button (); @@ -4057,7 +4057,7 @@ namespace Gtk { public Statusbar (); public uint get_context_id (string context_description); public bool get_has_resize_grip (); - public unowned Gtk.Widget get_message_area (); + public unowned Gtk.Container get_message_area (); public void pop (uint context_id); public uint push (uint context_id, string text); public void remove (uint context_id, uint message_id); diff --git a/vapi/gtk+-3.0.vapi b/vapi/gtk+-3.0.vapi index aba5a11..c566881 100644 --- a/vapi/gtk+-3.0.vapi +++ b/vapi/gtk+-3.0.vapi @@ -576,7 +576,7 @@ namespace Gtk { public unowned GLib.MenuModel get_menubar (); public unowned Gtk.Window get_window_by_id (uint id); public unowned GLib.List get_windows (); - public uint inhibit (Gtk.Window window, Gtk.ApplicationInhibitFlags flags, string reason); + public uint inhibit (Gtk.Window? window, Gtk.ApplicationInhibitFlags flags, string? reason); public bool is_inhibited (Gtk.ApplicationInhibitFlags flags); public void remove_accelerator (string action_name, GLib.Variant parameter); public void remove_window (Gtk.Window window); @@ -1373,7 +1373,7 @@ namespace Gtk { [CCode (cheader_filename = "gtk/gtk.h")] public class ColorChooserDialog : Gtk.Dialog, Atk.Implementor, Gtk.Buildable, Gtk.ColorChooser { [CCode (has_construct_function = false, type = "GtkWidget*")] - public ColorChooserDialog (string title, Gtk.Window parent); + public ColorChooserDialog (string? title, Gtk.Window? parent); [NoAccessorMethod] public bool show_editor { get; set; } } @@ -1421,7 +1421,7 @@ namespace Gtk { public class ColorSelectionDialog : Gtk.Dialog, Atk.Implementor, Gtk.Buildable { [CCode (has_construct_function = false, type = "GtkWidget*")] public ColorSelectionDialog (string title); - public unowned Gtk.Widget get_color_selection (); + public unowned Gtk.ColorSelection get_color_selection (); [NoAccessorMethod] public Gtk.Widget cancel_button { owned get; } public Gtk.Widget color_selection { get; } @@ -1998,7 +1998,7 @@ namespace Gtk { [CCode (cheader_filename = "gtk/gtk.h")] public class FontChooserDialog : Gtk.Dialog, Atk.Implementor, Gtk.Buildable, Gtk.FontChooser { [CCode (has_construct_function = false, type = "GtkWidget*")] - public FontChooserDialog (string title, Gtk.Window parent); + public FontChooserDialog (string? title, Gtk.Window? parent); } [CCode (cheader_filename = "gtk/gtk.h")] public class FontChooserWidget : Gtk.Box, Atk.Implementor, Gtk.Buildable, Gtk.Orientable, Gtk.FontChooser { @@ -2076,7 +2076,7 @@ namespace Gtk { [CCode (has_construct_function = false, type = "GtkWidget*")] public Grid (); public void attach (Gtk.Widget child, int left, int top, int width, int height); - public void attach_next_to (Gtk.Widget child, Gtk.Widget sibling, Gtk.PositionType side, int width, int height); + public void attach_next_to (Gtk.Widget child, Gtk.Widget? sibling, Gtk.PositionType side, int width, int height); public unowned Gtk.Widget get_child_at (int left, int top); public bool get_column_homogeneous (); public uint get_column_spacing (); @@ -2115,8 +2115,8 @@ namespace Gtk { public class HSV : Gtk.Widget, Atk.Implementor, Gtk.Buildable { [CCode (has_construct_function = false, type = "GtkWidget*")] public HSV (); - public void get_color (double h, double s, double v); - public void get_metrics (int size, int ring_width); + public void get_color (out double h, out double s, out double v); + public void get_metrics (out int size, out int ring_width); public bool is_adjusting (); public void set_color (double h, double s, double v); public void set_metrics (int size, int ring_width); @@ -2471,10 +2471,10 @@ namespace Gtk { [CCode (has_construct_function = false, type = "GtkWidget*")] public InfoBar (); public void add_action_widget (Gtk.Widget child, int response_id); - public unowned Gtk.Widget add_button (string button_text, int response_id); + public unowned Gtk.Button add_button (string button_text, int response_id); public void add_buttons (...); public unowned Gtk.Widget get_action_area (); - public unowned Gtk.Widget get_content_area (); + public unowned Gtk.Container get_content_area (); public Gtk.MessageType get_message_type (); public void set_default_response (int response_id); public void set_message_type (Gtk.MessageType message_type); @@ -2805,7 +2805,7 @@ namespace Gtk { public virtual signal void toggle_size_request (void* requisition); } [CCode (cheader_filename = "gtk/gtk.h")] - public class MenuShell : Gtk.Container, Atk.Implementor, Gtk.Buildable { + public abstract class MenuShell : Gtk.Container, Atk.Implementor, Gtk.Buildable { [CCode (has_construct_function = false)] protected MenuShell (); public void activate_item (Gtk.Widget menu_item, bool force_deactivate); @@ -3334,18 +3334,18 @@ namespace Gtk { [CCode (has_construct_function = false, type = "GtkWidget*")] public RadioButton (GLib.SList? group); [CCode (has_construct_function = false, type = "GtkWidget*")] - public RadioButton.from_widget (Gtk.RadioButton radio_group_member); + public RadioButton.from_widget (Gtk.RadioButton? radio_group_member); public unowned GLib.SList get_group (); public void join_group (Gtk.RadioButton group_source); public void set_group (GLib.SList group); [CCode (has_construct_function = false, type = "GtkWidget*")] public RadioButton.with_label (GLib.SList? group, string label); [CCode (has_construct_function = false, type = "GtkWidget*")] - public RadioButton.with_label_from_widget (Gtk.RadioButton radio_group_member, string label); + public RadioButton.with_label_from_widget (Gtk.RadioButton? radio_group_member, string label); [CCode (has_construct_function = false, type = "GtkWidget*")] public RadioButton.with_mnemonic (GLib.SList? group, string label); [CCode (has_construct_function = false, type = "GtkWidget*")] - public RadioButton.with_mnemonic_from_widget (Gtk.RadioButton radio_group_member, string label); + public RadioButton.with_mnemonic_from_widget (Gtk.RadioButton? radio_group_member, string label); [NoAccessorMethod] public Gtk.RadioButton group { set; } public virtual signal void group_changed (); @@ -3353,17 +3353,17 @@ namespace Gtk { [CCode (cheader_filename = "gtk/gtk.h")] public class RadioMenuItem : Gtk.CheckMenuItem, Atk.Implementor, Gtk.Buildable, Gtk.Activatable { [CCode (has_construct_function = false, type = "GtkWidget*")] - public RadioMenuItem (GLib.SList group); + public RadioMenuItem (GLib.SList? group); [CCode (has_construct_function = false, type = "GtkWidget*")] public RadioMenuItem.from_widget (Gtk.RadioMenuItem group); public unowned GLib.SList get_group (); - public void set_group (GLib.SList group); + public void set_group (GLib.SList? group); [CCode (has_construct_function = false, type = "GtkWidget*")] - public RadioMenuItem.with_label (GLib.SList group, string label); + public RadioMenuItem.with_label (GLib.SList? group, string label); [CCode (has_construct_function = false, type = "GtkWidget*")] public RadioMenuItem.with_label_from_widget (Gtk.RadioMenuItem group, string label); [CCode (has_construct_function = false, type = "GtkWidget*")] - public RadioMenuItem.with_mnemonic (GLib.SList group, string label); + public RadioMenuItem.with_mnemonic (GLib.SList? group, string label); [CCode (has_construct_function = false, type = "GtkWidget*")] public RadioMenuItem.with_mnemonic_from_widget (Gtk.RadioMenuItem group, string label); public Gtk.RadioMenuItem group { set; } @@ -3632,7 +3632,7 @@ namespace Gtk { [CCode (cheader_filename = "gtk/gtk.h")] public class ScaleButton : Gtk.Button, Atk.Implementor, Gtk.Buildable, Gtk.Actionable, Gtk.Activatable, Gtk.Orientable { [CCode (has_construct_function = false, type = "GtkWidget*")] - public ScaleButton (Gtk.IconSize size, double min, double max, double step, [CCode (array_length = false)] string[] icons); + public ScaleButton (Gtk.IconSize size, double min = 0.0, double max = 100.0, double step = 2.0, [CCode (array_length = false)] string[]? icons = null); public unowned Gtk.Adjustment get_adjustment (); public unowned Gtk.Widget get_minus_button (); public unowned Gtk.Widget get_plus_button (); @@ -4070,7 +4070,7 @@ namespace Gtk { [CCode (has_construct_function = false, type = "GtkWidget*")] public Statusbar (); public uint get_context_id (string context_description); - public unowned Gtk.Widget get_message_area (); + public unowned Gtk.Container get_message_area (); public void pop (uint context_id); public uint push (uint context_id, string text); public void remove (uint context_id, uint message_id); @@ -5642,6 +5642,7 @@ namespace Gtk { public unowned Gdk.Visual get_visual (); public unowned Gdk.Window get_window (); public void grab_default (); + public bool has_grab (); [Deprecated (replacement = "StyleContext", since = "3,0")] public bool has_rc_style (); public bool has_screen (); diff --git a/vapi/gtksourceview-3.0.vapi b/vapi/gtksourceview-3.0.vapi index ac48733..9b70857 100644 --- a/vapi/gtksourceview-3.0.vapi +++ b/vapi/gtksourceview-3.0.vapi @@ -66,7 +66,7 @@ namespace Gtk { protected SourceCompletion (); public bool add_provider (Gtk.SourceCompletionProvider provider) throws GLib.Error; public void block_interactive (); - public Gtk.SourceCompletionContext create_context (Gtk.TextIter? position); + public unowned Gtk.SourceCompletionContext create_context (Gtk.TextIter? position); public unowned Gtk.SourceCompletionInfo get_info_window (); public unowned GLib.List get_providers (); public unowned Gtk.SourceView get_view (); @@ -75,7 +75,7 @@ namespace Gtk { public virtual bool proposal_activated (Gtk.SourceCompletionProvider provider, Gtk.SourceCompletionProposal proposal); public bool remove_provider (Gtk.SourceCompletionProvider provider) throws GLib.Error; [CCode (cname = "gtk_source_completion_show")] - public bool start (GLib.List? providers, owned Gtk.SourceCompletionContext context); + public bool start (GLib.List? providers, Gtk.SourceCompletionContext context); public void unblock_interactive (); [NoAccessorMethod] public uint accelerators { get; set construct; } @@ -148,6 +148,11 @@ namespace Gtk { [NoAccessorMethod] public string text { owned get; set; } } + [CCode (cheader_filename = "gtksourceview/gtksource.h")] + [Compact] + [GIR (name = "CompletionModel")] + public class SourceCompletionModel { + } [CCode (cheader_filename = "gtksourceview/gtksource.h", type_id = "gtk_source_completion_words_get_type ()")] [GIR (name = "CompletionWords")] public class SourceCompletionWords : GLib.Object, Gtk.SourceCompletionProvider { @@ -170,6 +175,16 @@ namespace Gtk { [NoAccessorMethod] public uint scan_batch_size { get; set construct; } } + [CCode (cheader_filename = "gtksourceview/gtksource.h")] + [Compact] + [GIR (name = "ContextEngine")] + public class SourceContextEngine { + } + [CCode (cheader_filename = "gtksourceview/gtksource.h")] + [Compact] + [GIR (name = "Engine")] + public class SourceEngine { + } [CCode (cheader_filename = "gtksourceview/gtksource.h", type_id = "gtk_source_gutter_get_type ()")] [GIR (name = "Gutter")] public class SourceGutter : GLib.Object { @@ -246,6 +261,16 @@ namespace Gtk { [HasEmitter] public virtual signal void queue_draw (); } + [CCode (cheader_filename = "gtksourceview/gtksource.h")] + [Compact] + [GIR (name = "GutterRendererLines")] + public class SourceGutterRendererLines { + } + [CCode (cheader_filename = "gtksourceview/gtksource.h")] + [Compact] + [GIR (name = "GutterRendererMarks")] + public class SourceGutterRendererMarks { + } [CCode (cheader_filename = "gtksourceview/gtksource.h", type_id = "gtk_source_gutter_renderer_pixbuf_get_type ()")] [GIR (name = "GutterRendererPixbuf")] public class SourceGutterRendererPixbuf : Gtk.SourceGutterRenderer { @@ -356,6 +381,11 @@ namespace Gtk { public signal string query_tooltip_markup (Gtk.SourceMark mark); public signal string query_tooltip_text (Gtk.SourceMark mark); } + [CCode (cheader_filename = "gtksourceview/gtksource.h")] + [Compact] + [GIR (name = "PixbufHelper")] + public class SourcePixbufHelper { + } [CCode (cheader_filename = "gtksourceview/gtksource.h", type_id = "gtk_source_print_compositor_get_type ()")] [GIR (name = "PrintCompositor")] public class SourcePrintCompositor : GLib.Object { @@ -411,6 +441,11 @@ namespace Gtk { public uint tab_width { get; set; } public Gtk.WrapMode wrap_mode { get; set; } } + [CCode (cheader_filename = "gtksourceview/gtksource.h")] + [Compact] + [GIR (name = "Regex")] + public class SourceRegex { + } [CCode (cheader_filename = "gtksourceview/gtksource.h", type_id = "gtk_source_style_get_type ()")] [GIR (name = "Style")] public class SourceStyle : GLib.Object { @@ -483,6 +518,11 @@ namespace Gtk { [CCode (array_length = false, array_null_terminated = true)] public string[] search_path { get; set; } } + [CCode (cheader_filename = "gtksourceview/gtksource.h")] + [Compact] + [GIR (name = "UndoManagerDefault")] + public class SourceUndoManagerDefault { + } [CCode (cheader_filename = "gtksourceview/gtksource.h", type_id = "gtk_source_view_get_type ()")] [GIR (name = "View")] public class SourceView : Gtk.TextView, Atk.Implementor, Gtk.Buildable, Gtk.Scrollable { diff --git a/vapi/libwnck-3.0.vapi b/vapi/libwnck-3.0.vapi index d8ff688..d49f74f 100644 --- a/vapi/libwnck-3.0.vapi +++ b/vapi/libwnck-3.0.vapi @@ -120,6 +120,7 @@ namespace Wnck { public void set_grouping (Wnck.TasklistGroupingType grouping); public void set_grouping_limit (int limit); public void set_include_all_workspaces (bool include_all_workspaces); + public void set_orientation (Gtk.Orientation orient); public void set_switch_workspace_on_unminimize (bool switch_workspace_on_unminimize); } [CCode (cheader_filename = "libwnck/libwnck.h", type_id = "wnck_window_get_type ()")] diff --git a/vapi/libxml-2.0.vapi b/vapi/libxml-2.0.vapi index dd2fe59..bf51c53 100644 --- a/vapi/libxml-2.0.vapi +++ b/vapi/libxml-2.0.vapi @@ -191,7 +191,7 @@ namespace Xml { public static Doc* read_memory (string text, int len, string? url = null, string? encoding = null, int options = 0); } - [CCode (cname = "xmlParserOption", cprefix = "XML_PARSE_", cheader_filename = "libxml/parser.h")] + [CCode (cname = "xmlParserOption", cprefix = "XML_PARSE_", cheader_filename = "libxml/parser.h", has_type_id = false)] public enum ParserOption { RECOVER, NOENT, @@ -212,7 +212,7 @@ namespace Xml { COMPACT, } - [CCode (cname = "xmlCharEncoding", cprefix = "XML_CHAR_ENCODING_", cheader_filename = "libxml/encoding.h")] + [CCode (cname = "xmlCharEncoding", cprefix = "XML_CHAR_ENCODING_", cheader_filename = "libxml/encoding.h", has_type_id = false)] public enum CharEncoding { ERROR, NONE, @@ -300,7 +300,7 @@ namespace Xml { public weak string elem; } - [CCode (cname = "xmlAttributeDefault", cprefix = "XML_ATTRIBUTE_", cheader_filename = "libxml/tree.h")] + [CCode (cname = "xmlAttributeDefault", cprefix = "XML_ATTRIBUTE_", cheader_filename = "libxml/tree.h", has_type_id = false)] public enum AttributeDefault { NONE, REQUIRED, @@ -308,7 +308,7 @@ namespace Xml { FIXED } - [CCode (cname = "xmlAttributeType", cprefix = "XML_ATTRIBUTE_", cheader_filename = "libxml/tree.h")] + [CCode (cname = "xmlAttributeType", cprefix = "XML_ATTRIBUTE_", cheader_filename = "libxml/tree.h", has_type_id = false)] public enum AttributeType { CDATA, ID, @@ -487,7 +487,7 @@ namespace Xml { public weak string prefix; } - [CCode (cname = "xmlElementType", cprefix = "XML_", cheader_filename = "libxml/tree.h")] + [CCode (cname = "xmlElementType", cprefix = "XML_", cheader_filename = "libxml/tree.h", has_type_id = false)] public enum ElementType { ELEMENT_NODE, ATTRIBUTE_NODE, @@ -527,7 +527,7 @@ namespace Xml { public const string prefix; } - [CCode (cname = "xmlElementContentType", cprefix = "XML_ELEMENT_CONTENT_", cheader_filename = "libxml/tree.h")] + [CCode (cname = "xmlElementContentType", cprefix = "XML_ELEMENT_CONTENT_", cheader_filename = "libxml/tree.h", has_type_id = false)] public enum ElementContentType { PCDATA, ELEMENT, @@ -535,7 +535,7 @@ namespace Xml { OR } - [CCode (cname = "xmlElementContentOccur", cprefix = "XML_ELEMENT_CONTENT_", cheader_filename = "libxml/tree.h")] + [CCode (cname = "xmlElementContentOccur", cprefix = "XML_ELEMENT_CONTENT_", cheader_filename = "libxml/tree.h", has_type_id = false)] public enum ElementContentOccur { ONCE, OPT, @@ -570,7 +570,7 @@ namespace Xml { public int checked; } - [CCode (cname = "xmlEntityType", cprefix = "XML_", cheader_filename = "libxml/tree.h")] + [CCode (cname = "xmlEntityType", cprefix = "XML_", cheader_filename = "libxml/tree.h", has_type_id = false)] public enum EntityType { INTERNAL_GENERAL_ENTITY, EXTERNAL_GENERAL_PARSED_ENTITY, @@ -1062,7 +1062,7 @@ namespace Xml { /* xmlreader - the XMLReader implementation */ - [CCode (cname = "xmlParserProperties", cprefix = "XML_PARSER_", cheader_filename = "libxml/xmlreader.h")] + [CCode (cname = "xmlParserProperties", cprefix = "XML_PARSER_", cheader_filename = "libxml/xmlreader.h", has_type_id = false)] public enum ParserProperties { LOADDTD, DEFAULTATTRS, @@ -1070,7 +1070,7 @@ namespace Xml { SUBST_ENTITIES } - [CCode (cname = "xmlParserSeverities", cprefix = "XML_PARSER_SEVERITY_", cheader_filename = "libxml/xmlreader.h")] + [CCode (cname = "xmlParserSeverities", cprefix = "XML_PARSER_SEVERITY_", cheader_filename = "libxml/xmlreader.h", has_type_id = false)] public enum ParserSeverities { VALIDITY_WARNING, VALIDITY_ERROR, @@ -1078,7 +1078,7 @@ namespace Xml { ERROR } - [CCode (cname = "xmlReaderTypes", cheader_filename = "libxml/xmlreader.h")] + [CCode (cname = "xmlReaderTypes", cheader_filename = "libxml/xmlreader.h", has_type_id = false)] public enum ReaderType { NONE, ELEMENT, @@ -1334,7 +1334,7 @@ namespace Xml { public class TextReaderLocator { } - [CCode (cname = "xmlTextReaderMode", cprefix = "XML_TEXTREADER_MODE_", cheader_filename = "libxml/xmlreader.h")] + [CCode (cname = "xmlTextReaderMode", cprefix = "XML_TEXTREADER_MODE_", cheader_filename = "libxml/xmlreader.h", has_type_id = false)] public enum TextReaderMode { INITIAL, INTERACTIVE, @@ -1390,7 +1390,7 @@ namespace Xml { public Context (Doc* doc); } - [CCode (cname = "xmlXPathError", cprefix = "XPATH_", cheader_filename = "libxml/xpath.h")] + [CCode (cname = "xmlXPathError", cprefix = "XPATH_", cheader_filename = "libxml/xpath.h", has_type_id = false)] public enum Error { EXPRESSION_OK, NUMBER_ERROR, @@ -1434,7 +1434,7 @@ namespace Xml { public int index2; } - [CCode (cname = "xmlXPathObjectType", cprefix = "XPATH_", cheader_filename = "libxml/xpath.h")] + [CCode (cname = "xmlXPathObjectType", cprefix = "XPATH_", cheader_filename = "libxml/xpath.h", has_type_id = false)] public enum ObjectType { UNDEFINED, NODESET, @@ -1628,7 +1628,7 @@ namespace Xml { public void* node; } - [CCode (cname = "xmlErrorLevel", cprefix = "XML_ERR_", cheader_filename = "libxml/xmlerror.h")] + [CCode (cname = "xmlErrorLevel", cprefix = "XML_ERR_", cheader_filename = "libxml/xmlerror.h", has_type_id = false)] public enum ErrorLevel { NONE = 0, WARNING = 1, @@ -1654,7 +1654,7 @@ namespace Html { [CCode (cname = "htmlHandleOmittedElem", cheader_filename = "libxml/HTMLparser.h")] public static bool handle_omitted_elem (bool val); - [CCode (cname = "htmlParserOption", cprefix = "HTML_PARSE_", cheader_filename = "libxml/HTMLparser.h")] + [CCode (cname = "htmlParserOption", cprefix = "HTML_PARSE_", cheader_filename = "libxml/HTMLparser.h", has_type_id = false)] public enum ParserOption { RECOVER, NOERROR, @@ -1665,7 +1665,7 @@ namespace Html { COMPACT, } - [CCode (cname = "htmlStatus", cprefix = "HTML_", cheader_filename = "libxml/HTMLparser.h")] + [CCode (cname = "htmlStatus", cprefix = "HTML_", cheader_filename = "libxml/HTMLparser.h", has_type_id = false)] public enum Status { NA, INVALID, diff --git a/vapi/linux.vapi b/vapi/linux.vapi index da424d5..47ebe57 100644 --- a/vapi/linux.vapi +++ b/vapi/linux.vapi @@ -3670,13 +3670,13 @@ namespace Linux { [CCode (cname = "struct uinput_user_dev", cheader_filename = "linux/uinput.h")] struct UserDevice { - string name; + char name[80]; Input.Id id; int ff_effects_max; - int[] absmax; - int[] absmin; - int[] absfuzz; - int[] absflat; + int absmax[64]; + int absmin[64]; + int absfuzz[64]; + int absflat[64]; } } diff --git a/vapi/posix.vapi b/vapi/posix.vapi index dc3cade..ea2d025 100644 --- a/vapi/posix.vapi +++ b/vapi/posix.vapi @@ -353,7 +353,7 @@ namespace Posix { [CCode (cheader_filename = "arpa/inet.h")] public unowned string inet_ntoa (InAddr addr); [CCode (cheader_filename = "arpa/inet.h")] - public unowned string inet_ntop (int af, void* src, uint8[] dst); + public unowned string? inet_ntop (int af, void* src, uint8[] dst); [CCode (cheader_filename = "arpa/inet.h")] public int inet_pton (int af, string src, void* dst); [CCode (cheader_filename = "arpa/inet.h")] @@ -2483,5 +2483,66 @@ namespace Posix { [CCode (cname = "glob", instance_pos = -1)] public int glob (string pattern, int flags = 0, GlobErrorFunction? errfunc = null); } -} + [CCode (cheader_filename = "langinfo.h", cprefix = "")] + public enum NLItem { + ABDAY_1, + ABDAY_2, + ABDAY_3, + ABDAY_4, + ABDAY_5, + ABDAY_6, + ABDAY_7, + DAY_1, + DAY_2, + DAY_3, + DAY_4, + DAY_5, + DAY_6, + DAY_7, + ABMON_1, + ABMON_2, + ABMON_3, + ABMON_4, + ABMON_5, + ABMON_6, + ABMON_7, + ABMON_8, + ABMON_9, + ABMON_10, + ABMON_11, + ABMON_12, + MON_1, + MON_2, + MON_3, + MON_4, + MON_5, + MON_6, + MON_7, + MON_8, + MON_9, + MON_10, + MON_11, + MON_12, + AM_STR, + PM_STR, + D_T_FMT, + D_FMT, + T_FMT, + T_FMT_AMPM, + ERA, + ERA_D_FMT, + ALT_DIGITS, + ERA_D_T_FMT, + ERA_T_FMT, + CODESET, + CRNCYSTR, + RADIXCHAR, + THOUSEP, + YESEXPR, + NOEXPR + } + + [CCode (cheader_filename = "langinfo.h")] + public unowned string nl_langinfo (NLItem item); +} diff --git a/vapi/udisks2.vapi b/vapi/udisks2.vapi index 217b305..0099037 100644 --- a/vapi/udisks2.vapi +++ b/vapi/udisks2.vapi @@ -22,7 +22,7 @@ namespace UDisks { public class Client : GLib.Object, GLib.AsyncInitable, GLib.Initable { [CCode (cname = "udisks_client_new", has_construct_function = false)] public async Client (GLib.Cancellable? cancellable) throws GLib.Error; - public UDisks.Block get_block_for_dev (int block_device_number); + public UDisks.Block get_block_for_dev (uint64 block_device_number); public UDisks.Block get_block_for_drive (UDisks.Drive drive, bool get_physical); public GLib.List get_block_for_label (string label); public GLib.List get_block_for_uuid (string uuid); @@ -30,6 +30,7 @@ namespace UDisks { public UDisks.Drive get_drive_for_block (UDisks.Block block); public void get_drive_info (UDisks.Drive drive, out string out_name, out string out_description, out GLib.Icon out_drive_icon, out string out_media_description, out GLib.Icon out_media_icon); public string get_id_for_display (string usage, string type, string version, bool long_string); + public string get_job_description (UDisks.Job job); public GLib.List get_jobs_for_object (UDisks.Object object); public UDisks.Loop get_loop_for_block (UDisks.Block block); public unowned UDisks.Manager get_manager (); @@ -266,18 +267,24 @@ namespace UDisks { public bool call_get_secret_configuration_sync (GLib.Variant arg_options, out GLib.Variant out_configuration, GLib.Cancellable? cancellable = null) throws GLib.Error; public async bool call_open_for_backup (GLib.Variant arg_options, GLib.UnixFDList? fd_list, GLib.Cancellable? cancellable, out GLib.Variant out_fd, out GLib.UnixFDList out_fd_list) throws GLib.Error; public bool call_open_for_backup_sync (GLib.Variant arg_options, GLib.UnixFDList? fd_list, out GLib.Variant out_fd, out GLib.UnixFDList out_fd_list, GLib.Cancellable? cancellable = null) throws GLib.Error; + public async bool call_open_for_benchmark (GLib.Variant arg_options, GLib.UnixFDList? fd_list, GLib.Cancellable? cancellable, out GLib.Variant out_fd, out GLib.UnixFDList out_fd_list) throws GLib.Error; + public bool call_open_for_benchmark_sync (GLib.Variant arg_options, GLib.UnixFDList? fd_list, out GLib.Variant out_fd, out GLib.UnixFDList out_fd_list, GLib.Cancellable? cancellable = null) throws GLib.Error; public async bool call_open_for_restore (GLib.Variant arg_options, GLib.UnixFDList? fd_list, GLib.Cancellable? cancellable, out GLib.Variant out_fd, out GLib.UnixFDList out_fd_list) throws GLib.Error; public bool call_open_for_restore_sync (GLib.Variant arg_options, GLib.UnixFDList? fd_list, out GLib.Variant out_fd, out GLib.UnixFDList out_fd_list, GLib.Cancellable? cancellable = null) throws GLib.Error; public async bool call_remove_configuration_item (GLib.Variant arg_item, GLib.Variant arg_options, GLib.Cancellable? cancellable) throws GLib.Error; public bool call_remove_configuration_item_sync (GLib.Variant arg_item, GLib.Variant arg_options, GLib.Cancellable? cancellable = null) throws GLib.Error; + public async bool call_rescan (GLib.Variant arg_options, GLib.Cancellable? cancellable) throws GLib.Error; + public bool call_rescan_sync (GLib.Variant arg_options, GLib.Cancellable? cancellable = null) throws GLib.Error; public async bool call_update_configuration_item (GLib.Variant arg_old_item, GLib.Variant arg_new_item, GLib.Variant arg_options, GLib.Cancellable? cancellable) throws GLib.Error; public bool call_update_configuration_item_sync (GLib.Variant arg_old_item, GLib.Variant arg_new_item, GLib.Variant arg_options, GLib.Cancellable? cancellable = null) throws GLib.Error; public void complete_add_configuration_item (owned GLib.DBusMethodInvocation invocation); public void complete_format (owned GLib.DBusMethodInvocation invocation); public void complete_get_secret_configuration (owned GLib.DBusMethodInvocation invocation, GLib.Variant configuration); public void complete_open_for_backup (owned GLib.DBusMethodInvocation invocation, GLib.UnixFDList? fd_list, GLib.Variant fd); + public void complete_open_for_benchmark (owned GLib.DBusMethodInvocation invocation, GLib.UnixFDList? fd_list, GLib.Variant fd); public void complete_open_for_restore (owned GLib.DBusMethodInvocation invocation, GLib.UnixFDList? fd_list, GLib.Variant fd); public void complete_remove_configuration_item (owned GLib.DBusMethodInvocation invocation); + public void complete_rescan (owned GLib.DBusMethodInvocation invocation); public void complete_update_configuration_item (owned GLib.DBusMethodInvocation invocation); public static unowned GLib.DBusInterfaceInfo interface_info (); public static uint override_properties (GLib.ObjectClass klass, uint property_id_begin); @@ -326,22 +333,31 @@ namespace UDisks { public virtual signal bool handle_format (GLib.DBusMethodInvocation invocation, string arg_type, GLib.Variant arg_options); public virtual signal bool handle_get_secret_configuration (GLib.DBusMethodInvocation invocation, GLib.Variant arg_options); public virtual signal bool handle_open_for_backup (GLib.DBusMethodInvocation invocation, GLib.UnixFDList? fd_list, GLib.Variant arg_options); + public virtual signal bool handle_open_for_benchmark (GLib.DBusMethodInvocation invocation, GLib.UnixFDList? fd_list, GLib.Variant arg_options); public virtual signal bool handle_open_for_restore (GLib.DBusMethodInvocation invocation, GLib.UnixFDList? fd_list, GLib.Variant arg_options); public virtual signal bool handle_remove_configuration_item (GLib.DBusMethodInvocation invocation, GLib.Variant arg_item, GLib.Variant arg_options); + public virtual signal bool handle_rescan (GLib.DBusMethodInvocation invocation, GLib.Variant arg_options); public virtual signal bool handle_update_configuration_item (GLib.DBusMethodInvocation invocation, GLib.Variant arg_old_item, GLib.Variant arg_new_item, GLib.Variant arg_options); } [CCode (cheader_filename = "udisks/udisks.h", type_id = "udisks_drive_get_type ()")] public interface Drive : GLib.Object { public async bool call_eject (GLib.Variant arg_options, GLib.Cancellable? cancellable) throws GLib.Error; public bool call_eject_sync (GLib.Variant arg_options, GLib.Cancellable? cancellable = null) throws GLib.Error; + public async bool call_set_configuration (GLib.Variant arg_value, GLib.Variant arg_options, GLib.Cancellable? cancellable) throws GLib.Error; + public bool call_set_configuration_sync (GLib.Variant arg_value, GLib.Variant arg_options, GLib.Cancellable? cancellable = null) throws GLib.Error; public void complete_eject (owned GLib.DBusMethodInvocation invocation); + public void complete_set_configuration (owned GLib.DBusMethodInvocation invocation); public static unowned GLib.DBusInterfaceInfo interface_info (); public static uint override_properties (GLib.ObjectClass klass, uint property_id_begin); [NoAccessorMethod] + public abstract GLib.Variant configuration { owned get; set; } + [NoAccessorMethod] public abstract string connection_bus { owned get; set; } [NoAccessorMethod] public abstract bool ejectable { get; set; } [NoAccessorMethod] + public abstract string id { owned get; set; } + [NoAccessorMethod] public abstract string media { owned get; set; } [NoAccessorMethod] public abstract bool media_available { get; set; } @@ -389,9 +405,18 @@ namespace UDisks { [NoAccessorMethod] public abstract string wwn { owned get; set; } public virtual signal bool handle_eject (GLib.DBusMethodInvocation invocation, GLib.Variant arg_options); + public virtual signal bool handle_set_configuration (GLib.DBusMethodInvocation invocation, GLib.Variant arg_value, GLib.Variant arg_options); } [CCode (cheader_filename = "udisks/udisks.h", type_id = "udisks_drive_ata_get_type ()")] public interface DriveAta : GLib.Object { + public async bool call_pm_get_state (GLib.Variant arg_options, GLib.Cancellable? cancellable, out uint8 out_state) throws GLib.Error; + public bool call_pm_get_state_sync (GLib.Variant arg_options, out uint8 out_state, GLib.Cancellable? cancellable = null) throws GLib.Error; + public async bool call_pm_standby (GLib.Variant arg_options, GLib.Cancellable? cancellable) throws GLib.Error; + public bool call_pm_standby_sync (GLib.Variant arg_options, GLib.Cancellable? cancellable = null) throws GLib.Error; + public async bool call_pm_wakeup (GLib.Variant arg_options, GLib.Cancellable? cancellable) throws GLib.Error; + public bool call_pm_wakeup_sync (GLib.Variant arg_options, GLib.Cancellable? cancellable = null) throws GLib.Error; + public async bool call_security_erase_unit (GLib.Variant arg_options, GLib.Cancellable? cancellable) throws GLib.Error; + public bool call_security_erase_unit_sync (GLib.Variant arg_options, GLib.Cancellable? cancellable = null) throws GLib.Error; public async bool call_smart_get_attributes (GLib.Variant arg_options, GLib.Cancellable? cancellable, out GLib.Variant out_attributes) throws GLib.Error; public bool call_smart_get_attributes_sync (GLib.Variant arg_options, out GLib.Variant out_attributes, GLib.Cancellable? cancellable = null) throws GLib.Error; public async bool call_smart_selftest_abort (GLib.Variant arg_options, GLib.Cancellable? cancellable) throws GLib.Error; @@ -400,6 +425,10 @@ namespace UDisks { public bool call_smart_selftest_start_sync (string arg_type, GLib.Variant arg_options, GLib.Cancellable? cancellable = null) throws GLib.Error; public async bool call_smart_update (GLib.Variant arg_options, GLib.Cancellable? cancellable) throws GLib.Error; public bool call_smart_update_sync (GLib.Variant arg_options, GLib.Cancellable? cancellable = null) throws GLib.Error; + public void complete_pm_get_state (owned GLib.DBusMethodInvocation invocation, uint8 state); + public void complete_pm_standby (owned GLib.DBusMethodInvocation invocation); + public void complete_pm_wakeup (owned GLib.DBusMethodInvocation invocation); + public void complete_security_erase_unit (owned GLib.DBusMethodInvocation invocation); public void complete_smart_get_attributes (owned GLib.DBusMethodInvocation invocation, GLib.Variant attributes); public void complete_smart_selftest_abort (owned GLib.DBusMethodInvocation invocation); public void complete_smart_selftest_start (owned GLib.DBusMethodInvocation invocation); @@ -407,6 +436,26 @@ namespace UDisks { public static unowned GLib.DBusInterfaceInfo interface_info (); public static uint override_properties (GLib.ObjectClass klass, uint property_id_begin); [NoAccessorMethod] + public abstract bool aam_enabled { get; set; } + [NoAccessorMethod] + public abstract bool aam_supported { get; set; } + [NoAccessorMethod] + public abstract int aam_vendor_recommended_value { get; set; } + [NoAccessorMethod] + public abstract bool apm_enabled { get; set; } + [NoAccessorMethod] + public abstract bool apm_supported { get; set; } + [NoAccessorMethod] + public abstract bool pm_enabled { get; set; } + [NoAccessorMethod] + public abstract bool pm_supported { get; set; } + [NoAccessorMethod] + public abstract int security_enhanced_erase_unit_minutes { get; set; } + [NoAccessorMethod] + public abstract int security_erase_unit_minutes { get; set; } + [NoAccessorMethod] + public abstract bool security_frozen { get; set; } + [NoAccessorMethod] public abstract bool smart_enabled { get; set; } [NoAccessorMethod] public abstract bool smart_failing { get; set; } @@ -428,6 +477,10 @@ namespace UDisks { public abstract double smart_temperature { get; set; } [NoAccessorMethod] public abstract uint64 smart_updated { get; set; } + public virtual signal bool handle_pm_get_state (GLib.DBusMethodInvocation invocation, GLib.Variant arg_options); + public virtual signal bool handle_pm_standby (GLib.DBusMethodInvocation invocation, GLib.Variant arg_options); + public virtual signal bool handle_pm_wakeup (GLib.DBusMethodInvocation invocation, GLib.Variant arg_options); + public virtual signal bool handle_security_erase_unit (GLib.DBusMethodInvocation invocation, GLib.Variant arg_options); public virtual signal bool handle_smart_get_attributes (GLib.DBusMethodInvocation invocation, GLib.Variant arg_options); public virtual signal bool handle_smart_selftest_abort (GLib.DBusMethodInvocation invocation, GLib.Variant arg_options); public virtual signal bool handle_smart_selftest_start (GLib.DBusMethodInvocation invocation, string arg_type, GLib.Variant arg_options); @@ -479,14 +532,22 @@ namespace UDisks { public static unowned GLib.DBusInterfaceInfo interface_info (); public static uint override_properties (GLib.ObjectClass klass, uint property_id_begin); [NoAccessorMethod] + public abstract bool cancelable { get; set; } + [NoAccessorMethod] public abstract uint64 expected_end_time { get; set; } [CCode (array_length = false, array_null_terminated = true)] [NoAccessorMethod] public abstract string[] objects { owned get; set; } [NoAccessorMethod] + public abstract string operation { owned get; set; } + [NoAccessorMethod] public abstract double progress { get; set; } [NoAccessorMethod] + public abstract bool progress_valid { get; set; } + [NoAccessorMethod] public abstract uint64 start_time { get; set; } + [NoAccessorMethod] + public abstract uint started_by_uid { get; set; } public virtual signal void completed (bool arg_success, string arg_message); public virtual signal bool handle_cancel (GLib.DBusMethodInvocation invocation, GLib.Variant arg_options); } @@ -589,7 +650,7 @@ namespace UDisks { [NoAccessorMethod] public abstract string table { owned get; set; } [NoAccessorMethod] - public abstract string type_ { owned get; set; } + public abstract string type { owned get; set; } [NoAccessorMethod] public abstract string uuid { owned get; set; } public virtual signal bool handle_delete (GLib.DBusMethodInvocation invocation, GLib.Variant arg_options); @@ -605,7 +666,7 @@ namespace UDisks { public static unowned GLib.DBusInterfaceInfo interface_info (); public static uint override_properties (GLib.ObjectClass klass, uint property_id_begin); [NoAccessorMethod] - public abstract string type_ { owned get; set; } + public abstract string type { owned get; set; } public virtual signal bool handle_create_partition (GLib.DBusMethodInvocation invocation, uint64 arg_offset, uint64 arg_size, string arg_type, string arg_name, GLib.Variant arg_options); } [CCode (cheader_filename = "udisks/udisks.h", type_id = "udisks_swapspace_get_type ()")] @@ -623,8 +684,18 @@ namespace UDisks { public virtual signal bool handle_start (GLib.DBusMethodInvocation invocation, GLib.Variant arg_options); public virtual signal bool handle_stop (GLib.DBusMethodInvocation invocation, GLib.Variant arg_options); } + [CCode (cheader_filename = "udisks/udisks.h", cprefix = "UDISKS_PARTITION_TYPE_INFO_FLAGS_", type_id = "udisks_partition_type_info_flags_get_type ()")] + [Flags] + public enum PartitionTypeInfoFlags { + NONE, + SWAP, + RAID, + HIDDEN, + CREATE_ONLY, + SYSTEM + } [CCode (cheader_filename = "udisks/udisks.h", cprefix = "UDISKS_ERROR_")] - public enum Error { + public errordomain Error { FAILED, CANCELLED, ALREADY_CANCELLED, @@ -642,16 +713,6 @@ namespace UDisks { DEVICE_BUSY; public static GLib.Quark quark (); } - [CCode (cheader_filename = "udisks/udisks.h", cprefix = "UDISKS_PARTITION_TYPE_INFO_FLAGS_")] - [Flags] - public enum PartitionTypeInfoFlags { - NONE, - SWAP, - RAID, - HIDDEN, - CREATE_ONLY, - SYSTEM - } [CCode (cheader_filename = "udisks/udisks.h", cname = "UDISKS_ERROR_NUM_ENTRIES")] public const int ERROR_NUM_ENTRIES; [CCode (cheader_filename = "udisks/udisks.h", cname = "UDISKS_MAJOR_VERSION")] diff --git a/vapigen/Makefile.am b/vapigen/Makefile.am index 8460a5e..bc8539a 100644 --- a/vapigen/Makefile.am +++ b/vapigen/Makefile.am @@ -1,6 +1,6 @@ NULL = -VALAC = $(top_builddir)/compiler/valac +VALAC = $(top_builddir)/compiler/valac$(EXEEXT) SUBDIRS = \ vala-gen-introspect \ diff --git a/vapigen/Makefile.in b/vapigen/Makefile.in index 24a4ea1..693bc35 100644 --- a/vapigen/Makefile.in +++ b/vapigen/Makefile.in @@ -277,7 +277,7 @@ SED = @SED@ SET_MAKE = @SET_MAKE@ SHELL = @SHELL@ STRIP = @STRIP@ -VALAC = $(top_builddir)/compiler/valac +VALAC = $(top_builddir)/compiler/valac$(EXEEXT) VALAFLAGS = @VALAFLAGS@ VERSION = @VERSION@ XSLTPROC = @XSLTPROC@ diff --git a/vapigen/vala-gen-introspect/Makefile.am b/vapigen/vala-gen-introspect/Makefile.am index 4f0c471..854cb9d 100644 --- a/vapigen/vala-gen-introspect/Makefile.am +++ b/vapigen/vala-gen-introspect/Makefile.am @@ -10,5 +10,5 @@ EXTRA_DIST = \ if ENABLE_UNVERSIONED install-exec-hook: - cd $(DESTDIR)$(bindir) && $(LN_S) -f vala-gen-introspect@PACKAGE_SUFFIX@$(EXEEXT) vala-gen-introspect$(EXEEXT) + cd $(DESTDIR)$(bindir) && $(LN_S) -f vala-gen-introspect@PACKAGE_SUFFIX@ vala-gen-introspect endif diff --git a/vapigen/vala-gen-introspect/Makefile.in b/vapigen/vala-gen-introspect/Makefile.in index bcab732..5864511 100644 --- a/vapigen/vala-gen-introspect/Makefile.in +++ b/vapigen/vala-gen-introspect/Makefile.in @@ -496,7 +496,7 @@ uninstall-am: uninstall-binSCRIPTS $(NULL) @ENABLE_UNVERSIONED_TRUE@install-exec-hook: -@ENABLE_UNVERSIONED_TRUE@ cd $(DESTDIR)$(bindir) && $(LN_S) -f vala-gen-introspect@PACKAGE_SUFFIX@$(EXEEXT) vala-gen-introspect$(EXEEXT) +@ENABLE_UNVERSIONED_TRUE@ cd $(DESTDIR)$(bindir) && $(LN_S) -f vala-gen-introspect@PACKAGE_SUFFIX@ vala-gen-introspect # Tell versions [3.59,3.63) of GNU make to not export all variables. # Otherwise a system limit (for SysV at least) may be exceeded. -- 2.7.4