diff -Nru vala-0.48.20/build-aux/git-version-gen vala-0.48.22/build-aux/git-version-gen --- vala-0.48.20/build-aux/git-version-gen 2021-12-02 12:46:14.000000000 +0000 +++ vala-0.48.22/build-aux/git-version-gen 2022-01-09 09:11:08.000000000 +0000 @@ -1,8 +1,8 @@ #!/bin/sh # Print a version string. -scriptversion=2017-09-13.06; # UTC +scriptversion=2019-10-13.15; # UTC -# Copyright (C) 2007-2017 Free Software Foundation, Inc. +# Copyright (C) 2007-2021 Free Software Foundation, Inc. # # This program is free software: you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by @@ -72,9 +72,10 @@ me=$0 +year=`expr "$scriptversion" : '\([^-]*\)'` version="git-version-gen $scriptversion -Copyright 2011 Free Software Foundation, Inc. +Copyright $year Free Software Foundation, Inc. There is NO warranty. You may redistribute this software under the terms of the GNU General Public License. For more information about these matters, see the files named COPYING." @@ -141,11 +142,9 @@ v=`cat $tarball_version_file` || v= case $v in *$nl*) v= ;; # reject multi-line output - [0-9]*) ;; - *) v= ;; esac test "x$v" = x \ - && echo "$0: WARNING: $tarball_version_file is missing or damaged" 1>&2 + && echo "$0: WARNING: $tarball_version_file is damaged" 1>&2 fi if test "x$v" != x @@ -219,7 +218,7 @@ printf %s "$v" # Local variables: -# eval: (add-hook 'write-file-hooks 'time-stamp) +# eval: (add-hook 'before-save-hook 'time-stamp) # time-stamp-start: "scriptversion=" # time-stamp-format: "%:y-%02m-%02d.%02H" # time-stamp-time-zone: "UTC0" diff -Nru vala-0.48.20/ccode/valaccodeassignment.c vala-0.48.22/ccode/valaccodeassignment.c --- vala-0.48.20/ccode/valaccodeassignment.c 2021-12-02 13:42:42.000000000 +0000 +++ vala-0.48.22/ccode/valaccodeassignment.c 2022-01-09 12:57:25.000000000 +0000 @@ -82,10 +82,8 @@ vala_ccode_assignment_get_operator (ValaCCodeAssignment* self) { ValaCCodeAssignmentOperator result; - ValaCCodeAssignmentOperator _tmp0_; g_return_val_if_fail (self != NULL, 0); - _tmp0_ = self->priv->_operator; - result = _tmp0_; + result = self->priv->_operator; return result; } diff -Nru vala-0.48.20/ccode/valaccodebinaryexpression.c vala-0.48.22/ccode/valaccodebinaryexpression.c --- vala-0.48.20/ccode/valaccodebinaryexpression.c 2021-12-02 13:42:42.000000000 +0000 +++ vala-0.48.22/ccode/valaccodebinaryexpression.c 2022-01-09 12:57:25.000000000 +0000 @@ -54,10 +54,8 @@ vala_ccode_binary_expression_get_operator (ValaCCodeBinaryExpression* self) { ValaCCodeBinaryOperator result; - ValaCCodeBinaryOperator _tmp0_; g_return_val_if_fail (self != NULL, 0); - _tmp0_ = self->priv->_operator; - result = _tmp0_; + result = self->priv->_operator; return result; } diff -Nru vala-0.48.20/ccode/valaccodeggnucsection.c vala-0.48.22/ccode/valaccodeggnucsection.c --- vala-0.48.20/ccode/valaccodeggnucsection.c 2021-12-02 13:42:42.000000000 +0000 +++ vala-0.48.22/ccode/valaccodeggnucsection.c 2022-01-09 12:57:25.000000000 +0000 @@ -57,10 +57,8 @@ vala_ccode_ggnuc_section_get_section_type (ValaCCodeGGnucSection* self) { ValaGGnucSectionType result; - ValaGGnucSectionType _tmp0_; g_return_val_if_fail (self != NULL, 0); - _tmp0_ = self->priv->_section_type; - result = _tmp0_; + result = self->priv->_section_type; return result; } diff -Nru vala-0.48.20/ccode/valaccodenode.c vala-0.48.22/ccode/valaccodenode.c --- vala-0.48.20/ccode/valaccodenode.c 2021-12-02 13:42:42.000000000 +0000 +++ vala-0.48.22/ccode/valaccodenode.c 2022-01-09 12:57:25.000000000 +0000 @@ -89,10 +89,8 @@ vala_ccode_node_get_modifiers (ValaCCodeNode* self) { ValaCCodeModifiers result; - ValaCCodeModifiers _tmp0_; g_return_val_if_fail (self != NULL, 0U); - _tmp0_ = self->priv->_modifiers; - result = _tmp0_; + result = self->priv->_modifiers; return result; } diff -Nru vala-0.48.20/ccode/valaccodeunaryexpression.c vala-0.48.22/ccode/valaccodeunaryexpression.c --- vala-0.48.20/ccode/valaccodeunaryexpression.c 2021-12-02 13:42:42.000000000 +0000 +++ vala-0.48.22/ccode/valaccodeunaryexpression.c 2022-01-09 12:57:25.000000000 +0000 @@ -53,10 +53,8 @@ vala_ccode_unary_expression_get_operator (ValaCCodeUnaryExpression* self) { ValaCCodeUnaryOperator result; - ValaCCodeUnaryOperator _tmp0_; g_return_val_if_fail (self != NULL, 0); - _tmp0_ = self->priv->_operator; - result = _tmp0_; + result = self->priv->_operator; return result; } diff -Nru vala-0.48.20/ChangeLog vala-0.48.22/ChangeLog --- vala-0.48.20/ChangeLog 2021-12-02 14:08:53.000000000 +0000 +++ vala-0.48.22/ChangeLog 2022-01-09 12:58:29.000000000 +0000 @@ -1,3 +1,86 @@ +2022-01-09 Rico Tzschichholz + + Release 0.48.22 + + gstreamer: Cherry-pick bindings fixes from 0.56 + + girparser: Avoid possibily creating duplicated attributes + Don't append an attribute without checking if there is an existing one. + In case the attribute already exists append the new key/value pairs. + + tests: Add "type-parameter property clash" test to increase coverage + This needs to be handled gracefully. So throwing an error is no option. + + codegen: Use a dedicated EmitContext for _variant_get*() functions + + tests: Add more "chain up" tests to increase coverage + + vala: Set is_yield_expression in async context when chaining up to async base ctor + vala-CRITICAL **: vala_member_access_get_inner: assertion 'self != NULL' failed + vala-CRITICAL **: vala_member_access_get_member_name: assertion 'self != NULL' failed + + Avoid these spurious criticals and trigger the currently expected error. + + codegen: Correctly handle chain up of struct creation methods + Fixes https://gitlab.gnome.org/GNOME/vala/issues/1264 + +2022-01-09 wxx <769218589@qq.com> + + vala: NullLiteral is not a valid argument for string concatenation + Fixes https://gitlab.gnome.org/GNOME/vala/issues/1260 + +2022-01-09 Lorenz Wildberg + + tests/girwriter: Use the actual expected output of our girwriter + +2022-01-09 Rico Tzschichholz + + build: Update git-version-gen to latest upstream + From commit 378351df7e63daca234c581f086b542026e07a27 of + https://git.savannah.gnu.org/cgit/autoconf.git/tree/build-aux/git-version-gen + +2022-01-09 Alexander Kanavin + + vapigen.m4: use $PKG_CONFIG_SYSROOT_DIR + This is necessary in cross-compiling environments, where directories + returned by pkg-config should be prefixed with sysroot location. + +2022-01-09 Rico Tzschichholz + + glib-2.0: Always use the actual C type for CCode.array_length_type + +2022-01-08 Rico Tzschichholz + + Release 0.48.21 + + codegen: Clear existing length values when revisiting a slice expression + Fixes https://gitlab.gnome.org/GNOME/vala/issues/1274 + + tests: Add "async signal handler" test to increase coverage + +2022-01-04 Rico Tzschichholz + + codegen: Cast given default-value of struct with possible member initializer + Fixes https://gitlab.gnome.org/GNOME/vala/issues/1272 + + codegen: Allow boxing of non-external SimpleType structs + Fixes https://gitlab.gnome.org/GNOME/vala/issues/1273 + + gio-2.0: Add custom MemoryOutputStream.with_*data() wrappers + Fixes https://gitlab.gnome.org/GNOME/vala/issues/1271 + + vala: Correctly replace "in" expression in pre-/postconditions of method + Fixes https://gitlab.gnome.org/GNOME/vala/issues/1269 + +2021-12-20 Rico Tzschichholz + + vala: Non nullable enum types are simple types + Fixes a regression of 5b6345a6386b05aaf3f11cb3572940413eb878a8 + + Fixes https://gitlab.gnome.org/GNOME/vala/issues/1268 + + vala: Allow unsafe assignment of integer to enum while reporting a notice + 2021-12-02 Rico Tzschichholz Release 0.48.20 diff -Nru vala-0.48.20/codegen/codegen.vapi vala-0.48.22/codegen/codegen.vapi --- vala-0.48.20/codegen/codegen.vapi 2021-12-02 13:42:49.000000000 +0000 +++ vala-0.48.22/codegen/codegen.vapi 2022-01-09 12:57:32.000000000 +0000 @@ -911,6 +911,8 @@ [CCode (cheader_filename = "valacodegen.h")] public static bool is_reference_counting (Vala.TypeSymbol sym); [CCode (cheader_filename = "valacodegen.h")] + public static void set_array_length (Vala.Expression expr, Vala.CCodeExpression size); + [CCode (cheader_filename = "valacodegen.h")] public static void set_array_size_cvalue (Vala.TargetValue value, Vala.CCodeExpression? cvalue); [CCode (cheader_filename = "valacodegen.h")] public static void set_cvalue (Vala.Expression expr, Vala.CCodeExpression? cvalue); diff -Nru vala-0.48.20/codegen/valaccodearraymodule.c vala-0.48.22/codegen/valaccodearraymodule.c --- vala-0.48.20/codegen/valaccodearraymodule.c 2021-12-02 13:42:48.000000000 +0000 +++ vala-0.48.22/codegen/valaccodearraymodule.c 2022-01-09 12:57:30.000000000 +0000 @@ -1139,7 +1139,7 @@ _tmp13_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_MINUS, cstop, cstart); splicelen = _tmp13_; vala_set_cvalue ((ValaExpression*) expr, (ValaCCodeExpression*) cstartpointer); - vala_append_array_length ((ValaExpression*) expr, (ValaCCodeExpression*) splicelen); + vala_set_array_length ((ValaExpression*) expr, (ValaCCodeExpression*) splicelen); _vala_ccode_node_unref0 (splicelen); _vala_ccode_node_unref0 (cstartpointer); _vala_ccode_node_unref0 (cstop); @@ -2901,10 +2901,10 @@ ValaCCodeFunction* _tmp38_; ValaDataType* _tmp39_; ValaDataType* _tmp40_; - ValaCCodeFile* _tmp260_; - ValaCCodeFunction* _tmp261_; - ValaCCodeFile* _tmp262_; - ValaCCodeFunction* _tmp263_; + ValaCCodeFile* _tmp259_; + ValaCCodeFunction* _tmp260_; + ValaCCodeFile* _tmp261_; + ValaCCodeFunction* _tmp262_; gchar* result = NULL; g_return_val_if_fail (self != NULL, NULL); g_return_val_if_fail (array_type != NULL, NULL); @@ -3012,84 +3012,83 @@ ValaProfile _tmp78_; ValaProfile _tmp79_; ValaCCodeBinaryExpression* length_check = NULL; - ValaCCodeBinaryOperator _tmp93_; + ValaCCodeIdentifier* _tmp93_; ValaCCodeIdentifier* _tmp94_; - ValaCCodeIdentifier* _tmp95_; + ValaCCodeConstant* _tmp95_; ValaCCodeConstant* _tmp96_; - ValaCCodeConstant* _tmp97_; + ValaCCodeBinaryExpression* _tmp97_; ValaCCodeBinaryExpression* _tmp98_; - ValaCCodeBinaryExpression* _tmp99_; + ValaCCodeFunction* _tmp99_; ValaCCodeFunction* _tmp100_; - ValaCCodeFunction* _tmp101_; - ValaCCodeBinaryExpression* _tmp102_; + ValaCCodeBinaryExpression* _tmp101_; + ValaCCodeFunction* _tmp102_; ValaCCodeFunction* _tmp103_; - ValaCCodeFunction* _tmp104_; + gchar* _tmp104_; gchar* _tmp105_; - gchar* _tmp106_; - ValaCCodeVariableDeclarator* _tmp107_; + ValaCCodeVariableDeclarator* _tmp106_; + ValaCCodeFunction* _tmp107_; ValaCCodeFunction* _tmp108_; - ValaCCodeFunction* _tmp109_; + ValaCCodeIdentifier* _tmp109_; ValaCCodeIdentifier* _tmp110_; - ValaCCodeIdentifier* _tmp111_; - ValaCCodeFunctionCall* _tmp112_; + ValaCCodeFunctionCall* _tmp111_; + ValaCCodeFunction* _tmp112_; ValaCCodeFunction* _tmp113_; - ValaCCodeFunction* _tmp114_; - ValaDataType* _tmp115_; + ValaDataType* _tmp114_; + gchar* _tmp115_; gchar* _tmp116_; - gchar* _tmp117_; + ValaCCodeVariableDeclarator* _tmp117_; ValaCCodeVariableDeclarator* _tmp118_; - ValaCCodeVariableDeclarator* _tmp119_; + ValaCCodeFunction* _tmp119_; ValaCCodeFunction* _tmp120_; - ValaCCodeFunction* _tmp121_; + ValaCCodeIdentifier* _tmp121_; ValaCCodeIdentifier* _tmp122_; - ValaCCodeIdentifier* _tmp123_; + ValaCCodeConstant* _tmp123_; ValaCCodeConstant* _tmp124_; - ValaCCodeConstant* _tmp125_; + ValaCCodeAssignment* _tmp125_; ValaCCodeAssignment* _tmp126_; - ValaCCodeAssignment* _tmp127_; + ValaCCodeIdentifier* _tmp127_; ValaCCodeIdentifier* _tmp128_; ValaCCodeIdentifier* _tmp129_; ValaCCodeIdentifier* _tmp130_; - ValaCCodeIdentifier* _tmp131_; + ValaCCodeBinaryExpression* _tmp131_; ValaCCodeBinaryExpression* _tmp132_; - ValaCCodeBinaryExpression* _tmp133_; + ValaCCodeIdentifier* _tmp133_; ValaCCodeIdentifier* _tmp134_; - ValaCCodeIdentifier* _tmp135_; + ValaCCodeUnaryExpression* _tmp135_; ValaCCodeUnaryExpression* _tmp136_; - ValaCCodeUnaryExpression* _tmp137_; + ValaCCodeFunction* _tmp137_; ValaCCodeFunction* _tmp138_; - ValaCCodeFunction* _tmp139_; + ValaCCodeIdentifier* _tmp139_; ValaCCodeIdentifier* _tmp140_; ValaCCodeIdentifier* _tmp141_; ValaCCodeIdentifier* _tmp142_; - ValaCCodeIdentifier* _tmp143_; + ValaCCodeElementAccess* _tmp143_; ValaCCodeElementAccess* _tmp144_; - ValaCCodeElementAccess* _tmp145_; + ValaDataType* _tmp145_; ValaDataType* _tmp146_; - ValaDataType* _tmp147_; + ValaCCodeIdentifier* _tmp147_; ValaCCodeIdentifier* _tmp148_; ValaCCodeIdentifier* _tmp149_; ValaCCodeIdentifier* _tmp150_; - ValaCCodeIdentifier* _tmp151_; + ValaCCodeElementAccess* _tmp151_; ValaCCodeElementAccess* _tmp152_; - ValaCCodeElementAccess* _tmp153_; + ValaGLibValue* _tmp153_; ValaGLibValue* _tmp154_; - ValaGLibValue* _tmp155_; + ValaTargetValue* _tmp155_; ValaTargetValue* _tmp156_; - ValaTargetValue* _tmp157_; - ValaCCodeExpression* _tmp158_; + ValaCCodeExpression* _tmp157_; + ValaCCodeFunction* _tmp158_; ValaCCodeFunction* _tmp159_; ValaCCodeFunction* _tmp160_; ValaCCodeFunction* _tmp161_; - ValaCCodeFunction* _tmp162_; + ValaCCodeIdentifier* _tmp162_; ValaCCodeIdentifier* _tmp163_; - ValaCCodeIdentifier* _tmp164_; + ValaCCodeFunction* _tmp164_; ValaCCodeFunction* _tmp165_; ValaCCodeFunction* _tmp166_; ValaCCodeFunction* _tmp167_; - ValaCCodeFunction* _tmp168_; + ValaCCodeConstant* _tmp168_; ValaCCodeConstant* _tmp169_; - ValaCCodeConstant* _tmp170_; _tmp41_ = vala_ccode_variable_declarator_new ("result", NULL, NULL); cvardecl = _tmp41_; _tmp42_ = vala_ccode_base_module_get_context ((ValaCCodeBaseModule*) self); @@ -3215,368 +3214,367 @@ vala_ccode_function_call_add_argument (_tmp91_, (ValaCCodeExpression*) _tmp92_); _vala_ccode_node_unref0 (csizeof); } - _tmp93_ = length_check_op; - _tmp94_ = vala_ccode_identifier_new ("length"); - _tmp95_ = _tmp94_; - _tmp96_ = vala_ccode_constant_new ("0"); - _tmp97_ = _tmp96_; - _tmp98_ = vala_ccode_binary_expression_new (_tmp93_, (ValaCCodeExpression*) _tmp95_, (ValaCCodeExpression*) _tmp97_); - _tmp99_ = _tmp98_; - _vala_ccode_node_unref0 (_tmp97_); - _vala_ccode_node_unref0 (_tmp95_); - length_check = _tmp99_; - _tmp100_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); - _tmp101_ = _tmp100_; - _tmp102_ = length_check; - vala_ccode_function_open_if (_tmp101_, (ValaCCodeExpression*) _tmp102_); - _tmp103_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); - _tmp104_ = _tmp103_; - _tmp105_ = vala_get_ccode_name ((ValaCodeNode*) array_type); - _tmp106_ = _tmp105_; - _tmp107_ = cvardecl; - vala_ccode_function_add_declaration (_tmp104_, _tmp106_, (ValaCCodeDeclarator*) _tmp107_, 0); - _g_free0 (_tmp106_); - _tmp108_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); - _tmp109_ = _tmp108_; - _tmp110_ = vala_ccode_identifier_new ("result"); - _tmp111_ = _tmp110_; - _tmp112_ = gnew; - vala_ccode_function_add_assignment (_tmp109_, (ValaCCodeExpression*) _tmp111_, (ValaCCodeExpression*) _tmp112_); - _vala_ccode_node_unref0 (_tmp111_); - _tmp113_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); - _tmp114_ = _tmp113_; - _tmp115_ = ((ValaCCodeBaseModule*) self)->int_type; - _tmp116_ = vala_get_ccode_name ((ValaCodeNode*) _tmp115_); - _tmp117_ = _tmp116_; - _tmp118_ = vala_ccode_variable_declarator_new ("i", NULL, NULL); - _tmp119_ = _tmp118_; - vala_ccode_function_add_declaration (_tmp114_, _tmp117_, (ValaCCodeDeclarator*) _tmp119_, 0); - _vala_ccode_node_unref0 (_tmp119_); - _g_free0 (_tmp117_); - _tmp120_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); - _tmp121_ = _tmp120_; - _tmp122_ = vala_ccode_identifier_new ("i"); - _tmp123_ = _tmp122_; - _tmp124_ = vala_ccode_constant_new ("0"); - _tmp125_ = _tmp124_; - _tmp126_ = vala_ccode_assignment_new ((ValaCCodeExpression*) _tmp123_, (ValaCCodeExpression*) _tmp125_, VALA_CCODE_ASSIGNMENT_OPERATOR_SIMPLE); - _tmp127_ = _tmp126_; - _tmp128_ = vala_ccode_identifier_new ("i"); - _tmp129_ = _tmp128_; - _tmp130_ = vala_ccode_identifier_new ("length"); - _tmp131_ = _tmp130_; - _tmp132_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_LESS_THAN, (ValaCCodeExpression*) _tmp129_, (ValaCCodeExpression*) _tmp131_); - _tmp133_ = _tmp132_; - _tmp134_ = vala_ccode_identifier_new ("i"); - _tmp135_ = _tmp134_; - _tmp136_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_POSTFIX_INCREMENT, (ValaCCodeExpression*) _tmp135_); - _tmp137_ = _tmp136_; - vala_ccode_function_open_for (_tmp121_, (ValaCCodeExpression*) _tmp127_, (ValaCCodeExpression*) _tmp133_, (ValaCCodeExpression*) _tmp137_); - _vala_ccode_node_unref0 (_tmp137_); - _vala_ccode_node_unref0 (_tmp135_); - _vala_ccode_node_unref0 (_tmp133_); - _vala_ccode_node_unref0 (_tmp131_); - _vala_ccode_node_unref0 (_tmp129_); - _vala_ccode_node_unref0 (_tmp127_); - _vala_ccode_node_unref0 (_tmp125_); - _vala_ccode_node_unref0 (_tmp123_); - _tmp138_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); - _tmp139_ = _tmp138_; - _tmp140_ = vala_ccode_identifier_new ("result"); - _tmp141_ = _tmp140_; - _tmp142_ = vala_ccode_identifier_new ("i"); - _tmp143_ = _tmp142_; - _tmp144_ = vala_ccode_element_access_new ((ValaCCodeExpression*) _tmp141_, (ValaCCodeExpression*) _tmp143_); - _tmp145_ = _tmp144_; - _tmp146_ = vala_array_type_get_element_type (array_type); - _tmp147_ = _tmp146_; - _tmp148_ = vala_ccode_identifier_new ("self"); - _tmp149_ = _tmp148_; - _tmp150_ = vala_ccode_identifier_new ("i"); - _tmp151_ = _tmp150_; - _tmp152_ = vala_ccode_element_access_new ((ValaCCodeExpression*) _tmp149_, (ValaCCodeExpression*) _tmp151_); - _tmp153_ = _tmp152_; - _tmp154_ = vala_glib_value_new (_tmp147_, (ValaCCodeExpression*) _tmp153_, TRUE); - _tmp155_ = _tmp154_; - _tmp156_ = vala_ccode_base_module_copy_value ((ValaCCodeBaseModule*) self, (ValaTargetValue*) _tmp155_, (ValaCodeNode*) array_type); - _tmp157_ = _tmp156_; - _tmp158_ = vala_get_cvalue_ (_tmp157_); - vala_ccode_function_add_assignment (_tmp139_, (ValaCCodeExpression*) _tmp145_, _tmp158_); - _vala_target_value_unref0 (_tmp157_); - _vala_target_value_unref0 (_tmp155_); - _vala_ccode_node_unref0 (_tmp153_); - _vala_ccode_node_unref0 (_tmp151_); - _vala_ccode_node_unref0 (_tmp149_); - _vala_ccode_node_unref0 (_tmp145_); - _vala_ccode_node_unref0 (_tmp143_); - _vala_ccode_node_unref0 (_tmp141_); - _tmp159_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); - _tmp160_ = _tmp159_; - vala_ccode_function_close (_tmp160_); - _tmp161_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); - _tmp162_ = _tmp161_; - _tmp163_ = vala_ccode_identifier_new ("result"); - _tmp164_ = _tmp163_; - vala_ccode_function_add_return (_tmp162_, (ValaCCodeExpression*) _tmp164_); - _vala_ccode_node_unref0 (_tmp164_); - _tmp165_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); - _tmp166_ = _tmp165_; - vala_ccode_function_close (_tmp166_); - _tmp167_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); - _tmp168_ = _tmp167_; - _tmp169_ = vala_ccode_constant_new ("NULL"); - _tmp170_ = _tmp169_; - vala_ccode_function_add_return (_tmp168_, (ValaCCodeExpression*) _tmp170_); - _vala_ccode_node_unref0 (_tmp170_); + _tmp93_ = vala_ccode_identifier_new ("length"); + _tmp94_ = _tmp93_; + _tmp95_ = vala_ccode_constant_new ("0"); + _tmp96_ = _tmp95_; + _tmp97_ = vala_ccode_binary_expression_new (length_check_op, (ValaCCodeExpression*) _tmp94_, (ValaCCodeExpression*) _tmp96_); + _tmp98_ = _tmp97_; + _vala_ccode_node_unref0 (_tmp96_); + _vala_ccode_node_unref0 (_tmp94_); + length_check = _tmp98_; + _tmp99_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp100_ = _tmp99_; + _tmp101_ = length_check; + vala_ccode_function_open_if (_tmp100_, (ValaCCodeExpression*) _tmp101_); + _tmp102_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp103_ = _tmp102_; + _tmp104_ = vala_get_ccode_name ((ValaCodeNode*) array_type); + _tmp105_ = _tmp104_; + _tmp106_ = cvardecl; + vala_ccode_function_add_declaration (_tmp103_, _tmp105_, (ValaCCodeDeclarator*) _tmp106_, 0); + _g_free0 (_tmp105_); + _tmp107_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp108_ = _tmp107_; + _tmp109_ = vala_ccode_identifier_new ("result"); + _tmp110_ = _tmp109_; + _tmp111_ = gnew; + vala_ccode_function_add_assignment (_tmp108_, (ValaCCodeExpression*) _tmp110_, (ValaCCodeExpression*) _tmp111_); + _vala_ccode_node_unref0 (_tmp110_); + _tmp112_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp113_ = _tmp112_; + _tmp114_ = ((ValaCCodeBaseModule*) self)->int_type; + _tmp115_ = vala_get_ccode_name ((ValaCodeNode*) _tmp114_); + _tmp116_ = _tmp115_; + _tmp117_ = vala_ccode_variable_declarator_new ("i", NULL, NULL); + _tmp118_ = _tmp117_; + vala_ccode_function_add_declaration (_tmp113_, _tmp116_, (ValaCCodeDeclarator*) _tmp118_, 0); + _vala_ccode_node_unref0 (_tmp118_); + _g_free0 (_tmp116_); + _tmp119_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp120_ = _tmp119_; + _tmp121_ = vala_ccode_identifier_new ("i"); + _tmp122_ = _tmp121_; + _tmp123_ = vala_ccode_constant_new ("0"); + _tmp124_ = _tmp123_; + _tmp125_ = vala_ccode_assignment_new ((ValaCCodeExpression*) _tmp122_, (ValaCCodeExpression*) _tmp124_, VALA_CCODE_ASSIGNMENT_OPERATOR_SIMPLE); + _tmp126_ = _tmp125_; + _tmp127_ = vala_ccode_identifier_new ("i"); + _tmp128_ = _tmp127_; + _tmp129_ = vala_ccode_identifier_new ("length"); + _tmp130_ = _tmp129_; + _tmp131_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_LESS_THAN, (ValaCCodeExpression*) _tmp128_, (ValaCCodeExpression*) _tmp130_); + _tmp132_ = _tmp131_; + _tmp133_ = vala_ccode_identifier_new ("i"); + _tmp134_ = _tmp133_; + _tmp135_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_POSTFIX_INCREMENT, (ValaCCodeExpression*) _tmp134_); + _tmp136_ = _tmp135_; + vala_ccode_function_open_for (_tmp120_, (ValaCCodeExpression*) _tmp126_, (ValaCCodeExpression*) _tmp132_, (ValaCCodeExpression*) _tmp136_); + _vala_ccode_node_unref0 (_tmp136_); + _vala_ccode_node_unref0 (_tmp134_); + _vala_ccode_node_unref0 (_tmp132_); + _vala_ccode_node_unref0 (_tmp130_); + _vala_ccode_node_unref0 (_tmp128_); + _vala_ccode_node_unref0 (_tmp126_); + _vala_ccode_node_unref0 (_tmp124_); + _vala_ccode_node_unref0 (_tmp122_); + _tmp137_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp138_ = _tmp137_; + _tmp139_ = vala_ccode_identifier_new ("result"); + _tmp140_ = _tmp139_; + _tmp141_ = vala_ccode_identifier_new ("i"); + _tmp142_ = _tmp141_; + _tmp143_ = vala_ccode_element_access_new ((ValaCCodeExpression*) _tmp140_, (ValaCCodeExpression*) _tmp142_); + _tmp144_ = _tmp143_; + _tmp145_ = vala_array_type_get_element_type (array_type); + _tmp146_ = _tmp145_; + _tmp147_ = vala_ccode_identifier_new ("self"); + _tmp148_ = _tmp147_; + _tmp149_ = vala_ccode_identifier_new ("i"); + _tmp150_ = _tmp149_; + _tmp151_ = vala_ccode_element_access_new ((ValaCCodeExpression*) _tmp148_, (ValaCCodeExpression*) _tmp150_); + _tmp152_ = _tmp151_; + _tmp153_ = vala_glib_value_new (_tmp146_, (ValaCCodeExpression*) _tmp152_, TRUE); + _tmp154_ = _tmp153_; + _tmp155_ = vala_ccode_base_module_copy_value ((ValaCCodeBaseModule*) self, (ValaTargetValue*) _tmp154_, (ValaCodeNode*) array_type); + _tmp156_ = _tmp155_; + _tmp157_ = vala_get_cvalue_ (_tmp156_); + vala_ccode_function_add_assignment (_tmp138_, (ValaCCodeExpression*) _tmp144_, _tmp157_); + _vala_target_value_unref0 (_tmp156_); + _vala_target_value_unref0 (_tmp154_); + _vala_ccode_node_unref0 (_tmp152_); + _vala_ccode_node_unref0 (_tmp150_); + _vala_ccode_node_unref0 (_tmp148_); + _vala_ccode_node_unref0 (_tmp144_); + _vala_ccode_node_unref0 (_tmp142_); + _vala_ccode_node_unref0 (_tmp140_); + _tmp158_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp159_ = _tmp158_; + vala_ccode_function_close (_tmp159_); + _tmp160_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp161_ = _tmp160_; + _tmp162_ = vala_ccode_identifier_new ("result"); + _tmp163_ = _tmp162_; + vala_ccode_function_add_return (_tmp161_, (ValaCCodeExpression*) _tmp163_); + _vala_ccode_node_unref0 (_tmp163_); + _tmp164_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp165_ = _tmp164_; + vala_ccode_function_close (_tmp165_); + _tmp166_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp167_ = _tmp166_; + _tmp168_ = vala_ccode_constant_new ("NULL"); + _tmp169_ = _tmp168_; + vala_ccode_function_add_return (_tmp167_, (ValaCCodeExpression*) _tmp169_); + _vala_ccode_node_unref0 (_tmp169_); _vala_ccode_node_unref0 (length_check); _vala_ccode_node_unref0 (length_expr); _vala_ccode_node_unref0 (gnew); _vala_ccode_node_unref0 (cvardecl); } else { ValaCCodeBinaryExpression* length_check = NULL; + ValaCCodeIdentifier* _tmp170_; ValaCCodeIdentifier* _tmp171_; - ValaCCodeIdentifier* _tmp172_; + ValaCCodeConstant* _tmp172_; ValaCCodeConstant* _tmp173_; - ValaCCodeConstant* _tmp174_; + ValaCCodeBinaryExpression* _tmp174_; ValaCCodeBinaryExpression* _tmp175_; - ValaCCodeBinaryExpression* _tmp176_; + ValaCCodeFunction* _tmp176_; ValaCCodeFunction* _tmp177_; - ValaCCodeFunction* _tmp178_; - ValaCCodeBinaryExpression* _tmp179_; + ValaCCodeBinaryExpression* _tmp178_; ValaCCodeFunctionCall* sizeof_call = NULL; + ValaCCodeIdentifier* _tmp179_; ValaCCodeIdentifier* _tmp180_; - ValaCCodeIdentifier* _tmp181_; + ValaCCodeFunctionCall* _tmp181_; ValaCCodeFunctionCall* _tmp182_; ValaCCodeFunctionCall* _tmp183_; - ValaCCodeFunctionCall* _tmp184_; + ValaDataType* _tmp184_; ValaDataType* _tmp185_; - ValaDataType* _tmp186_; + gchar* _tmp186_; gchar* _tmp187_; - gchar* _tmp188_; + ValaCCodeIdentifier* _tmp188_; ValaCCodeIdentifier* _tmp189_; - ValaCCodeIdentifier* _tmp190_; ValaCCodeIdentifier* length_expr = NULL; - ValaCCodeIdentifier* _tmp191_; + ValaCCodeIdentifier* _tmp190_; + ValaCodeContext* _tmp191_; ValaCodeContext* _tmp192_; - ValaCodeContext* _tmp193_; + ValaProfile _tmp193_; ValaProfile _tmp194_; - ValaProfile _tmp195_; + ValaCCodeFunction* _tmp253_; ValaCCodeFunction* _tmp254_; ValaCCodeFunction* _tmp255_; ValaCCodeFunction* _tmp256_; - ValaCCodeFunction* _tmp257_; + ValaCCodeConstant* _tmp257_; ValaCCodeConstant* _tmp258_; - ValaCCodeConstant* _tmp259_; - _tmp171_ = vala_ccode_identifier_new ("length"); - _tmp172_ = _tmp171_; - _tmp173_ = vala_ccode_constant_new ("0"); - _tmp174_ = _tmp173_; - _tmp175_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_GREATER_THAN, (ValaCCodeExpression*) _tmp172_, (ValaCCodeExpression*) _tmp174_); - _tmp176_ = _tmp175_; - _vala_ccode_node_unref0 (_tmp174_); - _vala_ccode_node_unref0 (_tmp172_); - length_check = _tmp176_; - _tmp177_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); - _tmp178_ = _tmp177_; - _tmp179_ = length_check; - vala_ccode_function_open_if (_tmp178_, (ValaCCodeExpression*) _tmp179_); - _tmp180_ = vala_ccode_identifier_new ("sizeof"); - _tmp181_ = _tmp180_; - _tmp182_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp181_); - _tmp183_ = _tmp182_; - _vala_ccode_node_unref0 (_tmp181_); - sizeof_call = _tmp183_; - _tmp184_ = sizeof_call; - _tmp185_ = vala_array_type_get_element_type (array_type); - _tmp186_ = _tmp185_; - _tmp187_ = vala_get_ccode_name ((ValaCodeNode*) _tmp186_); - _tmp188_ = _tmp187_; - _tmp189_ = vala_ccode_identifier_new (_tmp188_); - _tmp190_ = _tmp189_; - vala_ccode_function_call_add_argument (_tmp184_, (ValaCCodeExpression*) _tmp190_); - _vala_ccode_node_unref0 (_tmp190_); - _g_free0 (_tmp188_); - _tmp191_ = vala_ccode_identifier_new ("length"); - length_expr = _tmp191_; - _tmp192_ = vala_ccode_base_module_get_context ((ValaCCodeBaseModule*) self); - _tmp193_ = _tmp192_; - _tmp194_ = vala_code_context_get_profile (_tmp193_); - _tmp195_ = _tmp194_; - if (_tmp195_ == VALA_PROFILE_POSIX) { + _tmp170_ = vala_ccode_identifier_new ("length"); + _tmp171_ = _tmp170_; + _tmp172_ = vala_ccode_constant_new ("0"); + _tmp173_ = _tmp172_; + _tmp174_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_GREATER_THAN, (ValaCCodeExpression*) _tmp171_, (ValaCCodeExpression*) _tmp173_); + _tmp175_ = _tmp174_; + _vala_ccode_node_unref0 (_tmp173_); + _vala_ccode_node_unref0 (_tmp171_); + length_check = _tmp175_; + _tmp176_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp177_ = _tmp176_; + _tmp178_ = length_check; + vala_ccode_function_open_if (_tmp177_, (ValaCCodeExpression*) _tmp178_); + _tmp179_ = vala_ccode_identifier_new ("sizeof"); + _tmp180_ = _tmp179_; + _tmp181_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp180_); + _tmp182_ = _tmp181_; + _vala_ccode_node_unref0 (_tmp180_); + sizeof_call = _tmp182_; + _tmp183_ = sizeof_call; + _tmp184_ = vala_array_type_get_element_type (array_type); + _tmp185_ = _tmp184_; + _tmp186_ = vala_get_ccode_name ((ValaCodeNode*) _tmp185_); + _tmp187_ = _tmp186_; + _tmp188_ = vala_ccode_identifier_new (_tmp187_); + _tmp189_ = _tmp188_; + vala_ccode_function_call_add_argument (_tmp183_, (ValaCCodeExpression*) _tmp189_); + _vala_ccode_node_unref0 (_tmp189_); + _g_free0 (_tmp187_); + _tmp190_ = vala_ccode_identifier_new ("length"); + length_expr = _tmp190_; + _tmp191_ = vala_ccode_base_module_get_context ((ValaCCodeBaseModule*) self); + _tmp192_ = _tmp191_; + _tmp193_ = vala_code_context_get_profile (_tmp192_); + _tmp194_ = _tmp193_; + if (_tmp194_ == VALA_PROFILE_POSIX) { + ValaCCodeFile* _tmp195_; ValaCCodeFile* _tmp196_; - ValaCCodeFile* _tmp197_; ValaCCodeFunctionCall* alloc = NULL; + ValaCCodeIdentifier* _tmp197_; ValaCCodeIdentifier* _tmp198_; - ValaCCodeIdentifier* _tmp199_; + ValaCCodeFunctionCall* _tmp199_; ValaCCodeFunctionCall* _tmp200_; ValaCCodeFunctionCall* _tmp201_; - ValaCCodeFunctionCall* _tmp202_; - ValaCCodeIdentifier* _tmp203_; + ValaCCodeIdentifier* _tmp202_; + ValaCCodeFunctionCall* _tmp203_; ValaCCodeFunctionCall* _tmp204_; - ValaCCodeFunctionCall* _tmp205_; ValaCCodeVariableDeclarator* cvardecl = NULL; - ValaCCodeVariableDeclarator* _tmp206_; + ValaCCodeVariableDeclarator* _tmp205_; + ValaCCodeFunction* _tmp206_; ValaCCodeFunction* _tmp207_; - ValaCCodeFunction* _tmp208_; + gchar* _tmp208_; gchar* _tmp209_; - gchar* _tmp210_; - ValaCCodeVariableDeclarator* _tmp211_; + ValaCCodeVariableDeclarator* _tmp210_; + ValaCCodeFunction* _tmp211_; ValaCCodeFunction* _tmp212_; - ValaCCodeFunction* _tmp213_; + ValaCCodeIdentifier* _tmp213_; ValaCCodeIdentifier* _tmp214_; - ValaCCodeIdentifier* _tmp215_; - ValaCCodeFunctionCall* _tmp216_; + ValaCCodeFunctionCall* _tmp215_; ValaCCodeFunctionCall* dup_call = NULL; + ValaCCodeIdentifier* _tmp216_; ValaCCodeIdentifier* _tmp217_; - ValaCCodeIdentifier* _tmp218_; + ValaCCodeFunctionCall* _tmp218_; ValaCCodeFunctionCall* _tmp219_; ValaCCodeFunctionCall* _tmp220_; - ValaCCodeFunctionCall* _tmp221_; + ValaCCodeIdentifier* _tmp221_; ValaCCodeIdentifier* _tmp222_; - ValaCCodeIdentifier* _tmp223_; - ValaCCodeFunctionCall* _tmp224_; + ValaCCodeFunctionCall* _tmp223_; + ValaCCodeIdentifier* _tmp224_; ValaCCodeIdentifier* _tmp225_; - ValaCCodeIdentifier* _tmp226_; - ValaCCodeFunctionCall* _tmp227_; - ValaCCodeIdentifier* _tmp228_; - ValaCCodeFunctionCall* _tmp229_; + ValaCCodeFunctionCall* _tmp226_; + ValaCCodeIdentifier* _tmp227_; + ValaCCodeFunctionCall* _tmp228_; + ValaCCodeBinaryExpression* _tmp229_; ValaCCodeBinaryExpression* _tmp230_; - ValaCCodeBinaryExpression* _tmp231_; + ValaCCodeFunction* _tmp231_; ValaCCodeFunction* _tmp232_; - ValaCCodeFunction* _tmp233_; - ValaCCodeFunctionCall* _tmp234_; + ValaCCodeFunctionCall* _tmp233_; + ValaCCodeFunction* _tmp234_; ValaCCodeFunction* _tmp235_; - ValaCCodeFunction* _tmp236_; + ValaCCodeIdentifier* _tmp236_; ValaCCodeIdentifier* _tmp237_; - ValaCCodeIdentifier* _tmp238_; + _tmp195_ = ((ValaCCodeBaseModule*) self)->cfile; + vala_ccode_file_add_include (_tmp195_, "stdlib.h", FALSE); _tmp196_ = ((ValaCCodeBaseModule*) self)->cfile; - vala_ccode_file_add_include (_tmp196_, "stdlib.h", FALSE); - _tmp197_ = ((ValaCCodeBaseModule*) self)->cfile; - vala_ccode_file_add_include (_tmp197_, "string.h", FALSE); - _tmp198_ = vala_ccode_identifier_new ("calloc"); - _tmp199_ = _tmp198_; - _tmp200_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp199_); - _tmp201_ = _tmp200_; - _vala_ccode_node_unref0 (_tmp199_); - alloc = _tmp201_; - _tmp202_ = alloc; - _tmp203_ = length_expr; - vala_ccode_function_call_add_argument (_tmp202_, (ValaCCodeExpression*) _tmp203_); - _tmp204_ = alloc; - _tmp205_ = sizeof_call; - vala_ccode_function_call_add_argument (_tmp204_, (ValaCCodeExpression*) _tmp205_); - _tmp206_ = vala_ccode_variable_declarator_new ("result", NULL, NULL); - cvardecl = _tmp206_; - _tmp207_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); - _tmp208_ = _tmp207_; - _tmp209_ = vala_get_ccode_name ((ValaCodeNode*) array_type); - _tmp210_ = _tmp209_; - _tmp211_ = cvardecl; - vala_ccode_function_add_declaration (_tmp208_, _tmp210_, (ValaCCodeDeclarator*) _tmp211_, 0); - _g_free0 (_tmp210_); - _tmp212_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); - _tmp213_ = _tmp212_; - _tmp214_ = vala_ccode_identifier_new ("result"); - _tmp215_ = _tmp214_; - _tmp216_ = alloc; - vala_ccode_function_add_assignment (_tmp213_, (ValaCCodeExpression*) _tmp215_, (ValaCCodeExpression*) _tmp216_); - _vala_ccode_node_unref0 (_tmp215_); - _tmp217_ = vala_ccode_identifier_new ("memcpy"); - _tmp218_ = _tmp217_; - _tmp219_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp218_); - _tmp220_ = _tmp219_; - _vala_ccode_node_unref0 (_tmp218_); - dup_call = _tmp220_; - _tmp221_ = dup_call; - _tmp222_ = vala_ccode_identifier_new ("result"); - _tmp223_ = _tmp222_; - vala_ccode_function_call_add_argument (_tmp221_, (ValaCCodeExpression*) _tmp223_); - _vala_ccode_node_unref0 (_tmp223_); - _tmp224_ = dup_call; - _tmp225_ = vala_ccode_identifier_new ("self"); - _tmp226_ = _tmp225_; - vala_ccode_function_call_add_argument (_tmp224_, (ValaCCodeExpression*) _tmp226_); - _vala_ccode_node_unref0 (_tmp226_); - _tmp227_ = dup_call; - _tmp228_ = length_expr; - _tmp229_ = sizeof_call; - _tmp230_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_MUL, (ValaCCodeExpression*) _tmp228_, (ValaCCodeExpression*) _tmp229_); - _tmp231_ = _tmp230_; - vala_ccode_function_call_add_argument (_tmp227_, (ValaCCodeExpression*) _tmp231_); - _vala_ccode_node_unref0 (_tmp231_); - _tmp232_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); - _tmp233_ = _tmp232_; - _tmp234_ = dup_call; - vala_ccode_function_add_expression (_tmp233_, (ValaCCodeExpression*) _tmp234_); - _tmp235_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); - _tmp236_ = _tmp235_; - _tmp237_ = vala_ccode_identifier_new ("result"); - _tmp238_ = _tmp237_; - vala_ccode_function_add_return (_tmp236_, (ValaCCodeExpression*) _tmp238_); - _vala_ccode_node_unref0 (_tmp238_); + vala_ccode_file_add_include (_tmp196_, "string.h", FALSE); + _tmp197_ = vala_ccode_identifier_new ("calloc"); + _tmp198_ = _tmp197_; + _tmp199_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp198_); + _tmp200_ = _tmp199_; + _vala_ccode_node_unref0 (_tmp198_); + alloc = _tmp200_; + _tmp201_ = alloc; + _tmp202_ = length_expr; + vala_ccode_function_call_add_argument (_tmp201_, (ValaCCodeExpression*) _tmp202_); + _tmp203_ = alloc; + _tmp204_ = sizeof_call; + vala_ccode_function_call_add_argument (_tmp203_, (ValaCCodeExpression*) _tmp204_); + _tmp205_ = vala_ccode_variable_declarator_new ("result", NULL, NULL); + cvardecl = _tmp205_; + _tmp206_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp207_ = _tmp206_; + _tmp208_ = vala_get_ccode_name ((ValaCodeNode*) array_type); + _tmp209_ = _tmp208_; + _tmp210_ = cvardecl; + vala_ccode_function_add_declaration (_tmp207_, _tmp209_, (ValaCCodeDeclarator*) _tmp210_, 0); + _g_free0 (_tmp209_); + _tmp211_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp212_ = _tmp211_; + _tmp213_ = vala_ccode_identifier_new ("result"); + _tmp214_ = _tmp213_; + _tmp215_ = alloc; + vala_ccode_function_add_assignment (_tmp212_, (ValaCCodeExpression*) _tmp214_, (ValaCCodeExpression*) _tmp215_); + _vala_ccode_node_unref0 (_tmp214_); + _tmp216_ = vala_ccode_identifier_new ("memcpy"); + _tmp217_ = _tmp216_; + _tmp218_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp217_); + _tmp219_ = _tmp218_; + _vala_ccode_node_unref0 (_tmp217_); + dup_call = _tmp219_; + _tmp220_ = dup_call; + _tmp221_ = vala_ccode_identifier_new ("result"); + _tmp222_ = _tmp221_; + vala_ccode_function_call_add_argument (_tmp220_, (ValaCCodeExpression*) _tmp222_); + _vala_ccode_node_unref0 (_tmp222_); + _tmp223_ = dup_call; + _tmp224_ = vala_ccode_identifier_new ("self"); + _tmp225_ = _tmp224_; + vala_ccode_function_call_add_argument (_tmp223_, (ValaCCodeExpression*) _tmp225_); + _vala_ccode_node_unref0 (_tmp225_); + _tmp226_ = dup_call; + _tmp227_ = length_expr; + _tmp228_ = sizeof_call; + _tmp229_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_MUL, (ValaCCodeExpression*) _tmp227_, (ValaCCodeExpression*) _tmp228_); + _tmp230_ = _tmp229_; + vala_ccode_function_call_add_argument (_tmp226_, (ValaCCodeExpression*) _tmp230_); + _vala_ccode_node_unref0 (_tmp230_); + _tmp231_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp232_ = _tmp231_; + _tmp233_ = dup_call; + vala_ccode_function_add_expression (_tmp232_, (ValaCCodeExpression*) _tmp233_); + _tmp234_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp235_ = _tmp234_; + _tmp236_ = vala_ccode_identifier_new ("result"); + _tmp237_ = _tmp236_; + vala_ccode_function_add_return (_tmp235_, (ValaCCodeExpression*) _tmp237_); + _vala_ccode_node_unref0 (_tmp237_); _vala_ccode_node_unref0 (dup_call); _vala_ccode_node_unref0 (cvardecl); _vala_ccode_node_unref0 (alloc); } else { ValaCCodeFunctionCall* dup_call = NULL; + ValaCCodeIdentifier* _tmp238_; ValaCCodeIdentifier* _tmp239_; - ValaCCodeIdentifier* _tmp240_; + ValaCCodeFunctionCall* _tmp240_; ValaCCodeFunctionCall* _tmp241_; ValaCCodeFunctionCall* _tmp242_; - ValaCCodeFunctionCall* _tmp243_; + ValaCCodeIdentifier* _tmp243_; ValaCCodeIdentifier* _tmp244_; - ValaCCodeIdentifier* _tmp245_; - ValaCCodeFunctionCall* _tmp246_; - ValaCCodeIdentifier* _tmp247_; - ValaCCodeFunctionCall* _tmp248_; + ValaCCodeFunctionCall* _tmp245_; + ValaCCodeIdentifier* _tmp246_; + ValaCCodeFunctionCall* _tmp247_; + ValaCCodeBinaryExpression* _tmp248_; ValaCCodeBinaryExpression* _tmp249_; - ValaCCodeBinaryExpression* _tmp250_; + ValaCCodeFunction* _tmp250_; ValaCCodeFunction* _tmp251_; - ValaCCodeFunction* _tmp252_; - ValaCCodeFunctionCall* _tmp253_; - _tmp239_ = vala_ccode_identifier_new ("g_memdup"); - _tmp240_ = _tmp239_; - _tmp241_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp240_); - _tmp242_ = _tmp241_; - _vala_ccode_node_unref0 (_tmp240_); - dup_call = _tmp242_; - _tmp243_ = dup_call; - _tmp244_ = vala_ccode_identifier_new ("self"); - _tmp245_ = _tmp244_; - vala_ccode_function_call_add_argument (_tmp243_, (ValaCCodeExpression*) _tmp245_); - _vala_ccode_node_unref0 (_tmp245_); - _tmp246_ = dup_call; - _tmp247_ = length_expr; - _tmp248_ = sizeof_call; - _tmp249_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_MUL, (ValaCCodeExpression*) _tmp247_, (ValaCCodeExpression*) _tmp248_); - _tmp250_ = _tmp249_; - vala_ccode_function_call_add_argument (_tmp246_, (ValaCCodeExpression*) _tmp250_); - _vala_ccode_node_unref0 (_tmp250_); - _tmp251_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); - _tmp252_ = _tmp251_; - _tmp253_ = dup_call; - vala_ccode_function_add_return (_tmp252_, (ValaCCodeExpression*) _tmp253_); + ValaCCodeFunctionCall* _tmp252_; + _tmp238_ = vala_ccode_identifier_new ("g_memdup"); + _tmp239_ = _tmp238_; + _tmp240_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp239_); + _tmp241_ = _tmp240_; + _vala_ccode_node_unref0 (_tmp239_); + dup_call = _tmp241_; + _tmp242_ = dup_call; + _tmp243_ = vala_ccode_identifier_new ("self"); + _tmp244_ = _tmp243_; + vala_ccode_function_call_add_argument (_tmp242_, (ValaCCodeExpression*) _tmp244_); + _vala_ccode_node_unref0 (_tmp244_); + _tmp245_ = dup_call; + _tmp246_ = length_expr; + _tmp247_ = sizeof_call; + _tmp248_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_MUL, (ValaCCodeExpression*) _tmp246_, (ValaCCodeExpression*) _tmp247_); + _tmp249_ = _tmp248_; + vala_ccode_function_call_add_argument (_tmp245_, (ValaCCodeExpression*) _tmp249_); + _vala_ccode_node_unref0 (_tmp249_); + _tmp250_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp251_ = _tmp250_; + _tmp252_ = dup_call; + vala_ccode_function_add_return (_tmp251_, (ValaCCodeExpression*) _tmp252_); _vala_ccode_node_unref0 (dup_call); } - _tmp254_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); - _tmp255_ = _tmp254_; - vala_ccode_function_close (_tmp255_); - _tmp256_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); - _tmp257_ = _tmp256_; - _tmp258_ = vala_ccode_constant_new ("NULL"); - _tmp259_ = _tmp258_; - vala_ccode_function_add_return (_tmp257_, (ValaCCodeExpression*) _tmp259_); - _vala_ccode_node_unref0 (_tmp259_); + _tmp253_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp254_ = _tmp253_; + vala_ccode_function_close (_tmp254_); + _tmp255_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp256_ = _tmp255_; + _tmp257_ = vala_ccode_constant_new ("NULL"); + _tmp258_ = _tmp257_; + vala_ccode_function_add_return (_tmp256_, (ValaCCodeExpression*) _tmp258_); + _vala_ccode_node_unref0 (_tmp258_); _vala_ccode_node_unref0 (length_expr); _vala_ccode_node_unref0 (sizeof_call); _vala_ccode_node_unref0 (length_check); } - _tmp260_ = ((ValaCCodeBaseModule*) self)->cfile; - _tmp261_ = function; - vala_ccode_file_add_function_declaration (_tmp260_, _tmp261_); - _tmp262_ = ((ValaCCodeBaseModule*) self)->cfile; - _tmp263_ = function; - vala_ccode_file_add_function (_tmp262_, _tmp263_); + _tmp259_ = ((ValaCCodeBaseModule*) self)->cfile; + _tmp260_ = function; + vala_ccode_file_add_function_declaration (_tmp259_, _tmp260_); + _tmp261_ = ((ValaCCodeBaseModule*) self)->cfile; + _tmp262_ = function; + vala_ccode_file_add_function (_tmp261_, _tmp262_); vala_ccode_base_module_pop_context ((ValaCCodeBaseModule*) self); result = dup_func; _vala_ccode_node_unref0 (function); diff -Nru vala-0.48.20/codegen/valaccodearraymodule.vala vala-0.48.22/codegen/valaccodearraymodule.vala --- vala-0.48.20/codegen/valaccodearraymodule.vala 2021-12-02 13:10:08.000000000 +0000 +++ vala-0.48.22/codegen/valaccodearraymodule.vala 2022-01-09 09:09:58.000000000 +0000 @@ -210,7 +210,8 @@ var splicelen = new CCodeBinaryExpression (CCodeBinaryOperator.MINUS, cstop, cstart); set_cvalue (expr, cstartpointer); - append_array_length (expr, splicelen); + // Make sure no previous length values are preserved + set_array_length (expr, splicelen); } void append_struct_array_free_loop (Struct st) { diff -Nru vala-0.48.20/codegen/valaccodeassignmentmodule.c vala-0.48.22/codegen/valaccodeassignmentmodule.c --- vala-0.48.20/codegen/valaccodeassignmentmodule.c 2021-12-02 13:42:48.000000000 +0000 +++ vala-0.48.22/codegen/valaccodeassignmentmodule.c 2022-01-09 12:57:30.000000000 +0000 @@ -88,11 +88,11 @@ ValaDataType* _tmp3_; ValaAssignmentOperator _tmp12_; ValaAssignmentOperator _tmp13_; - gboolean _tmp75_ = FALSE; + gboolean _tmp74_ = FALSE; + ValaExpression* _tmp75_; ValaExpression* _tmp76_; - ValaExpression* _tmp77_; + ValaDataType* _tmp77_; ValaDataType* _tmp78_; - ValaDataType* _tmp79_; ValaTargetValue* result = NULL; g_return_val_if_fail (self != NULL, NULL); g_return_val_if_fail (assignment != NULL, NULL); @@ -155,11 +155,10 @@ ValaExpression* _tmp67_; ValaExpression* _tmp68_; ValaCCodeExpression* _tmp69_; - ValaCCodeAssignmentOperator _tmp70_; - ValaCCodeAssignment* _tmp71_; + ValaCCodeAssignment* _tmp70_; + ValaCCodeFunction* _tmp71_; ValaCCodeFunction* _tmp72_; - ValaCCodeFunction* _tmp73_; - ValaCCodeExpression* _tmp74_; + ValaCCodeExpression* _tmp73_; _tmp24_ = vala_assignment_get_operator (assignment); _tmp25_ = _tmp24_; switch (_tmp25_) { @@ -330,73 +329,72 @@ _tmp67_ = vala_assignment_get_right (assignment); _tmp68_ = _tmp67_; _tmp69_ = vala_get_cvalue (_tmp68_); - _tmp70_ = cop; - _tmp71_ = vala_ccode_assignment_new (_tmp66_, _tmp69_, _tmp70_); - codenode = (ValaCCodeExpression*) _tmp71_; - _tmp72_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); - _tmp73_ = _tmp72_; - _tmp74_ = codenode; - vala_ccode_function_add_expression (_tmp73_, _tmp74_); + _tmp70_ = vala_ccode_assignment_new (_tmp66_, _tmp69_, cop); + codenode = (ValaCCodeExpression*) _tmp70_; + _tmp71_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp72_ = _tmp71_; + _tmp73_ = codenode; + vala_ccode_function_add_expression (_tmp72_, _tmp73_); _vala_ccode_node_unref0 (codenode); } - _tmp76_ = vala_assignment_get_left (assignment); - _tmp77_ = _tmp76_; - _tmp78_ = vala_expression_get_value_type (_tmp77_); - _tmp79_ = _tmp78_; - if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp79_, VALA_TYPE_ARRAY_TYPE)) { + _tmp75_ = vala_assignment_get_left (assignment); + _tmp76_ = _tmp75_; + _tmp77_ = vala_expression_get_value_type (_tmp76_); + _tmp78_ = _tmp77_; + if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp78_, VALA_TYPE_ARRAY_TYPE)) { + ValaExpression* _tmp79_; ValaExpression* _tmp80_; - ValaExpression* _tmp81_; + ValaDataType* _tmp81_; ValaDataType* _tmp82_; - ValaDataType* _tmp83_; + gboolean _tmp83_; gboolean _tmp84_; - gboolean _tmp85_; - _tmp80_ = vala_assignment_get_left (assignment); - _tmp81_ = _tmp80_; - _tmp82_ = vala_expression_get_value_type (_tmp81_); - _tmp83_ = _tmp82_; - _tmp84_ = vala_array_type_get_inline_allocated (G_TYPE_CHECK_INSTANCE_CAST (_tmp83_, VALA_TYPE_ARRAY_TYPE, ValaArrayType)); - _tmp85_ = _tmp84_; - _tmp75_ = _tmp85_; + _tmp79_ = vala_assignment_get_left (assignment); + _tmp80_ = _tmp79_; + _tmp81_ = vala_expression_get_value_type (_tmp80_); + _tmp82_ = _tmp81_; + _tmp83_ = vala_array_type_get_inline_allocated (G_TYPE_CHECK_INSTANCE_CAST (_tmp82_, VALA_TYPE_ARRAY_TYPE, ValaArrayType)); + _tmp84_ = _tmp83_; + _tmp74_ = _tmp84_; } else { - _tmp75_ = FALSE; + _tmp74_ = FALSE; } - if (_tmp75_) { + if (_tmp74_) { ValaVariable* variable = NULL; + ValaExpression* _tmp85_; ValaExpression* _tmp86_; - ValaExpression* _tmp87_; + ValaSymbol* _tmp87_; ValaSymbol* _tmp88_; - ValaSymbol* _tmp89_; - ValaVariable* _tmp90_; + ValaVariable* _tmp89_; + ValaExpression* _tmp90_; ValaExpression* _tmp91_; - ValaExpression* _tmp92_; + ValaTargetValue* _tmp92_; ValaTargetValue* _tmp93_; ValaTargetValue* _tmp94_; - ValaTargetValue* _tmp95_; - _tmp86_ = vala_assignment_get_left (assignment); - _tmp87_ = _tmp86_; - _tmp88_ = vala_expression_get_symbol_reference (_tmp87_); - _tmp89_ = _tmp88_; - variable = G_TYPE_CHECK_INSTANCE_CAST (_tmp89_, VALA_TYPE_VARIABLE, ValaVariable); - _tmp90_ = variable; - _tmp91_ = vala_assignment_get_left (assignment); - _tmp92_ = _tmp91_; - _tmp93_ = vala_expression_get_target_value (_tmp92_); - _tmp94_ = _tmp93_; - _tmp95_ = vala_ccode_base_module_load_variable ((ValaCCodeBaseModule*) self, _tmp90_, _tmp94_, NULL); - result = _tmp95_; + _tmp85_ = vala_assignment_get_left (assignment); + _tmp86_ = _tmp85_; + _tmp87_ = vala_expression_get_symbol_reference (_tmp86_); + _tmp88_ = _tmp87_; + variable = G_TYPE_CHECK_INSTANCE_CAST (_tmp88_, VALA_TYPE_VARIABLE, ValaVariable); + _tmp89_ = variable; + _tmp90_ = vala_assignment_get_left (assignment); + _tmp91_ = _tmp90_; + _tmp92_ = vala_expression_get_target_value (_tmp91_); + _tmp93_ = _tmp92_; + _tmp94_ = vala_ccode_base_module_load_variable ((ValaCCodeBaseModule*) self, _tmp89_, _tmp93_, NULL); + result = _tmp94_; return result; } else { + ValaExpression* _tmp95_; ValaExpression* _tmp96_; - ValaExpression* _tmp97_; + ValaTargetValue* _tmp97_; ValaTargetValue* _tmp98_; ValaTargetValue* _tmp99_; - ValaTargetValue* _tmp100_; - _tmp96_ = vala_assignment_get_left (assignment); - _tmp97_ = _tmp96_; - _tmp98_ = vala_expression_get_target_value (_tmp97_); - _tmp99_ = _tmp98_; - _tmp100_ = _vala_target_value_ref0 (_tmp99_); - result = _tmp100_; + _tmp95_ = vala_assignment_get_left (assignment); + _tmp96_ = _tmp95_; + _tmp97_ = vala_expression_get_target_value (_tmp96_); + _tmp98_ = _tmp97_; + _tmp99_ = _vala_target_value_ref0 (_tmp98_); + result = _tmp99_; return result; } } diff -Nru vala-0.48.20/codegen/valaccodeattribute.c vala-0.48.22/codegen/valaccodeattribute.c --- vala-0.48.20/codegen/valaccodeattribute.c 2021-12-02 13:42:48.000000000 +0000 +++ vala-0.48.22/codegen/valaccodeattribute.c 2022-01-09 12:57:30.000000000 +0000 @@ -748,13 +748,14 @@ vala_ccode_attribute_get_dup_function (ValaCCodeAttribute* self) { const gchar* result; - const gchar* _tmp13_; + const gchar* _tmp15_; g_return_val_if_fail (self != NULL, NULL); if (!self->priv->dup_function_set) { ValaAttribute* _tmp0_; gboolean _tmp3_ = FALSE; gboolean _tmp4_ = FALSE; - const gchar* _tmp5_; + gboolean _tmp5_ = FALSE; + const gchar* _tmp6_; _tmp0_ = self->priv->ccode; if (_tmp0_ != NULL) { ValaAttribute* _tmp1_; @@ -764,39 +765,46 @@ _g_free0 (self->priv->_dup_function); self->priv->_dup_function = _tmp2_; } - _tmp5_ = self->priv->_dup_function; - if (_tmp5_ == NULL) { - ValaSymbol* _tmp6_; - gboolean _tmp7_; + _tmp6_ = self->priv->_dup_function; + if (_tmp6_ == NULL) { + ValaSymbol* _tmp7_; gboolean _tmp8_; - _tmp6_ = self->priv->sym; - _tmp7_ = vala_symbol_get_external_package (_tmp6_); - _tmp8_ = _tmp7_; - _tmp4_ = !_tmp8_; + gboolean _tmp9_; + _tmp7_ = self->priv->sym; + _tmp8_ = vala_symbol_get_external_package (_tmp7_); + _tmp9_ = _tmp8_; + _tmp5_ = !_tmp9_; + } else { + _tmp5_ = FALSE; + } + if (_tmp5_) { + ValaSymbol* _tmp10_; + _tmp10_ = self->priv->sym; + _tmp4_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp10_, VALA_TYPE_STRUCT); } else { _tmp4_ = FALSE; } if (_tmp4_) { - ValaSymbol* _tmp9_; - _tmp9_ = self->priv->sym; - _tmp3_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp9_, VALA_TYPE_STRUCT); + ValaSymbol* _tmp11_; + _tmp11_ = self->priv->sym; + _tmp3_ = !vala_struct_is_simple_type (G_TYPE_CHECK_INSTANCE_CAST (_tmp11_, VALA_TYPE_STRUCT, ValaStruct)); } else { _tmp3_ = FALSE; } if (_tmp3_) { - const gchar* _tmp10_; - const gchar* _tmp11_; - gchar* _tmp12_; - _tmp10_ = vala_ccode_attribute_get_lower_case_prefix (self); - _tmp11_ = _tmp10_; - _tmp12_ = g_strdup_printf ("%sdup", _tmp11_); + const gchar* _tmp12_; + const gchar* _tmp13_; + gchar* _tmp14_; + _tmp12_ = vala_ccode_attribute_get_lower_case_prefix (self); + _tmp13_ = _tmp12_; + _tmp14_ = g_strdup_printf ("%sdup", _tmp13_); _g_free0 (self->priv->_dup_function); - self->priv->_dup_function = _tmp12_; + self->priv->_dup_function = _tmp14_; } self->priv->dup_function_set = TRUE; } - _tmp13_ = self->priv->_dup_function; - result = _tmp13_; + _tmp15_ = self->priv->_dup_function; + result = _tmp15_; return result; } @@ -4157,20 +4165,28 @@ ValaSymbol* _tmp12_; _tmp12_ = self->priv->sym; if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp12_, VALA_TYPE_STRUCT)) { - ValaSymbol* _tmp13_; - gboolean _tmp14_; + gboolean _tmp13_ = FALSE; + ValaSymbol* _tmp14_; gboolean _tmp15_; - _tmp13_ = self->priv->sym; - _tmp14_ = vala_symbol_get_external_package (_tmp13_); - _tmp15_ = _tmp14_; - if (!_tmp15_) { - const gchar* _tmp16_; - const gchar* _tmp17_; - gchar* _tmp18_; - _tmp16_ = vala_ccode_attribute_get_lower_case_prefix (self); - _tmp17_ = _tmp16_; - _tmp18_ = g_strdup_printf ("%sfree", _tmp17_); - result = _tmp18_; + gboolean _tmp16_; + _tmp14_ = self->priv->sym; + _tmp15_ = vala_symbol_get_external_package (_tmp14_); + _tmp16_ = _tmp15_; + if (!_tmp16_) { + ValaSymbol* _tmp17_; + _tmp17_ = self->priv->sym; + _tmp13_ = !vala_struct_is_simple_type (G_TYPE_CHECK_INSTANCE_CAST (_tmp17_, VALA_TYPE_STRUCT, ValaStruct)); + } else { + _tmp13_ = FALSE; + } + if (_tmp13_) { + const gchar* _tmp18_; + const gchar* _tmp19_; + gchar* _tmp20_; + _tmp18_ = vala_ccode_attribute_get_lower_case_prefix (self); + _tmp19_ = _tmp18_; + _tmp20_ = g_strdup_printf ("%sfree", _tmp19_); + result = _tmp20_; return result; } } diff -Nru vala-0.48.20/codegen/valaccodeattribute.vala vala-0.48.22/codegen/valaccodeattribute.vala --- vala-0.48.20/codegen/valaccodeattribute.vala 2021-12-02 13:10:08.000000000 +0000 +++ vala-0.48.22/codegen/valaccodeattribute.vala 2022-01-09 09:09:58.000000000 +0000 @@ -249,7 +249,8 @@ if (ccode != null) { _dup_function = ccode.get_string ("dup_function"); } - if (_dup_function == null && !sym.external_package && sym is Struct) { + if (_dup_function == null && !sym.external_package + && sym is Struct && !((Struct) sym).is_simple_type ()) { _dup_function = "%sdup".printf (lower_case_prefix); } dup_function_set = true; @@ -1012,7 +1013,7 @@ } return "%sfree".printf (lower_case_prefix); } else if (sym is Struct) { - if (!sym.external_package) { + if (!sym.external_package && !((Struct) sym).is_simple_type ()) { return "%sfree".printf (lower_case_prefix); } } diff -Nru vala-0.48.20/codegen/valaccodebasemodule.c vala-0.48.22/codegen/valaccodebasemodule.c --- vala-0.48.20/codegen/valaccodebasemodule.c 2021-12-02 13:42:48.000000000 +0000 +++ vala-0.48.22/codegen/valaccodebasemodule.c 2022-01-09 12:57:30.000000000 +0000 @@ -4656,14 +4656,13 @@ gchar* _tmp13_; gchar* _tmp14_; gchar* _tmp15_; - ValaCCodeModifiers _tmp16_; + ValaDataType* _tmp16_; ValaDataType* _tmp17_; - ValaDataType* _tmp18_; + ValaCCodeDeclaratorSuffix* _tmp18_; ValaCCodeDeclaratorSuffix* _tmp19_; - ValaCCodeDeclaratorSuffix* _tmp20_; - gboolean _tmp21_ = FALSE; + gboolean _tmp20_ = FALSE; + ValaDataType* _tmp21_; ValaDataType* _tmp22_; - ValaDataType* _tmp23_; g_return_if_fail (self != NULL); g_return_if_fail (ccode_struct != NULL); g_return_if_fail (f != NULL); @@ -4694,103 +4693,102 @@ _tmp13_ = _tmp12_; _tmp14_ = vala_get_ccode_name ((ValaCodeNode*) f); _tmp15_ = _tmp14_; - _tmp16_ = modifiers; - _tmp17_ = vala_variable_get_variable_type ((ValaVariable*) f); - _tmp18_ = _tmp17_; - _tmp19_ = vala_ccode_base_module_get_ccode_declarator_suffix (self, _tmp18_); - _tmp20_ = _tmp19_; - vala_ccode_struct_add_field (ccode_struct, _tmp13_, _tmp15_, _tmp16_, _tmp20_); - _vala_ccode_declarator_suffix_unref0 (_tmp20_); + _tmp16_ = vala_variable_get_variable_type ((ValaVariable*) f); + _tmp17_ = _tmp16_; + _tmp18_ = vala_ccode_base_module_get_ccode_declarator_suffix (self, _tmp17_); + _tmp19_ = _tmp18_; + vala_ccode_struct_add_field (ccode_struct, _tmp13_, _tmp15_, modifiers, _tmp19_); + _vala_ccode_declarator_suffix_unref0 (_tmp19_); _g_free0 (_tmp15_); _g_free0 (_tmp13_); - _tmp22_ = vala_variable_get_variable_type ((ValaVariable*) f); - _tmp23_ = _tmp22_; - if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp23_, VALA_TYPE_ARRAY_TYPE)) { - _tmp21_ = vala_get_ccode_array_length ((ValaCodeNode*) f); + _tmp21_ = vala_variable_get_variable_type ((ValaVariable*) f); + _tmp22_ = _tmp21_; + if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp22_, VALA_TYPE_ARRAY_TYPE)) { + _tmp20_ = vala_get_ccode_array_length ((ValaCodeNode*) f); } else { - _tmp21_ = FALSE; + _tmp20_ = FALSE; } - if (_tmp21_) { + if (_tmp20_) { ValaArrayType* array_type = NULL; + ValaDataType* _tmp23_; ValaDataType* _tmp24_; - ValaDataType* _tmp25_; + ValaArrayType* _tmp25_; ValaArrayType* _tmp26_; - ValaArrayType* _tmp27_; + gboolean _tmp27_; gboolean _tmp28_; - gboolean _tmp29_; - _tmp24_ = vala_variable_get_variable_type ((ValaVariable*) f); - _tmp25_ = _tmp24_; - _tmp26_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp25_, VALA_TYPE_ARRAY_TYPE, ValaArrayType)); - array_type = _tmp26_; - _tmp27_ = array_type; - _tmp28_ = vala_array_type_get_fixed_length (_tmp27_); - _tmp29_ = _tmp28_; - if (!_tmp29_) { + _tmp23_ = vala_variable_get_variable_type ((ValaVariable*) f); + _tmp24_ = _tmp23_; + _tmp25_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp24_, VALA_TYPE_ARRAY_TYPE, ValaArrayType)); + array_type = _tmp25_; + _tmp26_ = array_type; + _tmp27_ = vala_array_type_get_fixed_length (_tmp26_); + _tmp28_ = _tmp27_; + if (!_tmp28_) { gchar* length_ctype = NULL; - gchar* _tmp30_; - gboolean _tmp39_ = FALSE; - ValaArrayType* _tmp40_; + gchar* _tmp29_; + gboolean _tmp38_ = FALSE; + ValaArrayType* _tmp39_; + gint _tmp40_; gint _tmp41_; - gint _tmp42_; - _tmp30_ = vala_get_ccode_array_length_type ((ValaCodeNode*) f); - length_ctype = _tmp30_; + _tmp29_ = vala_get_ccode_array_length_type ((ValaCodeNode*) f); + length_ctype = _tmp29_; { gint dim = 0; dim = 1; { - gboolean _tmp31_ = FALSE; - _tmp31_ = TRUE; + gboolean _tmp30_ = FALSE; + _tmp30_ = TRUE; while (TRUE) { - ValaArrayType* _tmp33_; + ValaArrayType* _tmp32_; + gint _tmp33_; gint _tmp34_; - gint _tmp35_; gchar* length_cname = NULL; - gchar* _tmp36_; + gchar* _tmp35_; + const gchar* _tmp36_; const gchar* _tmp37_; - const gchar* _tmp38_; - if (!_tmp31_) { - gint _tmp32_; - _tmp32_ = dim; - dim = _tmp32_ + 1; - } - _tmp31_ = FALSE; - _tmp33_ = array_type; - _tmp34_ = vala_array_type_get_rank (_tmp33_); - _tmp35_ = _tmp34_; - if (!(dim <= _tmp35_)) { + if (!_tmp30_) { + gint _tmp31_; + _tmp31_ = dim; + dim = _tmp31_ + 1; + } + _tmp30_ = FALSE; + _tmp32_ = array_type; + _tmp33_ = vala_array_type_get_rank (_tmp32_); + _tmp34_ = _tmp33_; + if (!(dim <= _tmp34_)) { break; } - _tmp36_ = vala_ccode_base_module_get_variable_array_length_cname (self, (ValaVariable*) f, dim); - length_cname = _tmp36_; - _tmp37_ = length_ctype; - _tmp38_ = length_cname; - vala_ccode_struct_add_field (ccode_struct, _tmp37_, _tmp38_, 0, NULL); + _tmp35_ = vala_ccode_base_module_get_variable_array_length_cname (self, (ValaVariable*) f, dim); + length_cname = _tmp35_; + _tmp36_ = length_ctype; + _tmp37_ = length_cname; + vala_ccode_struct_add_field (ccode_struct, _tmp36_, _tmp37_, 0, NULL); _g_free0 (length_cname); } } } - _tmp40_ = array_type; - _tmp41_ = vala_array_type_get_rank (_tmp40_); - _tmp42_ = _tmp41_; - if (_tmp42_ == 1) { - _tmp39_ = vala_symbol_is_internal_symbol ((ValaSymbol*) f); + _tmp39_ = array_type; + _tmp40_ = vala_array_type_get_rank (_tmp39_); + _tmp41_ = _tmp40_; + if (_tmp41_ == 1) { + _tmp38_ = vala_symbol_is_internal_symbol ((ValaSymbol*) f); } else { - _tmp39_ = FALSE; + _tmp38_ = FALSE; } - if (_tmp39_) { - const gchar* _tmp43_; + if (_tmp38_) { + const gchar* _tmp42_; + gchar* _tmp43_; gchar* _tmp44_; gchar* _tmp45_; gchar* _tmp46_; - gchar* _tmp47_; - _tmp43_ = length_ctype; - _tmp44_ = vala_get_ccode_name ((ValaCodeNode*) f); - _tmp45_ = _tmp44_; - _tmp46_ = vala_ccode_base_module_get_array_size_cname (self, _tmp45_); - _tmp47_ = _tmp46_; - vala_ccode_struct_add_field (ccode_struct, _tmp43_, _tmp47_, 0, NULL); - _g_free0 (_tmp47_); - _g_free0 (_tmp45_); + _tmp42_ = length_ctype; + _tmp43_ = vala_get_ccode_name ((ValaCodeNode*) f); + _tmp44_ = _tmp43_; + _tmp45_ = vala_ccode_base_module_get_array_size_cname (self, _tmp44_); + _tmp46_ = _tmp45_; + vala_ccode_struct_add_field (ccode_struct, _tmp42_, _tmp46_, 0, NULL); + _g_free0 (_tmp46_); + _g_free0 (_tmp44_); } _g_free0 (length_ctype); } @@ -4798,53 +4796,53 @@ } else { if (vala_get_ccode_delegate_target ((ValaCodeNode*) f)) { ValaDelegateType* delegate_type = NULL; + ValaDataType* _tmp47_; ValaDataType* _tmp48_; - ValaDataType* _tmp49_; + ValaDelegateType* _tmp49_; ValaDelegateType* _tmp50_; - ValaDelegateType* _tmp51_; + ValaDelegate* _tmp51_; ValaDelegate* _tmp52_; - ValaDelegate* _tmp53_; + gboolean _tmp53_; gboolean _tmp54_; - gboolean _tmp55_; - _tmp48_ = vala_variable_get_variable_type ((ValaVariable*) f); - _tmp49_ = _tmp48_; - _tmp50_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp49_, VALA_TYPE_DELEGATE_TYPE, ValaDelegateType)); - delegate_type = _tmp50_; - _tmp51_ = delegate_type; - _tmp52_ = vala_delegate_type_get_delegate_symbol (_tmp51_); - _tmp53_ = _tmp52_; - _tmp54_ = vala_delegate_get_has_target (_tmp53_); - _tmp55_ = _tmp54_; - if (_tmp55_) { - ValaDataType* _tmp56_; + _tmp47_ = vala_variable_get_variable_type ((ValaVariable*) f); + _tmp48_ = _tmp47_; + _tmp49_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp48_, VALA_TYPE_DELEGATE_TYPE, ValaDelegateType)); + delegate_type = _tmp49_; + _tmp50_ = delegate_type; + _tmp51_ = vala_delegate_type_get_delegate_symbol (_tmp50_); + _tmp52_ = _tmp51_; + _tmp53_ = vala_delegate_get_has_target (_tmp52_); + _tmp54_ = _tmp53_; + if (_tmp54_) { + ValaDataType* _tmp55_; + gchar* _tmp56_; gchar* _tmp57_; gchar* _tmp58_; gchar* _tmp59_; - gchar* _tmp60_; - ValaDelegateType* _tmp61_; - _tmp56_ = self->delegate_target_type; - _tmp57_ = vala_get_ccode_name ((ValaCodeNode*) _tmp56_); - _tmp58_ = _tmp57_; - _tmp59_ = vala_get_ccode_delegate_target_name ((ValaVariable*) f); - _tmp60_ = _tmp59_; - vala_ccode_struct_add_field (ccode_struct, _tmp58_, _tmp60_, 0, NULL); - _g_free0 (_tmp60_); - _g_free0 (_tmp58_); - _tmp61_ = delegate_type; - if (vala_data_type_is_disposable ((ValaDataType*) _tmp61_)) { - ValaDelegateType* _tmp62_; + ValaDelegateType* _tmp60_; + _tmp55_ = self->delegate_target_type; + _tmp56_ = vala_get_ccode_name ((ValaCodeNode*) _tmp55_); + _tmp57_ = _tmp56_; + _tmp58_ = vala_get_ccode_delegate_target_name ((ValaVariable*) f); + _tmp59_ = _tmp58_; + vala_ccode_struct_add_field (ccode_struct, _tmp57_, _tmp59_, 0, NULL); + _g_free0 (_tmp59_); + _g_free0 (_tmp57_); + _tmp60_ = delegate_type; + if (vala_data_type_is_disposable ((ValaDataType*) _tmp60_)) { + ValaDelegateType* _tmp61_; + gchar* _tmp62_; gchar* _tmp63_; gchar* _tmp64_; gchar* _tmp65_; - gchar* _tmp66_; - _tmp62_ = self->delegate_target_destroy_type; - _tmp63_ = vala_get_ccode_name ((ValaCodeNode*) _tmp62_); - _tmp64_ = _tmp63_; - _tmp65_ = vala_get_ccode_delegate_target_destroy_notify_name ((ValaVariable*) f); - _tmp66_ = _tmp65_; - vala_ccode_struct_add_field (ccode_struct, _tmp64_, _tmp66_, 0, NULL); - _g_free0 (_tmp66_); - _g_free0 (_tmp64_); + _tmp61_ = self->delegate_target_destroy_type; + _tmp62_ = vala_get_ccode_name ((ValaCodeNode*) _tmp61_); + _tmp63_ = _tmp62_; + _tmp64_ = vala_get_ccode_delegate_target_destroy_notify_name ((ValaVariable*) f); + _tmp65_ = _tmp64_; + vala_ccode_struct_add_field (ccode_struct, _tmp63_, _tmp65_, 0, NULL); + _g_free0 (_tmp65_); + _g_free0 (_tmp63_); } } _vala_code_node_unref0 (delegate_type); @@ -25340,30 +25338,29 @@ ValaMemberAccess* _tmp2_; ValaMemberAccess* _tmp3_; ValaTargetValue* temp_value = NULL; + ValaExpression* _tmp31_; ValaExpression* _tmp32_; - ValaExpression* _tmp33_; + ValaTargetValue* _tmp33_; ValaTargetValue* _tmp34_; ValaTargetValue* _tmp35_; - ValaTargetValue* _tmp36_; - ValaCCodeBinaryOperator _tmp37_ = 0; + ValaCCodeBinaryOperator _tmp36_ = 0; + gboolean _tmp37_; gboolean _tmp38_; - gboolean _tmp39_; ValaCCodeBinaryOperator op = 0; ValaCCodeBinaryExpression* cexpr = NULL; - ValaCCodeBinaryOperator _tmp40_; - ValaTargetValue* _tmp41_; - ValaCCodeExpression* _tmp42_; - ValaCCodeConstant* _tmp43_; - ValaCCodeConstant* _tmp44_; - ValaCCodeBinaryExpression* _tmp45_; - ValaCCodeBinaryExpression* _tmp46_; - ValaCCodeFunction* _tmp47_; - ValaCCodeFunction* _tmp48_; - ValaExpression* _tmp49_; - ValaExpression* _tmp50_; - ValaCCodeExpression* _tmp51_; - ValaCCodeBinaryExpression* _tmp52_; - ValaTargetValue* _tmp53_; + ValaTargetValue* _tmp39_; + ValaCCodeExpression* _tmp40_; + ValaCCodeConstant* _tmp41_; + ValaCCodeConstant* _tmp42_; + ValaCCodeBinaryExpression* _tmp43_; + ValaCCodeBinaryExpression* _tmp44_; + ValaCCodeFunction* _tmp45_; + ValaCCodeFunction* _tmp46_; + ValaExpression* _tmp47_; + ValaExpression* _tmp48_; + ValaCCodeExpression* _tmp49_; + ValaCCodeBinaryExpression* _tmp50_; + ValaTargetValue* _tmp51_; self = (ValaCCodeBaseModule*) base; g_return_if_fail (expr != NULL); _tmp0_ = vala_postfix_expression_get_inner (expr); @@ -25382,27 +25379,26 @@ gboolean _tmp10_; ValaCCodeBinaryOperator op = 0; ValaCCodeBinaryExpression* cexpr = NULL; - ValaCCodeBinaryOperator _tmp11_; + ValaExpression* _tmp11_; ValaExpression* _tmp12_; - ValaExpression* _tmp13_; - ValaCCodeExpression* _tmp14_; + ValaCCodeExpression* _tmp13_; + ValaCCodeConstant* _tmp14_; ValaCCodeConstant* _tmp15_; - ValaCCodeConstant* _tmp16_; + ValaCCodeBinaryExpression* _tmp16_; ValaCCodeBinaryExpression* _tmp17_; - ValaCCodeBinaryExpression* _tmp18_; - ValaProperty* _tmp19_; - ValaMemberAccess* _tmp20_; + ValaProperty* _tmp18_; + ValaMemberAccess* _tmp19_; + ValaExpression* _tmp20_; ValaExpression* _tmp21_; - ValaExpression* _tmp22_; + ValaDataType* _tmp22_; ValaDataType* _tmp23_; - ValaDataType* _tmp24_; - ValaCCodeBinaryExpression* _tmp25_; + ValaCCodeBinaryExpression* _tmp24_; + ValaGLibValue* _tmp25_; ValaGLibValue* _tmp26_; - ValaGLibValue* _tmp27_; + ValaExpression* _tmp27_; ValaExpression* _tmp28_; - ValaExpression* _tmp29_; + ValaTargetValue* _tmp29_; ValaTargetValue* _tmp30_; - ValaTargetValue* _tmp31_; _tmp4_ = ma; _tmp5_ = vala_expression_get_symbol_reference ((ValaExpression*) _tmp4_); _tmp6_ = _tmp5_; @@ -25416,69 +25412,67 @@ _tmp8_ = VALA_CCODE_BINARY_OPERATOR_MINUS; } op = _tmp8_; - _tmp11_ = op; - _tmp12_ = vala_postfix_expression_get_inner (expr); - _tmp13_ = _tmp12_; - _tmp14_ = vala_get_cvalue (_tmp13_); - _tmp15_ = vala_ccode_constant_new ("1"); - _tmp16_ = _tmp15_; - _tmp17_ = vala_ccode_binary_expression_new (_tmp11_, _tmp14_, (ValaCCodeExpression*) _tmp16_); - _tmp18_ = _tmp17_; - _vala_ccode_node_unref0 (_tmp16_); - cexpr = _tmp18_; - _tmp19_ = prop; - _tmp20_ = ma; - _tmp21_ = vala_member_access_get_inner (_tmp20_); - _tmp22_ = _tmp21_; - _tmp23_ = vala_expression_get_value_type ((ValaExpression*) expr); - _tmp24_ = _tmp23_; - _tmp25_ = cexpr; - _tmp26_ = vala_glib_value_new (_tmp24_, (ValaCCodeExpression*) _tmp25_, FALSE); - _tmp27_ = _tmp26_; - vala_ccode_base_module_store_property (self, _tmp19_, _tmp22_, (ValaTargetValue*) _tmp27_); - _vala_target_value_unref0 (_tmp27_); - _tmp28_ = vala_postfix_expression_get_inner (expr); - _tmp29_ = _tmp28_; - _tmp30_ = vala_expression_get_target_value (_tmp29_); - _tmp31_ = _tmp30_; - vala_expression_set_target_value ((ValaExpression*) expr, _tmp31_); + _tmp11_ = vala_postfix_expression_get_inner (expr); + _tmp12_ = _tmp11_; + _tmp13_ = vala_get_cvalue (_tmp12_); + _tmp14_ = vala_ccode_constant_new ("1"); + _tmp15_ = _tmp14_; + _tmp16_ = vala_ccode_binary_expression_new (op, _tmp13_, (ValaCCodeExpression*) _tmp15_); + _tmp17_ = _tmp16_; + _vala_ccode_node_unref0 (_tmp15_); + cexpr = _tmp17_; + _tmp18_ = prop; + _tmp19_ = ma; + _tmp20_ = vala_member_access_get_inner (_tmp19_); + _tmp21_ = _tmp20_; + _tmp22_ = vala_expression_get_value_type ((ValaExpression*) expr); + _tmp23_ = _tmp22_; + _tmp24_ = cexpr; + _tmp25_ = vala_glib_value_new (_tmp23_, (ValaCCodeExpression*) _tmp24_, FALSE); + _tmp26_ = _tmp25_; + vala_ccode_base_module_store_property (self, _tmp18_, _tmp21_, (ValaTargetValue*) _tmp26_); + _vala_target_value_unref0 (_tmp26_); + _tmp27_ = vala_postfix_expression_get_inner (expr); + _tmp28_ = _tmp27_; + _tmp29_ = vala_expression_get_target_value (_tmp28_); + _tmp30_ = _tmp29_; + vala_expression_set_target_value ((ValaExpression*) expr, _tmp30_); _vala_ccode_node_unref0 (cexpr); _vala_code_node_unref0 (prop); _vala_code_node_unref0 (ma); return; } - _tmp32_ = vala_postfix_expression_get_inner (expr); - _tmp33_ = _tmp32_; - _tmp34_ = vala_expression_get_target_value (_tmp33_); - _tmp35_ = _tmp34_; - _tmp36_ = vala_ccode_base_module_store_temp_value (self, _tmp35_, (ValaCodeNode*) expr, NULL); - temp_value = _tmp36_; - _tmp38_ = vala_postfix_expression_get_increment (expr); - _tmp39_ = _tmp38_; - if (_tmp39_) { - _tmp37_ = VALA_CCODE_BINARY_OPERATOR_PLUS; + _tmp31_ = vala_postfix_expression_get_inner (expr); + _tmp32_ = _tmp31_; + _tmp33_ = vala_expression_get_target_value (_tmp32_); + _tmp34_ = _tmp33_; + _tmp35_ = vala_ccode_base_module_store_temp_value (self, _tmp34_, (ValaCodeNode*) expr, NULL); + temp_value = _tmp35_; + _tmp37_ = vala_postfix_expression_get_increment (expr); + _tmp38_ = _tmp37_; + if (_tmp38_) { + _tmp36_ = VALA_CCODE_BINARY_OPERATOR_PLUS; } else { - _tmp37_ = VALA_CCODE_BINARY_OPERATOR_MINUS; + _tmp36_ = VALA_CCODE_BINARY_OPERATOR_MINUS; } - op = _tmp37_; - _tmp40_ = op; - _tmp41_ = temp_value; - _tmp42_ = vala_get_cvalue_ (_tmp41_); - _tmp43_ = vala_ccode_constant_new ("1"); + op = _tmp36_; + _tmp39_ = temp_value; + _tmp40_ = vala_get_cvalue_ (_tmp39_); + _tmp41_ = vala_ccode_constant_new ("1"); + _tmp42_ = _tmp41_; + _tmp43_ = vala_ccode_binary_expression_new (op, _tmp40_, (ValaCCodeExpression*) _tmp42_); _tmp44_ = _tmp43_; - _tmp45_ = vala_ccode_binary_expression_new (_tmp40_, _tmp42_, (ValaCCodeExpression*) _tmp44_); + _vala_ccode_node_unref0 (_tmp42_); + cexpr = _tmp44_; + _tmp45_ = vala_ccode_base_module_get_ccode (self); _tmp46_ = _tmp45_; - _vala_ccode_node_unref0 (_tmp44_); - cexpr = _tmp46_; - _tmp47_ = vala_ccode_base_module_get_ccode (self); + _tmp47_ = vala_postfix_expression_get_inner (expr); _tmp48_ = _tmp47_; - _tmp49_ = vala_postfix_expression_get_inner (expr); - _tmp50_ = _tmp49_; - _tmp51_ = vala_get_cvalue (_tmp50_); - _tmp52_ = cexpr; - vala_ccode_function_add_assignment (_tmp48_, _tmp51_, (ValaCCodeExpression*) _tmp52_); - _tmp53_ = temp_value; - vala_expression_set_target_value ((ValaExpression*) expr, _tmp53_); + _tmp49_ = vala_get_cvalue (_tmp48_); + _tmp50_ = cexpr; + vala_ccode_function_add_assignment (_tmp46_, _tmp49_, (ValaCCodeExpression*) _tmp50_); + _tmp51_ = temp_value; + vala_expression_set_target_value ((ValaExpression*) expr, _tmp51_); _vala_ccode_node_unref0 (cexpr); _vala_target_value_unref0 (temp_value); _vala_code_node_unref0 (ma); @@ -26864,16 +26858,16 @@ gboolean _tmp4_ = FALSE; gboolean _tmp5_ = FALSE; ValaStruct* _tmp6_; - ValaSymbol* _tmp134_; - ValaSymbol* _tmp135_; + ValaSymbol* _tmp137_; + ValaSymbol* _tmp138_; ValaLocalVariable* local = NULL; - ValaCodeNode* _tmp655_; - ValaCodeNode* _tmp656_; - ValaLocalVariable* _tmp657_; - gboolean _tmp658_ = FALSE; - ValaLocalVariable* _tmp659_; - ValaTargetValue* _tmp894_; - ValaTargetValue* _tmp895_; + ValaCodeNode* _tmp662_; + ValaCodeNode* _tmp663_; + ValaLocalVariable* _tmp664_; + gboolean _tmp665_ = FALSE; + ValaLocalVariable* _tmp666_; + ValaTargetValue* _tmp901_; + ValaTargetValue* _tmp902_; self = (ValaCCodeBaseModule*) base; g_return_if_fail (expr != NULL); instance = NULL; @@ -27214,23 +27208,34 @@ } _vala_code_node_unref0 (param); } else { - ValaTargetValue* temp_value = NULL; - ValaDataType* _tmp128_; - ValaDataType* _tmp129_; - ValaTargetValue* _tmp130_; - ValaTargetValue* _tmp131_; - ValaCCodeExpression* _tmp132_; - ValaCCodeExpression* _tmp133_; - _tmp128_ = vala_object_creation_expression_get_type_reference (expr); + gboolean _tmp128_; + gboolean _tmp129_; + _tmp128_ = vala_object_creation_expression_get_is_chainup (expr); _tmp129_ = _tmp128_; - _tmp130_ = vala_ccode_base_module_create_temp_value (self, _tmp129_, TRUE, (ValaCodeNode*) expr, NULL); - temp_value = _tmp130_; - _tmp131_ = temp_value; - _tmp132_ = vala_get_cvalue_ (_tmp131_); - _tmp133_ = _vala_ccode_node_ref0 (_tmp132_); - _vala_ccode_node_unref0 (instance); - instance = _tmp133_; - _vala_target_value_unref0 (temp_value); + if (_tmp129_) { + ValaCCodeExpression* _tmp130_; + _tmp130_ = vala_ccode_base_module_get_this_cexpression (self); + _vala_ccode_node_unref0 (instance); + instance = _tmp130_; + } else { + ValaTargetValue* temp_value = NULL; + ValaDataType* _tmp131_; + ValaDataType* _tmp132_; + ValaTargetValue* _tmp133_; + ValaTargetValue* _tmp134_; + ValaCCodeExpression* _tmp135_; + ValaCCodeExpression* _tmp136_; + _tmp131_ = vala_object_creation_expression_get_type_reference (expr); + _tmp132_ = _tmp131_; + _tmp133_ = vala_ccode_base_module_create_temp_value (self, _tmp132_, TRUE, (ValaCodeNode*) expr, NULL); + temp_value = _tmp133_; + _tmp134_ = temp_value; + _tmp135_ = vala_get_cvalue_ (_tmp134_); + _tmp136_ = _vala_ccode_node_ref0 (_tmp135_); + _vala_ccode_node_unref0 (instance); + instance = _tmp136_; + _vala_target_value_unref0 (temp_value); + } } } } @@ -27238,502 +27243,514 @@ _vala_code_node_unref0 (field); _vala_code_node_unref0 (local); } - _tmp134_ = vala_expression_get_symbol_reference ((ValaExpression*) expr); - _tmp135_ = _tmp134_; - if (_tmp135_ == NULL) { - ValaDataType* _tmp136_; - ValaDataType* _tmp137_; - ValaTypeSymbol* _tmp138_; - ValaTypeSymbol* _tmp139_; - _tmp136_ = vala_object_creation_expression_get_type_reference (expr); - _tmp137_ = _tmp136_; - _tmp138_ = vala_data_type_get_type_symbol (_tmp137_); - _tmp139_ = _tmp138_; - if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp139_, VALA_TYPE_STRUCT)) { - ValaCCodeFile* _tmp140_; + _tmp137_ = vala_expression_get_symbol_reference ((ValaExpression*) expr); + _tmp138_ = _tmp137_; + if (_tmp138_ == NULL) { + ValaDataType* _tmp139_; + ValaDataType* _tmp140_; + ValaTypeSymbol* _tmp141_; + ValaTypeSymbol* _tmp142_; + _tmp139_ = vala_object_creation_expression_get_type_reference (expr); + _tmp140_ = _tmp139_; + _tmp141_ = vala_data_type_get_type_symbol (_tmp140_); + _tmp142_ = _tmp141_; + if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp142_, VALA_TYPE_STRUCT)) { + ValaCCodeFile* _tmp143_; ValaCCodeFunctionCall* creation_call = NULL; - ValaCCodeIdentifier* _tmp141_; - ValaCCodeIdentifier* _tmp142_; - ValaCCodeFunctionCall* _tmp143_; - ValaCCodeFunctionCall* _tmp144_; - ValaCCodeFunctionCall* _tmp145_; - ValaCCodeExpression* _tmp146_; - ValaCCodeUnaryExpression* _tmp147_; - ValaCCodeUnaryExpression* _tmp148_; - ValaCCodeFunctionCall* _tmp149_; - ValaCCodeConstant* _tmp150_; - ValaCCodeConstant* _tmp151_; + ValaCCodeIdentifier* _tmp144_; + ValaCCodeIdentifier* _tmp145_; + ValaCCodeFunctionCall* _tmp146_; + ValaCCodeFunctionCall* _tmp147_; + ValaCCodeFunctionCall* _tmp148_; + ValaCCodeExpression* _tmp149_; + ValaCCodeUnaryExpression* _tmp150_; + ValaCCodeUnaryExpression* _tmp151_; ValaCCodeFunctionCall* _tmp152_; - ValaDataType* _tmp153_; - ValaDataType* _tmp154_; - gchar* _tmp155_; - gchar* _tmp156_; - gchar* _tmp157_; + ValaCCodeConstant* _tmp153_; + ValaCCodeConstant* _tmp154_; + ValaCCodeFunctionCall* _tmp155_; + ValaDataType* _tmp156_; + ValaDataType* _tmp157_; gchar* _tmp158_; - ValaCCodeIdentifier* _tmp159_; - ValaCCodeIdentifier* _tmp160_; - ValaCCodeFunctionCall* _tmp161_; - ValaCCodeExpression* _tmp162_; - _tmp140_ = self->cfile; - vala_ccode_file_add_include (_tmp140_, "string.h", FALSE); - _tmp141_ = vala_ccode_identifier_new ("memset"); - _tmp142_ = _tmp141_; - _tmp143_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp142_); - _tmp144_ = _tmp143_; - _vala_ccode_node_unref0 (_tmp142_); - creation_call = _tmp144_; - _tmp145_ = creation_call; - _tmp146_ = instance; - _tmp147_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, _tmp146_); - _tmp148_ = _tmp147_; - vala_ccode_function_call_add_argument (_tmp145_, (ValaCCodeExpression*) _tmp148_); - _vala_ccode_node_unref0 (_tmp148_); - _tmp149_ = creation_call; - _tmp150_ = vala_ccode_constant_new ("0"); + gchar* _tmp159_; + gchar* _tmp160_; + gchar* _tmp161_; + ValaCCodeIdentifier* _tmp162_; + ValaCCodeIdentifier* _tmp163_; + ValaCCodeFunctionCall* _tmp164_; + ValaCCodeExpression* _tmp165_; + _tmp143_ = self->cfile; + vala_ccode_file_add_include (_tmp143_, "string.h", FALSE); + _tmp144_ = vala_ccode_identifier_new ("memset"); + _tmp145_ = _tmp144_; + _tmp146_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp145_); + _tmp147_ = _tmp146_; + _vala_ccode_node_unref0 (_tmp145_); + creation_call = _tmp147_; + _tmp148_ = creation_call; + _tmp149_ = instance; + _tmp150_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, _tmp149_); _tmp151_ = _tmp150_; - vala_ccode_function_call_add_argument (_tmp149_, (ValaCCodeExpression*) _tmp151_); + vala_ccode_function_call_add_argument (_tmp148_, (ValaCCodeExpression*) _tmp151_); _vala_ccode_node_unref0 (_tmp151_); _tmp152_ = creation_call; - _tmp153_ = vala_object_creation_expression_get_type_reference (expr); + _tmp153_ = vala_ccode_constant_new ("0"); _tmp154_ = _tmp153_; - _tmp155_ = vala_get_ccode_name ((ValaCodeNode*) _tmp154_); - _tmp156_ = _tmp155_; - _tmp157_ = g_strdup_printf ("sizeof (%s)", _tmp156_); - _tmp158_ = _tmp157_; - _tmp159_ = vala_ccode_identifier_new (_tmp158_); - _tmp160_ = _tmp159_; - vala_ccode_function_call_add_argument (_tmp152_, (ValaCCodeExpression*) _tmp160_); - _vala_ccode_node_unref0 (_tmp160_); - _g_free0 (_tmp158_); - _g_free0 (_tmp156_); - _tmp161_ = creation_call; - _tmp162_ = _vala_ccode_node_ref0 ((ValaCCodeExpression*) _tmp161_); + vala_ccode_function_call_add_argument (_tmp152_, (ValaCCodeExpression*) _tmp154_); + _vala_ccode_node_unref0 (_tmp154_); + _tmp155_ = creation_call; + _tmp156_ = vala_object_creation_expression_get_type_reference (expr); + _tmp157_ = _tmp156_; + _tmp158_ = vala_get_ccode_name ((ValaCodeNode*) _tmp157_); + _tmp159_ = _tmp158_; + _tmp160_ = g_strdup_printf ("sizeof (%s)", _tmp159_); + _tmp161_ = _tmp160_; + _tmp162_ = vala_ccode_identifier_new (_tmp161_); + _tmp163_ = _tmp162_; + vala_ccode_function_call_add_argument (_tmp155_, (ValaCCodeExpression*) _tmp163_); + _vala_ccode_node_unref0 (_tmp163_); + _g_free0 (_tmp161_); + _g_free0 (_tmp159_); + _tmp164_ = creation_call; + _tmp165_ = _vala_ccode_node_ref0 ((ValaCCodeExpression*) _tmp164_); _vala_ccode_node_unref0 (creation_expr); - creation_expr = _tmp162_; + creation_expr = _tmp165_; _vala_ccode_node_unref0 (creation_call); } } else { - gboolean _tmp163_ = FALSE; - ValaDataType* _tmp164_; - ValaDataType* _tmp165_; - ValaTypeSymbol* _tmp166_; - ValaTypeSymbol* _tmp167_; - ValaClass* _tmp168_; - _tmp164_ = vala_object_creation_expression_get_type_reference (expr); - _tmp165_ = _tmp164_; - _tmp166_ = vala_data_type_get_type_symbol (_tmp165_); - _tmp167_ = _tmp166_; - _tmp168_ = self->glist_type; - if (_tmp167_ == G_TYPE_CHECK_INSTANCE_CAST (_tmp168_, VALA_TYPE_TYPESYMBOL, ValaTypeSymbol)) { - _tmp163_ = TRUE; + gboolean _tmp166_ = FALSE; + ValaDataType* _tmp167_; + ValaDataType* _tmp168_; + ValaTypeSymbol* _tmp169_; + ValaTypeSymbol* _tmp170_; + ValaClass* _tmp171_; + _tmp167_ = vala_object_creation_expression_get_type_reference (expr); + _tmp168_ = _tmp167_; + _tmp169_ = vala_data_type_get_type_symbol (_tmp168_); + _tmp170_ = _tmp169_; + _tmp171_ = self->glist_type; + if (_tmp170_ == G_TYPE_CHECK_INSTANCE_CAST (_tmp171_, VALA_TYPE_TYPESYMBOL, ValaTypeSymbol)) { + _tmp166_ = TRUE; } else { - ValaDataType* _tmp169_; - ValaDataType* _tmp170_; - ValaTypeSymbol* _tmp171_; - ValaTypeSymbol* _tmp172_; - ValaClass* _tmp173_; - _tmp169_ = vala_object_creation_expression_get_type_reference (expr); - _tmp170_ = _tmp169_; - _tmp171_ = vala_data_type_get_type_symbol (_tmp170_); - _tmp172_ = _tmp171_; - _tmp173_ = self->gslist_type; - _tmp163_ = _tmp172_ == G_TYPE_CHECK_INSTANCE_CAST (_tmp173_, VALA_TYPE_TYPESYMBOL, ValaTypeSymbol); - } - if (_tmp163_) { - ValaCCodeConstant* _tmp174_; - ValaCCodeConstant* _tmp175_; - _tmp174_ = vala_ccode_constant_new ("NULL"); + ValaDataType* _tmp172_; + ValaDataType* _tmp173_; + ValaTypeSymbol* _tmp174_; + ValaTypeSymbol* _tmp175_; + ValaClass* _tmp176_; + _tmp172_ = vala_object_creation_expression_get_type_reference (expr); + _tmp173_ = _tmp172_; + _tmp174_ = vala_data_type_get_type_symbol (_tmp173_); _tmp175_ = _tmp174_; - vala_set_cvalue ((ValaExpression*) expr, (ValaCCodeExpression*) _tmp175_); - _vala_ccode_node_unref0 (_tmp175_); + _tmp176_ = self->gslist_type; + _tmp166_ = _tmp175_ == G_TYPE_CHECK_INSTANCE_CAST (_tmp176_, VALA_TYPE_TYPESYMBOL, ValaTypeSymbol); + } + if (_tmp166_) { + ValaCCodeConstant* _tmp177_; + ValaCCodeConstant* _tmp178_; + _tmp177_ = vala_ccode_constant_new ("NULL"); + _tmp178_ = _tmp177_; + vala_set_cvalue ((ValaExpression*) expr, (ValaCCodeExpression*) _tmp178_); + _vala_ccode_node_unref0 (_tmp178_); } else { - ValaSymbol* _tmp176_; - ValaSymbol* _tmp177_; - _tmp176_ = vala_expression_get_symbol_reference ((ValaExpression*) expr); - _tmp177_ = _tmp176_; - if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp177_, VALA_TYPE_METHOD)) { + ValaSymbol* _tmp179_; + ValaSymbol* _tmp180_; + _tmp179_ = vala_expression_get_symbol_reference ((ValaExpression*) expr); + _tmp180_ = _tmp179_; + if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp180_, VALA_TYPE_METHOD)) { ValaMethod* m = NULL; - ValaSymbol* _tmp178_; - ValaSymbol* _tmp179_; - ValaMethod* _tmp180_; + ValaSymbol* _tmp181_; + ValaSymbol* _tmp182_; + ValaMethod* _tmp183_; ValaList* params = NULL; - ValaMethod* _tmp181_; - ValaList* _tmp182_; - ValaList* _tmp183_; + ValaMethod* _tmp184_; + ValaList* _tmp185_; + ValaList* _tmp186_; ValaCCodeFunctionCall* creation_call = NULL; ValaCCodeFunctionCall* async_call = NULL; ValaCCodeFunctionCall* finish_call = NULL; - ValaMethod* _tmp184_; - ValaCCodeFile* _tmp185_; + ValaMethod* _tmp187_; + ValaCCodeFile* _tmp188_; ValaClass* cl = NULL; - ValaDataType* _tmp186_; - ValaDataType* _tmp187_; - ValaTypeSymbol* _tmp188_; - ValaTypeSymbol* _tmp189_; - ValaMethod* _tmp190_; - gboolean _tmp209_ = FALSE; - gboolean _tmp210_ = FALSE; - ValaStruct* _tmp211_; - ValaDataType* _tmp291_; - ValaDataType* _tmp292_; - ValaCCodeFile* _tmp293_; + ValaDataType* _tmp189_; + ValaDataType* _tmp190_; + ValaTypeSymbol* _tmp191_; + ValaTypeSymbol* _tmp192_; + ValaMethod* _tmp193_; + gboolean _tmp212_ = FALSE; + gboolean _tmp213_ = FALSE; + ValaStruct* _tmp214_; + ValaDataType* _tmp298_; + ValaDataType* _tmp299_; + ValaCCodeFile* _tmp300_; ValaHashMap* in_arg_map = NULL; - GHashFunc _tmp294_; - GEqualFunc _tmp295_; - GEqualFunc _tmp296_; - ValaHashMap* _tmp297_; + GHashFunc _tmp301_; + GEqualFunc _tmp302_; + GEqualFunc _tmp303_; + ValaHashMap* _tmp304_; ValaHashMap* out_arg_map = NULL; - ValaHashMap* _tmp298_; - ValaHashMap* _tmp299_; - gboolean _tmp300_ = FALSE; - ValaMethod* _tmp301_; - gboolean _tmp329_ = FALSE; - ValaClass* _tmp330_; + ValaHashMap* _tmp305_; + ValaHashMap* _tmp306_; + gboolean _tmp307_ = FALSE; + ValaMethod* _tmp308_; + gboolean _tmp336_ = FALSE; + ValaClass* _tmp337_; gboolean ellipsis = FALSE; gint i = 0; gint arg_pos = 0; ValaIterator* params_it = NULL; - ValaList* _tmp361_; - ValaIterator* _tmp362_; - ValaIterator* _tmp460_; - gboolean _tmp470_; - gboolean _tmp471_; - gboolean _tmp498_ = FALSE; - gboolean _tmp499_ = FALSE; - ValaStruct* _tmp500_; - gboolean _tmp507_ = FALSE; - ValaMethod* _tmp508_; - gboolean _tmp524_ = FALSE; - gboolean _tmp525_ = FALSE; - ValaMethod* _tmp526_; + ValaList* _tmp368_; + ValaIterator* _tmp369_; + ValaIterator* _tmp467_; + gboolean _tmp477_; + gboolean _tmp478_; + gboolean _tmp505_ = FALSE; + gboolean _tmp506_ = FALSE; + ValaStruct* _tmp507_; + gboolean _tmp514_ = FALSE; + ValaMethod* _tmp515_; + gboolean _tmp531_ = FALSE; + gboolean _tmp532_ = FALSE; + ValaMethod* _tmp533_; gint last_pos = 0; gint min_pos = 0; - ValaCCodeFunctionCall* _tmp541_; - ValaCCodeFunctionCall* _tmp542_; - ValaCCodeFunctionCall* _tmp557_; - gboolean _tmp572_; - gboolean _tmp573_; - ValaCCodeFunctionCall* _tmp597_; - ValaCCodeExpression* _tmp598_; - ValaMethod* _tmp599_; - gchar* _tmp600_; - gchar* _tmp601_; - gboolean _tmp602_; - _tmp178_ = vala_expression_get_symbol_reference ((ValaExpression*) expr); - _tmp179_ = _tmp178_; - _tmp180_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp179_, VALA_TYPE_METHOD, ValaMethod)); - m = _tmp180_; - _tmp181_ = m; - _tmp182_ = vala_callable_get_parameters ((ValaCallable*) _tmp181_); - _tmp183_ = _vala_iterable_ref0 (_tmp182_); - params = _tmp183_; + ValaCCodeFunctionCall* _tmp548_; + ValaCCodeFunctionCall* _tmp549_; + ValaCCodeFunctionCall* _tmp564_; + gboolean _tmp579_; + gboolean _tmp580_; + ValaCCodeFunctionCall* _tmp604_; + ValaCCodeExpression* _tmp605_; + ValaMethod* _tmp606_; + gchar* _tmp607_; + gchar* _tmp608_; + gboolean _tmp609_; + _tmp181_ = vala_expression_get_symbol_reference ((ValaExpression*) expr); + _tmp182_ = _tmp181_; + _tmp183_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp182_, VALA_TYPE_METHOD, ValaMethod)); + m = _tmp183_; + _tmp184_ = m; + _tmp185_ = vala_callable_get_parameters ((ValaCallable*) _tmp184_); + _tmp186_ = _vala_iterable_ref0 (_tmp185_); + params = _tmp186_; async_call = NULL; finish_call = NULL; - _tmp184_ = m; - _tmp185_ = self->cfile; - vala_ccode_base_module_generate_method_declaration (self, _tmp184_, _tmp185_); - _tmp186_ = vala_object_creation_expression_get_type_reference (expr); - _tmp187_ = _tmp186_; - _tmp188_ = vala_data_type_get_type_symbol (_tmp187_); - _tmp189_ = _tmp188_; - cl = G_TYPE_CHECK_INSTANCE_TYPE (_tmp189_, VALA_TYPE_CLASS) ? ((ValaClass*) _tmp189_) : NULL; - _tmp190_ = m; - if (!vala_get_ccode_has_new_function (_tmp190_)) { - ValaMethod* _tmp191_; - gchar* _tmp192_; - gchar* _tmp193_; - ValaCCodeIdentifier* _tmp194_; - ValaCCodeIdentifier* _tmp195_; - ValaCCodeFunctionCall* _tmp196_; - ValaCCodeFunctionCall* _tmp197_; - ValaClass* _tmp198_; - gchar* _tmp199_; - gchar* _tmp200_; - ValaCCodeIdentifier* _tmp201_; - ValaCCodeIdentifier* _tmp202_; - _tmp191_ = m; - _tmp192_ = vala_get_ccode_real_name ((ValaSymbol*) _tmp191_); - _tmp193_ = _tmp192_; - _tmp194_ = vala_ccode_identifier_new (_tmp193_); - _tmp195_ = _tmp194_; - _tmp196_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp195_); + _tmp187_ = m; + _tmp188_ = self->cfile; + vala_ccode_base_module_generate_method_declaration (self, _tmp187_, _tmp188_); + _tmp189_ = vala_object_creation_expression_get_type_reference (expr); + _tmp190_ = _tmp189_; + _tmp191_ = vala_data_type_get_type_symbol (_tmp190_); + _tmp192_ = _tmp191_; + cl = G_TYPE_CHECK_INSTANCE_TYPE (_tmp192_, VALA_TYPE_CLASS) ? ((ValaClass*) _tmp192_) : NULL; + _tmp193_ = m; + if (!vala_get_ccode_has_new_function (_tmp193_)) { + ValaMethod* _tmp194_; + gchar* _tmp195_; + gchar* _tmp196_; + ValaCCodeIdentifier* _tmp197_; + ValaCCodeIdentifier* _tmp198_; + ValaCCodeFunctionCall* _tmp199_; + ValaCCodeFunctionCall* _tmp200_; + ValaClass* _tmp201_; + gchar* _tmp202_; + gchar* _tmp203_; + ValaCCodeIdentifier* _tmp204_; + ValaCCodeIdentifier* _tmp205_; + _tmp194_ = m; + _tmp195_ = vala_get_ccode_real_name ((ValaSymbol*) _tmp194_); + _tmp196_ = _tmp195_; + _tmp197_ = vala_ccode_identifier_new (_tmp196_); + _tmp198_ = _tmp197_; + _tmp199_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp198_); _vala_ccode_node_unref0 (creation_call); - creation_call = _tmp196_; - _vala_ccode_node_unref0 (_tmp195_); - _g_free0 (_tmp193_); - _tmp197_ = creation_call; - _tmp198_ = cl; - _tmp199_ = vala_get_ccode_type_id ((ValaCodeNode*) _tmp198_); - _tmp200_ = _tmp199_; - _tmp201_ = vala_ccode_identifier_new (_tmp200_); - _tmp202_ = _tmp201_; - vala_ccode_function_call_add_argument (_tmp197_, (ValaCCodeExpression*) _tmp202_); - _vala_ccode_node_unref0 (_tmp202_); - _g_free0 (_tmp200_); - } else { - ValaMethod* _tmp203_; - gchar* _tmp204_; - gchar* _tmp205_; - ValaCCodeIdentifier* _tmp206_; - ValaCCodeIdentifier* _tmp207_; - ValaCCodeFunctionCall* _tmp208_; - _tmp203_ = m; - _tmp204_ = vala_get_ccode_name ((ValaCodeNode*) _tmp203_); + creation_call = _tmp199_; + _vala_ccode_node_unref0 (_tmp198_); + _g_free0 (_tmp196_); + _tmp200_ = creation_call; + _tmp201_ = cl; + _tmp202_ = vala_get_ccode_type_id ((ValaCodeNode*) _tmp201_); + _tmp203_ = _tmp202_; + _tmp204_ = vala_ccode_identifier_new (_tmp203_); _tmp205_ = _tmp204_; - _tmp206_ = vala_ccode_identifier_new (_tmp205_); - _tmp207_ = _tmp206_; - _tmp208_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp207_); - _vala_ccode_node_unref0 (creation_call); - creation_call = _tmp208_; - _vala_ccode_node_unref0 (_tmp207_); - _g_free0 (_tmp205_); - } - _tmp211_ = st; - if (_tmp211_ != NULL) { - ValaStruct* _tmp212_; - _tmp212_ = st; - _tmp210_ = !vala_struct_is_simple_type (_tmp212_); - } else { - _tmp210_ = FALSE; - } - if (_tmp210_) { - ValaMethod* _tmp213_; - _tmp213_ = m; - _tmp209_ = !(vala_get_ccode_instance_pos ((ValaCodeNode*) _tmp213_) < ((gdouble) 0)); - } else { - _tmp209_ = FALSE; - } - if (_tmp209_) { - ValaCCodeFunctionCall* _tmp214_; - ValaCCodeExpression* _tmp215_; - ValaCCodeUnaryExpression* _tmp216_; - ValaCCodeUnaryExpression* _tmp217_; - _tmp214_ = creation_call; - _tmp215_ = instance; - _tmp216_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, _tmp215_); - _tmp217_ = _tmp216_; - vala_ccode_function_call_add_argument (_tmp214_, (ValaCCodeExpression*) _tmp217_); - _vala_ccode_node_unref0 (_tmp217_); + vala_ccode_function_call_add_argument (_tmp200_, (ValaCCodeExpression*) _tmp205_); + _vala_ccode_node_unref0 (_tmp205_); + _g_free0 (_tmp203_); } else { - gboolean _tmp218_ = FALSE; - ValaStruct* _tmp219_; - _tmp219_ = st; - if (_tmp219_ != NULL) { - ValaStruct* _tmp220_; - gchar* _tmp221_; - gchar* _tmp222_; - _tmp220_ = st; - _tmp221_ = vala_get_ccode_name ((ValaCodeNode*) _tmp220_); - _tmp222_ = _tmp221_; - _tmp218_ = g_strcmp0 (_tmp222_, "va_list") == 0; - _g_free0 (_tmp222_); + ValaMethod* _tmp206_; + gchar* _tmp207_; + gchar* _tmp208_; + ValaCCodeIdentifier* _tmp209_; + ValaCCodeIdentifier* _tmp210_; + ValaCCodeFunctionCall* _tmp211_; + _tmp206_ = m; + _tmp207_ = vala_get_ccode_name ((ValaCodeNode*) _tmp206_); + _tmp208_ = _tmp207_; + _tmp209_ = vala_ccode_identifier_new (_tmp208_); + _tmp210_ = _tmp209_; + _tmp211_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp210_); + _vala_ccode_node_unref0 (creation_call); + creation_call = _tmp211_; + _vala_ccode_node_unref0 (_tmp210_); + _g_free0 (_tmp208_); + } + _tmp214_ = st; + if (_tmp214_ != NULL) { + ValaStruct* _tmp215_; + _tmp215_ = st; + _tmp213_ = !vala_struct_is_simple_type (_tmp215_); + } else { + _tmp213_ = FALSE; + } + if (_tmp213_) { + ValaMethod* _tmp216_; + _tmp216_ = m; + _tmp212_ = !(vala_get_ccode_instance_pos ((ValaCodeNode*) _tmp216_) < ((gdouble) 0)); + } else { + _tmp212_ = FALSE; + } + if (_tmp212_) { + gboolean _tmp217_; + gboolean _tmp218_; + _tmp217_ = vala_object_creation_expression_get_is_chainup (expr); + _tmp218_ = _tmp217_; + if (_tmp218_) { + ValaCCodeFunctionCall* _tmp219_; + ValaCCodeExpression* _tmp220_; + _tmp219_ = creation_call; + _tmp220_ = instance; + vala_ccode_function_call_add_argument (_tmp219_, _tmp220_); } else { - _tmp218_ = FALSE; + ValaCCodeFunctionCall* _tmp221_; + ValaCCodeExpression* _tmp222_; + ValaCCodeUnaryExpression* _tmp223_; + ValaCCodeUnaryExpression* _tmp224_; + _tmp221_ = creation_call; + _tmp222_ = instance; + _tmp223_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, _tmp222_); + _tmp224_ = _tmp223_; + vala_ccode_function_call_add_argument (_tmp221_, (ValaCCodeExpression*) _tmp224_); + _vala_ccode_node_unref0 (_tmp224_); + } + } else { + gboolean _tmp225_ = FALSE; + ValaStruct* _tmp226_; + _tmp226_ = st; + if (_tmp226_ != NULL) { + ValaStruct* _tmp227_; + gchar* _tmp228_; + gchar* _tmp229_; + _tmp227_ = st; + _tmp228_ = vala_get_ccode_name ((ValaCodeNode*) _tmp227_); + _tmp229_ = _tmp228_; + _tmp225_ = g_strcmp0 (_tmp229_, "va_list") == 0; + _g_free0 (_tmp229_); + } else { + _tmp225_ = FALSE; } - if (_tmp218_) { - ValaCCodeFunctionCall* _tmp223_; - ValaCCodeExpression* _tmp224_; - ValaMethod* _tmp225_; - gchar* _tmp226_; - gchar* _tmp227_; - gboolean _tmp228_; - _tmp223_ = creation_call; - _tmp224_ = instance; - vala_ccode_function_call_add_argument (_tmp223_, _tmp224_); - _tmp225_ = m; - _tmp226_ = vala_get_ccode_name ((ValaCodeNode*) _tmp225_); - _tmp227_ = _tmp226_; - _tmp228_ = g_strcmp0 (_tmp227_, "va_start") == 0; - _g_free0 (_tmp227_); - if (_tmp228_) { + if (_tmp225_) { + ValaCCodeFunctionCall* _tmp230_; + ValaCCodeExpression* _tmp231_; + ValaMethod* _tmp232_; + gchar* _tmp233_; + gchar* _tmp234_; + gboolean _tmp235_; + _tmp230_ = creation_call; + _tmp231_ = instance; + vala_ccode_function_call_add_argument (_tmp230_, _tmp231_); + _tmp232_ = m; + _tmp233_ = vala_get_ccode_name ((ValaCodeNode*) _tmp232_); + _tmp234_ = _tmp233_; + _tmp235_ = g_strcmp0 (_tmp234_, "va_start") == 0; + _g_free0 (_tmp234_); + if (_tmp235_) { ValaClass* parent = NULL; - ValaMethod* _tmp229_; - ValaMethod* _tmp230_; - ValaSymbol* _tmp231_; - ValaSymbol* _tmp232_; - gboolean _tmp233_ = FALSE; - gboolean _tmp234_ = FALSE; - gboolean _tmp235_; - gboolean _tmp236_; - _tmp229_ = vala_ccode_base_module_get_current_method (self); - _tmp230_ = _tmp229_; - _tmp231_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp230_); - _tmp232_ = _tmp231_; - parent = G_TYPE_CHECK_INSTANCE_TYPE (_tmp232_, VALA_TYPE_CLASS) ? ((ValaClass*) _tmp232_) : NULL; - _tmp235_ = vala_ccode_base_module_get_in_creation_method (self); - _tmp236_ = _tmp235_; - if (_tmp236_) { - ValaClass* _tmp237_; - _tmp237_ = parent; - _tmp234_ = _tmp237_ != NULL; + ValaMethod* _tmp236_; + ValaMethod* _tmp237_; + ValaSymbol* _tmp238_; + ValaSymbol* _tmp239_; + gboolean _tmp240_ = FALSE; + gboolean _tmp241_ = FALSE; + gboolean _tmp242_; + gboolean _tmp243_; + _tmp236_ = vala_ccode_base_module_get_current_method (self); + _tmp237_ = _tmp236_; + _tmp238_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp237_); + _tmp239_ = _tmp238_; + parent = G_TYPE_CHECK_INSTANCE_TYPE (_tmp239_, VALA_TYPE_CLASS) ? ((ValaClass*) _tmp239_) : NULL; + _tmp242_ = vala_ccode_base_module_get_in_creation_method (self); + _tmp243_ = _tmp242_; + if (_tmp243_) { + ValaClass* _tmp244_; + _tmp244_ = parent; + _tmp241_ = _tmp244_ != NULL; } else { - _tmp234_ = FALSE; + _tmp241_ = FALSE; } - if (_tmp234_) { - ValaClass* _tmp238_; - gboolean _tmp239_; - gboolean _tmp240_; - _tmp238_ = parent; - _tmp239_ = vala_class_get_is_compact (_tmp238_); - _tmp240_ = _tmp239_; - _tmp233_ = !_tmp240_; + if (_tmp241_) { + ValaClass* _tmp245_; + gboolean _tmp246_; + gboolean _tmp247_; + _tmp245_ = parent; + _tmp246_ = vala_class_get_is_compact (_tmp245_); + _tmp247_ = _tmp246_; + _tmp240_ = !_tmp247_; } else { - _tmp233_ = FALSE; + _tmp240_ = FALSE; } - if (_tmp233_) { - ValaCCodeIdentifier* _tmp241_; - ValaCCodeIdentifier* _tmp242_; - ValaCCodeFunctionCall* _tmp243_; - ValaCCodeFunctionCall* _tmp244_; - ValaCCodeExpression* _tmp245_; - ValaCCodeFunctionCall* _tmp246_; - ValaCCodeIdentifier* _tmp247_; + if (_tmp240_) { ValaCCodeIdentifier* _tmp248_; - _tmp241_ = vala_ccode_identifier_new ("va_copy"); - _tmp242_ = _tmp241_; - _tmp243_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp242_); + ValaCCodeIdentifier* _tmp249_; + ValaCCodeFunctionCall* _tmp250_; + ValaCCodeFunctionCall* _tmp251_; + ValaCCodeExpression* _tmp252_; + ValaCCodeFunctionCall* _tmp253_; + ValaCCodeIdentifier* _tmp254_; + ValaCCodeIdentifier* _tmp255_; + _tmp248_ = vala_ccode_identifier_new ("va_copy"); + _tmp249_ = _tmp248_; + _tmp250_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp249_); _vala_ccode_node_unref0 (creation_call); - creation_call = _tmp243_; - _vala_ccode_node_unref0 (_tmp242_); - _tmp244_ = creation_call; - _tmp245_ = instance; - vala_ccode_function_call_add_argument (_tmp244_, _tmp245_); - _tmp246_ = creation_call; - _tmp247_ = vala_ccode_identifier_new ("_vala_va_list"); - _tmp248_ = _tmp247_; - vala_ccode_function_call_add_argument (_tmp246_, (ValaCCodeExpression*) _tmp248_); - _vala_ccode_node_unref0 (_tmp248_); + creation_call = _tmp250_; + _vala_ccode_node_unref0 (_tmp249_); + _tmp251_ = creation_call; + _tmp252_ = instance; + vala_ccode_function_call_add_argument (_tmp251_, _tmp252_); + _tmp253_ = creation_call; + _tmp254_ = vala_ccode_identifier_new ("_vala_va_list"); + _tmp255_ = _tmp254_; + vala_ccode_function_call_add_argument (_tmp253_, (ValaCCodeExpression*) _tmp255_); + _vala_ccode_node_unref0 (_tmp255_); } else { ValaParameter* last_param = NULL; gint nParams = 0; - ValaCCodeFunction* _tmp269_; - ValaCCodeFunction* _tmp270_; - gboolean _tmp271_ = FALSE; + ValaCCodeFunction* _tmp276_; + ValaCCodeFunction* _tmp277_; + gboolean _tmp278_ = FALSE; last_param = NULL; { ValaList* _param_list = NULL; - ValaMethod* _tmp249_; - ValaMethod* _tmp250_; - ValaList* _tmp251_; - ValaList* _tmp252_; + ValaMethod* _tmp256_; + ValaMethod* _tmp257_; + ValaList* _tmp258_; + ValaList* _tmp259_; gint _param_size = 0; - ValaList* _tmp253_; - gint _tmp254_; - gint _tmp255_; + ValaList* _tmp260_; + gint _tmp261_; + gint _tmp262_; gint _param_index = 0; - _tmp249_ = vala_ccode_base_module_get_current_method (self); - _tmp250_ = _tmp249_; - _tmp251_ = vala_callable_get_parameters ((ValaCallable*) _tmp250_); - _tmp252_ = _vala_iterable_ref0 (_tmp251_); - _param_list = _tmp252_; - _tmp253_ = _param_list; - _tmp254_ = vala_collection_get_size ((ValaCollection*) _tmp253_); - _tmp255_ = _tmp254_; - _param_size = _tmp255_; + _tmp256_ = vala_ccode_base_module_get_current_method (self); + _tmp257_ = _tmp256_; + _tmp258_ = vala_callable_get_parameters ((ValaCallable*) _tmp257_); + _tmp259_ = _vala_iterable_ref0 (_tmp258_); + _param_list = _tmp259_; + _tmp260_ = _param_list; + _tmp261_ = vala_collection_get_size ((ValaCollection*) _tmp260_); + _tmp262_ = _tmp261_; + _param_size = _tmp262_; _param_index = -1; while (TRUE) { - gint _tmp256_; - gint _tmp257_; + gint _tmp263_; + gint _tmp264_; ValaParameter* param = NULL; - ValaList* _tmp258_; - gpointer _tmp259_; - gboolean _tmp260_ = FALSE; - ValaParameter* _tmp261_; - gboolean _tmp262_; - gboolean _tmp263_; - ValaParameter* _tmp267_; + ValaList* _tmp265_; + gpointer _tmp266_; + gboolean _tmp267_ = FALSE; ValaParameter* _tmp268_; + gboolean _tmp269_; + gboolean _tmp270_; + ValaParameter* _tmp274_; + ValaParameter* _tmp275_; _param_index = _param_index + 1; - _tmp256_ = _param_index; - _tmp257_ = _param_size; - if (!(_tmp256_ < _tmp257_)) { + _tmp263_ = _param_index; + _tmp264_ = _param_size; + if (!(_tmp263_ < _tmp264_)) { break; } - _tmp258_ = _param_list; - _tmp259_ = vala_list_get (_tmp258_, _param_index); - param = (ValaParameter*) _tmp259_; - _tmp261_ = param; - _tmp262_ = vala_parameter_get_ellipsis (_tmp261_); - _tmp263_ = _tmp262_; - if (_tmp263_) { - _tmp260_ = TRUE; + _tmp265_ = _param_list; + _tmp266_ = vala_list_get (_tmp265_, _param_index); + param = (ValaParameter*) _tmp266_; + _tmp268_ = param; + _tmp269_ = vala_parameter_get_ellipsis (_tmp268_); + _tmp270_ = _tmp269_; + if (_tmp270_) { + _tmp267_ = TRUE; } else { - ValaParameter* _tmp264_; - gboolean _tmp265_; - gboolean _tmp266_; - _tmp264_ = param; - _tmp265_ = vala_parameter_get_params_array (_tmp264_); - _tmp266_ = _tmp265_; - _tmp260_ = _tmp266_; + ValaParameter* _tmp271_; + gboolean _tmp272_; + gboolean _tmp273_; + _tmp271_ = param; + _tmp272_ = vala_parameter_get_params_array (_tmp271_); + _tmp273_ = _tmp272_; + _tmp267_ = _tmp273_; } - if (_tmp260_) { + if (_tmp267_) { _vala_code_node_unref0 (param); break; } - _tmp267_ = param; - _tmp268_ = _vala_code_node_ref0 (_tmp267_); + _tmp274_ = param; + _tmp275_ = _vala_code_node_ref0 (_tmp274_); _vala_code_node_unref0 (last_param); - last_param = _tmp268_; + last_param = _tmp275_; _vala_code_node_unref0 (param); } _vala_iterable_unref0 (_param_list); } - _tmp269_ = vala_ccode_base_module_get_ccode (self); - _tmp270_ = _tmp269_; - nParams = vala_ccode_function_get_parameter_count (_tmp270_); + _tmp276_ = vala_ccode_base_module_get_ccode (self); + _tmp277_ = _tmp276_; + nParams = vala_ccode_function_get_parameter_count (_tmp277_); if (nParams == 0) { - _tmp271_ = TRUE; + _tmp278_ = TRUE; } else { - ValaCCodeFunction* _tmp272_; - ValaCCodeFunction* _tmp273_; - ValaCCodeParameter* _tmp274_; - ValaCCodeParameter* _tmp275_; - gboolean _tmp276_; - gboolean _tmp277_; - _tmp272_ = vala_ccode_base_module_get_ccode (self); - _tmp273_ = _tmp272_; - _tmp274_ = vala_ccode_function_get_parameter (_tmp273_, nParams - 1); - _tmp275_ = _tmp274_; - _tmp276_ = vala_ccode_parameter_get_ellipsis (_tmp275_); - _tmp277_ = _tmp276_; - _tmp271_ = !_tmp277_; - _vala_ccode_node_unref0 (_tmp275_); + ValaCCodeFunction* _tmp279_; + ValaCCodeFunction* _tmp280_; + ValaCCodeParameter* _tmp281_; + ValaCCodeParameter* _tmp282_; + gboolean _tmp283_; + gboolean _tmp284_; + _tmp279_ = vala_ccode_base_module_get_ccode (self); + _tmp280_ = _tmp279_; + _tmp281_ = vala_ccode_function_get_parameter (_tmp280_, nParams - 1); + _tmp282_ = _tmp281_; + _tmp283_ = vala_ccode_parameter_get_ellipsis (_tmp282_); + _tmp284_ = _tmp283_; + _tmp278_ = !_tmp284_; + _vala_ccode_node_unref0 (_tmp282_); } - if (_tmp271_) { - ValaSourceReference* _tmp278_; - ValaSourceReference* _tmp279_; - _tmp278_ = vala_code_node_get_source_reference ((ValaCodeNode*) expr); - _tmp279_ = _tmp278_; - vala_report_error (_tmp279_, "`va_list' used in method with fixed args"); + if (_tmp278_) { + ValaSourceReference* _tmp285_; + ValaSourceReference* _tmp286_; + _tmp285_ = vala_code_node_get_source_reference ((ValaCodeNode*) expr); + _tmp286_ = _tmp285_; + vala_report_error (_tmp286_, "`va_list' used in method with fixed args"); } else { if (nParams == 1) { - ValaSourceReference* _tmp280_; - ValaSourceReference* _tmp281_; - _tmp280_ = vala_code_node_get_source_reference ((ValaCodeNode*) expr); - _tmp281_ = _tmp280_; - vala_report_error (_tmp281_, "`va_list' used in method without parameter"); - } else { - ValaCCodeFunctionCall* _tmp282_; - ValaCCodeFunction* _tmp283_; - ValaCCodeFunction* _tmp284_; - ValaCCodeParameter* _tmp285_; - ValaCCodeParameter* _tmp286_; - const gchar* _tmp287_; - const gchar* _tmp288_; - ValaCCodeIdentifier* _tmp289_; - ValaCCodeIdentifier* _tmp290_; - _tmp282_ = creation_call; - _tmp283_ = vala_ccode_base_module_get_ccode (self); - _tmp284_ = _tmp283_; - _tmp285_ = vala_ccode_function_get_parameter (_tmp284_, nParams - 2); - _tmp286_ = _tmp285_; - _tmp287_ = vala_ccode_parameter_get_name (_tmp286_); + ValaSourceReference* _tmp287_; + ValaSourceReference* _tmp288_; + _tmp287_ = vala_code_node_get_source_reference ((ValaCodeNode*) expr); _tmp288_ = _tmp287_; - _tmp289_ = vala_ccode_identifier_new (_tmp288_); - _tmp290_ = _tmp289_; - vala_ccode_function_call_add_argument (_tmp282_, (ValaCCodeExpression*) _tmp290_); - _vala_ccode_node_unref0 (_tmp290_); - _vala_ccode_node_unref0 (_tmp286_); + vala_report_error (_tmp288_, "`va_list' used in method without parameter"); + } else { + ValaCCodeFunctionCall* _tmp289_; + ValaCCodeFunction* _tmp290_; + ValaCCodeFunction* _tmp291_; + ValaCCodeParameter* _tmp292_; + ValaCCodeParameter* _tmp293_; + const gchar* _tmp294_; + const gchar* _tmp295_; + ValaCCodeIdentifier* _tmp296_; + ValaCCodeIdentifier* _tmp297_; + _tmp289_ = creation_call; + _tmp290_ = vala_ccode_base_module_get_ccode (self); + _tmp291_ = _tmp290_; + _tmp292_ = vala_ccode_function_get_parameter (_tmp291_, nParams - 2); + _tmp293_ = _tmp292_; + _tmp294_ = vala_ccode_parameter_get_name (_tmp293_); + _tmp295_ = _tmp294_; + _tmp296_ = vala_ccode_identifier_new (_tmp295_); + _tmp297_ = _tmp296_; + vala_ccode_function_call_add_argument (_tmp289_, (ValaCCodeExpression*) _tmp297_); + _vala_ccode_node_unref0 (_tmp297_); + _vala_ccode_node_unref0 (_tmp293_); } } _vala_code_node_unref0 (last_param); @@ -27741,193 +27758,193 @@ } } } - _tmp291_ = vala_object_creation_expression_get_type_reference (expr); - _tmp292_ = _tmp291_; - _tmp293_ = self->cfile; - vala_ccode_base_module_generate_type_declaration (self, _tmp292_, _tmp293_); - _tmp294_ = g_direct_hash; - _tmp295_ = g_direct_equal; - _tmp296_ = g_direct_equal; - _tmp297_ = vala_hash_map_new (G_TYPE_INT, NULL, NULL, VALA_TYPE_CCODE_EXPRESSION, (GBoxedCopyFunc) vala_ccode_node_ref, (GDestroyNotify) vala_ccode_node_unref, _tmp294_, _tmp295_, _tmp296_); - in_arg_map = _tmp297_; - _tmp298_ = in_arg_map; - _tmp299_ = _vala_map_ref0 (_tmp298_); - out_arg_map = _tmp299_; - _tmp301_ = m; - if (_tmp301_ != NULL) { - ValaMethod* _tmp302_; - gboolean _tmp303_; - gboolean _tmp304_; - _tmp302_ = m; - _tmp303_ = vala_method_get_coroutine (_tmp302_); - _tmp304_ = _tmp303_; - _tmp300_ = _tmp304_; - } else { - _tmp300_ = FALSE; - } - if (_tmp300_) { - ValaMethod* _tmp305_; - gchar* _tmp306_; - gchar* _tmp307_; - ValaCCodeIdentifier* _tmp308_; - ValaCCodeIdentifier* _tmp309_; - ValaCCodeFunctionCall* _tmp310_; - ValaMethod* _tmp311_; - gchar* _tmp312_; + _tmp298_ = vala_object_creation_expression_get_type_reference (expr); + _tmp299_ = _tmp298_; + _tmp300_ = self->cfile; + vala_ccode_base_module_generate_type_declaration (self, _tmp299_, _tmp300_); + _tmp301_ = g_direct_hash; + _tmp302_ = g_direct_equal; + _tmp303_ = g_direct_equal; + _tmp304_ = vala_hash_map_new (G_TYPE_INT, NULL, NULL, VALA_TYPE_CCODE_EXPRESSION, (GBoxedCopyFunc) vala_ccode_node_ref, (GDestroyNotify) vala_ccode_node_unref, _tmp301_, _tmp302_, _tmp303_); + in_arg_map = _tmp304_; + _tmp305_ = in_arg_map; + _tmp306_ = _vala_map_ref0 (_tmp305_); + out_arg_map = _tmp306_; + _tmp308_ = m; + if (_tmp308_ != NULL) { + ValaMethod* _tmp309_; + gboolean _tmp310_; + gboolean _tmp311_; + _tmp309_ = m; + _tmp310_ = vala_method_get_coroutine (_tmp309_); + _tmp311_ = _tmp310_; + _tmp307_ = _tmp311_; + } else { + _tmp307_ = FALSE; + } + if (_tmp307_) { + ValaMethod* _tmp312_; gchar* _tmp313_; - ValaCCodeIdentifier* _tmp314_; + gchar* _tmp314_; ValaCCodeIdentifier* _tmp315_; - ValaCCodeFunctionCall* _tmp316_; + ValaCCodeIdentifier* _tmp316_; ValaCCodeFunctionCall* _tmp317_; - ValaCCodeFunctionCall* _tmp318_; - GHashFunc _tmp319_; - GEqualFunc _tmp320_; - GEqualFunc _tmp321_; - ValaHashMap* _tmp322_; - ValaHashMap* _tmp323_; - ValaMethod* _tmp324_; - ValaCCodeIdentifier* _tmp325_; - ValaCCodeIdentifier* _tmp326_; - ValaCCodeMemberAccess* _tmp327_; - ValaCCodeMemberAccess* _tmp328_; - _tmp305_ = m; - _tmp306_ = vala_get_ccode_name ((ValaCodeNode*) _tmp305_); - _tmp307_ = _tmp306_; - _tmp308_ = vala_ccode_identifier_new (_tmp307_); - _tmp309_ = _tmp308_; - _tmp310_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp309_); + ValaMethod* _tmp318_; + gchar* _tmp319_; + gchar* _tmp320_; + ValaCCodeIdentifier* _tmp321_; + ValaCCodeIdentifier* _tmp322_; + ValaCCodeFunctionCall* _tmp323_; + ValaCCodeFunctionCall* _tmp324_; + ValaCCodeFunctionCall* _tmp325_; + GHashFunc _tmp326_; + GEqualFunc _tmp327_; + GEqualFunc _tmp328_; + ValaHashMap* _tmp329_; + ValaHashMap* _tmp330_; + ValaMethod* _tmp331_; + ValaCCodeIdentifier* _tmp332_; + ValaCCodeIdentifier* _tmp333_; + ValaCCodeMemberAccess* _tmp334_; + ValaCCodeMemberAccess* _tmp335_; + _tmp312_ = m; + _tmp313_ = vala_get_ccode_name ((ValaCodeNode*) _tmp312_); + _tmp314_ = _tmp313_; + _tmp315_ = vala_ccode_identifier_new (_tmp314_); + _tmp316_ = _tmp315_; + _tmp317_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp316_); _vala_ccode_node_unref0 (async_call); - async_call = _tmp310_; - _vala_ccode_node_unref0 (_tmp309_); - _g_free0 (_tmp307_); - _tmp311_ = m; - _tmp312_ = vala_get_ccode_finish_name (_tmp311_); - _tmp313_ = _tmp312_; - _tmp314_ = vala_ccode_identifier_new (_tmp313_); - _tmp315_ = _tmp314_; - _tmp316_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp315_); + async_call = _tmp317_; + _vala_ccode_node_unref0 (_tmp316_); + _g_free0 (_tmp314_); + _tmp318_ = m; + _tmp319_ = vala_get_ccode_finish_name (_tmp318_); + _tmp320_ = _tmp319_; + _tmp321_ = vala_ccode_identifier_new (_tmp320_); + _tmp322_ = _tmp321_; + _tmp323_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp322_); _vala_ccode_node_unref0 (finish_call); - finish_call = _tmp316_; - _vala_ccode_node_unref0 (_tmp315_); - _g_free0 (_tmp313_); - _tmp317_ = finish_call; - _tmp318_ = _vala_ccode_node_ref0 (_tmp317_); + finish_call = _tmp323_; + _vala_ccode_node_unref0 (_tmp322_); + _g_free0 (_tmp320_); + _tmp324_ = finish_call; + _tmp325_ = _vala_ccode_node_ref0 (_tmp324_); _vala_ccode_node_unref0 (creation_call); - creation_call = _tmp318_; - _tmp319_ = g_direct_hash; - _tmp320_ = g_direct_equal; - _tmp321_ = g_direct_equal; - _tmp322_ = vala_hash_map_new (G_TYPE_INT, NULL, NULL, VALA_TYPE_CCODE_EXPRESSION, (GBoxedCopyFunc) vala_ccode_node_ref, (GDestroyNotify) vala_ccode_node_unref, _tmp319_, _tmp320_, _tmp321_); + creation_call = _tmp325_; + _tmp326_ = g_direct_hash; + _tmp327_ = g_direct_equal; + _tmp328_ = g_direct_equal; + _tmp329_ = vala_hash_map_new (G_TYPE_INT, NULL, NULL, VALA_TYPE_CCODE_EXPRESSION, (GBoxedCopyFunc) vala_ccode_node_ref, (GDestroyNotify) vala_ccode_node_unref, _tmp326_, _tmp327_, _tmp328_); _vala_map_unref0 (out_arg_map); - out_arg_map = _tmp322_; - _tmp323_ = out_arg_map; - _tmp324_ = m; - _tmp325_ = vala_ccode_identifier_new ("_data_"); - _tmp326_ = _tmp325_; - _tmp327_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp326_, "_res_"); - _tmp328_ = _tmp327_; - vala_map_set ((ValaMap*) _tmp323_, (gpointer) ((gintptr) vala_ccode_base_module_get_param_pos (self, vala_get_ccode_async_result_pos (_tmp324_), FALSE)), (ValaCCodeExpression*) _tmp328_); - _vala_ccode_node_unref0 (_tmp328_); - _vala_ccode_node_unref0 (_tmp326_); - } - _tmp330_ = cl; - if (_tmp330_ != NULL) { - ValaClass* _tmp331_; - gboolean _tmp332_; - gboolean _tmp333_; - _tmp331_ = cl; - _tmp332_ = vala_class_get_is_compact (_tmp331_); + out_arg_map = _tmp329_; + _tmp330_ = out_arg_map; + _tmp331_ = m; + _tmp332_ = vala_ccode_identifier_new ("_data_"); _tmp333_ = _tmp332_; - _tmp329_ = !_tmp333_; - } else { - _tmp329_ = FALSE; - } - if (_tmp329_) { - ValaHashMap* _tmp334_; - ValaDataType* _tmp335_; - ValaDataType* _tmp336_; - ValaList* _tmp337_; - _tmp334_ = in_arg_map; - _tmp335_ = vala_object_creation_expression_get_type_reference (expr); - _tmp336_ = _tmp335_; - _tmp337_ = vala_data_type_get_type_arguments (_tmp336_); - vala_ccode_base_module_add_generic_type_arguments (self, (ValaMap*) _tmp334_, _tmp337_, (ValaCodeNode*) expr, FALSE, NULL); - } else { - gboolean _tmp338_ = FALSE; - ValaClass* _tmp339_; - _tmp339_ = cl; - if (_tmp339_ != NULL) { - ValaMethod* _tmp340_; - _tmp340_ = m; - _tmp338_ = vala_get_ccode_simple_generics (_tmp340_); + _tmp334_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp333_, "_res_"); + _tmp335_ = _tmp334_; + vala_map_set ((ValaMap*) _tmp330_, (gpointer) ((gintptr) vala_ccode_base_module_get_param_pos (self, vala_get_ccode_async_result_pos (_tmp331_), FALSE)), (ValaCCodeExpression*) _tmp335_); + _vala_ccode_node_unref0 (_tmp335_); + _vala_ccode_node_unref0 (_tmp333_); + } + _tmp337_ = cl; + if (_tmp337_ != NULL) { + ValaClass* _tmp338_; + gboolean _tmp339_; + gboolean _tmp340_; + _tmp338_ = cl; + _tmp339_ = vala_class_get_is_compact (_tmp338_); + _tmp340_ = _tmp339_; + _tmp336_ = !_tmp340_; + } else { + _tmp336_ = FALSE; + } + if (_tmp336_) { + ValaHashMap* _tmp341_; + ValaDataType* _tmp342_; + ValaDataType* _tmp343_; + ValaList* _tmp344_; + _tmp341_ = in_arg_map; + _tmp342_ = vala_object_creation_expression_get_type_reference (expr); + _tmp343_ = _tmp342_; + _tmp344_ = vala_data_type_get_type_arguments (_tmp343_); + vala_ccode_base_module_add_generic_type_arguments (self, (ValaMap*) _tmp341_, _tmp344_, (ValaCodeNode*) expr, FALSE, NULL); + } else { + gboolean _tmp345_ = FALSE; + ValaClass* _tmp346_; + _tmp346_ = cl; + if (_tmp346_ != NULL) { + ValaMethod* _tmp347_; + _tmp347_ = m; + _tmp345_ = vala_get_ccode_simple_generics (_tmp347_); } else { - _tmp338_ = FALSE; + _tmp345_ = FALSE; } - if (_tmp338_) { + if (_tmp345_) { gint type_param_index = 0; type_param_index = 0; { ValaList* _type_arg_list = NULL; - ValaDataType* _tmp341_; - ValaDataType* _tmp342_; - ValaList* _tmp343_; - ValaList* _tmp344_; + ValaDataType* _tmp348_; + ValaDataType* _tmp349_; + ValaList* _tmp350_; + ValaList* _tmp351_; gint _type_arg_size = 0; - ValaList* _tmp345_; - gint _tmp346_; - gint _tmp347_; + ValaList* _tmp352_; + gint _tmp353_; + gint _tmp354_; gint _type_arg_index = 0; - _tmp341_ = vala_object_creation_expression_get_type_reference (expr); - _tmp342_ = _tmp341_; - _tmp343_ = vala_data_type_get_type_arguments (_tmp342_); - _tmp344_ = _vala_iterable_ref0 (_tmp343_); - _type_arg_list = _tmp344_; - _tmp345_ = _type_arg_list; - _tmp346_ = vala_collection_get_size ((ValaCollection*) _tmp345_); - _tmp347_ = _tmp346_; - _type_arg_size = _tmp347_; + _tmp348_ = vala_object_creation_expression_get_type_reference (expr); + _tmp349_ = _tmp348_; + _tmp350_ = vala_data_type_get_type_arguments (_tmp349_); + _tmp351_ = _vala_iterable_ref0 (_tmp350_); + _type_arg_list = _tmp351_; + _tmp352_ = _type_arg_list; + _tmp353_ = vala_collection_get_size ((ValaCollection*) _tmp352_); + _tmp354_ = _tmp353_; + _type_arg_size = _tmp354_; _type_arg_index = -1; while (TRUE) { - gint _tmp348_; - gint _tmp349_; + gint _tmp355_; + gint _tmp356_; ValaDataType* type_arg = NULL; - ValaList* _tmp350_; - gpointer _tmp351_; - ValaDataType* _tmp352_; - gint _tmp360_; + ValaList* _tmp357_; + gpointer _tmp358_; + ValaDataType* _tmp359_; + gint _tmp367_; _type_arg_index = _type_arg_index + 1; - _tmp348_ = _type_arg_index; - _tmp349_ = _type_arg_size; - if (!(_tmp348_ < _tmp349_)) { + _tmp355_ = _type_arg_index; + _tmp356_ = _type_arg_size; + if (!(_tmp355_ < _tmp356_)) { break; } - _tmp350_ = _type_arg_list; - _tmp351_ = vala_list_get (_tmp350_, _type_arg_index); - type_arg = (ValaDataType*) _tmp351_; - _tmp352_ = type_arg; - if (vala_ccode_base_module_requires_copy (_tmp352_)) { - ValaHashMap* _tmp353_; - ValaDataType* _tmp354_; - ValaCCodeExpression* _tmp355_; - ValaCCodeExpression* _tmp356_; - _tmp353_ = in_arg_map; - _tmp354_ = type_arg; - _tmp355_ = vala_ccode_base_module_get_destroy0_func_expression (self, _tmp354_, FALSE); - _tmp356_ = _tmp355_; - vala_map_set ((ValaMap*) _tmp353_, (gpointer) ((gintptr) vala_ccode_base_module_get_param_pos (self, (-1 + (0.1 * type_param_index)) + 0.03, FALSE)), _tmp356_); - _vala_ccode_node_unref0 (_tmp356_); + _tmp357_ = _type_arg_list; + _tmp358_ = vala_list_get (_tmp357_, _type_arg_index); + type_arg = (ValaDataType*) _tmp358_; + _tmp359_ = type_arg; + if (vala_ccode_base_module_requires_copy (_tmp359_)) { + ValaHashMap* _tmp360_; + ValaDataType* _tmp361_; + ValaCCodeExpression* _tmp362_; + ValaCCodeExpression* _tmp363_; + _tmp360_ = in_arg_map; + _tmp361_ = type_arg; + _tmp362_ = vala_ccode_base_module_get_destroy0_func_expression (self, _tmp361_, FALSE); + _tmp363_ = _tmp362_; + vala_map_set ((ValaMap*) _tmp360_, (gpointer) ((gintptr) vala_ccode_base_module_get_param_pos (self, (-1 + (0.1 * type_param_index)) + 0.03, FALSE)), _tmp363_); + _vala_ccode_node_unref0 (_tmp363_); } else { - ValaHashMap* _tmp357_; - ValaCCodeConstant* _tmp358_; - ValaCCodeConstant* _tmp359_; - _tmp357_ = in_arg_map; - _tmp358_ = vala_ccode_constant_new ("NULL"); - _tmp359_ = _tmp358_; - vala_map_set ((ValaMap*) _tmp357_, (gpointer) ((gintptr) vala_ccode_base_module_get_param_pos (self, (-1 + (0.1 * type_param_index)) + 0.03, FALSE)), (ValaCCodeExpression*) _tmp359_); - _vala_ccode_node_unref0 (_tmp359_); + ValaHashMap* _tmp364_; + ValaCCodeConstant* _tmp365_; + ValaCCodeConstant* _tmp366_; + _tmp364_ = in_arg_map; + _tmp365_ = vala_ccode_constant_new ("NULL"); + _tmp366_ = _tmp365_; + vala_map_set ((ValaMap*) _tmp364_, (gpointer) ((gintptr) vala_ccode_base_module_get_param_pos (self, (-1 + (0.1 * type_param_index)) + 0.03, FALSE)), (ValaCCodeExpression*) _tmp366_); + _vala_ccode_node_unref0 (_tmp366_); } - _tmp360_ = type_param_index; - type_param_index = _tmp360_ + 1; + _tmp367_ = type_param_index; + type_param_index = _tmp367_ + 1; _vala_code_node_unref0 (type_arg); } _vala_iterable_unref0 (_type_arg_list); @@ -27936,245 +27953,245 @@ } ellipsis = FALSE; i = 1; - _tmp361_ = params; - _tmp362_ = vala_iterable_iterator ((ValaIterable*) _tmp361_); - params_it = _tmp362_; + _tmp368_ = params; + _tmp369_ = vala_iterable_iterator ((ValaIterable*) _tmp368_); + params_it = _tmp369_; { ValaList* _arg_list = NULL; - ValaList* _tmp363_; - ValaList* _tmp364_; + ValaList* _tmp370_; + ValaList* _tmp371_; gint _arg_size = 0; - ValaList* _tmp365_; - gint _tmp366_; - gint _tmp367_; + ValaList* _tmp372_; + gint _tmp373_; + gint _tmp374_; gint _arg_index = 0; - _tmp363_ = vala_object_creation_expression_get_argument_list (expr); - _tmp364_ = _vala_iterable_ref0 (_tmp363_); - _arg_list = _tmp364_; - _tmp365_ = _arg_list; - _tmp366_ = vala_collection_get_size ((ValaCollection*) _tmp365_); - _tmp367_ = _tmp366_; - _arg_size = _tmp367_; + _tmp370_ = vala_object_creation_expression_get_argument_list (expr); + _tmp371_ = _vala_iterable_ref0 (_tmp370_); + _arg_list = _tmp371_; + _tmp372_ = _arg_list; + _tmp373_ = vala_collection_get_size ((ValaCollection*) _tmp372_); + _tmp374_ = _tmp373_; + _arg_size = _tmp374_; _arg_index = -1; while (TRUE) { - gint _tmp368_; - gint _tmp369_; + gint _tmp375_; + gint _tmp376_; ValaExpression* arg = NULL; - ValaList* _tmp370_; - gpointer _tmp371_; + ValaList* _tmp377_; + gpointer _tmp378_; ValaCCodeExpression* cexpr = NULL; - ValaExpression* _tmp372_; - ValaCCodeExpression* _tmp373_; - ValaCCodeExpression* _tmp374_; + ValaExpression* _tmp379_; + ValaCCodeExpression* _tmp380_; + ValaCCodeExpression* _tmp381_; ValaHashMap* carg_map = NULL; - ValaHashMap* _tmp375_; - ValaHashMap* _tmp376_; + ValaHashMap* _tmp382_; + ValaHashMap* _tmp383_; ValaParameter* param = NULL; - ValaIterator* _tmp377_; - ValaHashMap* _tmp457_; - ValaCCodeExpression* _tmp458_; - gint _tmp459_; + ValaIterator* _tmp384_; + ValaHashMap* _tmp464_; + ValaCCodeExpression* _tmp465_; + gint _tmp466_; _arg_index = _arg_index + 1; - _tmp368_ = _arg_index; - _tmp369_ = _arg_size; - if (!(_tmp368_ < _tmp369_)) { + _tmp375_ = _arg_index; + _tmp376_ = _arg_size; + if (!(_tmp375_ < _tmp376_)) { break; } - _tmp370_ = _arg_list; - _tmp371_ = vala_list_get (_tmp370_, _arg_index); - arg = (ValaExpression*) _tmp371_; - _tmp372_ = arg; - _tmp373_ = vala_get_cvalue (_tmp372_); - _tmp374_ = _vala_ccode_node_ref0 (_tmp373_); - cexpr = _tmp374_; - _tmp375_ = in_arg_map; - _tmp376_ = _vala_map_ref0 (_tmp375_); - carg_map = _tmp376_; + _tmp377_ = _arg_list; + _tmp378_ = vala_list_get (_tmp377_, _arg_index); + arg = (ValaExpression*) _tmp378_; + _tmp379_ = arg; + _tmp380_ = vala_get_cvalue (_tmp379_); + _tmp381_ = _vala_ccode_node_ref0 (_tmp380_); + cexpr = _tmp381_; + _tmp382_ = in_arg_map; + _tmp383_ = _vala_map_ref0 (_tmp382_); + carg_map = _tmp383_; param = NULL; - _tmp377_ = params_it; - if (vala_iterator_next (_tmp377_)) { - ValaIterator* _tmp378_; - gpointer _tmp379_; - gboolean _tmp380_ = FALSE; - ValaParameter* _tmp381_; - gboolean _tmp382_; - gboolean _tmp383_; - ValaParameter* _tmp453_; - _tmp378_ = params_it; - _tmp379_ = vala_iterator_get (_tmp378_); + _tmp384_ = params_it; + if (vala_iterator_next (_tmp384_)) { + ValaIterator* _tmp385_; + gpointer _tmp386_; + gboolean _tmp387_ = FALSE; + ValaParameter* _tmp388_; + gboolean _tmp389_; + gboolean _tmp390_; + ValaParameter* _tmp460_; + _tmp385_ = params_it; + _tmp386_ = vala_iterator_get (_tmp385_); _vala_code_node_unref0 (param); - param = (ValaParameter*) _tmp379_; - _tmp381_ = param; - _tmp382_ = vala_parameter_get_ellipsis (_tmp381_); - _tmp383_ = _tmp382_; - if (_tmp383_) { - _tmp380_ = TRUE; + param = (ValaParameter*) _tmp386_; + _tmp388_ = param; + _tmp389_ = vala_parameter_get_ellipsis (_tmp388_); + _tmp390_ = _tmp389_; + if (_tmp390_) { + _tmp387_ = TRUE; } else { - ValaParameter* _tmp384_; - gboolean _tmp385_; - gboolean _tmp386_; - _tmp384_ = param; - _tmp385_ = vala_parameter_get_params_array (_tmp384_); - _tmp386_ = _tmp385_; - _tmp380_ = _tmp386_; + ValaParameter* _tmp391_; + gboolean _tmp392_; + gboolean _tmp393_; + _tmp391_ = param; + _tmp392_ = vala_parameter_get_params_array (_tmp391_); + _tmp393_ = _tmp392_; + _tmp387_ = _tmp393_; } - ellipsis = _tmp380_; + ellipsis = _tmp387_; if (!ellipsis) { - ValaParameter* _tmp387_; - ValaParameterDirection _tmp388_; - ValaParameterDirection _tmp389_; - gboolean _tmp392_ = FALSE; - ValaParameter* _tmp393_; - ValaParameter* _tmp437_; - ValaExpression* _tmp438_; - ValaCCodeExpression* _tmp439_; - ValaCCodeExpression* _tmp440_; - ValaParameter* _tmp441_; - gchar* _tmp442_; - gchar* _tmp443_; - gboolean _tmp444_; - _tmp387_ = param; - _tmp388_ = vala_parameter_get_direction (_tmp387_); - _tmp389_ = _tmp388_; - if (_tmp389_ == VALA_PARAMETER_DIRECTION_OUT) { - ValaHashMap* _tmp390_; - ValaHashMap* _tmp391_; - _tmp390_ = out_arg_map; - _tmp391_ = _vala_map_ref0 (_tmp390_); + ValaParameter* _tmp394_; + ValaParameterDirection _tmp395_; + ValaParameterDirection _tmp396_; + gboolean _tmp399_ = FALSE; + ValaParameter* _tmp400_; + ValaParameter* _tmp444_; + ValaExpression* _tmp445_; + ValaCCodeExpression* _tmp446_; + ValaCCodeExpression* _tmp447_; + ValaParameter* _tmp448_; + gchar* _tmp449_; + gchar* _tmp450_; + gboolean _tmp451_; + _tmp394_ = param; + _tmp395_ = vala_parameter_get_direction (_tmp394_); + _tmp396_ = _tmp395_; + if (_tmp396_ == VALA_PARAMETER_DIRECTION_OUT) { + ValaHashMap* _tmp397_; + ValaHashMap* _tmp398_; + _tmp397_ = out_arg_map; + _tmp398_ = _vala_map_ref0 (_tmp397_); _vala_map_unref0 (carg_map); - carg_map = _tmp391_; + carg_map = _tmp398_; } - _tmp393_ = param; - if (vala_get_ccode_array_length ((ValaCodeNode*) _tmp393_)) { - ValaParameter* _tmp394_; - ValaDataType* _tmp395_; - ValaDataType* _tmp396_; - _tmp394_ = param; - _tmp395_ = vala_variable_get_variable_type ((ValaVariable*) _tmp394_); - _tmp396_ = _tmp395_; - _tmp392_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp396_, VALA_TYPE_ARRAY_TYPE); + _tmp400_ = param; + if (vala_get_ccode_array_length ((ValaCodeNode*) _tmp400_)) { + ValaParameter* _tmp401_; + ValaDataType* _tmp402_; + ValaDataType* _tmp403_; + _tmp401_ = param; + _tmp402_ = vala_variable_get_variable_type ((ValaVariable*) _tmp401_); + _tmp403_ = _tmp402_; + _tmp399_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp403_, VALA_TYPE_ARRAY_TYPE); } else { - _tmp392_ = FALSE; + _tmp399_ = FALSE; } - if (_tmp392_) { + if (_tmp399_) { ValaArrayType* array_type = NULL; - ValaParameter* _tmp397_; - ValaDataType* _tmp398_; - ValaDataType* _tmp399_; - ValaArrayType* _tmp400_; - _tmp397_ = param; - _tmp398_ = vala_variable_get_variable_type ((ValaVariable*) _tmp397_); - _tmp399_ = _tmp398_; - _tmp400_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp399_, VALA_TYPE_ARRAY_TYPE, ValaArrayType)); - array_type = _tmp400_; + ValaParameter* _tmp404_; + ValaDataType* _tmp405_; + ValaDataType* _tmp406_; + ValaArrayType* _tmp407_; + _tmp404_ = param; + _tmp405_ = vala_variable_get_variable_type ((ValaVariable*) _tmp404_); + _tmp406_ = _tmp405_; + _tmp407_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp406_, VALA_TYPE_ARRAY_TYPE, ValaArrayType)); + array_type = _tmp407_; { gint dim = 0; dim = 1; { - gboolean _tmp401_ = FALSE; - _tmp401_ = TRUE; + gboolean _tmp408_ = FALSE; + _tmp408_ = TRUE; while (TRUE) { - ValaArrayType* _tmp403_; - gint _tmp404_; - gint _tmp405_; - ValaHashMap* _tmp406_; - ValaParameter* _tmp407_; - ValaExpression* _tmp408_; - ValaCCodeExpression* _tmp409_; - ValaCCodeExpression* _tmp410_; - if (!_tmp401_) { - gint _tmp402_; - _tmp402_ = dim; - dim = _tmp402_ + 1; + ValaArrayType* _tmp410_; + gint _tmp411_; + gint _tmp412_; + ValaHashMap* _tmp413_; + ValaParameter* _tmp414_; + ValaExpression* _tmp415_; + ValaCCodeExpression* _tmp416_; + ValaCCodeExpression* _tmp417_; + if (!_tmp408_) { + gint _tmp409_; + _tmp409_ = dim; + dim = _tmp409_ + 1; } - _tmp401_ = FALSE; - _tmp403_ = array_type; - _tmp404_ = vala_array_type_get_rank (_tmp403_); - _tmp405_ = _tmp404_; - if (!(dim <= _tmp405_)) { + _tmp408_ = FALSE; + _tmp410_ = array_type; + _tmp411_ = vala_array_type_get_rank (_tmp410_); + _tmp412_ = _tmp411_; + if (!(dim <= _tmp412_)) { break; } - _tmp406_ = carg_map; - _tmp407_ = param; - _tmp408_ = arg; - _tmp409_ = vala_ccode_base_module_get_array_length_cexpression (self, _tmp408_, dim); - _tmp410_ = _tmp409_; - vala_map_set ((ValaMap*) _tmp406_, (gpointer) ((gintptr) vala_ccode_base_module_get_param_pos (self, vala_get_ccode_array_length_pos ((ValaCodeNode*) _tmp407_) + (0.01 * dim), FALSE)), _tmp410_); - _vala_ccode_node_unref0 (_tmp410_); + _tmp413_ = carg_map; + _tmp414_ = param; + _tmp415_ = arg; + _tmp416_ = vala_ccode_base_module_get_array_length_cexpression (self, _tmp415_, dim); + _tmp417_ = _tmp416_; + vala_map_set ((ValaMap*) _tmp413_, (gpointer) ((gintptr) vala_ccode_base_module_get_param_pos (self, vala_get_ccode_array_length_pos ((ValaCodeNode*) _tmp414_) + (0.01 * dim), FALSE)), _tmp417_); + _vala_ccode_node_unref0 (_tmp417_); } } } _vala_code_node_unref0 (array_type); } else { - gboolean _tmp411_ = FALSE; - ValaParameter* _tmp412_; - _tmp412_ = param; - if (vala_get_ccode_delegate_target ((ValaCodeNode*) _tmp412_)) { - ValaParameter* _tmp413_; - ValaDataType* _tmp414_; - ValaDataType* _tmp415_; - _tmp413_ = param; - _tmp414_ = vala_variable_get_variable_type ((ValaVariable*) _tmp413_); - _tmp415_ = _tmp414_; - _tmp411_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp415_, VALA_TYPE_DELEGATE_TYPE); + gboolean _tmp418_ = FALSE; + ValaParameter* _tmp419_; + _tmp419_ = param; + if (vala_get_ccode_delegate_target ((ValaCodeNode*) _tmp419_)) { + ValaParameter* _tmp420_; + ValaDataType* _tmp421_; + ValaDataType* _tmp422_; + _tmp420_ = param; + _tmp421_ = vala_variable_get_variable_type ((ValaVariable*) _tmp420_); + _tmp422_ = _tmp421_; + _tmp418_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp422_, VALA_TYPE_DELEGATE_TYPE); } else { - _tmp411_ = FALSE; + _tmp418_ = FALSE; } - if (_tmp411_) { + if (_tmp418_) { ValaDelegateType* deleg_type = NULL; - ValaParameter* _tmp416_; - ValaDataType* _tmp417_; - ValaDataType* _tmp418_; - ValaDelegateType* _tmp419_; + ValaParameter* _tmp423_; + ValaDataType* _tmp424_; + ValaDataType* _tmp425_; + ValaDelegateType* _tmp426_; ValaDelegate* d = NULL; - ValaDelegateType* _tmp420_; - ValaDelegate* _tmp421_; - ValaDelegate* _tmp422_; - ValaDelegate* _tmp423_; - ValaDelegate* _tmp424_; - gboolean _tmp425_; - gboolean _tmp426_; - _tmp416_ = param; - _tmp417_ = vala_variable_get_variable_type ((ValaVariable*) _tmp416_); - _tmp418_ = _tmp417_; - _tmp419_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp418_, VALA_TYPE_DELEGATE_TYPE, ValaDelegateType)); - deleg_type = _tmp419_; - _tmp420_ = deleg_type; - _tmp421_ = vala_delegate_type_get_delegate_symbol (_tmp420_); - _tmp422_ = _tmp421_; - _tmp423_ = _vala_code_node_ref0 (_tmp422_); - d = _tmp423_; - _tmp424_ = d; - _tmp425_ = vala_delegate_get_has_target (_tmp424_); - _tmp426_ = _tmp425_; - if (_tmp426_) { + ValaDelegateType* _tmp427_; + ValaDelegate* _tmp428_; + ValaDelegate* _tmp429_; + ValaDelegate* _tmp430_; + ValaDelegate* _tmp431_; + gboolean _tmp432_; + gboolean _tmp433_; + _tmp423_ = param; + _tmp424_ = vala_variable_get_variable_type ((ValaVariable*) _tmp423_); + _tmp425_ = _tmp424_; + _tmp426_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp425_, VALA_TYPE_DELEGATE_TYPE, ValaDelegateType)); + deleg_type = _tmp426_; + _tmp427_ = deleg_type; + _tmp428_ = vala_delegate_type_get_delegate_symbol (_tmp427_); + _tmp429_ = _tmp428_; + _tmp430_ = _vala_code_node_ref0 (_tmp429_); + d = _tmp430_; + _tmp431_ = d; + _tmp432_ = vala_delegate_get_has_target (_tmp431_); + _tmp433_ = _tmp432_; + if (_tmp433_) { ValaCCodeExpression* delegate_target_destroy_notify = NULL; ValaCCodeExpression* delegate_target = NULL; - ValaExpression* _tmp427_; - ValaCCodeExpression* _tmp428_ = NULL; - ValaCCodeExpression* _tmp429_; - ValaHashMap* _tmp430_; - ValaParameter* _tmp431_; - ValaCCodeExpression* _tmp432_; - ValaDelegateType* _tmp433_; - _tmp427_ = arg; - _tmp429_ = vala_ccode_base_module_get_delegate_target_cexpression (self, _tmp427_, &_tmp428_); + ValaExpression* _tmp434_; + ValaCCodeExpression* _tmp435_ = NULL; + ValaCCodeExpression* _tmp436_; + ValaHashMap* _tmp437_; + ValaParameter* _tmp438_; + ValaCCodeExpression* _tmp439_; + ValaDelegateType* _tmp440_; + _tmp434_ = arg; + _tmp436_ = vala_ccode_base_module_get_delegate_target_cexpression (self, _tmp434_, &_tmp435_); _vala_ccode_node_unref0 (delegate_target_destroy_notify); - delegate_target_destroy_notify = _tmp428_; - delegate_target = _tmp429_; - _tmp430_ = carg_map; - _tmp431_ = param; - _tmp432_ = delegate_target; - vala_map_set ((ValaMap*) _tmp430_, (gpointer) ((gintptr) vala_ccode_base_module_get_param_pos (self, vala_get_ccode_delegate_target_pos ((ValaCodeNode*) _tmp431_), FALSE)), _tmp432_); - _tmp433_ = deleg_type; - if (vala_data_type_is_disposable ((ValaDataType*) _tmp433_)) { - ValaHashMap* _tmp434_; - ValaParameter* _tmp435_; - ValaCCodeExpression* _tmp436_; - _tmp434_ = carg_map; - _tmp435_ = param; - _tmp436_ = delegate_target_destroy_notify; - vala_map_set ((ValaMap*) _tmp434_, (gpointer) ((gintptr) vala_ccode_base_module_get_param_pos (self, vala_get_ccode_destroy_notify_pos ((ValaCodeNode*) _tmp435_), FALSE)), _tmp436_); + delegate_target_destroy_notify = _tmp435_; + delegate_target = _tmp436_; + _tmp437_ = carg_map; + _tmp438_ = param; + _tmp439_ = delegate_target; + vala_map_set ((ValaMap*) _tmp437_, (gpointer) ((gintptr) vala_ccode_base_module_get_param_pos (self, vala_get_ccode_delegate_target_pos ((ValaCodeNode*) _tmp438_), FALSE)), _tmp439_); + _tmp440_ = deleg_type; + if (vala_data_type_is_disposable ((ValaDataType*) _tmp440_)) { + ValaHashMap* _tmp441_; + ValaParameter* _tmp442_; + ValaCCodeExpression* _tmp443_; + _tmp441_ = carg_map; + _tmp442_ = param; + _tmp443_ = delegate_target_destroy_notify; + vala_map_set ((ValaMap*) _tmp441_, (gpointer) ((gintptr) vala_ccode_base_module_get_param_pos (self, vala_get_ccode_destroy_notify_pos ((ValaCodeNode*) _tmp442_), FALSE)), _tmp443_); } _vala_ccode_node_unref0 (delegate_target); _vala_ccode_node_unref0 (delegate_target_destroy_notify); @@ -28183,60 +28200,60 @@ _vala_code_node_unref0 (deleg_type); } } - _tmp437_ = param; - _tmp438_ = arg; - _tmp439_ = cexpr; - _tmp440_ = vala_ccode_base_module_handle_struct_argument (self, _tmp437_, _tmp438_, _tmp439_); + _tmp444_ = param; + _tmp445_ = arg; + _tmp446_ = cexpr; + _tmp447_ = vala_ccode_base_module_handle_struct_argument (self, _tmp444_, _tmp445_, _tmp446_); _vala_ccode_node_unref0 (cexpr); - cexpr = _tmp440_; - _tmp441_ = param; - _tmp442_ = vala_get_ccode_type ((ValaCodeNode*) _tmp441_); - _tmp443_ = _tmp442_; - _tmp444_ = _tmp443_ != NULL; - _g_free0 (_tmp443_); - if (_tmp444_) { - ValaCCodeExpression* _tmp445_; - ValaParameter* _tmp446_; - gchar* _tmp447_; - gchar* _tmp448_; - ValaCCodeCastExpression* _tmp449_; - _tmp445_ = cexpr; - _tmp446_ = param; - _tmp447_ = vala_get_ccode_type ((ValaCodeNode*) _tmp446_); - _tmp448_ = _tmp447_; - _tmp449_ = vala_ccode_cast_expression_new (_tmp445_, _tmp448_); + cexpr = _tmp447_; + _tmp448_ = param; + _tmp449_ = vala_get_ccode_type ((ValaCodeNode*) _tmp448_); + _tmp450_ = _tmp449_; + _tmp451_ = _tmp450_ != NULL; + _g_free0 (_tmp450_); + if (_tmp451_) { + ValaCCodeExpression* _tmp452_; + ValaParameter* _tmp453_; + gchar* _tmp454_; + gchar* _tmp455_; + ValaCCodeCastExpression* _tmp456_; + _tmp452_ = cexpr; + _tmp453_ = param; + _tmp454_ = vala_get_ccode_type ((ValaCodeNode*) _tmp453_); + _tmp455_ = _tmp454_; + _tmp456_ = vala_ccode_cast_expression_new (_tmp452_, _tmp455_); _vala_ccode_node_unref0 (cexpr); - cexpr = (ValaCCodeExpression*) _tmp449_; - _g_free0 (_tmp448_); + cexpr = (ValaCCodeExpression*) _tmp456_; + _g_free0 (_tmp455_); } } else { - ValaExpression* _tmp450_; - ValaCCodeExpression* _tmp451_; - ValaCCodeExpression* _tmp452_; - _tmp450_ = arg; - _tmp451_ = cexpr; - _tmp452_ = vala_ccode_base_module_handle_struct_argument (self, NULL, _tmp450_, _tmp451_); + ValaExpression* _tmp457_; + ValaCCodeExpression* _tmp458_; + ValaCCodeExpression* _tmp459_; + _tmp457_ = arg; + _tmp458_ = cexpr; + _tmp459_ = vala_ccode_base_module_handle_struct_argument (self, NULL, _tmp457_, _tmp458_); _vala_ccode_node_unref0 (cexpr); - cexpr = _tmp452_; + cexpr = _tmp459_; } - _tmp453_ = param; - arg_pos = vala_ccode_base_module_get_param_pos (self, vala_get_ccode_pos (_tmp453_), ellipsis); + _tmp460_ = param; + arg_pos = vala_ccode_base_module_get_param_pos (self, vala_get_ccode_pos (_tmp460_), ellipsis); } else { - ValaExpression* _tmp454_; - ValaCCodeExpression* _tmp455_; - ValaCCodeExpression* _tmp456_; - _tmp454_ = arg; - _tmp455_ = cexpr; - _tmp456_ = vala_ccode_base_module_handle_struct_argument (self, NULL, _tmp454_, _tmp455_); + ValaExpression* _tmp461_; + ValaCCodeExpression* _tmp462_; + ValaCCodeExpression* _tmp463_; + _tmp461_ = arg; + _tmp462_ = cexpr; + _tmp463_ = vala_ccode_base_module_handle_struct_argument (self, NULL, _tmp461_, _tmp462_); _vala_ccode_node_unref0 (cexpr); - cexpr = _tmp456_; + cexpr = _tmp463_; arg_pos = vala_ccode_base_module_get_param_pos (self, (gdouble) i, ellipsis); } - _tmp457_ = carg_map; - _tmp458_ = cexpr; - vala_map_set ((ValaMap*) _tmp457_, (gpointer) ((gintptr) arg_pos), _tmp458_); - _tmp459_ = i; - i = _tmp459_ + 1; + _tmp464_ = carg_map; + _tmp465_ = cexpr; + vala_map_set ((ValaMap*) _tmp464_, (gpointer) ((gintptr) arg_pos), _tmp465_); + _tmp466_ = i; + i = _tmp466_ + 1; _vala_code_node_unref0 (param); _vala_map_unref0 (carg_map); _vala_ccode_node_unref0 (cexpr); @@ -28244,286 +28261,286 @@ } _vala_iterable_unref0 (_arg_list); } - _tmp460_ = params_it; - if (vala_iterator_next (_tmp460_)) { + _tmp467_ = params_it; + if (vala_iterator_next (_tmp467_)) { ValaParameter* param = NULL; - ValaIterator* _tmp461_; - gpointer _tmp462_; - gboolean _tmp463_ = FALSE; - ValaParameter* _tmp464_; - gboolean _tmp465_; - gboolean _tmp466_; - _tmp461_ = params_it; - _tmp462_ = vala_iterator_get (_tmp461_); - param = (ValaParameter*) _tmp462_; - _tmp464_ = param; - _tmp465_ = vala_parameter_get_params_array (_tmp464_); - _tmp466_ = _tmp465_; - if (_tmp466_) { - _tmp463_ = TRUE; + ValaIterator* _tmp468_; + gpointer _tmp469_; + gboolean _tmp470_ = FALSE; + ValaParameter* _tmp471_; + gboolean _tmp472_; + gboolean _tmp473_; + _tmp468_ = params_it; + _tmp469_ = vala_iterator_get (_tmp468_); + param = (ValaParameter*) _tmp469_; + _tmp471_ = param; + _tmp472_ = vala_parameter_get_params_array (_tmp471_); + _tmp473_ = _tmp472_; + if (_tmp473_) { + _tmp470_ = TRUE; } else { - ValaParameter* _tmp467_; - gboolean _tmp468_; - gboolean _tmp469_; - _tmp467_ = param; - _tmp468_ = vala_parameter_get_ellipsis (_tmp467_); - _tmp469_ = _tmp468_; - _tmp463_ = _tmp469_; + ValaParameter* _tmp474_; + gboolean _tmp475_; + gboolean _tmp476_; + _tmp474_ = param; + _tmp475_ = vala_parameter_get_ellipsis (_tmp474_); + _tmp476_ = _tmp475_; + _tmp470_ = _tmp476_; } - _vala_assert (_tmp463_, "param.params_array || param.ellipsis"); + _vala_assert (_tmp470_, "param.params_array || param.ellipsis"); ellipsis = TRUE; _vala_code_node_unref0 (param); } - _tmp470_ = vala_code_node_get_tree_can_fail ((ValaCodeNode*) expr); - _tmp471_ = _tmp470_; - if (_tmp471_) { - ValaHashMap* _tmp472_; - ValaCCodeExpression* _tmp473_; - ValaCCodeExpression* _tmp474_; - ValaCCodeUnaryExpression* _tmp475_; - ValaCCodeUnaryExpression* _tmp476_; + _tmp477_ = vala_code_node_get_tree_can_fail ((ValaCodeNode*) expr); + _tmp478_ = _tmp477_; + if (_tmp478_) { + ValaHashMap* _tmp479_; + ValaCCodeExpression* _tmp480_; + ValaCCodeExpression* _tmp481_; + ValaCCodeUnaryExpression* _tmp482_; + ValaCCodeUnaryExpression* _tmp483_; vala_ccode_base_module_set_current_method_inner_error (self, TRUE); - _tmp472_ = out_arg_map; - _tmp473_ = vala_ccode_base_module_get_inner_error_cexpression (self); - _tmp474_ = _tmp473_; - _tmp475_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, _tmp474_); - _tmp476_ = _tmp475_; - vala_map_set ((ValaMap*) _tmp472_, (gpointer) ((gintptr) vala_ccode_base_module_get_param_pos (self, (gdouble) -1, FALSE)), (ValaCCodeExpression*) _tmp476_); - _vala_ccode_node_unref0 (_tmp476_); - _vala_ccode_node_unref0 (_tmp474_); + _tmp479_ = out_arg_map; + _tmp480_ = vala_ccode_base_module_get_inner_error_cexpression (self); + _tmp481_ = _tmp480_; + _tmp482_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, _tmp481_); + _tmp483_ = _tmp482_; + vala_map_set ((ValaMap*) _tmp479_, (gpointer) ((gintptr) vala_ccode_base_module_get_param_pos (self, (gdouble) -1, FALSE)), (ValaCCodeExpression*) _tmp483_); + _vala_ccode_node_unref0 (_tmp483_); + _vala_ccode_node_unref0 (_tmp481_); } if (ellipsis) { - ValaMethod* _tmp477_; - _tmp477_ = m; - if (_tmp477_ == NULL) { - ValaHashMap* _tmp478_; - ValaCCodeConstant* _tmp479_; - ValaCCodeConstant* _tmp480_; - _tmp478_ = in_arg_map; - _tmp479_ = vala_ccode_constant_new ("NULL"); - _tmp480_ = _tmp479_; - vala_map_set ((ValaMap*) _tmp478_, (gpointer) ((gintptr) vala_ccode_base_module_get_param_pos (self, (gdouble) -1, TRUE)), (ValaCCodeExpression*) _tmp480_); - _vala_ccode_node_unref0 (_tmp480_); + ValaMethod* _tmp484_; + _tmp484_ = m; + if (_tmp484_ == NULL) { + ValaHashMap* _tmp485_; + ValaCCodeConstant* _tmp486_; + ValaCCodeConstant* _tmp487_; + _tmp485_ = in_arg_map; + _tmp486_ = vala_ccode_constant_new ("NULL"); + _tmp487_ = _tmp486_; + vala_map_set ((ValaMap*) _tmp485_, (gpointer) ((gintptr) vala_ccode_base_module_get_param_pos (self, (gdouble) -1, TRUE)), (ValaCCodeExpression*) _tmp487_); + _vala_ccode_node_unref0 (_tmp487_); } else { - gboolean _tmp481_ = FALSE; - gboolean _tmp482_ = FALSE; - ValaMethod* _tmp483_; - gboolean _tmp484_; - gboolean _tmp485_; - _tmp483_ = m; - _tmp484_ = vala_method_get_printf_format (_tmp483_); - _tmp485_ = _tmp484_; - if (!_tmp485_) { - ValaMethod* _tmp486_; - gboolean _tmp487_; - gboolean _tmp488_; - _tmp486_ = m; - _tmp487_ = vala_method_get_scanf_format (_tmp486_); - _tmp488_ = _tmp487_; - _tmp482_ = !_tmp488_; + gboolean _tmp488_ = FALSE; + gboolean _tmp489_ = FALSE; + ValaMethod* _tmp490_; + gboolean _tmp491_; + gboolean _tmp492_; + _tmp490_ = m; + _tmp491_ = vala_method_get_printf_format (_tmp490_); + _tmp492_ = _tmp491_; + if (!_tmp492_) { + ValaMethod* _tmp493_; + gboolean _tmp494_; + gboolean _tmp495_; + _tmp493_ = m; + _tmp494_ = vala_method_get_scanf_format (_tmp493_); + _tmp495_ = _tmp494_; + _tmp489_ = !_tmp495_; } else { - _tmp482_ = FALSE; + _tmp489_ = FALSE; } - if (_tmp482_) { - ValaMethod* _tmp489_; - gchar* _tmp490_; - gchar* _tmp491_; - _tmp489_ = m; - _tmp490_ = vala_get_ccode_sentinel (_tmp489_); - _tmp491_ = _tmp490_; - _tmp481_ = g_strcmp0 (_tmp491_, "") != 0; - _g_free0 (_tmp491_); + if (_tmp489_) { + ValaMethod* _tmp496_; + gchar* _tmp497_; + gchar* _tmp498_; + _tmp496_ = m; + _tmp497_ = vala_get_ccode_sentinel (_tmp496_); + _tmp498_ = _tmp497_; + _tmp488_ = g_strcmp0 (_tmp498_, "") != 0; + _g_free0 (_tmp498_); } else { - _tmp481_ = FALSE; + _tmp488_ = FALSE; } - if (_tmp481_) { - ValaHashMap* _tmp492_; - ValaMethod* _tmp493_; - gchar* _tmp494_; - gchar* _tmp495_; - ValaCCodeConstant* _tmp496_; - ValaCCodeConstant* _tmp497_; - _tmp492_ = in_arg_map; - _tmp493_ = m; - _tmp494_ = vala_get_ccode_sentinel (_tmp493_); - _tmp495_ = _tmp494_; - _tmp496_ = vala_ccode_constant_new (_tmp495_); - _tmp497_ = _tmp496_; - vala_map_set ((ValaMap*) _tmp492_, (gpointer) ((gintptr) vala_ccode_base_module_get_param_pos (self, (gdouble) -1, TRUE)), (ValaCCodeExpression*) _tmp497_); - _vala_ccode_node_unref0 (_tmp497_); - _g_free0 (_tmp495_); + if (_tmp488_) { + ValaHashMap* _tmp499_; + ValaMethod* _tmp500_; + gchar* _tmp501_; + gchar* _tmp502_; + ValaCCodeConstant* _tmp503_; + ValaCCodeConstant* _tmp504_; + _tmp499_ = in_arg_map; + _tmp500_ = m; + _tmp501_ = vala_get_ccode_sentinel (_tmp500_); + _tmp502_ = _tmp501_; + _tmp503_ = vala_ccode_constant_new (_tmp502_); + _tmp504_ = _tmp503_; + vala_map_set ((ValaMap*) _tmp499_, (gpointer) ((gintptr) vala_ccode_base_module_get_param_pos (self, (gdouble) -1, TRUE)), (ValaCCodeExpression*) _tmp504_); + _vala_ccode_node_unref0 (_tmp504_); + _g_free0 (_tmp502_); } } } - _tmp500_ = st; - if (_tmp500_ != NULL) { - ValaStruct* _tmp501_; - _tmp501_ = st; - _tmp499_ = !vala_struct_is_simple_type (_tmp501_); - } else { - _tmp499_ = FALSE; - } - if (_tmp499_) { - ValaMethod* _tmp502_; - _tmp502_ = m; - _tmp498_ = vala_get_ccode_instance_pos ((ValaCodeNode*) _tmp502_) < ((gdouble) 0); - } else { - _tmp498_ = FALSE; - } - if (_tmp498_) { - ValaHashMap* _tmp503_; - ValaCCodeExpression* _tmp504_; - ValaCCodeUnaryExpression* _tmp505_; - ValaCCodeUnaryExpression* _tmp506_; - _tmp503_ = out_arg_map; - _tmp504_ = instance; - _tmp505_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, _tmp504_); - _tmp506_ = _tmp505_; - vala_map_set ((ValaMap*) _tmp503_, (gpointer) ((gintptr) vala_ccode_base_module_get_param_pos (self, (gdouble) -3, FALSE)), (ValaCCodeExpression*) _tmp506_); - _vala_ccode_node_unref0 (_tmp506_); + _tmp507_ = st; + if (_tmp507_ != NULL) { + ValaStruct* _tmp508_; + _tmp508_ = st; + _tmp506_ = !vala_struct_is_simple_type (_tmp508_); + } else { + _tmp506_ = FALSE; } - _tmp508_ = m; - if (_tmp508_ != NULL) { + if (_tmp506_) { ValaMethod* _tmp509_; - gboolean _tmp510_; - gboolean _tmp511_; _tmp509_ = m; - _tmp510_ = vala_method_get_coroutine (_tmp509_); - _tmp511_ = _tmp510_; - _tmp507_ = _tmp511_; - } else { - _tmp507_ = FALSE; - } - if (_tmp507_) { - gboolean _tmp512_; - gboolean _tmp513_; - _tmp512_ = vala_object_creation_expression_get_is_yield_expression (expr); + _tmp505_ = vala_get_ccode_instance_pos ((ValaCodeNode*) _tmp509_) < ((gdouble) 0); + } else { + _tmp505_ = FALSE; + } + if (_tmp505_) { + ValaHashMap* _tmp510_; + ValaCCodeExpression* _tmp511_; + ValaCCodeUnaryExpression* _tmp512_; + ValaCCodeUnaryExpression* _tmp513_; + _tmp510_ = out_arg_map; + _tmp511_ = instance; + _tmp512_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, _tmp511_); _tmp513_ = _tmp512_; - if (_tmp513_) { - ValaHashMap* _tmp514_; - ValaMethod* _tmp515_; - ValaMethod* _tmp516_; - gchar* _tmp517_; - gchar* _tmp518_; - ValaCCodeIdentifier* _tmp519_; - ValaCCodeIdentifier* _tmp520_; + vala_map_set ((ValaMap*) _tmp510_, (gpointer) ((gintptr) vala_ccode_base_module_get_param_pos (self, (gdouble) -3, FALSE)), (ValaCCodeExpression*) _tmp513_); + _vala_ccode_node_unref0 (_tmp513_); + } + _tmp515_ = m; + if (_tmp515_ != NULL) { + ValaMethod* _tmp516_; + gboolean _tmp517_; + gboolean _tmp518_; + _tmp516_ = m; + _tmp517_ = vala_method_get_coroutine (_tmp516_); + _tmp518_ = _tmp517_; + _tmp514_ = _tmp518_; + } else { + _tmp514_ = FALSE; + } + if (_tmp514_) { + gboolean _tmp519_; + gboolean _tmp520_; + _tmp519_ = vala_object_creation_expression_get_is_yield_expression (expr); + _tmp520_ = _tmp519_; + if (_tmp520_) { ValaHashMap* _tmp521_; - ValaCCodeIdentifier* _tmp522_; - ValaCCodeIdentifier* _tmp523_; - _tmp514_ = in_arg_map; - _tmp515_ = vala_ccode_base_module_get_current_method (self); - _tmp516_ = _tmp515_; - _tmp517_ = vala_ccode_base_module_generate_ready_function (self, _tmp516_); - _tmp518_ = _tmp517_; - _tmp519_ = vala_ccode_identifier_new (_tmp518_); - _tmp520_ = _tmp519_; - vala_map_set ((ValaMap*) _tmp514_, (gpointer) ((gintptr) vala_ccode_base_module_get_param_pos (self, (gdouble) -1, FALSE)), (ValaCCodeExpression*) _tmp520_); - _vala_ccode_node_unref0 (_tmp520_); - _g_free0 (_tmp518_); + ValaMethod* _tmp522_; + ValaMethod* _tmp523_; + gchar* _tmp524_; + gchar* _tmp525_; + ValaCCodeIdentifier* _tmp526_; + ValaCCodeIdentifier* _tmp527_; + ValaHashMap* _tmp528_; + ValaCCodeIdentifier* _tmp529_; + ValaCCodeIdentifier* _tmp530_; _tmp521_ = in_arg_map; - _tmp522_ = vala_ccode_identifier_new ("_data_"); + _tmp522_ = vala_ccode_base_module_get_current_method (self); _tmp523_ = _tmp522_; - vala_map_set ((ValaMap*) _tmp521_, (gpointer) ((gintptr) vala_ccode_base_module_get_param_pos (self, -0.9, FALSE)), (ValaCCodeExpression*) _tmp523_); - _vala_ccode_node_unref0 (_tmp523_); - } - } - _tmp526_ = m; - if (_tmp526_ != NULL) { - ValaMethod* _tmp527_; - gboolean _tmp528_; - gboolean _tmp529_; - _tmp527_ = m; - _tmp528_ = vala_method_get_coroutine (_tmp527_); - _tmp529_ = _tmp528_; - _tmp525_ = _tmp529_; - } else { - _tmp525_ = FALSE; - } - if (_tmp525_) { - ValaMethod* _tmp530_; - ValaSymbol* _tmp531_; - ValaSymbol* _tmp532_; - _tmp530_ = m; - _tmp531_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp530_); - _tmp532_ = _tmp531_; - _tmp524_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp532_, VALA_TYPE_CLASS); - } else { - _tmp524_ = FALSE; - } - if (_tmp524_) { - ValaMethod* _tmp533_; - _tmp533_ = m; - if (vala_get_ccode_finish_instance (_tmp533_)) { + _tmp524_ = vala_ccode_base_module_generate_ready_function (self, _tmp523_); + _tmp525_ = _tmp524_; + _tmp526_ = vala_ccode_identifier_new (_tmp525_); + _tmp527_ = _tmp526_; + vala_map_set ((ValaMap*) _tmp521_, (gpointer) ((gintptr) vala_ccode_base_module_get_param_pos (self, (gdouble) -1, FALSE)), (ValaCCodeExpression*) _tmp527_); + _vala_ccode_node_unref0 (_tmp527_); + _g_free0 (_tmp525_); + _tmp528_ = in_arg_map; + _tmp529_ = vala_ccode_identifier_new ("_data_"); + _tmp530_ = _tmp529_; + vala_map_set ((ValaMap*) _tmp528_, (gpointer) ((gintptr) vala_ccode_base_module_get_param_pos (self, -0.9, FALSE)), (ValaCCodeExpression*) _tmp530_); + _vala_ccode_node_unref0 (_tmp530_); + } + } + _tmp533_ = m; + if (_tmp533_ != NULL) { + ValaMethod* _tmp534_; + gboolean _tmp535_; + gboolean _tmp536_; + _tmp534_ = m; + _tmp535_ = vala_method_get_coroutine (_tmp534_); + _tmp536_ = _tmp535_; + _tmp532_ = _tmp536_; + } else { + _tmp532_ = FALSE; + } + if (_tmp532_) { + ValaMethod* _tmp537_; + ValaSymbol* _tmp538_; + ValaSymbol* _tmp539_; + _tmp537_ = m; + _tmp538_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp537_); + _tmp539_ = _tmp538_; + _tmp531_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp539_, VALA_TYPE_CLASS); + } else { + _tmp531_ = FALSE; + } + if (_tmp531_) { + ValaMethod* _tmp540_; + _tmp540_ = m; + if (vala_get_ccode_finish_instance (_tmp540_)) { ValaCCodeMemberAccess* tmp = NULL; - ValaCCodeIdentifier* _tmp534_; - ValaCCodeIdentifier* _tmp535_; - ValaCCodeMemberAccess* _tmp536_; - ValaCCodeMemberAccess* _tmp537_; - ValaHashMap* _tmp538_; - ValaMethod* _tmp539_; - ValaCCodeMemberAccess* _tmp540_; - _tmp534_ = vala_ccode_identifier_new ("_data_"); - _tmp535_ = _tmp534_; - _tmp536_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp535_, "_source_object_"); - _tmp537_ = _tmp536_; - _vala_ccode_node_unref0 (_tmp535_); - tmp = _tmp537_; - _tmp538_ = out_arg_map; - _tmp539_ = m; - _tmp540_ = tmp; - vala_map_set ((ValaMap*) _tmp538_, (gpointer) ((gintptr) vala_ccode_base_module_get_param_pos (self, vala_get_ccode_instance_pos ((ValaCodeNode*) _tmp539_), FALSE)), (ValaCCodeExpression*) _tmp540_); + ValaCCodeIdentifier* _tmp541_; + ValaCCodeIdentifier* _tmp542_; + ValaCCodeMemberAccess* _tmp543_; + ValaCCodeMemberAccess* _tmp544_; + ValaHashMap* _tmp545_; + ValaMethod* _tmp546_; + ValaCCodeMemberAccess* _tmp547_; + _tmp541_ = vala_ccode_identifier_new ("_data_"); + _tmp542_ = _tmp541_; + _tmp543_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp542_, "_source_object_"); + _tmp544_ = _tmp543_; + _vala_ccode_node_unref0 (_tmp542_); + tmp = _tmp544_; + _tmp545_ = out_arg_map; + _tmp546_ = m; + _tmp547_ = tmp; + vala_map_set ((ValaMap*) _tmp545_, (gpointer) ((gintptr) vala_ccode_base_module_get_param_pos (self, vala_get_ccode_instance_pos ((ValaCodeNode*) _tmp546_), FALSE)), (ValaCCodeExpression*) _tmp547_); _vala_ccode_node_unref0 (tmp); } } - _tmp541_ = async_call; - _tmp542_ = creation_call; - if (_tmp541_ != _tmp542_) { + _tmp548_ = async_call; + _tmp549_ = creation_call; + if (_tmp548_ != _tmp549_) { last_pos = -1; while (TRUE) { - ValaCCodeFunctionCall* _tmp553_; - ValaHashMap* _tmp554_; - gpointer _tmp555_; - ValaCCodeExpression* _tmp556_; + ValaCCodeFunctionCall* _tmp560_; + ValaHashMap* _tmp561_; + gpointer _tmp562_; + ValaCCodeExpression* _tmp563_; min_pos = -1; { ValaIterator* _pos_it = NULL; - ValaHashMap* _tmp543_; - ValaSet* _tmp544_; - ValaSet* _tmp545_; - ValaIterator* _tmp546_; - ValaIterator* _tmp547_; - _tmp543_ = out_arg_map; - _tmp544_ = vala_map_get_keys ((ValaMap*) _tmp543_); - _tmp545_ = _tmp544_; - _tmp546_ = vala_iterable_iterator ((ValaIterable*) _tmp545_); - _tmp547_ = _tmp546_; - _vala_iterable_unref0 (_tmp545_); - _pos_it = _tmp547_; + ValaHashMap* _tmp550_; + ValaSet* _tmp551_; + ValaSet* _tmp552_; + ValaIterator* _tmp553_; + ValaIterator* _tmp554_; + _tmp550_ = out_arg_map; + _tmp551_ = vala_map_get_keys ((ValaMap*) _tmp550_); + _tmp552_ = _tmp551_; + _tmp553_ = vala_iterable_iterator ((ValaIterable*) _tmp552_); + _tmp554_ = _tmp553_; + _vala_iterable_unref0 (_tmp552_); + _pos_it = _tmp554_; while (TRUE) { - ValaIterator* _tmp548_; + ValaIterator* _tmp555_; gint pos = 0; - ValaIterator* _tmp549_; - gpointer _tmp550_; - gboolean _tmp551_ = FALSE; - _tmp548_ = _pos_it; - if (!vala_iterator_next (_tmp548_)) { + ValaIterator* _tmp556_; + gpointer _tmp557_; + gboolean _tmp558_ = FALSE; + _tmp555_ = _pos_it; + if (!vala_iterator_next (_tmp555_)) { break; } - _tmp549_ = _pos_it; - _tmp550_ = vala_iterator_get (_tmp549_); - pos = (gint) ((gintptr) _tmp550_); + _tmp556_ = _pos_it; + _tmp557_ = vala_iterator_get (_tmp556_); + pos = (gint) ((gintptr) _tmp557_); if (pos > last_pos) { - gboolean _tmp552_ = FALSE; + gboolean _tmp559_ = FALSE; if (min_pos == -1) { - _tmp552_ = TRUE; + _tmp559_ = TRUE; } else { - _tmp552_ = pos < min_pos; + _tmp559_ = pos < min_pos; } - _tmp551_ = _tmp552_; + _tmp558_ = _tmp559_; } else { - _tmp551_ = FALSE; + _tmp558_ = FALSE; } - if (_tmp551_) { + if (_tmp558_) { min_pos = pos; } } @@ -28532,63 +28549,63 @@ if (min_pos == -1) { break; } - _tmp553_ = creation_call; - _tmp554_ = out_arg_map; - _tmp555_ = vala_map_get ((ValaMap*) _tmp554_, (gpointer) ((gintptr) min_pos)); - _tmp556_ = (ValaCCodeExpression*) _tmp555_; - vala_ccode_function_call_add_argument (_tmp553_, _tmp556_); - _vala_ccode_node_unref0 (_tmp556_); + _tmp560_ = creation_call; + _tmp561_ = out_arg_map; + _tmp562_ = vala_map_get ((ValaMap*) _tmp561_, (gpointer) ((gintptr) min_pos)); + _tmp563_ = (ValaCCodeExpression*) _tmp562_; + vala_ccode_function_call_add_argument (_tmp560_, _tmp563_); + _vala_ccode_node_unref0 (_tmp563_); last_pos = min_pos; } } - _tmp557_ = async_call; - if (_tmp557_ != NULL) { + _tmp564_ = async_call; + if (_tmp564_ != NULL) { last_pos = -1; while (TRUE) { - ValaCCodeFunctionCall* _tmp568_; - ValaHashMap* _tmp569_; - gpointer _tmp570_; - ValaCCodeExpression* _tmp571_; + ValaCCodeFunctionCall* _tmp575_; + ValaHashMap* _tmp576_; + gpointer _tmp577_; + ValaCCodeExpression* _tmp578_; min_pos = -1; { ValaIterator* _pos_it = NULL; - ValaHashMap* _tmp558_; - ValaSet* _tmp559_; - ValaSet* _tmp560_; - ValaIterator* _tmp561_; - ValaIterator* _tmp562_; - _tmp558_ = in_arg_map; - _tmp559_ = vala_map_get_keys ((ValaMap*) _tmp558_); - _tmp560_ = _tmp559_; - _tmp561_ = vala_iterable_iterator ((ValaIterable*) _tmp560_); - _tmp562_ = _tmp561_; - _vala_iterable_unref0 (_tmp560_); - _pos_it = _tmp562_; + ValaHashMap* _tmp565_; + ValaSet* _tmp566_; + ValaSet* _tmp567_; + ValaIterator* _tmp568_; + ValaIterator* _tmp569_; + _tmp565_ = in_arg_map; + _tmp566_ = vala_map_get_keys ((ValaMap*) _tmp565_); + _tmp567_ = _tmp566_; + _tmp568_ = vala_iterable_iterator ((ValaIterable*) _tmp567_); + _tmp569_ = _tmp568_; + _vala_iterable_unref0 (_tmp567_); + _pos_it = _tmp569_; while (TRUE) { - ValaIterator* _tmp563_; + ValaIterator* _tmp570_; gint pos = 0; - ValaIterator* _tmp564_; - gpointer _tmp565_; - gboolean _tmp566_ = FALSE; - _tmp563_ = _pos_it; - if (!vala_iterator_next (_tmp563_)) { + ValaIterator* _tmp571_; + gpointer _tmp572_; + gboolean _tmp573_ = FALSE; + _tmp570_ = _pos_it; + if (!vala_iterator_next (_tmp570_)) { break; } - _tmp564_ = _pos_it; - _tmp565_ = vala_iterator_get (_tmp564_); - pos = (gint) ((gintptr) _tmp565_); + _tmp571_ = _pos_it; + _tmp572_ = vala_iterator_get (_tmp571_); + pos = (gint) ((gintptr) _tmp572_); if (pos > last_pos) { - gboolean _tmp567_ = FALSE; + gboolean _tmp574_ = FALSE; if (min_pos == -1) { - _tmp567_ = TRUE; + _tmp574_ = TRUE; } else { - _tmp567_ = pos < min_pos; + _tmp574_ = pos < min_pos; } - _tmp566_ = _tmp567_; + _tmp573_ = _tmp574_; } else { - _tmp566_ = FALSE; + _tmp573_ = FALSE; } - if (_tmp566_) { + if (_tmp573_) { min_pos = pos; } } @@ -28597,103 +28614,103 @@ if (min_pos == -1) { break; } - _tmp568_ = async_call; - _tmp569_ = in_arg_map; - _tmp570_ = vala_map_get ((ValaMap*) _tmp569_, (gpointer) ((gintptr) min_pos)); - _tmp571_ = (ValaCCodeExpression*) _tmp570_; - vala_ccode_function_call_add_argument (_tmp568_, _tmp571_); - _vala_ccode_node_unref0 (_tmp571_); + _tmp575_ = async_call; + _tmp576_ = in_arg_map; + _tmp577_ = vala_map_get ((ValaMap*) _tmp576_, (gpointer) ((gintptr) min_pos)); + _tmp578_ = (ValaCCodeExpression*) _tmp577_; + vala_ccode_function_call_add_argument (_tmp575_, _tmp578_); + _vala_ccode_node_unref0 (_tmp578_); last_pos = min_pos; } } - _tmp572_ = vala_object_creation_expression_get_is_yield_expression (expr); - _tmp573_ = _tmp572_; - if (_tmp573_) { + _tmp579_ = vala_object_creation_expression_get_is_yield_expression (expr); + _tmp580_ = _tmp579_; + if (_tmp580_) { gint state = 0; - ValaCCodeBaseModuleEmitContext* _tmp574_; - gint _tmp575_; - ValaCCodeFunction* _tmp576_; - ValaCCodeFunction* _tmp577_; - ValaCCodeIdentifier* _tmp578_; - ValaCCodeIdentifier* _tmp579_; - ValaCCodeMemberAccess* _tmp580_; - ValaCCodeMemberAccess* _tmp581_; - gchar* _tmp582_; - gchar* _tmp583_; - ValaCCodeConstant* _tmp584_; - ValaCCodeConstant* _tmp585_; - ValaCCodeFunction* _tmp586_; - ValaCCodeFunction* _tmp587_; - ValaCCodeFunctionCall* _tmp588_; - ValaCCodeFunction* _tmp589_; - ValaCCodeFunction* _tmp590_; + ValaCCodeBaseModuleEmitContext* _tmp581_; + gint _tmp582_; + ValaCCodeFunction* _tmp583_; + ValaCCodeFunction* _tmp584_; + ValaCCodeIdentifier* _tmp585_; + ValaCCodeIdentifier* _tmp586_; + ValaCCodeMemberAccess* _tmp587_; + ValaCCodeMemberAccess* _tmp588_; + gchar* _tmp589_; + gchar* _tmp590_; ValaCCodeConstant* _tmp591_; ValaCCodeConstant* _tmp592_; ValaCCodeFunction* _tmp593_; ValaCCodeFunction* _tmp594_; - gchar* _tmp595_; - gchar* _tmp596_; - _tmp574_ = self->emit_context; - _tmp575_ = _tmp574_->next_coroutine_state; - _tmp574_->next_coroutine_state = _tmp575_ + 1; - state = _tmp575_; - _tmp576_ = vala_ccode_base_module_get_ccode (self); - _tmp577_ = _tmp576_; - _tmp578_ = vala_ccode_identifier_new ("_data_"); - _tmp579_ = _tmp578_; - _tmp580_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp579_, "_state_"); - _tmp581_ = _tmp580_; - _tmp582_ = g_strdup_printf ("%i", state); - _tmp583_ = _tmp582_; - _tmp584_ = vala_ccode_constant_new (_tmp583_); - _tmp585_ = _tmp584_; - vala_ccode_function_add_assignment (_tmp577_, (ValaCCodeExpression*) _tmp581_, (ValaCCodeExpression*) _tmp585_); - _vala_ccode_node_unref0 (_tmp585_); - _g_free0 (_tmp583_); - _vala_ccode_node_unref0 (_tmp581_); - _vala_ccode_node_unref0 (_tmp579_); - _tmp586_ = vala_ccode_base_module_get_ccode (self); - _tmp587_ = _tmp586_; - _tmp588_ = async_call; - vala_ccode_function_add_expression (_tmp587_, (ValaCCodeExpression*) _tmp588_); - _tmp589_ = vala_ccode_base_module_get_ccode (self); + ValaCCodeFunctionCall* _tmp595_; + ValaCCodeFunction* _tmp596_; + ValaCCodeFunction* _tmp597_; + ValaCCodeConstant* _tmp598_; + ValaCCodeConstant* _tmp599_; + ValaCCodeFunction* _tmp600_; + ValaCCodeFunction* _tmp601_; + gchar* _tmp602_; + gchar* _tmp603_; + _tmp581_ = self->emit_context; + _tmp582_ = _tmp581_->next_coroutine_state; + _tmp581_->next_coroutine_state = _tmp582_ + 1; + state = _tmp582_; + _tmp583_ = vala_ccode_base_module_get_ccode (self); + _tmp584_ = _tmp583_; + _tmp585_ = vala_ccode_identifier_new ("_data_"); + _tmp586_ = _tmp585_; + _tmp587_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp586_, "_state_"); + _tmp588_ = _tmp587_; + _tmp589_ = g_strdup_printf ("%i", state); _tmp590_ = _tmp589_; - _tmp591_ = vala_ccode_constant_new ("FALSE"); + _tmp591_ = vala_ccode_constant_new (_tmp590_); _tmp592_ = _tmp591_; - vala_ccode_function_add_return (_tmp590_, (ValaCCodeExpression*) _tmp592_); + vala_ccode_function_add_assignment (_tmp584_, (ValaCCodeExpression*) _tmp588_, (ValaCCodeExpression*) _tmp592_); _vala_ccode_node_unref0 (_tmp592_); + _g_free0 (_tmp590_); + _vala_ccode_node_unref0 (_tmp588_); + _vala_ccode_node_unref0 (_tmp586_); _tmp593_ = vala_ccode_base_module_get_ccode (self); _tmp594_ = _tmp593_; - _tmp595_ = g_strdup_printf ("_state_%d", state); - _tmp596_ = _tmp595_; - vala_ccode_function_add_label (_tmp594_, _tmp596_); - _g_free0 (_tmp596_); + _tmp595_ = async_call; + vala_ccode_function_add_expression (_tmp594_, (ValaCCodeExpression*) _tmp595_); + _tmp596_ = vala_ccode_base_module_get_ccode (self); + _tmp597_ = _tmp596_; + _tmp598_ = vala_ccode_constant_new ("FALSE"); + _tmp599_ = _tmp598_; + vala_ccode_function_add_return (_tmp597_, (ValaCCodeExpression*) _tmp599_); + _vala_ccode_node_unref0 (_tmp599_); + _tmp600_ = vala_ccode_base_module_get_ccode (self); + _tmp601_ = _tmp600_; + _tmp602_ = g_strdup_printf ("_state_%d", state); + _tmp603_ = _tmp602_; + vala_ccode_function_add_label (_tmp601_, _tmp603_); + _g_free0 (_tmp603_); } - _tmp597_ = creation_call; - _tmp598_ = _vala_ccode_node_ref0 ((ValaCCodeExpression*) _tmp597_); + _tmp604_ = creation_call; + _tmp605_ = _vala_ccode_node_ref0 ((ValaCCodeExpression*) _tmp604_); _vala_ccode_node_unref0 (creation_expr); - creation_expr = _tmp598_; - _tmp599_ = m; - _tmp600_ = vala_get_ccode_type ((ValaCodeNode*) _tmp599_); - _tmp601_ = _tmp600_; - _tmp602_ = _tmp601_ != NULL; - _g_free0 (_tmp601_); - if (_tmp602_) { - ValaCCodeExpression* _tmp603_; - ValaDataType* _tmp604_; - ValaDataType* _tmp605_; - gchar* _tmp606_; - gchar* _tmp607_; - ValaCCodeCastExpression* _tmp608_; - _tmp603_ = creation_expr; - _tmp604_ = vala_object_creation_expression_get_type_reference (expr); - _tmp605_ = _tmp604_; - _tmp606_ = vala_get_ccode_name ((ValaCodeNode*) _tmp605_); - _tmp607_ = _tmp606_; - _tmp608_ = vala_ccode_cast_expression_new (_tmp603_, _tmp607_); + creation_expr = _tmp605_; + _tmp606_ = m; + _tmp607_ = vala_get_ccode_type ((ValaCodeNode*) _tmp606_); + _tmp608_ = _tmp607_; + _tmp609_ = _tmp608_ != NULL; + _g_free0 (_tmp608_); + if (_tmp609_) { + ValaCCodeExpression* _tmp610_; + ValaDataType* _tmp611_; + ValaDataType* _tmp612_; + gchar* _tmp613_; + gchar* _tmp614_; + ValaCCodeCastExpression* _tmp615_; + _tmp610_ = creation_expr; + _tmp611_ = vala_object_creation_expression_get_type_reference (expr); + _tmp612_ = _tmp611_; + _tmp613_ = vala_get_ccode_name ((ValaCodeNode*) _tmp612_); + _tmp614_ = _tmp613_; + _tmp615_ = vala_ccode_cast_expression_new (_tmp610_, _tmp614_); _vala_ccode_node_unref0 (creation_expr); - creation_expr = (ValaCCodeExpression*) _tmp608_; - _g_free0 (_tmp607_); + creation_expr = (ValaCCodeExpression*) _tmp615_; + _g_free0 (_tmp614_); } _vala_iterator_unref0 (params_it); _vala_map_unref0 (out_arg_map); @@ -28704,141 +28721,141 @@ _vala_iterable_unref0 (params); _vala_code_node_unref0 (m); } else { - ValaSymbol* _tmp609_; - ValaSymbol* _tmp610_; - _tmp609_ = vala_expression_get_symbol_reference ((ValaExpression*) expr); - _tmp610_ = _tmp609_; - if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp610_, VALA_TYPE_ERROR_CODE)) { + ValaSymbol* _tmp616_; + ValaSymbol* _tmp617_; + _tmp616_ = vala_expression_get_symbol_reference ((ValaExpression*) expr); + _tmp617_ = _tmp616_; + if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp617_, VALA_TYPE_ERROR_CODE)) { ValaErrorCode* ecode = NULL; - ValaSymbol* _tmp611_; - ValaSymbol* _tmp612_; - ValaErrorCode* _tmp613_; + ValaSymbol* _tmp618_; + ValaSymbol* _tmp619_; + ValaErrorCode* _tmp620_; ValaErrorDomain* edomain = NULL; - ValaErrorCode* _tmp614_; - ValaSymbol* _tmp615_; - ValaSymbol* _tmp616_; - ValaErrorDomain* _tmp617_; + ValaErrorCode* _tmp621_; + ValaSymbol* _tmp622_; + ValaSymbol* _tmp623_; + ValaErrorDomain* _tmp624_; ValaCCodeFunctionCall* creation_call = NULL; - ValaErrorDomain* _tmp618_; - ValaCCodeFile* _tmp619_; - ValaList* _tmp620_; - gint _tmp621_; - gint _tmp622_; - ValaCCodeFunctionCall* _tmp629_; - ValaErrorDomain* _tmp630_; - gchar* _tmp631_; - gchar* _tmp632_; - ValaCCodeIdentifier* _tmp633_; - ValaCCodeIdentifier* _tmp634_; - ValaCCodeFunctionCall* _tmp635_; - ValaErrorCode* _tmp636_; - gchar* _tmp637_; + ValaErrorDomain* _tmp625_; + ValaCCodeFile* _tmp626_; + ValaList* _tmp627_; + gint _tmp628_; + gint _tmp629_; + ValaCCodeFunctionCall* _tmp636_; + ValaErrorDomain* _tmp637_; gchar* _tmp638_; - ValaCCodeIdentifier* _tmp639_; + gchar* _tmp639_; ValaCCodeIdentifier* _tmp640_; - ValaCCodeFunctionCall* _tmp653_; - ValaCCodeExpression* _tmp654_; - _tmp611_ = vala_expression_get_symbol_reference ((ValaExpression*) expr); - _tmp612_ = _tmp611_; - _tmp613_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp612_, VALA_TYPE_ERROR_CODE, ValaErrorCode)); - ecode = _tmp613_; - _tmp614_ = ecode; - _tmp615_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp614_); - _tmp616_ = _tmp615_; - _tmp617_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp616_, VALA_TYPE_ERROR_DOMAIN, ValaErrorDomain)); - edomain = _tmp617_; - _tmp618_ = edomain; - _tmp619_ = self->cfile; - vala_ccode_base_module_generate_error_domain_declaration (self, _tmp618_, _tmp619_); - _tmp620_ = vala_object_creation_expression_get_argument_list (expr); - _tmp621_ = vala_collection_get_size ((ValaCollection*) _tmp620_); - _tmp622_ = _tmp621_; - if (_tmp622_ == 1) { - ValaCCodeIdentifier* _tmp623_; - ValaCCodeIdentifier* _tmp624_; - ValaCCodeFunctionCall* _tmp625_; - _tmp623_ = vala_ccode_identifier_new ("g_error_new_literal"); - _tmp624_ = _tmp623_; - _tmp625_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp624_); + ValaCCodeIdentifier* _tmp641_; + ValaCCodeFunctionCall* _tmp642_; + ValaErrorCode* _tmp643_; + gchar* _tmp644_; + gchar* _tmp645_; + ValaCCodeIdentifier* _tmp646_; + ValaCCodeIdentifier* _tmp647_; + ValaCCodeFunctionCall* _tmp660_; + ValaCCodeExpression* _tmp661_; + _tmp618_ = vala_expression_get_symbol_reference ((ValaExpression*) expr); + _tmp619_ = _tmp618_; + _tmp620_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp619_, VALA_TYPE_ERROR_CODE, ValaErrorCode)); + ecode = _tmp620_; + _tmp621_ = ecode; + _tmp622_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp621_); + _tmp623_ = _tmp622_; + _tmp624_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp623_, VALA_TYPE_ERROR_DOMAIN, ValaErrorDomain)); + edomain = _tmp624_; + _tmp625_ = edomain; + _tmp626_ = self->cfile; + vala_ccode_base_module_generate_error_domain_declaration (self, _tmp625_, _tmp626_); + _tmp627_ = vala_object_creation_expression_get_argument_list (expr); + _tmp628_ = vala_collection_get_size ((ValaCollection*) _tmp627_); + _tmp629_ = _tmp628_; + if (_tmp629_ == 1) { + ValaCCodeIdentifier* _tmp630_; + ValaCCodeIdentifier* _tmp631_; + ValaCCodeFunctionCall* _tmp632_; + _tmp630_ = vala_ccode_identifier_new ("g_error_new_literal"); + _tmp631_ = _tmp630_; + _tmp632_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp631_); _vala_ccode_node_unref0 (creation_call); - creation_call = _tmp625_; - _vala_ccode_node_unref0 (_tmp624_); + creation_call = _tmp632_; + _vala_ccode_node_unref0 (_tmp631_); } else { - ValaCCodeIdentifier* _tmp626_; - ValaCCodeIdentifier* _tmp627_; - ValaCCodeFunctionCall* _tmp628_; - _tmp626_ = vala_ccode_identifier_new ("g_error_new"); - _tmp627_ = _tmp626_; - _tmp628_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp627_); + ValaCCodeIdentifier* _tmp633_; + ValaCCodeIdentifier* _tmp634_; + ValaCCodeFunctionCall* _tmp635_; + _tmp633_ = vala_ccode_identifier_new ("g_error_new"); + _tmp634_ = _tmp633_; + _tmp635_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp634_); _vala_ccode_node_unref0 (creation_call); - creation_call = _tmp628_; - _vala_ccode_node_unref0 (_tmp627_); + creation_call = _tmp635_; + _vala_ccode_node_unref0 (_tmp634_); } - _tmp629_ = creation_call; - _tmp630_ = edomain; - _tmp631_ = vala_get_ccode_upper_case_name ((ValaSymbol*) _tmp630_, NULL); - _tmp632_ = _tmp631_; - _tmp633_ = vala_ccode_identifier_new (_tmp632_); - _tmp634_ = _tmp633_; - vala_ccode_function_call_add_argument (_tmp629_, (ValaCCodeExpression*) _tmp634_); - _vala_ccode_node_unref0 (_tmp634_); - _g_free0 (_tmp632_); - _tmp635_ = creation_call; - _tmp636_ = ecode; - _tmp637_ = vala_get_ccode_name ((ValaCodeNode*) _tmp636_); - _tmp638_ = _tmp637_; - _tmp639_ = vala_ccode_identifier_new (_tmp638_); - _tmp640_ = _tmp639_; - vala_ccode_function_call_add_argument (_tmp635_, (ValaCCodeExpression*) _tmp640_); - _vala_ccode_node_unref0 (_tmp640_); - _g_free0 (_tmp638_); + _tmp636_ = creation_call; + _tmp637_ = edomain; + _tmp638_ = vala_get_ccode_upper_case_name ((ValaSymbol*) _tmp637_, NULL); + _tmp639_ = _tmp638_; + _tmp640_ = vala_ccode_identifier_new (_tmp639_); + _tmp641_ = _tmp640_; + vala_ccode_function_call_add_argument (_tmp636_, (ValaCCodeExpression*) _tmp641_); + _vala_ccode_node_unref0 (_tmp641_); + _g_free0 (_tmp639_); + _tmp642_ = creation_call; + _tmp643_ = ecode; + _tmp644_ = vala_get_ccode_name ((ValaCodeNode*) _tmp643_); + _tmp645_ = _tmp644_; + _tmp646_ = vala_ccode_identifier_new (_tmp645_); + _tmp647_ = _tmp646_; + vala_ccode_function_call_add_argument (_tmp642_, (ValaCCodeExpression*) _tmp647_); + _vala_ccode_node_unref0 (_tmp647_); + _g_free0 (_tmp645_); { ValaList* _arg_list = NULL; - ValaList* _tmp641_; - ValaList* _tmp642_; + ValaList* _tmp648_; + ValaList* _tmp649_; gint _arg_size = 0; - ValaList* _tmp643_; - gint _tmp644_; - gint _tmp645_; + ValaList* _tmp650_; + gint _tmp651_; + gint _tmp652_; gint _arg_index = 0; - _tmp641_ = vala_object_creation_expression_get_argument_list (expr); - _tmp642_ = _vala_iterable_ref0 (_tmp641_); - _arg_list = _tmp642_; - _tmp643_ = _arg_list; - _tmp644_ = vala_collection_get_size ((ValaCollection*) _tmp643_); - _tmp645_ = _tmp644_; - _arg_size = _tmp645_; + _tmp648_ = vala_object_creation_expression_get_argument_list (expr); + _tmp649_ = _vala_iterable_ref0 (_tmp648_); + _arg_list = _tmp649_; + _tmp650_ = _arg_list; + _tmp651_ = vala_collection_get_size ((ValaCollection*) _tmp650_); + _tmp652_ = _tmp651_; + _arg_size = _tmp652_; _arg_index = -1; while (TRUE) { - gint _tmp646_; - gint _tmp647_; + gint _tmp653_; + gint _tmp654_; ValaExpression* arg = NULL; - ValaList* _tmp648_; - gpointer _tmp649_; - ValaCCodeFunctionCall* _tmp650_; - ValaExpression* _tmp651_; - ValaCCodeExpression* _tmp652_; + ValaList* _tmp655_; + gpointer _tmp656_; + ValaCCodeFunctionCall* _tmp657_; + ValaExpression* _tmp658_; + ValaCCodeExpression* _tmp659_; _arg_index = _arg_index + 1; - _tmp646_ = _arg_index; - _tmp647_ = _arg_size; - if (!(_tmp646_ < _tmp647_)) { + _tmp653_ = _arg_index; + _tmp654_ = _arg_size; + if (!(_tmp653_ < _tmp654_)) { break; } - _tmp648_ = _arg_list; - _tmp649_ = vala_list_get (_tmp648_, _arg_index); - arg = (ValaExpression*) _tmp649_; - _tmp650_ = creation_call; - _tmp651_ = arg; - _tmp652_ = vala_get_cvalue (_tmp651_); - vala_ccode_function_call_add_argument (_tmp650_, _tmp652_); + _tmp655_ = _arg_list; + _tmp656_ = vala_list_get (_tmp655_, _arg_index); + arg = (ValaExpression*) _tmp656_; + _tmp657_ = creation_call; + _tmp658_ = arg; + _tmp659_ = vala_get_cvalue (_tmp658_); + vala_ccode_function_call_add_argument (_tmp657_, _tmp659_); _vala_code_node_unref0 (arg); } _vala_iterable_unref0 (_arg_list); } - _tmp653_ = creation_call; - _tmp654_ = _vala_ccode_node_ref0 ((ValaCCodeExpression*) _tmp653_); + _tmp660_ = creation_call; + _tmp661_ = _vala_ccode_node_ref0 ((ValaCCodeExpression*) _tmp660_); _vala_ccode_node_unref0 (creation_expr); - creation_expr = _tmp654_; + creation_expr = _tmp661_; _vala_ccode_node_unref0 (creation_call); _vala_code_node_unref0 (edomain); _vala_code_node_unref0 (ecode); @@ -28848,639 +28865,639 @@ } } } - _tmp655_ = vala_code_node_get_parent_node ((ValaCodeNode*) expr); - _tmp656_ = _tmp655_; - _tmp657_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp656_, VALA_TYPE_LOCAL_VARIABLE) ? ((ValaLocalVariable*) _tmp656_) : NULL); - local = _tmp657_; - _tmp659_ = local; - if (_tmp659_ != NULL) { - ValaLocalVariable* _tmp660_; - ValaLocalVariable* _tmp661_; - ValaExpression* _tmp662_; - ValaExpression* _tmp663_; - _tmp660_ = local; - _tmp661_ = local; - _tmp662_ = vala_variable_get_initializer ((ValaVariable*) _tmp661_); - _tmp663_ = _tmp662_; - _tmp658_ = vala_ccode_base_module_is_simple_struct_creation (self, (ValaVariable*) _tmp660_, _tmp663_); - } else { - _tmp658_ = FALSE; - } - if (_tmp658_) { - ValaCCodeFunction* _tmp664_; - ValaCCodeFunction* _tmp665_; - ValaCCodeExpression* _tmp666_; - ValaCCodeExpression* _tmp667_; - _tmp664_ = vala_ccode_base_module_get_ccode (self); - _tmp665_ = _tmp664_; - _tmp666_ = creation_expr; - vala_ccode_function_add_expression (_tmp665_, _tmp666_); - _tmp667_ = instance; - vala_set_cvalue ((ValaExpression*) expr, _tmp667_); - } else { - ValaCCodeExpression* _tmp668_; - _tmp668_ = instance; - if (_tmp668_ != NULL) { - ValaDataType* _tmp669_; - ValaDataType* _tmp670_; - ValaTypeSymbol* _tmp671_; - ValaTypeSymbol* _tmp672_; - ValaCCodeExpression* _tmp797_; - _tmp669_ = vala_object_creation_expression_get_type_reference (expr); - _tmp670_ = _tmp669_; - _tmp671_ = vala_data_type_get_type_symbol (_tmp670_); - _tmp672_ = _tmp671_; - if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp672_, VALA_TYPE_STRUCT)) { - ValaCCodeFunction* _tmp673_; - ValaCCodeFunction* _tmp674_; - ValaCCodeExpression* _tmp675_; - _tmp673_ = vala_ccode_base_module_get_ccode (self); - _tmp674_ = _tmp673_; - _tmp675_ = creation_expr; - vala_ccode_function_add_expression (_tmp674_, _tmp675_); - } else { - ValaCCodeFunction* _tmp676_; - ValaCCodeFunction* _tmp677_; - ValaCCodeExpression* _tmp678_; - ValaCCodeExpression* _tmp679_; - _tmp676_ = vala_ccode_base_module_get_ccode (self); - _tmp677_ = _tmp676_; - _tmp678_ = instance; - _tmp679_ = creation_expr; - vala_ccode_function_add_assignment (_tmp677_, _tmp678_, _tmp679_); + _tmp662_ = vala_code_node_get_parent_node ((ValaCodeNode*) expr); + _tmp663_ = _tmp662_; + _tmp664_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp663_, VALA_TYPE_LOCAL_VARIABLE) ? ((ValaLocalVariable*) _tmp663_) : NULL); + local = _tmp664_; + _tmp666_ = local; + if (_tmp666_ != NULL) { + ValaLocalVariable* _tmp667_; + ValaLocalVariable* _tmp668_; + ValaExpression* _tmp669_; + ValaExpression* _tmp670_; + _tmp667_ = local; + _tmp668_ = local; + _tmp669_ = vala_variable_get_initializer ((ValaVariable*) _tmp668_); + _tmp670_ = _tmp669_; + _tmp665_ = vala_ccode_base_module_is_simple_struct_creation (self, (ValaVariable*) _tmp667_, _tmp670_); + } else { + _tmp665_ = FALSE; + } + if (_tmp665_) { + ValaCCodeFunction* _tmp671_; + ValaCCodeFunction* _tmp672_; + ValaCCodeExpression* _tmp673_; + ValaCCodeExpression* _tmp674_; + _tmp671_ = vala_ccode_base_module_get_ccode (self); + _tmp672_ = _tmp671_; + _tmp673_ = creation_expr; + vala_ccode_function_add_expression (_tmp672_, _tmp673_); + _tmp674_ = instance; + vala_set_cvalue ((ValaExpression*) expr, _tmp674_); + } else { + ValaCCodeExpression* _tmp675_; + _tmp675_ = instance; + if (_tmp675_ != NULL) { + ValaDataType* _tmp676_; + ValaDataType* _tmp677_; + ValaTypeSymbol* _tmp678_; + ValaTypeSymbol* _tmp679_; + ValaCCodeExpression* _tmp804_; + _tmp676_ = vala_object_creation_expression_get_type_reference (expr); + _tmp677_ = _tmp676_; + _tmp678_ = vala_data_type_get_type_symbol (_tmp677_); + _tmp679_ = _tmp678_; + if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp679_, VALA_TYPE_STRUCT)) { + ValaCCodeFunction* _tmp680_; + ValaCCodeFunction* _tmp681_; + ValaCCodeExpression* _tmp682_; + _tmp680_ = vala_ccode_base_module_get_ccode (self); + _tmp681_ = _tmp680_; + _tmp682_ = creation_expr; + vala_ccode_function_add_expression (_tmp681_, _tmp682_); + } else { + ValaCCodeFunction* _tmp683_; + ValaCCodeFunction* _tmp684_; + ValaCCodeExpression* _tmp685_; + ValaCCodeExpression* _tmp686_; + _tmp683_ = vala_ccode_base_module_get_ccode (self); + _tmp684_ = _tmp683_; + _tmp685_ = instance; + _tmp686_ = creation_expr; + vala_ccode_function_add_assignment (_tmp684_, _tmp685_, _tmp686_); } { ValaList* _init_list = NULL; - ValaList* _tmp680_; - ValaList* _tmp681_; + ValaList* _tmp687_; + ValaList* _tmp688_; gint _init_size = 0; - ValaList* _tmp682_; - gint _tmp683_; - gint _tmp684_; + ValaList* _tmp689_; + gint _tmp690_; + gint _tmp691_; gint _init_index = 0; - _tmp680_ = vala_object_creation_expression_get_object_initializer (expr); - _tmp681_ = _vala_iterable_ref0 (_tmp680_); - _init_list = _tmp681_; - _tmp682_ = _init_list; - _tmp683_ = vala_collection_get_size ((ValaCollection*) _tmp682_); - _tmp684_ = _tmp683_; - _init_size = _tmp684_; + _tmp687_ = vala_object_creation_expression_get_object_initializer (expr); + _tmp688_ = _vala_iterable_ref0 (_tmp687_); + _init_list = _tmp688_; + _tmp689_ = _init_list; + _tmp690_ = vala_collection_get_size ((ValaCollection*) _tmp689_); + _tmp691_ = _tmp690_; + _init_size = _tmp691_; _init_index = -1; while (TRUE) { - gint _tmp685_; - gint _tmp686_; + gint _tmp692_; + gint _tmp693_; ValaMemberInitializer* init = NULL; - ValaList* _tmp687_; - gpointer _tmp688_; - ValaMemberInitializer* _tmp689_; - ValaSymbol* _tmp690_; - ValaSymbol* _tmp691_; + ValaList* _tmp694_; + gpointer _tmp695_; + ValaMemberInitializer* _tmp696_; + ValaSymbol* _tmp697_; + ValaSymbol* _tmp698_; _init_index = _init_index + 1; - _tmp685_ = _init_index; - _tmp686_ = _init_size; - if (!(_tmp685_ < _tmp686_)) { + _tmp692_ = _init_index; + _tmp693_ = _init_size; + if (!(_tmp692_ < _tmp693_)) { break; } - _tmp687_ = _init_list; - _tmp688_ = vala_list_get (_tmp687_, _init_index); - init = (ValaMemberInitializer*) _tmp688_; - _tmp689_ = init; - _tmp690_ = vala_member_initializer_get_symbol_reference (_tmp689_); - _tmp691_ = _tmp690_; - if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp691_, VALA_TYPE_FIELD)) { + _tmp694_ = _init_list; + _tmp695_ = vala_list_get (_tmp694_, _init_index); + init = (ValaMemberInitializer*) _tmp695_; + _tmp696_ = init; + _tmp697_ = vala_member_initializer_get_symbol_reference (_tmp696_); + _tmp698_ = _tmp697_; + if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp698_, VALA_TYPE_FIELD)) { ValaField* f = NULL; - ValaMemberInitializer* _tmp692_; - ValaSymbol* _tmp693_; - ValaSymbol* _tmp694_; - ValaField* _tmp695_; + ValaMemberInitializer* _tmp699_; + ValaSymbol* _tmp700_; + ValaSymbol* _tmp701_; + ValaField* _tmp702_; ValaDataType* instance_target_type = NULL; - ValaField* _tmp696_; - ValaSymbol* _tmp697_; - ValaSymbol* _tmp698_; - ValaDataType* _tmp699_; + ValaField* _tmp703_; + ValaSymbol* _tmp704_; + ValaSymbol* _tmp705_; + ValaDataType* _tmp706_; ValaTargetValue* typed_inst = NULL; - ValaDataType* _tmp700_; - ValaDataType* _tmp701_; - ValaCCodeExpression* _tmp702_; - ValaGLibValue* _tmp703_; - ValaGLibValue* _tmp704_; - ValaDataType* _tmp705_; - ValaMemberInitializer* _tmp706_; - ValaTargetValue* _tmp707_; - ValaTargetValue* _tmp708_; - ValaField* _tmp709_; - ValaTargetValue* _tmp710_; - ValaMemberInitializer* _tmp711_; - ValaExpression* _tmp712_; - ValaExpression* _tmp713_; + ValaDataType* _tmp707_; + ValaDataType* _tmp708_; + ValaCCodeExpression* _tmp709_; + ValaGLibValue* _tmp710_; + ValaGLibValue* _tmp711_; + ValaDataType* _tmp712_; + ValaMemberInitializer* _tmp713_; ValaTargetValue* _tmp714_; ValaTargetValue* _tmp715_; - ValaMemberInitializer* _tmp716_; - ValaSourceReference* _tmp717_; - ValaSourceReference* _tmp718_; + ValaField* _tmp716_; + ValaTargetValue* _tmp717_; + ValaMemberInitializer* _tmp718_; + ValaExpression* _tmp719_; + ValaExpression* _tmp720_; + ValaTargetValue* _tmp721_; + ValaTargetValue* _tmp722_; + ValaMemberInitializer* _tmp723_; + ValaSourceReference* _tmp724_; + ValaSourceReference* _tmp725_; ValaClass* cl = NULL; - ValaField* _tmp719_; - ValaSymbol* _tmp720_; - ValaSymbol* _tmp721_; - ValaClass* _tmp722_; - ValaClass* _tmp723_; - _tmp692_ = init; - _tmp693_ = vala_member_initializer_get_symbol_reference (_tmp692_); - _tmp694_ = _tmp693_; - _tmp695_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp694_, VALA_TYPE_FIELD, ValaField)); - f = _tmp695_; - _tmp696_ = f; - _tmp697_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp696_); - _tmp698_ = _tmp697_; - _tmp699_ = vala_semantic_analyzer_get_data_type_for_symbol ((ValaSymbol*) G_TYPE_CHECK_INSTANCE_CAST (_tmp698_, VALA_TYPE_TYPESYMBOL, ValaTypeSymbol)); - instance_target_type = _tmp699_; - _tmp700_ = vala_object_creation_expression_get_type_reference (expr); + ValaField* _tmp726_; + ValaSymbol* _tmp727_; + ValaSymbol* _tmp728_; + ValaClass* _tmp729_; + ValaClass* _tmp730_; + _tmp699_ = init; + _tmp700_ = vala_member_initializer_get_symbol_reference (_tmp699_); _tmp701_ = _tmp700_; - _tmp702_ = instance; - _tmp703_ = vala_glib_value_new (_tmp701_, _tmp702_, TRUE); - _tmp704_ = _tmp703_; - _tmp705_ = instance_target_type; - _tmp706_ = init; - _tmp707_ = vala_ccode_base_module_transform_value (self, (ValaTargetValue*) _tmp704_, _tmp705_, (ValaCodeNode*) _tmp706_); + _tmp702_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp701_, VALA_TYPE_FIELD, ValaField)); + f = _tmp702_; + _tmp703_ = f; + _tmp704_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp703_); + _tmp705_ = _tmp704_; + _tmp706_ = vala_semantic_analyzer_get_data_type_for_symbol ((ValaSymbol*) G_TYPE_CHECK_INSTANCE_CAST (_tmp705_, VALA_TYPE_TYPESYMBOL, ValaTypeSymbol)); + instance_target_type = _tmp706_; + _tmp707_ = vala_object_creation_expression_get_type_reference (expr); _tmp708_ = _tmp707_; - _vala_target_value_unref0 (_tmp704_); - typed_inst = _tmp708_; - _tmp709_ = f; - _tmp710_ = typed_inst; - _tmp711_ = init; - _tmp712_ = vala_member_initializer_get_initializer (_tmp711_); - _tmp713_ = _tmp712_; - _tmp714_ = vala_expression_get_target_value (_tmp713_); + _tmp709_ = instance; + _tmp710_ = vala_glib_value_new (_tmp708_, _tmp709_, TRUE); + _tmp711_ = _tmp710_; + _tmp712_ = instance_target_type; + _tmp713_ = init; + _tmp714_ = vala_ccode_base_module_transform_value (self, (ValaTargetValue*) _tmp711_, _tmp712_, (ValaCodeNode*) _tmp713_); _tmp715_ = _tmp714_; - _tmp716_ = init; - _tmp717_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp716_); - _tmp718_ = _tmp717_; - vala_code_generator_store_field ((ValaCodeGenerator*) self, _tmp709_, _tmp710_, _tmp715_, _tmp718_); - _tmp719_ = f; - _tmp720_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp719_); - _tmp721_ = _tmp720_; - _tmp722_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp721_, VALA_TYPE_CLASS) ? ((ValaClass*) _tmp721_) : NULL); - cl = _tmp722_; - _tmp723_ = cl; - if (_tmp723_ != NULL) { - ValaClass* _tmp724_; - ValaCCodeFile* _tmp725_; - _tmp724_ = cl; - _tmp725_ = self->cfile; - vala_ccode_base_module_generate_class_struct_declaration (self, _tmp724_, _tmp725_); + _vala_target_value_unref0 (_tmp711_); + typed_inst = _tmp715_; + _tmp716_ = f; + _tmp717_ = typed_inst; + _tmp718_ = init; + _tmp719_ = vala_member_initializer_get_initializer (_tmp718_); + _tmp720_ = _tmp719_; + _tmp721_ = vala_expression_get_target_value (_tmp720_); + _tmp722_ = _tmp721_; + _tmp723_ = init; + _tmp724_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp723_); + _tmp725_ = _tmp724_; + vala_code_generator_store_field ((ValaCodeGenerator*) self, _tmp716_, _tmp717_, _tmp722_, _tmp725_); + _tmp726_ = f; + _tmp727_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp726_); + _tmp728_ = _tmp727_; + _tmp729_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp728_, VALA_TYPE_CLASS) ? ((ValaClass*) _tmp728_) : NULL); + cl = _tmp729_; + _tmp730_ = cl; + if (_tmp730_ != NULL) { + ValaClass* _tmp731_; + ValaCCodeFile* _tmp732_; + _tmp731_ = cl; + _tmp732_ = self->cfile; + vala_ccode_base_module_generate_class_struct_declaration (self, _tmp731_, _tmp732_); } _vala_code_node_unref0 (cl); _vala_target_value_unref0 (typed_inst); _vala_code_node_unref0 (instance_target_type); _vala_code_node_unref0 (f); } else { - ValaMemberInitializer* _tmp726_; - ValaSymbol* _tmp727_; - ValaSymbol* _tmp728_; - _tmp726_ = init; - _tmp727_ = vala_member_initializer_get_symbol_reference (_tmp726_); - _tmp728_ = _tmp727_; - if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp728_, VALA_TYPE_PROPERTY)) { + ValaMemberInitializer* _tmp733_; + ValaSymbol* _tmp734_; + ValaSymbol* _tmp735_; + _tmp733_ = init; + _tmp734_ = vala_member_initializer_get_symbol_reference (_tmp733_); + _tmp735_ = _tmp734_; + if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp735_, VALA_TYPE_PROPERTY)) { ValaProperty* p = NULL; - ValaMemberInitializer* _tmp729_; - ValaSymbol* _tmp730_; - ValaSymbol* _tmp731_; - ValaProperty* _tmp732_; - ValaProperty* _tmp733_; - ValaProperty* _tmp734_; - ValaProperty* _tmp735_; + ValaMemberInitializer* _tmp736_; + ValaSymbol* _tmp737_; + ValaSymbol* _tmp738_; + ValaProperty* _tmp739_; + ValaProperty* _tmp740_; + ValaProperty* _tmp741_; + ValaProperty* _tmp742_; ValaDataType* instance_target_type = NULL; - ValaProperty* _tmp747_; - ValaSymbol* _tmp748_; - ValaSymbol* _tmp749_; - ValaDataType* _tmp750_; + ValaProperty* _tmp754_; + ValaSymbol* _tmp755_; + ValaSymbol* _tmp756_; + ValaDataType* _tmp757_; ValaTargetValue* typed_inst = NULL; - ValaDataType* _tmp751_; - ValaDataType* _tmp752_; - ValaCCodeExpression* _tmp753_; - ValaGLibValue* _tmp754_; - ValaGLibValue* _tmp755_; - ValaDataType* _tmp756_; - ValaMemberInitializer* _tmp757_; - ValaTargetValue* _tmp758_; - ValaTargetValue* _tmp759_; + ValaDataType* _tmp758_; + ValaDataType* _tmp759_; + ValaCCodeExpression* _tmp760_; + ValaGLibValue* _tmp761_; + ValaGLibValue* _tmp762_; + ValaDataType* _tmp763_; + ValaMemberInitializer* _tmp764_; + ValaTargetValue* _tmp765_; + ValaTargetValue* _tmp766_; ValaMemberAccess* inst_ma = NULL; - ValaMemberAccess* _tmp760_; - ValaMemberAccess* _tmp761_; - ValaTargetValue* _tmp762_; - ValaProperty* _tmp763_; - ValaMemberAccess* _tmp764_; - ValaMemberInitializer* _tmp765_; - ValaExpression* _tmp766_; - ValaExpression* _tmp767_; - ValaTargetValue* _tmp768_; + ValaMemberAccess* _tmp767_; + ValaMemberAccess* _tmp768_; ValaTargetValue* _tmp769_; - gboolean _tmp770_ = FALSE; - ValaProperty* _tmp771_; - ValaPropertyAccessor* _tmp772_; - ValaPropertyAccessor* _tmp773_; - ValaDataType* _tmp774_; - ValaDataType* _tmp775_; - gboolean _tmp776_; - gboolean _tmp777_; - _tmp729_ = init; - _tmp730_ = vala_member_initializer_get_symbol_reference (_tmp729_); - _tmp731_ = _tmp730_; - _tmp732_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp731_, VALA_TYPE_PROPERTY, ValaProperty)); - p = _tmp732_; - _tmp733_ = p; - _tmp734_ = vala_property_get_base_property (_tmp733_); - _tmp735_ = _tmp734_; - if (_tmp735_ != NULL) { - ValaProperty* _tmp736_; - ValaProperty* _tmp737_; - ValaProperty* _tmp738_; - ValaProperty* _tmp739_; - _tmp736_ = p; - _tmp737_ = vala_property_get_base_property (_tmp736_); - _tmp738_ = _tmp737_; - _tmp739_ = _vala_code_node_ref0 (_tmp738_); + ValaProperty* _tmp770_; + ValaMemberAccess* _tmp771_; + ValaMemberInitializer* _tmp772_; + ValaExpression* _tmp773_; + ValaExpression* _tmp774_; + ValaTargetValue* _tmp775_; + ValaTargetValue* _tmp776_; + gboolean _tmp777_ = FALSE; + ValaProperty* _tmp778_; + ValaPropertyAccessor* _tmp779_; + ValaPropertyAccessor* _tmp780_; + ValaDataType* _tmp781_; + ValaDataType* _tmp782_; + gboolean _tmp783_; + gboolean _tmp784_; + _tmp736_ = init; + _tmp737_ = vala_member_initializer_get_symbol_reference (_tmp736_); + _tmp738_ = _tmp737_; + _tmp739_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp738_, VALA_TYPE_PROPERTY, ValaProperty)); + p = _tmp739_; + _tmp740_ = p; + _tmp741_ = vala_property_get_base_property (_tmp740_); + _tmp742_ = _tmp741_; + if (_tmp742_ != NULL) { + ValaProperty* _tmp743_; + ValaProperty* _tmp744_; + ValaProperty* _tmp745_; + ValaProperty* _tmp746_; + _tmp743_ = p; + _tmp744_ = vala_property_get_base_property (_tmp743_); + _tmp745_ = _tmp744_; + _tmp746_ = _vala_code_node_ref0 (_tmp745_); _vala_code_node_unref0 (p); - p = _tmp739_; + p = _tmp746_; } else { - ValaProperty* _tmp740_; - ValaProperty* _tmp741_; - ValaProperty* _tmp742_; - _tmp740_ = p; - _tmp741_ = vala_property_get_base_interface_property (_tmp740_); - _tmp742_ = _tmp741_; - if (_tmp742_ != NULL) { - ValaProperty* _tmp743_; - ValaProperty* _tmp744_; - ValaProperty* _tmp745_; - ValaProperty* _tmp746_; - _tmp743_ = p; - _tmp744_ = vala_property_get_base_interface_property (_tmp743_); - _tmp745_ = _tmp744_; - _tmp746_ = _vala_code_node_ref0 (_tmp745_); + ValaProperty* _tmp747_; + ValaProperty* _tmp748_; + ValaProperty* _tmp749_; + _tmp747_ = p; + _tmp748_ = vala_property_get_base_interface_property (_tmp747_); + _tmp749_ = _tmp748_; + if (_tmp749_ != NULL) { + ValaProperty* _tmp750_; + ValaProperty* _tmp751_; + ValaProperty* _tmp752_; + ValaProperty* _tmp753_; + _tmp750_ = p; + _tmp751_ = vala_property_get_base_interface_property (_tmp750_); + _tmp752_ = _tmp751_; + _tmp753_ = _vala_code_node_ref0 (_tmp752_); _vala_code_node_unref0 (p); - p = _tmp746_; + p = _tmp753_; } } - _tmp747_ = p; - _tmp748_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp747_); - _tmp749_ = _tmp748_; - _tmp750_ = vala_semantic_analyzer_get_data_type_for_symbol ((ValaSymbol*) G_TYPE_CHECK_INSTANCE_CAST (_tmp749_, VALA_TYPE_TYPESYMBOL, ValaTypeSymbol)); - instance_target_type = _tmp750_; - _tmp751_ = vala_object_creation_expression_get_type_reference (expr); - _tmp752_ = _tmp751_; - _tmp753_ = instance; - _tmp754_ = vala_glib_value_new (_tmp752_, _tmp753_, FALSE); - _tmp755_ = _tmp754_; - _tmp756_ = instance_target_type; - _tmp757_ = init; - _tmp758_ = vala_ccode_base_module_transform_value (self, (ValaTargetValue*) _tmp755_, _tmp756_, (ValaCodeNode*) _tmp757_); + _tmp754_ = p; + _tmp755_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp754_); + _tmp756_ = _tmp755_; + _tmp757_ = vala_semantic_analyzer_get_data_type_for_symbol ((ValaSymbol*) G_TYPE_CHECK_INSTANCE_CAST (_tmp756_, VALA_TYPE_TYPESYMBOL, ValaTypeSymbol)); + instance_target_type = _tmp757_; + _tmp758_ = vala_object_creation_expression_get_type_reference (expr); _tmp759_ = _tmp758_; - _vala_target_value_unref0 (_tmp755_); - typed_inst = _tmp759_; - _tmp760_ = vala_member_access_new_simple ("fake", NULL); - inst_ma = _tmp760_; - _tmp761_ = inst_ma; - _tmp762_ = typed_inst; - vala_expression_set_target_value ((ValaExpression*) _tmp761_, _tmp762_); - _tmp763_ = p; - _tmp764_ = inst_ma; - _tmp765_ = init; - _tmp766_ = vala_member_initializer_get_initializer (_tmp765_); - _tmp767_ = _tmp766_; - _tmp768_ = vala_expression_get_target_value (_tmp767_); - _tmp769_ = _tmp768_; - vala_ccode_base_module_store_property (self, _tmp763_, (ValaExpression*) _tmp764_, _tmp769_); - _tmp771_ = p; - _tmp772_ = vala_property_get_set_accessor (_tmp771_); - _tmp773_ = _tmp772_; - _tmp774_ = vala_property_accessor_get_value_type (_tmp773_); - _tmp775_ = _tmp774_; - _tmp776_ = vala_data_type_get_value_owned (_tmp775_); - _tmp777_ = _tmp776_; - if (!_tmp777_) { - ValaMemberInitializer* _tmp778_; - ValaExpression* _tmp779_; - ValaExpression* _tmp780_; - ValaTargetValue* _tmp781_; - ValaTargetValue* _tmp782_; - ValaDataType* _tmp783_; - ValaDataType* _tmp784_; - _tmp778_ = init; - _tmp779_ = vala_member_initializer_get_initializer (_tmp778_); - _tmp780_ = _tmp779_; - _tmp781_ = vala_expression_get_target_value (_tmp780_); - _tmp782_ = _tmp781_; - _tmp783_ = vala_target_value_get_value_type (_tmp782_); - _tmp784_ = _tmp783_; - _tmp770_ = vala_ccode_base_module_requires_destroy (_tmp784_); - } else { - _tmp770_ = FALSE; - } - if (_tmp770_) { - ValaCCodeFunction* _tmp785_; - ValaCCodeFunction* _tmp786_; - ValaMemberInitializer* _tmp787_; - ValaExpression* _tmp788_; - ValaExpression* _tmp789_; - ValaTargetValue* _tmp790_; - ValaTargetValue* _tmp791_; - ValaCCodeExpression* _tmp792_; - ValaCCodeExpression* _tmp793_; - _tmp785_ = vala_ccode_base_module_get_ccode (self); - _tmp786_ = _tmp785_; - _tmp787_ = init; - _tmp788_ = vala_member_initializer_get_initializer (_tmp787_); + _tmp760_ = instance; + _tmp761_ = vala_glib_value_new (_tmp759_, _tmp760_, FALSE); + _tmp762_ = _tmp761_; + _tmp763_ = instance_target_type; + _tmp764_ = init; + _tmp765_ = vala_ccode_base_module_transform_value (self, (ValaTargetValue*) _tmp762_, _tmp763_, (ValaCodeNode*) _tmp764_); + _tmp766_ = _tmp765_; + _vala_target_value_unref0 (_tmp762_); + typed_inst = _tmp766_; + _tmp767_ = vala_member_access_new_simple ("fake", NULL); + inst_ma = _tmp767_; + _tmp768_ = inst_ma; + _tmp769_ = typed_inst; + vala_expression_set_target_value ((ValaExpression*) _tmp768_, _tmp769_); + _tmp770_ = p; + _tmp771_ = inst_ma; + _tmp772_ = init; + _tmp773_ = vala_member_initializer_get_initializer (_tmp772_); + _tmp774_ = _tmp773_; + _tmp775_ = vala_expression_get_target_value (_tmp774_); + _tmp776_ = _tmp775_; + vala_ccode_base_module_store_property (self, _tmp770_, (ValaExpression*) _tmp771_, _tmp776_); + _tmp778_ = p; + _tmp779_ = vala_property_get_set_accessor (_tmp778_); + _tmp780_ = _tmp779_; + _tmp781_ = vala_property_accessor_get_value_type (_tmp780_); + _tmp782_ = _tmp781_; + _tmp783_ = vala_data_type_get_value_owned (_tmp782_); + _tmp784_ = _tmp783_; + if (!_tmp784_) { + ValaMemberInitializer* _tmp785_; + ValaExpression* _tmp786_; + ValaExpression* _tmp787_; + ValaTargetValue* _tmp788_; + ValaTargetValue* _tmp789_; + ValaDataType* _tmp790_; + ValaDataType* _tmp791_; + _tmp785_ = init; + _tmp786_ = vala_member_initializer_get_initializer (_tmp785_); + _tmp787_ = _tmp786_; + _tmp788_ = vala_expression_get_target_value (_tmp787_); _tmp789_ = _tmp788_; - _tmp790_ = vala_expression_get_target_value (_tmp789_); + _tmp790_ = vala_target_value_get_value_type (_tmp789_); _tmp791_ = _tmp790_; - _tmp792_ = vala_ccode_base_module_destroy_value (self, _tmp791_, FALSE); + _tmp777_ = vala_ccode_base_module_requires_destroy (_tmp791_); + } else { + _tmp777_ = FALSE; + } + if (_tmp777_) { + ValaCCodeFunction* _tmp792_; + ValaCCodeFunction* _tmp793_; + ValaMemberInitializer* _tmp794_; + ValaExpression* _tmp795_; + ValaExpression* _tmp796_; + ValaTargetValue* _tmp797_; + ValaTargetValue* _tmp798_; + ValaCCodeExpression* _tmp799_; + ValaCCodeExpression* _tmp800_; + _tmp792_ = vala_ccode_base_module_get_ccode (self); _tmp793_ = _tmp792_; - vala_ccode_function_add_expression (_tmp786_, _tmp793_); - _vala_ccode_node_unref0 (_tmp793_); + _tmp794_ = init; + _tmp795_ = vala_member_initializer_get_initializer (_tmp794_); + _tmp796_ = _tmp795_; + _tmp797_ = vala_expression_get_target_value (_tmp796_); + _tmp798_ = _tmp797_; + _tmp799_ = vala_ccode_base_module_destroy_value (self, _tmp798_, FALSE); + _tmp800_ = _tmp799_; + vala_ccode_function_add_expression (_tmp793_, _tmp800_); + _vala_ccode_node_unref0 (_tmp800_); } _vala_code_node_unref0 (inst_ma); _vala_target_value_unref0 (typed_inst); _vala_code_node_unref0 (instance_target_type); _vala_code_node_unref0 (p); } else { - ValaMemberInitializer* _tmp794_; - ValaSourceReference* _tmp795_; - ValaSourceReference* _tmp796_; - _tmp794_ = init; - _tmp795_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp794_); - _tmp796_ = _tmp795_; - vala_report_error (_tmp796_, "internal: Unsupported symbol"); + ValaMemberInitializer* _tmp801_; + ValaSourceReference* _tmp802_; + ValaSourceReference* _tmp803_; + _tmp801_ = init; + _tmp802_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp801_); + _tmp803_ = _tmp802_; + vala_report_error (_tmp803_, "internal: Unsupported symbol"); } } _vala_code_node_unref0 (init); } _vala_iterable_unref0 (_init_list); } - _tmp797_ = instance; - vala_set_cvalue ((ValaExpression*) expr, _tmp797_); + _tmp804_ = instance; + vala_set_cvalue ((ValaExpression*) expr, _tmp804_); } else { - ValaCCodeExpression* _tmp798_; - _tmp798_ = creation_expr; - if (_tmp798_ != NULL) { + ValaCCodeExpression* _tmp805_; + _tmp805_ = creation_expr; + if (_tmp805_ != NULL) { ValaTargetValue* temp_value = NULL; - ValaDataType* _tmp799_; - ValaDataType* _tmp800_; - ValaTargetValue* _tmp801_; - ValaCCodeFunction* _tmp802_; - ValaCCodeFunction* _tmp803_; - ValaTargetValue* _tmp804_; - ValaCCodeExpression* _tmp805_; - ValaCCodeExpression* _tmp806_; - ValaTargetValue* _tmp807_; + ValaDataType* _tmp806_; + ValaDataType* _tmp807_; + ValaTargetValue* _tmp808_; + ValaCCodeFunction* _tmp809_; + ValaCCodeFunction* _tmp810_; + ValaTargetValue* _tmp811_; + ValaCCodeExpression* _tmp812_; + ValaCCodeExpression* _tmp813_; + ValaTargetValue* _tmp814_; ValaClass* cl = NULL; - ValaDataType* _tmp808_; - ValaDataType* _tmp809_; - ValaTypeSymbol* _tmp810_; - ValaTypeSymbol* _tmp811_; - ValaCodeContext* _tmp812_; - gboolean _tmp813_; - gboolean _tmp814_; - gboolean _tmp859_ = FALSE; - ValaClass* _tmp860_; - _tmp799_ = vala_expression_get_value_type ((ValaExpression*) expr); - _tmp800_ = _tmp799_; - _tmp801_ = vala_ccode_base_module_create_temp_value (self, _tmp800_, FALSE, (ValaCodeNode*) expr, NULL); - temp_value = _tmp801_; - _tmp802_ = vala_ccode_base_module_get_ccode (self); - _tmp803_ = _tmp802_; - _tmp804_ = temp_value; - _tmp805_ = vala_get_cvalue_ (_tmp804_); - _tmp806_ = creation_expr; - vala_ccode_function_add_assignment (_tmp803_, _tmp805_, _tmp806_); - _tmp807_ = temp_value; - vala_expression_set_target_value ((ValaExpression*) expr, _tmp807_); - _tmp808_ = vala_object_creation_expression_get_type_reference (expr); - _tmp809_ = _tmp808_; - _tmp810_ = vala_data_type_get_type_symbol (_tmp809_); - _tmp811_ = _tmp810_; - cl = G_TYPE_CHECK_INSTANCE_TYPE (_tmp811_, VALA_TYPE_CLASS) ? ((ValaClass*) _tmp811_) : NULL; - _tmp812_ = self->priv->_context; - _tmp813_ = vala_code_context_get_gobject_tracing (_tmp812_); - _tmp814_ = _tmp813_; - if (_tmp814_) { - gboolean _tmp815_ = FALSE; - ValaClass* _tmp816_; - _tmp816_ = cl; - if (_tmp816_ != NULL) { - ValaClass* _tmp817_; - ValaTypeSymbol* _tmp818_; - _tmp817_ = cl; - _tmp818_ = self->gobject_type; - _tmp815_ = vala_typesymbol_is_subtype_of ((ValaTypeSymbol*) _tmp817_, _tmp818_); + ValaDataType* _tmp815_; + ValaDataType* _tmp816_; + ValaTypeSymbol* _tmp817_; + ValaTypeSymbol* _tmp818_; + ValaCodeContext* _tmp819_; + gboolean _tmp820_; + gboolean _tmp821_; + gboolean _tmp866_ = FALSE; + ValaClass* _tmp867_; + _tmp806_ = vala_expression_get_value_type ((ValaExpression*) expr); + _tmp807_ = _tmp806_; + _tmp808_ = vala_ccode_base_module_create_temp_value (self, _tmp807_, FALSE, (ValaCodeNode*) expr, NULL); + temp_value = _tmp808_; + _tmp809_ = vala_ccode_base_module_get_ccode (self); + _tmp810_ = _tmp809_; + _tmp811_ = temp_value; + _tmp812_ = vala_get_cvalue_ (_tmp811_); + _tmp813_ = creation_expr; + vala_ccode_function_add_assignment (_tmp810_, _tmp812_, _tmp813_); + _tmp814_ = temp_value; + vala_expression_set_target_value ((ValaExpression*) expr, _tmp814_); + _tmp815_ = vala_object_creation_expression_get_type_reference (expr); + _tmp816_ = _tmp815_; + _tmp817_ = vala_data_type_get_type_symbol (_tmp816_); + _tmp818_ = _tmp817_; + cl = G_TYPE_CHECK_INSTANCE_TYPE (_tmp818_, VALA_TYPE_CLASS) ? ((ValaClass*) _tmp818_) : NULL; + _tmp819_ = self->priv->_context; + _tmp820_ = vala_code_context_get_gobject_tracing (_tmp819_); + _tmp821_ = _tmp820_; + if (_tmp821_) { + gboolean _tmp822_ = FALSE; + ValaClass* _tmp823_; + _tmp823_ = cl; + if (_tmp823_ != NULL) { + ValaClass* _tmp824_; + ValaTypeSymbol* _tmp825_; + _tmp824_ = cl; + _tmp825_ = self->gobject_type; + _tmp822_ = vala_typesymbol_is_subtype_of ((ValaTypeSymbol*) _tmp824_, _tmp825_); } else { - _tmp815_ = FALSE; + _tmp822_ = FALSE; } - if (_tmp815_) { - ValaCCodeFunction* _tmp819_; - ValaCCodeFunction* _tmp820_; - ValaTargetValue* _tmp821_; - ValaTargetValue* _tmp822_; - ValaCCodeExpression* _tmp823_; - ValaCCodeFunctionCall* set_data_call = NULL; - ValaCCodeIdentifier* _tmp824_; - ValaCCodeIdentifier* _tmp825_; - ValaCCodeFunctionCall* _tmp826_; - ValaCCodeFunctionCall* _tmp827_; - ValaCCodeFunctionCall* _tmp828_; + if (_tmp822_) { + ValaCCodeFunction* _tmp826_; + ValaCCodeFunction* _tmp827_; + ValaTargetValue* _tmp828_; ValaTargetValue* _tmp829_; - ValaTargetValue* _tmp830_; - ValaCCodeExpression* _tmp831_; - ValaCCodeCastExpression* _tmp832_; - ValaCCodeCastExpression* _tmp833_; + ValaCCodeExpression* _tmp830_; + ValaCCodeFunctionCall* set_data_call = NULL; + ValaCCodeIdentifier* _tmp831_; + ValaCCodeIdentifier* _tmp832_; + ValaCCodeFunctionCall* _tmp833_; ValaCCodeFunctionCall* _tmp834_; - ValaCCodeConstant* _tmp835_; - ValaCCodeConstant* _tmp836_; + ValaCCodeFunctionCall* _tmp835_; + ValaTargetValue* _tmp836_; + ValaTargetValue* _tmp837_; + ValaCCodeExpression* _tmp838_; + ValaCCodeCastExpression* _tmp839_; + ValaCCodeCastExpression* _tmp840_; + ValaCCodeFunctionCall* _tmp841_; + ValaCCodeConstant* _tmp842_; + ValaCCodeConstant* _tmp843_; gchar* func_name = NULL; - gchar* _tmp837_; - ValaMethod* _tmp838_; - ValaMethod* _tmp839_; - ValaCCodeFunctionCall* _tmp848_; - const gchar* _tmp849_; - gchar* _tmp850_; - gchar* _tmp851_; - ValaCCodeConstant* _tmp852_; - ValaCCodeConstant* _tmp853_; - ValaCCodeFunction* _tmp854_; - ValaCCodeFunction* _tmp855_; - ValaCCodeFunctionCall* _tmp856_; - ValaCCodeFunction* _tmp857_; - ValaCCodeFunction* _tmp858_; - _tmp819_ = vala_ccode_base_module_get_ccode (self); - _tmp820_ = _tmp819_; - _tmp821_ = vala_expression_get_target_value ((ValaExpression*) expr); - _tmp822_ = _tmp821_; - _tmp823_ = vala_get_cvalue_ (_tmp822_); - vala_ccode_function_open_if (_tmp820_, _tmp823_); - _tmp824_ = vala_ccode_identifier_new ("g_object_set_data"); - _tmp825_ = _tmp824_; - _tmp826_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp825_); + gchar* _tmp844_; + ValaMethod* _tmp845_; + ValaMethod* _tmp846_; + ValaCCodeFunctionCall* _tmp855_; + const gchar* _tmp856_; + gchar* _tmp857_; + gchar* _tmp858_; + ValaCCodeConstant* _tmp859_; + ValaCCodeConstant* _tmp860_; + ValaCCodeFunction* _tmp861_; + ValaCCodeFunction* _tmp862_; + ValaCCodeFunctionCall* _tmp863_; + ValaCCodeFunction* _tmp864_; + ValaCCodeFunction* _tmp865_; + _tmp826_ = vala_ccode_base_module_get_ccode (self); _tmp827_ = _tmp826_; - _vala_ccode_node_unref0 (_tmp825_); - set_data_call = _tmp827_; - _tmp828_ = set_data_call; - _tmp829_ = vala_expression_get_target_value ((ValaExpression*) expr); - _tmp830_ = _tmp829_; - _tmp831_ = vala_get_cvalue_ (_tmp830_); - _tmp832_ = vala_ccode_cast_expression_new (_tmp831_, "GObject *"); - _tmp833_ = _tmp832_; - vala_ccode_function_call_add_argument (_tmp828_, (ValaCCodeExpression*) _tmp833_); - _vala_ccode_node_unref0 (_tmp833_); - _tmp834_ = set_data_call; - _tmp835_ = vala_ccode_constant_new ("\"vala-creation-function\""); - _tmp836_ = _tmp835_; - vala_ccode_function_call_add_argument (_tmp834_, (ValaCCodeExpression*) _tmp836_); - _vala_ccode_node_unref0 (_tmp836_); - _tmp837_ = g_strdup (""); - func_name = _tmp837_; - _tmp838_ = vala_ccode_base_module_get_current_method (self); - _tmp839_ = _tmp838_; - if (_tmp839_ != NULL) { - ValaMethod* _tmp840_; - ValaMethod* _tmp841_; - gchar* _tmp842_; - _tmp840_ = vala_ccode_base_module_get_current_method (self); - _tmp841_ = _tmp840_; - _tmp842_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp841_); + _tmp828_ = vala_expression_get_target_value ((ValaExpression*) expr); + _tmp829_ = _tmp828_; + _tmp830_ = vala_get_cvalue_ (_tmp829_); + vala_ccode_function_open_if (_tmp827_, _tmp830_); + _tmp831_ = vala_ccode_identifier_new ("g_object_set_data"); + _tmp832_ = _tmp831_; + _tmp833_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp832_); + _tmp834_ = _tmp833_; + _vala_ccode_node_unref0 (_tmp832_); + set_data_call = _tmp834_; + _tmp835_ = set_data_call; + _tmp836_ = vala_expression_get_target_value ((ValaExpression*) expr); + _tmp837_ = _tmp836_; + _tmp838_ = vala_get_cvalue_ (_tmp837_); + _tmp839_ = vala_ccode_cast_expression_new (_tmp838_, "GObject *"); + _tmp840_ = _tmp839_; + vala_ccode_function_call_add_argument (_tmp835_, (ValaCCodeExpression*) _tmp840_); + _vala_ccode_node_unref0 (_tmp840_); + _tmp841_ = set_data_call; + _tmp842_ = vala_ccode_constant_new ("\"vala-creation-function\""); + _tmp843_ = _tmp842_; + vala_ccode_function_call_add_argument (_tmp841_, (ValaCCodeExpression*) _tmp843_); + _vala_ccode_node_unref0 (_tmp843_); + _tmp844_ = g_strdup (""); + func_name = _tmp844_; + _tmp845_ = vala_ccode_base_module_get_current_method (self); + _tmp846_ = _tmp845_; + if (_tmp846_ != NULL) { + ValaMethod* _tmp847_; + ValaMethod* _tmp848_; + gchar* _tmp849_; + _tmp847_ = vala_ccode_base_module_get_current_method (self); + _tmp848_ = _tmp847_; + _tmp849_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp848_); _g_free0 (func_name); - func_name = _tmp842_; + func_name = _tmp849_; } else { - ValaPropertyAccessor* _tmp843_; - ValaPropertyAccessor* _tmp844_; - _tmp843_ = vala_ccode_base_module_get_current_property_accessor (self); - _tmp844_ = _tmp843_; - if (_tmp844_ != NULL) { - ValaPropertyAccessor* _tmp845_; - ValaPropertyAccessor* _tmp846_; - gchar* _tmp847_; - _tmp845_ = vala_ccode_base_module_get_current_property_accessor (self); - _tmp846_ = _tmp845_; - _tmp847_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp846_); + ValaPropertyAccessor* _tmp850_; + ValaPropertyAccessor* _tmp851_; + _tmp850_ = vala_ccode_base_module_get_current_property_accessor (self); + _tmp851_ = _tmp850_; + if (_tmp851_ != NULL) { + ValaPropertyAccessor* _tmp852_; + ValaPropertyAccessor* _tmp853_; + gchar* _tmp854_; + _tmp852_ = vala_ccode_base_module_get_current_property_accessor (self); + _tmp853_ = _tmp852_; + _tmp854_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp853_); _g_free0 (func_name); - func_name = _tmp847_; + func_name = _tmp854_; } } - _tmp848_ = set_data_call; - _tmp849_ = func_name; - _tmp850_ = g_strdup_printf ("\"%s\"", _tmp849_); - _tmp851_ = _tmp850_; - _tmp852_ = vala_ccode_constant_new (_tmp851_); - _tmp853_ = _tmp852_; - vala_ccode_function_call_add_argument (_tmp848_, (ValaCCodeExpression*) _tmp853_); - _vala_ccode_node_unref0 (_tmp853_); - _g_free0 (_tmp851_); - _tmp854_ = vala_ccode_base_module_get_ccode (self); - _tmp855_ = _tmp854_; - _tmp856_ = set_data_call; - vala_ccode_function_add_expression (_tmp855_, (ValaCCodeExpression*) _tmp856_); - _tmp857_ = vala_ccode_base_module_get_ccode (self); + _tmp855_ = set_data_call; + _tmp856_ = func_name; + _tmp857_ = g_strdup_printf ("\"%s\"", _tmp856_); _tmp858_ = _tmp857_; - vala_ccode_function_close (_tmp858_); + _tmp859_ = vala_ccode_constant_new (_tmp858_); + _tmp860_ = _tmp859_; + vala_ccode_function_call_add_argument (_tmp855_, (ValaCCodeExpression*) _tmp860_); + _vala_ccode_node_unref0 (_tmp860_); + _g_free0 (_tmp858_); + _tmp861_ = vala_ccode_base_module_get_ccode (self); + _tmp862_ = _tmp861_; + _tmp863_ = set_data_call; + vala_ccode_function_add_expression (_tmp862_, (ValaCCodeExpression*) _tmp863_); + _tmp864_ = vala_ccode_base_module_get_ccode (self); + _tmp865_ = _tmp864_; + vala_ccode_function_close (_tmp865_); _g_free0 (func_name); _vala_ccode_node_unref0 (set_data_call); } } - _tmp860_ = cl; - if (_tmp860_ != NULL) { - ValaClass* _tmp861_; - ValaTypeSymbol* _tmp862_; - _tmp861_ = cl; - _tmp862_ = self->garray_type; - _tmp859_ = G_TYPE_CHECK_INSTANCE_CAST (_tmp861_, VALA_TYPE_TYPESYMBOL, ValaTypeSymbol) == _tmp862_; + _tmp867_ = cl; + if (_tmp867_ != NULL) { + ValaClass* _tmp868_; + ValaTypeSymbol* _tmp869_; + _tmp868_ = cl; + _tmp869_ = self->garray_type; + _tmp866_ = G_TYPE_CHECK_INSTANCE_CAST (_tmp868_, VALA_TYPE_TYPESYMBOL, ValaTypeSymbol) == _tmp869_; } else { - _tmp859_ = FALSE; + _tmp866_ = FALSE; } - if (_tmp859_) { + if (_tmp866_) { ValaDataType* type_arg = NULL; - ValaDataType* _tmp863_; - ValaDataType* _tmp864_; - ValaList* _tmp865_; - gpointer _tmp866_; - ValaDataType* _tmp867_; - _tmp863_ = vala_object_creation_expression_get_type_reference (expr); - _tmp864_ = _tmp863_; - _tmp865_ = vala_data_type_get_type_arguments (_tmp864_); - _tmp866_ = vala_list_get (_tmp865_, 0); - type_arg = (ValaDataType*) _tmp866_; - _tmp867_ = type_arg; - if (vala_ccode_base_module_requires_destroy (_tmp867_)) { + ValaDataType* _tmp870_; + ValaDataType* _tmp871_; + ValaList* _tmp872_; + gpointer _tmp873_; + ValaDataType* _tmp874_; + _tmp870_ = vala_object_creation_expression_get_type_reference (expr); + _tmp871_ = _tmp870_; + _tmp872_ = vala_data_type_get_type_arguments (_tmp871_); + _tmp873_ = vala_list_get (_tmp872_, 0); + type_arg = (ValaDataType*) _tmp873_; + _tmp874_ = type_arg; + if (vala_ccode_base_module_requires_destroy (_tmp874_)) { ValaCCodeFunctionCall* clear_func = NULL; - ValaCCodeIdentifier* _tmp868_; - ValaCCodeIdentifier* _tmp869_; - ValaCCodeFunctionCall* _tmp870_; - ValaCCodeFunctionCall* _tmp871_; - ValaCCodeFunctionCall* _tmp872_; - ValaTargetValue* _tmp873_; - ValaTargetValue* _tmp874_; - ValaCCodeExpression* _tmp875_; + ValaCCodeIdentifier* _tmp875_; + ValaCCodeIdentifier* _tmp876_; + ValaCCodeFunctionCall* _tmp877_; + ValaCCodeFunctionCall* _tmp878_; + ValaCCodeFunctionCall* _tmp879_; + ValaTargetValue* _tmp880_; + ValaTargetValue* _tmp881_; + ValaCCodeExpression* _tmp882_; gchar* destroy_func = NULL; - gboolean _tmp876_ = FALSE; - ValaDataType* _tmp877_; - ValaCCodeFunctionCall* _tmp885_; - const gchar* _tmp886_; - ValaCCodeIdentifier* _tmp887_; - ValaCCodeIdentifier* _tmp888_; - ValaCCodeCastExpression* _tmp889_; - ValaCCodeCastExpression* _tmp890_; - ValaCCodeFunction* _tmp891_; - ValaCCodeFunction* _tmp892_; - ValaCCodeFunctionCall* _tmp893_; - _tmp868_ = vala_ccode_identifier_new ("g_array_set_clear_func"); - _tmp869_ = _tmp868_; - _tmp870_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp869_); - _tmp871_ = _tmp870_; - _vala_ccode_node_unref0 (_tmp869_); - clear_func = _tmp871_; - _tmp872_ = clear_func; - _tmp873_ = vala_expression_get_target_value ((ValaExpression*) expr); - _tmp874_ = _tmp873_; - _tmp875_ = vala_get_cvalue_ (_tmp874_); - vala_ccode_function_call_add_argument (_tmp872_, _tmp875_); - _tmp877_ = type_arg; - if (vala_data_type_is_non_null_simple_type (_tmp877_)) { - _tmp876_ = TRUE; + gboolean _tmp883_ = FALSE; + ValaDataType* _tmp884_; + ValaCCodeFunctionCall* _tmp892_; + const gchar* _tmp893_; + ValaCCodeIdentifier* _tmp894_; + ValaCCodeIdentifier* _tmp895_; + ValaCCodeCastExpression* _tmp896_; + ValaCCodeCastExpression* _tmp897_; + ValaCCodeFunction* _tmp898_; + ValaCCodeFunction* _tmp899_; + ValaCCodeFunctionCall* _tmp900_; + _tmp875_ = vala_ccode_identifier_new ("g_array_set_clear_func"); + _tmp876_ = _tmp875_; + _tmp877_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp876_); + _tmp878_ = _tmp877_; + _vala_ccode_node_unref0 (_tmp876_); + clear_func = _tmp878_; + _tmp879_ = clear_func; + _tmp880_ = vala_expression_get_target_value ((ValaExpression*) expr); + _tmp881_ = _tmp880_; + _tmp882_ = vala_get_cvalue_ (_tmp881_); + vala_ccode_function_call_add_argument (_tmp879_, _tmp882_); + _tmp884_ = type_arg; + if (vala_data_type_is_non_null_simple_type (_tmp884_)) { + _tmp883_ = TRUE; } else { - ValaDataType* _tmp878_; - _tmp878_ = type_arg; - _tmp876_ = vala_data_type_is_real_non_null_struct_type (_tmp878_); - } - if (_tmp876_) { - ValaDataType* _tmp879_; - ValaTypeSymbol* _tmp880_; - ValaTypeSymbol* _tmp881_; - gchar* _tmp882_; - _tmp879_ = type_arg; - _tmp880_ = vala_data_type_get_type_symbol (_tmp879_); - _tmp881_ = _tmp880_; - _tmp882_ = vala_get_ccode_destroy_function (_tmp881_); + ValaDataType* _tmp885_; + _tmp885_ = type_arg; + _tmp883_ = vala_data_type_is_real_non_null_struct_type (_tmp885_); + } + if (_tmp883_) { + ValaDataType* _tmp886_; + ValaTypeSymbol* _tmp887_; + ValaTypeSymbol* _tmp888_; + gchar* _tmp889_; + _tmp886_ = type_arg; + _tmp887_ = vala_data_type_get_type_symbol (_tmp886_); + _tmp888_ = _tmp887_; + _tmp889_ = vala_get_ccode_destroy_function (_tmp888_); _g_free0 (destroy_func); - destroy_func = _tmp882_; + destroy_func = _tmp889_; } else { - ValaDataType* _tmp883_; - gchar* _tmp884_; - _tmp883_ = type_arg; - _tmp884_ = vala_ccode_base_module_generate_destroy_function_content_of_wrapper (self, _tmp883_); + ValaDataType* _tmp890_; + gchar* _tmp891_; + _tmp890_ = type_arg; + _tmp891_ = vala_ccode_base_module_generate_destroy_function_content_of_wrapper (self, _tmp890_); _g_free0 (destroy_func); - destroy_func = _tmp884_; + destroy_func = _tmp891_; } - _tmp885_ = clear_func; - _tmp886_ = destroy_func; - _tmp887_ = vala_ccode_identifier_new (_tmp886_); - _tmp888_ = _tmp887_; - _tmp889_ = vala_ccode_cast_expression_new ((ValaCCodeExpression*) _tmp888_, "GDestroyNotify"); - _tmp890_ = _tmp889_; - vala_ccode_function_call_add_argument (_tmp885_, (ValaCCodeExpression*) _tmp890_); - _vala_ccode_node_unref0 (_tmp890_); - _vala_ccode_node_unref0 (_tmp888_); - _tmp891_ = vala_ccode_base_module_get_ccode (self); - _tmp892_ = _tmp891_; - _tmp893_ = clear_func; - vala_ccode_function_add_expression (_tmp892_, (ValaCCodeExpression*) _tmp893_); + _tmp892_ = clear_func; + _tmp893_ = destroy_func; + _tmp894_ = vala_ccode_identifier_new (_tmp893_); + _tmp895_ = _tmp894_; + _tmp896_ = vala_ccode_cast_expression_new ((ValaCCodeExpression*) _tmp895_, "GDestroyNotify"); + _tmp897_ = _tmp896_; + vala_ccode_function_call_add_argument (_tmp892_, (ValaCCodeExpression*) _tmp897_); + _vala_ccode_node_unref0 (_tmp897_); + _vala_ccode_node_unref0 (_tmp895_); + _tmp898_ = vala_ccode_base_module_get_ccode (self); + _tmp899_ = _tmp898_; + _tmp900_ = clear_func; + vala_ccode_function_add_expression (_tmp899_, (ValaCCodeExpression*) _tmp900_); _g_free0 (destroy_func); _vala_ccode_node_unref0 (clear_func); } @@ -29490,9 +29507,9 @@ } } } - _tmp894_ = vala_expression_get_target_value ((ValaExpression*) expr); - _tmp895_ = _tmp894_; - G_TYPE_CHECK_INSTANCE_CAST (_tmp895_, VALA_TYPE_GLIB_VALUE, ValaGLibValue)->lvalue = TRUE; + _tmp901_ = vala_expression_get_target_value ((ValaExpression*) expr); + _tmp902_ = _tmp901_; + G_TYPE_CHECK_INSTANCE_CAST (_tmp902_, VALA_TYPE_GLIB_VALUE, ValaGLibValue)->lvalue = TRUE; _vala_code_node_unref0 (local); _vala_ccode_node_unref0 (creation_expr); _vala_ccode_node_unref0 (instance); @@ -29712,14 +29729,13 @@ ValaUnaryOperator _tmp67_; ValaUnaryOperator _tmp68_; ValaCCodeUnaryOperator op = 0; + ValaUnaryOperator _tmp108_; ValaUnaryOperator _tmp109_; - ValaUnaryOperator _tmp110_; - ValaCCodeUnaryOperator _tmp111_; - ValaExpression* _tmp112_; - ValaExpression* _tmp113_; - ValaCCodeExpression* _tmp114_; - ValaCCodeUnaryExpression* _tmp115_; - ValaCCodeUnaryExpression* _tmp116_; + ValaExpression* _tmp110_; + ValaExpression* _tmp111_; + ValaCCodeExpression* _tmp112_; + ValaCCodeUnaryExpression* _tmp113_; + ValaCCodeUnaryExpression* _tmp114_; self = (ValaCCodeBaseModule*) base; g_return_if_fail (expr != NULL); _tmp1_ = vala_unary_expression_get_operator (expr); @@ -29925,34 +29941,33 @@ ValaUnaryOperator _tmp73_; ValaCCodeBinaryOperator op = 0; ValaCCodeBinaryExpression* cexpr = NULL; - ValaCCodeBinaryOperator _tmp74_; + ValaExpression* _tmp74_; ValaExpression* _tmp75_; - ValaExpression* _tmp76_; + ValaTargetValue* _tmp76_; ValaTargetValue* _tmp77_; - ValaTargetValue* _tmp78_; - ValaCCodeExpression* _tmp79_; + ValaCCodeExpression* _tmp78_; + ValaCCodeConstant* _tmp79_; ValaCCodeConstant* _tmp80_; - ValaCCodeConstant* _tmp81_; + ValaCCodeBinaryExpression* _tmp81_; ValaCCodeBinaryExpression* _tmp82_; - ValaCCodeBinaryExpression* _tmp83_; + ValaCCodeFunction* _tmp83_; ValaCCodeFunction* _tmp84_; - ValaCCodeFunction* _tmp85_; + ValaExpression* _tmp85_; ValaExpression* _tmp86_; - ValaExpression* _tmp87_; - ValaCCodeExpression* _tmp88_; - ValaCCodeBinaryExpression* _tmp89_; + ValaCCodeExpression* _tmp87_; + ValaCCodeBinaryExpression* _tmp88_; ValaTargetValue* temp_value = NULL; + ValaExpression* _tmp89_; ValaExpression* _tmp90_; - ValaExpression* _tmp91_; + ValaTargetValue* _tmp91_; ValaTargetValue* _tmp92_; ValaTargetValue* _tmp93_; - ValaTargetValue* _tmp94_; ValaMemberAccess* ma = NULL; + ValaExpression* _tmp94_; ValaExpression* _tmp95_; - ValaExpression* _tmp96_; + ValaMemberAccess* _tmp96_; ValaMemberAccess* _tmp97_; - ValaMemberAccess* _tmp98_; - ValaTargetValue* _tmp108_; + ValaTargetValue* _tmp107_; _tmp72_ = vala_unary_expression_get_operator (expr); _tmp73_ = _tmp72_; if (_tmp73_ == VALA_UNARY_OPERATOR_INCREMENT) { @@ -29961,70 +29976,69 @@ _tmp71_ = VALA_CCODE_BINARY_OPERATOR_MINUS; } op = _tmp71_; - _tmp74_ = op; - _tmp75_ = vala_unary_expression_get_inner (expr); - _tmp76_ = _tmp75_; - _tmp77_ = vala_expression_get_target_value (_tmp76_); - _tmp78_ = _tmp77_; - _tmp79_ = vala_get_cvalue_ (_tmp78_); - _tmp80_ = vala_ccode_constant_new ("1"); - _tmp81_ = _tmp80_; - _tmp82_ = vala_ccode_binary_expression_new (_tmp74_, _tmp79_, (ValaCCodeExpression*) _tmp81_); - _tmp83_ = _tmp82_; - _vala_ccode_node_unref0 (_tmp81_); - cexpr = _tmp83_; - _tmp84_ = vala_ccode_base_module_get_ccode (self); - _tmp85_ = _tmp84_; - _tmp86_ = vala_unary_expression_get_inner (expr); - _tmp87_ = _tmp86_; - _tmp88_ = vala_get_cvalue (_tmp87_); - _tmp89_ = cexpr; - vala_ccode_function_add_assignment (_tmp85_, _tmp88_, (ValaCCodeExpression*) _tmp89_); - _tmp90_ = vala_unary_expression_get_inner (expr); - _tmp91_ = _tmp90_; - _tmp92_ = vala_expression_get_target_value (_tmp91_); - _tmp93_ = _tmp92_; - _tmp94_ = vala_ccode_base_module_store_temp_value (self, _tmp93_, (ValaCodeNode*) expr, NULL); - temp_value = _tmp94_; - _tmp95_ = vala_unary_expression_get_inner (expr); - _tmp96_ = _tmp95_; - _tmp97_ = vala_ccode_base_module_find_property_access (self, _tmp96_); - ma = _tmp97_; - _tmp98_ = ma; - if (_tmp98_ != NULL) { + _tmp74_ = vala_unary_expression_get_inner (expr); + _tmp75_ = _tmp74_; + _tmp76_ = vala_expression_get_target_value (_tmp75_); + _tmp77_ = _tmp76_; + _tmp78_ = vala_get_cvalue_ (_tmp77_); + _tmp79_ = vala_ccode_constant_new ("1"); + _tmp80_ = _tmp79_; + _tmp81_ = vala_ccode_binary_expression_new (op, _tmp78_, (ValaCCodeExpression*) _tmp80_); + _tmp82_ = _tmp81_; + _vala_ccode_node_unref0 (_tmp80_); + cexpr = _tmp82_; + _tmp83_ = vala_ccode_base_module_get_ccode (self); + _tmp84_ = _tmp83_; + _tmp85_ = vala_unary_expression_get_inner (expr); + _tmp86_ = _tmp85_; + _tmp87_ = vala_get_cvalue (_tmp86_); + _tmp88_ = cexpr; + vala_ccode_function_add_assignment (_tmp84_, _tmp87_, (ValaCCodeExpression*) _tmp88_); + _tmp89_ = vala_unary_expression_get_inner (expr); + _tmp90_ = _tmp89_; + _tmp91_ = vala_expression_get_target_value (_tmp90_); + _tmp92_ = _tmp91_; + _tmp93_ = vala_ccode_base_module_store_temp_value (self, _tmp92_, (ValaCodeNode*) expr, NULL); + temp_value = _tmp93_; + _tmp94_ = vala_unary_expression_get_inner (expr); + _tmp95_ = _tmp94_; + _tmp96_ = vala_ccode_base_module_find_property_access (self, _tmp95_); + ma = _tmp96_; + _tmp97_ = ma; + if (_tmp97_ != NULL) { ValaProperty* prop = NULL; - ValaMemberAccess* _tmp99_; + ValaMemberAccess* _tmp98_; + ValaSymbol* _tmp99_; ValaSymbol* _tmp100_; - ValaSymbol* _tmp101_; + ValaProperty* _tmp101_; ValaProperty* _tmp102_; - ValaProperty* _tmp103_; - ValaMemberAccess* _tmp104_; + ValaMemberAccess* _tmp103_; + ValaExpression* _tmp104_; ValaExpression* _tmp105_; - ValaExpression* _tmp106_; - ValaTargetValue* _tmp107_; - _tmp99_ = ma; - _tmp100_ = vala_expression_get_symbol_reference ((ValaExpression*) _tmp99_); - _tmp101_ = _tmp100_; - _tmp102_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp101_, VALA_TYPE_PROPERTY, ValaProperty)); - prop = _tmp102_; - _tmp103_ = prop; - _tmp104_ = ma; - _tmp105_ = vala_member_access_get_inner (_tmp104_); - _tmp106_ = _tmp105_; - _tmp107_ = temp_value; - vala_ccode_base_module_store_property (self, _tmp103_, _tmp106_, _tmp107_); + ValaTargetValue* _tmp106_; + _tmp98_ = ma; + _tmp99_ = vala_expression_get_symbol_reference ((ValaExpression*) _tmp98_); + _tmp100_ = _tmp99_; + _tmp101_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp100_, VALA_TYPE_PROPERTY, ValaProperty)); + prop = _tmp101_; + _tmp102_ = prop; + _tmp103_ = ma; + _tmp104_ = vala_member_access_get_inner (_tmp103_); + _tmp105_ = _tmp104_; + _tmp106_ = temp_value; + vala_ccode_base_module_store_property (self, _tmp102_, _tmp105_, _tmp106_); _vala_code_node_unref0 (prop); } - _tmp108_ = temp_value; - vala_expression_set_target_value ((ValaExpression*) expr, _tmp108_); + _tmp107_ = temp_value; + vala_expression_set_target_value ((ValaExpression*) expr, _tmp107_); _vala_code_node_unref0 (ma); _vala_target_value_unref0 (temp_value); _vala_ccode_node_unref0 (cexpr); return; } - _tmp109_ = vala_unary_expression_get_operator (expr); - _tmp110_ = _tmp109_; - switch (_tmp110_) { + _tmp108_ = vala_unary_expression_get_operator (expr); + _tmp109_ = _tmp108_; + switch (_tmp109_) { case VALA_UNARY_OPERATOR_PLUS: { op = VALA_CCODE_UNARY_OPERATOR_PLUS; @@ -30060,14 +30074,13 @@ g_assert_not_reached (); } } - _tmp111_ = op; - _tmp112_ = vala_unary_expression_get_inner (expr); - _tmp113_ = _tmp112_; - _tmp114_ = vala_get_cvalue (_tmp113_); - _tmp115_ = vala_ccode_unary_expression_new (_tmp111_, _tmp114_); - _tmp116_ = _tmp115_; - vala_set_cvalue ((ValaExpression*) expr, (ValaCCodeExpression*) _tmp116_); - _vala_ccode_node_unref0 (_tmp116_); + _tmp110_ = vala_unary_expression_get_inner (expr); + _tmp111_ = _tmp110_; + _tmp112_ = vala_get_cvalue (_tmp111_); + _tmp113_ = vala_ccode_unary_expression_new (op, _tmp112_); + _tmp114_ = _tmp113_; + vala_set_cvalue ((ValaExpression*) expr, (ValaCCodeExpression*) _tmp114_); + _vala_ccode_node_unref0 (_tmp114_); } static ValaCCodeExpression* @@ -31278,12 +31291,11 @@ ValaExpression* _tmp250_; gboolean has_string_literal = FALSE; gboolean _tmp253_ = FALSE; - ValaCCodeBinaryOperator _tmp380_; + ValaCCodeExpression* _tmp380_; ValaCCodeExpression* _tmp381_; - ValaCCodeExpression* _tmp382_; + ValaCCodeBinaryExpression* _tmp382_; ValaCCodeBinaryExpression* _tmp383_; - ValaCCodeBinaryExpression* _tmp384_; - ValaCCodeExpression* _tmp385_; + ValaCCodeExpression* _tmp384_; self = (ValaCCodeBaseModule*) base; g_return_if_fail (expr != NULL); _tmp0_ = vala_binary_expression_get_left (expr); @@ -32477,25 +32489,24 @@ } } } - _tmp380_ = op; - _tmp381_ = cleft; - _tmp382_ = cright; - _tmp383_ = vala_ccode_binary_expression_new (_tmp380_, _tmp381_, _tmp382_); - _tmp384_ = _tmp383_; - vala_set_cvalue ((ValaExpression*) expr, (ValaCCodeExpression*) _tmp384_); - _vala_ccode_node_unref0 (_tmp384_); - _tmp385_ = left_chain; - if (_tmp385_ != NULL) { + _tmp380_ = cleft; + _tmp381_ = cright; + _tmp382_ = vala_ccode_binary_expression_new (op, _tmp380_, _tmp381_); + _tmp383_ = _tmp382_; + vala_set_cvalue ((ValaExpression*) expr, (ValaCCodeExpression*) _tmp383_); + _vala_ccode_node_unref0 (_tmp383_); + _tmp384_ = left_chain; + if (_tmp384_ != NULL) { + ValaCCodeExpression* _tmp385_; ValaCCodeExpression* _tmp386_; - ValaCCodeExpression* _tmp387_; + ValaCCodeBinaryExpression* _tmp387_; ValaCCodeBinaryExpression* _tmp388_; - ValaCCodeBinaryExpression* _tmp389_; - _tmp386_ = left_chain; - _tmp387_ = vala_get_cvalue ((ValaExpression*) expr); - _tmp388_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_AND, _tmp386_, _tmp387_); - _tmp389_ = _tmp388_; - vala_set_cvalue ((ValaExpression*) expr, (ValaCCodeExpression*) _tmp389_); - _vala_ccode_node_unref0 (_tmp389_); + _tmp385_ = left_chain; + _tmp386_ = vala_get_cvalue ((ValaExpression*) expr); + _tmp387_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_AND, _tmp385_, _tmp386_); + _tmp388_ = _tmp387_; + vala_set_cvalue ((ValaExpression*) expr, (ValaCCodeExpression*) _tmp388_); + _vala_ccode_node_unref0 (_tmp388_); } _vala_ccode_node_unref0 (left_chain); _vala_ccode_node_unref0 (cright); @@ -36147,7 +36158,10 @@ } if (_tmp3_) { gchar* _tmp16_ = NULL; + ValaCCodeExpression* val = NULL; ValaCCodeConstant* _tmp23_; + gboolean _tmp24_ = FALSE; + ValaStruct* _tmp25_; if (on_error) { ValaTypeSymbol* _tmp17_; ValaTypeSymbol* _tmp18_; @@ -36168,151 +36182,181 @@ _tmp16_ = _tmp22_; } _tmp23_ = vala_ccode_constant_new (_tmp16_); - result = (ValaCCodeExpression*) _tmp23_; + val = (ValaCCodeExpression*) _tmp23_; + _tmp25_ = st; + if (_tmp25_ != NULL) { + ValaStruct* _tmp26_; + ValaList* _tmp27_; + gint _tmp28_; + gint _tmp29_; + _tmp26_ = st; + _tmp27_ = vala_struct_get_fields (_tmp26_); + _tmp28_ = vala_collection_get_size ((ValaCollection*) _tmp27_); + _tmp29_ = _tmp28_; + _tmp24_ = _tmp29_ > 0; + } else { + _tmp24_ = FALSE; + } + if (_tmp24_) { + ValaCCodeExpression* _tmp30_; + ValaStruct* _tmp31_; + gchar* _tmp32_; + gchar* _tmp33_; + ValaCCodeCastExpression* _tmp34_; + _tmp30_ = val; + _tmp31_ = st; + _tmp32_ = vala_get_ccode_name ((ValaCodeNode*) _tmp31_); + _tmp33_ = _tmp32_; + _tmp34_ = vala_ccode_cast_expression_new (_tmp30_, _tmp33_); + _vala_ccode_node_unref0 (val); + val = (ValaCCodeExpression*) _tmp34_; + _g_free0 (_tmp33_); + } + result = val; _g_free0 (_tmp16_); _vala_code_node_unref0 (array_type); return result; } else { - gboolean _tmp24_ = FALSE; - gboolean _tmp25_ = FALSE; + gboolean _tmp35_ = FALSE; + gboolean _tmp36_ = FALSE; if (initializer_expression) { - gboolean _tmp26_; - gboolean _tmp27_; - _tmp26_ = vala_data_type_get_nullable (type); - _tmp27_ = _tmp26_; - _tmp25_ = !_tmp27_; + gboolean _tmp37_; + gboolean _tmp38_; + _tmp37_ = vala_data_type_get_nullable (type); + _tmp38_ = _tmp37_; + _tmp36_ = !_tmp38_; } else { - _tmp25_ = FALSE; + _tmp36_ = FALSE; } - if (_tmp25_) { - gboolean _tmp28_ = FALSE; - ValaStruct* _tmp29_; - _tmp29_ = st; - if (_tmp29_ != NULL) { - _tmp28_ = TRUE; - } else { - gboolean _tmp30_ = FALSE; - ValaArrayType* _tmp31_; - _tmp31_ = array_type; - if (_tmp31_ != NULL) { - ValaArrayType* _tmp32_; - gboolean _tmp33_; - gboolean _tmp34_; - _tmp32_ = array_type; - _tmp33_ = vala_array_type_get_fixed_length (_tmp32_); - _tmp34_ = _tmp33_; - _tmp30_ = _tmp34_; + if (_tmp36_) { + gboolean _tmp39_ = FALSE; + ValaStruct* _tmp40_; + _tmp40_ = st; + if (_tmp40_ != NULL) { + _tmp39_ = TRUE; + } else { + gboolean _tmp41_ = FALSE; + ValaArrayType* _tmp42_; + _tmp42_ = array_type; + if (_tmp42_ != NULL) { + ValaArrayType* _tmp43_; + gboolean _tmp44_; + gboolean _tmp45_; + _tmp43_ = array_type; + _tmp44_ = vala_array_type_get_fixed_length (_tmp43_); + _tmp45_ = _tmp44_; + _tmp41_ = _tmp45_; } else { - _tmp30_ = FALSE; + _tmp41_ = FALSE; } - _tmp28_ = _tmp30_; + _tmp39_ = _tmp41_; } - _tmp24_ = _tmp28_; + _tmp35_ = _tmp39_; } else { - _tmp24_ = FALSE; + _tmp35_ = FALSE; } - if (_tmp24_) { + if (_tmp35_) { ValaCCodeInitializerList* clist = NULL; - ValaCCodeInitializerList* _tmp35_; - ValaCCodeInitializerList* _tmp36_; - ValaCCodeConstant* _tmp37_; - ValaCCodeConstant* _tmp38_; - _tmp35_ = vala_ccode_initializer_list_new (); - clist = _tmp35_; - _tmp36_ = clist; - _tmp37_ = vala_ccode_constant_new ("0"); - _tmp38_ = _tmp37_; - vala_ccode_initializer_list_append (_tmp36_, (ValaCCodeExpression*) _tmp38_); - _vala_ccode_node_unref0 (_tmp38_); + ValaCCodeInitializerList* _tmp46_; + ValaCCodeInitializerList* _tmp47_; + ValaCCodeConstant* _tmp48_; + ValaCCodeConstant* _tmp49_; + _tmp46_ = vala_ccode_initializer_list_new (); + clist = _tmp46_; + _tmp47_ = clist; + _tmp48_ = vala_ccode_constant_new ("0"); + _tmp49_ = _tmp48_; + vala_ccode_initializer_list_append (_tmp47_, (ValaCCodeExpression*) _tmp49_); + _vala_ccode_node_unref0 (_tmp49_); result = (ValaCCodeExpression*) clist; _vala_code_node_unref0 (array_type); return result; } else { - gboolean _tmp39_ = FALSE; - gboolean _tmp40_ = FALSE; - gboolean _tmp41_ = FALSE; - gboolean _tmp42_ = FALSE; - gboolean _tmp43_ = FALSE; - ValaTypeSymbol* _tmp44_; - ValaTypeSymbol* _tmp45_; - _tmp44_ = vala_data_type_get_type_symbol (type); - _tmp45_ = _tmp44_; - if (_tmp45_ != NULL) { - ValaTypeSymbol* _tmp46_; - ValaTypeSymbol* _tmp47_; - _tmp46_ = vala_data_type_get_type_symbol (type); - _tmp47_ = _tmp46_; - _tmp43_ = vala_typesymbol_is_reference_type (_tmp47_); + gboolean _tmp50_ = FALSE; + gboolean _tmp51_ = FALSE; + gboolean _tmp52_ = FALSE; + gboolean _tmp53_ = FALSE; + gboolean _tmp54_ = FALSE; + ValaTypeSymbol* _tmp55_; + ValaTypeSymbol* _tmp56_; + _tmp55_ = vala_data_type_get_type_symbol (type); + _tmp56_ = _tmp55_; + if (_tmp56_ != NULL) { + ValaTypeSymbol* _tmp57_; + ValaTypeSymbol* _tmp58_; + _tmp57_ = vala_data_type_get_type_symbol (type); + _tmp58_ = _tmp57_; + _tmp54_ = vala_typesymbol_is_reference_type (_tmp58_); } else { - _tmp43_ = FALSE; + _tmp54_ = FALSE; } - if (_tmp43_) { - _tmp42_ = TRUE; + if (_tmp54_) { + _tmp53_ = TRUE; } else { - gboolean _tmp48_; - gboolean _tmp49_; - _tmp48_ = vala_data_type_get_nullable (type); - _tmp49_ = _tmp48_; - _tmp42_ = _tmp49_; + gboolean _tmp59_; + gboolean _tmp60_; + _tmp59_ = vala_data_type_get_nullable (type); + _tmp60_ = _tmp59_; + _tmp53_ = _tmp60_; } - if (_tmp42_) { - _tmp41_ = TRUE; + if (_tmp53_) { + _tmp52_ = TRUE; } else { - _tmp41_ = G_TYPE_CHECK_INSTANCE_TYPE (type, VALA_TYPE_POINTER_TYPE); + _tmp52_ = G_TYPE_CHECK_INSTANCE_TYPE (type, VALA_TYPE_POINTER_TYPE); } - if (_tmp41_) { - _tmp40_ = TRUE; + if (_tmp52_) { + _tmp51_ = TRUE; } else { - _tmp40_ = G_TYPE_CHECK_INSTANCE_TYPE (type, VALA_TYPE_DELEGATE_TYPE); + _tmp51_ = G_TYPE_CHECK_INSTANCE_TYPE (type, VALA_TYPE_DELEGATE_TYPE); } - if (_tmp40_) { - _tmp39_ = TRUE; + if (_tmp51_) { + _tmp50_ = TRUE; } else { - gboolean _tmp50_ = FALSE; - ValaArrayType* _tmp51_; - _tmp51_ = array_type; - if (_tmp51_ != NULL) { - ValaArrayType* _tmp52_; - gboolean _tmp53_; - gboolean _tmp54_; - _tmp52_ = array_type; - _tmp53_ = vala_array_type_get_fixed_length (_tmp52_); - _tmp54_ = _tmp53_; - _tmp50_ = !_tmp54_; + gboolean _tmp61_ = FALSE; + ValaArrayType* _tmp62_; + _tmp62_ = array_type; + if (_tmp62_ != NULL) { + ValaArrayType* _tmp63_; + gboolean _tmp64_; + gboolean _tmp65_; + _tmp63_ = array_type; + _tmp64_ = vala_array_type_get_fixed_length (_tmp63_); + _tmp65_ = _tmp64_; + _tmp61_ = !_tmp65_; } else { - _tmp50_ = FALSE; + _tmp61_ = FALSE; } - _tmp39_ = _tmp50_; + _tmp50_ = _tmp61_; } - if (_tmp39_) { - ValaCCodeConstant* _tmp55_; - _tmp55_ = vala_ccode_constant_new ("NULL"); - result = (ValaCCodeExpression*) _tmp55_; + if (_tmp50_) { + ValaCCodeConstant* _tmp66_; + _tmp66_ = vala_ccode_constant_new ("NULL"); + result = (ValaCCodeExpression*) _tmp66_; _vala_code_node_unref0 (array_type); return result; } else { if (G_TYPE_CHECK_INSTANCE_TYPE (type, VALA_TYPE_GENERIC_TYPE)) { - ValaCCodeConstant* _tmp56_; - _tmp56_ = vala_ccode_constant_new ("NULL"); - result = (ValaCCodeExpression*) _tmp56_; + ValaCCodeConstant* _tmp67_; + _tmp67_ = vala_ccode_constant_new ("NULL"); + result = (ValaCCodeExpression*) _tmp67_; _vala_code_node_unref0 (array_type); return result; } else { if (G_TYPE_CHECK_INSTANCE_TYPE (type, VALA_TYPE_ERROR_TYPE)) { - ValaCCodeConstant* _tmp57_; - _tmp57_ = vala_ccode_constant_new ("NULL"); - result = (ValaCCodeExpression*) _tmp57_; + ValaCCodeConstant* _tmp68_; + _tmp68_ = vala_ccode_constant_new ("NULL"); + result = (ValaCCodeExpression*) _tmp68_; _vala_code_node_unref0 (array_type); return result; } else { if (VALA_IS_CTYPE (type)) { - const gchar* _tmp58_; - const gchar* _tmp59_; - ValaCCodeConstant* _tmp60_; - _tmp58_ = vala_ctype_get_cdefault_value (G_TYPE_CHECK_INSTANCE_CAST (type, VALA_TYPE_CTYPE, ValaCType)); - _tmp59_ = _tmp58_; - _tmp60_ = vala_ccode_constant_new (_tmp59_); - result = (ValaCCodeExpression*) _tmp60_; + const gchar* _tmp69_; + const gchar* _tmp70_; + ValaCCodeConstant* _tmp71_; + _tmp69_ = vala_ctype_get_cdefault_value (G_TYPE_CHECK_INSTANCE_CAST (type, VALA_TYPE_CTYPE, ValaCType)); + _tmp70_ = _tmp69_; + _tmp71_ = vala_ccode_constant_new (_tmp70_); + result = (ValaCCodeExpression*) _tmp71_; _vala_code_node_unref0 (array_type); return result; } diff -Nru vala-0.48.20/codegen/valaccodebasemodule.vala vala-0.48.22/codegen/valaccodebasemodule.vala --- vala-0.48.20/codegen/valaccodebasemodule.vala 2021-12-02 13:10:08.000000000 +0000 +++ vala-0.48.22/codegen/valaccodebasemodule.vala 2022-01-09 09:11:49.000000000 +0000 @@ -4821,6 +4821,8 @@ } else if (param != null) { instance = get_cvalue_ (get_parameter_cvalue (param)); } + } else if (expr.is_chainup) { + instance = get_this_cexpression (); } else { var temp_value = create_temp_value (expr.type_reference, true, expr); instance = get_cvalue_ (temp_value); @@ -4865,7 +4867,11 @@ } if ((st != null && !st.is_simple_type ()) && !(get_ccode_instance_pos (m) < 0)) { - creation_call.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, instance)); + if (expr.is_chainup) { + creation_call.add_argument (instance); + } else { + creation_call.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, instance)); + } } else if (st != null && get_ccode_name (st) == "va_list") { creation_call.add_argument (instance); if (get_ccode_name (m) == "va_start") { @@ -6382,7 +6388,11 @@ var array_type = type as ArrayType; if (type.type_symbol != null && !type.nullable && (on_error ? get_ccode_default_value_on_error (type.type_symbol) : get_ccode_default_value (type.type_symbol)) != "") { - return new CCodeConstant (on_error ? get_ccode_default_value_on_error (type.type_symbol) : get_ccode_default_value (type.type_symbol)); + CCodeExpression val = new CCodeConstant (on_error ? get_ccode_default_value_on_error (type.type_symbol) : get_ccode_default_value (type.type_symbol)); + if (st != null && st.get_fields ().size > 0) { + val = new CCodeCastExpression (val, get_ccode_name (st)); + } + return val; } else if (initializer_expression && !type.nullable && (st != null || (array_type != null && array_type.fixed_length))) { // 0-initialize struct with struct initializer { 0 } diff -Nru vala-0.48.20/codegen/valaccodemethodmodule.c vala-0.48.22/codegen/valaccodemethodmodule.c --- vala-0.48.20/codegen/valaccodemethodmodule.c 2021-12-02 13:42:48.000000000 +0000 +++ vala-0.48.22/codegen/valaccodemethodmodule.c 2022-01-09 12:57:31.000000000 +0000 @@ -1667,28 +1667,28 @@ gboolean _tmp268_ = FALSE; gboolean _tmp269_; gboolean _tmp270_; - ValaBlock* _tmp966_; - ValaBlock* _tmp967_; - gboolean _tmp1003_ = FALSE; - gboolean _tmp1036_ = FALSE; - gboolean _tmp1037_; - gboolean _tmp1038_; - gboolean _tmp1099_ = FALSE; - gboolean _tmp1100_; - gboolean _tmp1101_; - gboolean _tmp1148_ = FALSE; - gboolean _tmp1149_ = FALSE; + ValaBlock* _tmp968_; + ValaBlock* _tmp969_; + gboolean _tmp1005_ = FALSE; + gboolean _tmp1038_ = FALSE; + gboolean _tmp1039_; + gboolean _tmp1040_; + gboolean _tmp1101_ = FALSE; + gboolean _tmp1102_; + gboolean _tmp1103_; gboolean _tmp1150_ = FALSE; - gboolean _tmp1151_; - gboolean _tmp1152_; - gboolean _tmp1173_ = FALSE; - gboolean _tmp1174_ = FALSE; + gboolean _tmp1151_ = FALSE; + gboolean _tmp1152_ = FALSE; + gboolean _tmp1153_; + gboolean _tmp1154_; gboolean _tmp1175_ = FALSE; gboolean _tmp1176_ = FALSE; - gboolean _tmp1177_; - gboolean _tmp1178_; - gboolean _tmp1196_; - gboolean _tmp1197_; + gboolean _tmp1177_ = FALSE; + gboolean _tmp1178_ = FALSE; + gboolean _tmp1179_; + gboolean _tmp1180_; + gboolean _tmp1198_; + gboolean _tmp1199_; self = (ValaCCodeMethodModule*) base; g_return_if_fail (m != NULL); _tmp0_ = vala_ccode_base_module_emit_context_new ((ValaSymbol*) m); @@ -2462,11 +2462,11 @@ gboolean _tmp279_; gboolean _tmp300_; gboolean _tmp301_; - gboolean _tmp902_ = FALSE; - ValaCodeContext* _tmp903_; - ValaCodeContext* _tmp904_; - ValaMethod* _tmp905_; - ValaMethod* _tmp906_; + gboolean _tmp904_ = FALSE; + ValaCodeContext* _tmp905_; + ValaCodeContext* _tmp906_; + ValaMethod* _tmp907_; + ValaMethod* _tmp908_; _tmp278_ = vala_method_get_coroutine (m); _tmp279_ = _tmp278_; if (_tmp279_) { @@ -4101,156 +4101,162 @@ _g_free0 (_tmp870_); _vala_ccode_node_unref0 (vardecl); } else { - ValaCCodeFile* _tmp872_; - ValaCCodeFunctionCall* czero = NULL; - ValaCCodeIdentifier* _tmp873_; - ValaCCodeIdentifier* _tmp874_; - ValaCCodeFunctionCall* _tmp875_; - ValaCCodeFunctionCall* _tmp876_; - ValaCCodeFunctionCall* _tmp877_; - ValaCCodeIdentifier* _tmp878_; - ValaCCodeIdentifier* _tmp879_; - ValaCCodeFunctionCall* _tmp880_; - ValaCCodeConstant* _tmp881_; - ValaCCodeConstant* _tmp882_; - ValaCCodeFunctionCall* _tmp883_; - ValaStruct* _tmp884_; - gchar* _tmp885_; - gchar* _tmp886_; - gchar* _tmp887_; - gchar* _tmp888_; - ValaCCodeIdentifier* _tmp889_; - ValaCCodeIdentifier* _tmp890_; - ValaCCodeFunction* _tmp891_; - ValaCCodeFunction* _tmp892_; - ValaCCodeFunctionCall* _tmp893_; - _tmp872_ = ((ValaCCodeBaseModule*) self)->cfile; - vala_ccode_file_add_include (_tmp872_, "string.h", FALSE); - _tmp873_ = vala_ccode_identifier_new ("memset"); - _tmp874_ = _tmp873_; - _tmp875_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp874_); - _tmp876_ = _tmp875_; - _vala_ccode_node_unref0 (_tmp874_); - czero = _tmp876_; - _tmp877_ = czero; - _tmp878_ = vala_ccode_identifier_new ("self"); - _tmp879_ = _tmp878_; - vala_ccode_function_call_add_argument (_tmp877_, (ValaCCodeExpression*) _tmp879_); - _vala_ccode_node_unref0 (_tmp879_); - _tmp880_ = czero; - _tmp881_ = vala_ccode_constant_new ("0"); - _tmp882_ = _tmp881_; - vala_ccode_function_call_add_argument (_tmp880_, (ValaCCodeExpression*) _tmp882_); - _vala_ccode_node_unref0 (_tmp882_); - _tmp883_ = czero; - _tmp884_ = st; - _tmp885_ = vala_get_ccode_name ((ValaCodeNode*) _tmp884_); - _tmp886_ = _tmp885_; - _tmp887_ = g_strdup_printf ("sizeof (%s)", _tmp886_); - _tmp888_ = _tmp887_; - _tmp889_ = vala_ccode_identifier_new (_tmp888_); - _tmp890_ = _tmp889_; - vala_ccode_function_call_add_argument (_tmp883_, (ValaCCodeExpression*) _tmp890_); - _vala_ccode_node_unref0 (_tmp890_); - _g_free0 (_tmp888_); - _g_free0 (_tmp886_); - _tmp891_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); - _tmp892_ = _tmp891_; - _tmp893_ = czero; - vala_ccode_function_add_expression (_tmp892_, (ValaCCodeExpression*) _tmp893_); - _vala_ccode_node_unref0 (czero); + gboolean _tmp872_; + gboolean _tmp873_; + _tmp872_ = vala_creation_method_get_chain_up (G_TYPE_CHECK_INSTANCE_CAST (m, VALA_TYPE_CREATION_METHOD, ValaCreationMethod)); + _tmp873_ = _tmp872_; + if (!_tmp873_) { + ValaCCodeFile* _tmp874_; + ValaCCodeFunctionCall* czero = NULL; + ValaCCodeIdentifier* _tmp875_; + ValaCCodeIdentifier* _tmp876_; + ValaCCodeFunctionCall* _tmp877_; + ValaCCodeFunctionCall* _tmp878_; + ValaCCodeFunctionCall* _tmp879_; + ValaCCodeIdentifier* _tmp880_; + ValaCCodeIdentifier* _tmp881_; + ValaCCodeFunctionCall* _tmp882_; + ValaCCodeConstant* _tmp883_; + ValaCCodeConstant* _tmp884_; + ValaCCodeFunctionCall* _tmp885_; + ValaStruct* _tmp886_; + gchar* _tmp887_; + gchar* _tmp888_; + gchar* _tmp889_; + gchar* _tmp890_; + ValaCCodeIdentifier* _tmp891_; + ValaCCodeIdentifier* _tmp892_; + ValaCCodeFunction* _tmp893_; + ValaCCodeFunction* _tmp894_; + ValaCCodeFunctionCall* _tmp895_; + _tmp874_ = ((ValaCCodeBaseModule*) self)->cfile; + vala_ccode_file_add_include (_tmp874_, "string.h", FALSE); + _tmp875_ = vala_ccode_identifier_new ("memset"); + _tmp876_ = _tmp875_; + _tmp877_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp876_); + _tmp878_ = _tmp877_; + _vala_ccode_node_unref0 (_tmp876_); + czero = _tmp878_; + _tmp879_ = czero; + _tmp880_ = vala_ccode_identifier_new ("self"); + _tmp881_ = _tmp880_; + vala_ccode_function_call_add_argument (_tmp879_, (ValaCCodeExpression*) _tmp881_); + _vala_ccode_node_unref0 (_tmp881_); + _tmp882_ = czero; + _tmp883_ = vala_ccode_constant_new ("0"); + _tmp884_ = _tmp883_; + vala_ccode_function_call_add_argument (_tmp882_, (ValaCCodeExpression*) _tmp884_); + _vala_ccode_node_unref0 (_tmp884_); + _tmp885_ = czero; + _tmp886_ = st; + _tmp887_ = vala_get_ccode_name ((ValaCodeNode*) _tmp886_); + _tmp888_ = _tmp887_; + _tmp889_ = g_strdup_printf ("sizeof (%s)", _tmp888_); + _tmp890_ = _tmp889_; + _tmp891_ = vala_ccode_identifier_new (_tmp890_); + _tmp892_ = _tmp891_; + vala_ccode_function_call_add_argument (_tmp885_, (ValaCCodeExpression*) _tmp892_); + _vala_ccode_node_unref0 (_tmp892_); + _g_free0 (_tmp890_); + _g_free0 (_tmp888_); + _tmp893_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp894_ = _tmp893_; + _tmp895_ = czero; + vala_ccode_function_add_expression (_tmp894_, (ValaCCodeExpression*) _tmp895_); + _vala_ccode_node_unref0 (czero); + } } } else { - ValaSourceReference* _tmp894_; - ValaSourceReference* _tmp895_; - ValaSymbol* _tmp896_; - ValaSymbol* _tmp897_; - gchar* _tmp898_; - gchar* _tmp899_; + ValaSourceReference* _tmp896_; + ValaSourceReference* _tmp897_; + ValaSymbol* _tmp898_; + ValaSymbol* _tmp899_; gchar* _tmp900_; gchar* _tmp901_; - _tmp894_ = vala_code_node_get_source_reference ((ValaCodeNode*) m); - _tmp895_ = _tmp894_; - _tmp896_ = vala_symbol_get_parent_symbol ((ValaSymbol*) m); + gchar* _tmp902_; + gchar* _tmp903_; + _tmp896_ = vala_code_node_get_source_reference ((ValaCodeNode*) m); _tmp897_ = _tmp896_; - _tmp898_ = vala_symbol_get_full_name (_tmp897_); + _tmp898_ = vala_symbol_get_parent_symbol ((ValaSymbol*) m); _tmp899_ = _tmp898_; - _tmp900_ = g_strdup_printf ("internal: creation method not supported in `%s'", _tmp899_); + _tmp900_ = vala_symbol_get_full_name (_tmp899_); _tmp901_ = _tmp900_; - vala_report_error (_tmp895_, _tmp901_); + _tmp902_ = g_strdup_printf ("internal: creation method not supported in `%s'", _tmp901_); + _tmp903_ = _tmp902_; + vala_report_error (_tmp897_, _tmp903_); + _g_free0 (_tmp903_); _g_free0 (_tmp901_); - _g_free0 (_tmp899_); } } } } } - _tmp903_ = vala_ccode_base_module_get_context ((ValaCCodeBaseModule*) self); - _tmp904_ = _tmp903_; - _tmp905_ = vala_code_context_get_module_init_method (_tmp904_); + _tmp905_ = vala_ccode_base_module_get_context ((ValaCCodeBaseModule*) self); _tmp906_ = _tmp905_; - if (_tmp906_ == m) { - _tmp902_ = ((ValaCCodeBaseModule*) self)->in_plugin; + _tmp907_ = vala_code_context_get_module_init_method (_tmp906_); + _tmp908_ = _tmp907_; + if (_tmp908_ == m) { + _tmp904_ = ((ValaCCodeBaseModule*) self)->in_plugin; } else { - _tmp902_ = FALSE; + _tmp904_ = FALSE; } - if (_tmp902_) { - ValaCodeContext* _tmp907_; - ValaCodeContext* _tmp908_; - ValaNamespace* _tmp909_; - ValaNamespace* _tmp910_; - GHashFunc _tmp911_; - GEqualFunc _tmp912_; - ValaHashSet* _tmp913_; - ValaHashSet* _tmp914_; - _tmp907_ = vala_ccode_base_module_get_context ((ValaCCodeBaseModule*) self); - _tmp908_ = _tmp907_; - _tmp909_ = vala_code_context_get_root (_tmp908_); + if (_tmp904_) { + ValaCodeContext* _tmp909_; + ValaCodeContext* _tmp910_; + ValaNamespace* _tmp911_; + ValaNamespace* _tmp912_; + GHashFunc _tmp913_; + GEqualFunc _tmp914_; + ValaHashSet* _tmp915_; + ValaHashSet* _tmp916_; + _tmp909_ = vala_ccode_base_module_get_context ((ValaCCodeBaseModule*) self); _tmp910_ = _tmp909_; - _tmp911_ = g_direct_hash; - _tmp912_ = g_direct_equal; - _tmp913_ = vala_hash_set_new (VALA_TYPE_SYMBOL, (GBoxedCopyFunc) vala_code_node_ref, (GDestroyNotify) vala_code_node_unref, _tmp911_, _tmp912_); - _tmp914_ = _tmp913_; - vala_ccode_method_module_register_plugin_types (self, (ValaSymbol*) _tmp910_, (ValaSet*) _tmp914_); - _vala_iterable_unref0 (_tmp914_); + _tmp911_ = vala_code_context_get_root (_tmp910_); + _tmp912_ = _tmp911_; + _tmp913_ = g_direct_hash; + _tmp914_ = g_direct_equal; + _tmp915_ = vala_hash_set_new (VALA_TYPE_SYMBOL, (GBoxedCopyFunc) vala_code_node_ref, (GDestroyNotify) vala_code_node_unref, _tmp913_, _tmp914_); + _tmp916_ = _tmp915_; + vala_ccode_method_module_register_plugin_types (self, (ValaSymbol*) _tmp912_, (ValaSet*) _tmp916_); + _vala_iterable_unref0 (_tmp916_); } { ValaList* _precondition_list = NULL; - ValaList* _tmp915_; - ValaList* _tmp916_; - gint _precondition_size = 0; ValaList* _tmp917_; - gint _tmp918_; - gint _tmp919_; + ValaList* _tmp918_; + gint _precondition_size = 0; + ValaList* _tmp919_; + gint _tmp920_; + gint _tmp921_; gint _precondition_index = 0; - _tmp915_ = vala_method_get_preconditions (m); - _tmp916_ = _vala_iterable_ref0 (_tmp915_); - _precondition_list = _tmp916_; - _tmp917_ = _precondition_list; - _tmp918_ = vala_collection_get_size ((ValaCollection*) _tmp917_); - _tmp919_ = _tmp918_; - _precondition_size = _tmp919_; + _tmp917_ = vala_method_get_preconditions (m); + _tmp918_ = _vala_iterable_ref0 (_tmp917_); + _precondition_list = _tmp918_; + _tmp919_ = _precondition_list; + _tmp920_ = vala_collection_get_size ((ValaCollection*) _tmp919_); + _tmp921_ = _tmp920_; + _precondition_size = _tmp921_; _precondition_index = -1; while (TRUE) { - gint _tmp920_; - gint _tmp921_; + gint _tmp922_; + gint _tmp923_; ValaExpression* precondition = NULL; - ValaList* _tmp922_; - gpointer _tmp923_; - ValaDataType* _tmp924_; - ValaExpression* _tmp925_; + ValaList* _tmp924_; + gpointer _tmp925_; + ValaDataType* _tmp926_; + ValaExpression* _tmp927_; _precondition_index = _precondition_index + 1; - _tmp920_ = _precondition_index; - _tmp921_ = _precondition_size; - if (!(_tmp920_ < _tmp921_)) { + _tmp922_ = _precondition_index; + _tmp923_ = _precondition_size; + if (!(_tmp922_ < _tmp923_)) { break; } - _tmp922_ = _precondition_list; - _tmp923_ = vala_list_get (_tmp922_, _precondition_index); - precondition = (ValaExpression*) _tmp923_; - _tmp924_ = creturn_type; - _tmp925_ = precondition; - vala_ccode_method_module_create_precondition_statement (self, m, _tmp924_, _tmp925_); + _tmp924_ = _precondition_list; + _tmp925_ = vala_list_get (_tmp924_, _precondition_index); + precondition = (ValaExpression*) _tmp925_; + _tmp926_ = creturn_type; + _tmp927_ = precondition; + vala_ccode_method_module_create_precondition_statement (self, m, _tmp926_, _tmp927_); _vala_code_node_unref0 (precondition); } _vala_iterable_unref0 (_precondition_list); @@ -4259,925 +4265,925 @@ } if (profile) { gchar* prefix = NULL; - const gchar* _tmp926_; - gchar* _tmp927_; - ValaCCodeIdentifier* level = NULL; const gchar* _tmp928_; gchar* _tmp929_; - gchar* _tmp930_; - ValaCCodeIdentifier* _tmp931_; - ValaCCodeIdentifier* _tmp932_; - ValaCCodeFunction* _tmp933_; - ValaCCodeFunction* _tmp934_; - ValaCCodeIdentifier* _tmp935_; - ValaCCodeUnaryExpression* _tmp936_; - ValaCCodeUnaryExpression* _tmp937_; + ValaCCodeIdentifier* level = NULL; + const gchar* _tmp930_; + gchar* _tmp931_; + gchar* _tmp932_; + ValaCCodeIdentifier* _tmp933_; + ValaCCodeIdentifier* _tmp934_; + ValaCCodeFunction* _tmp935_; + ValaCCodeFunction* _tmp936_; + ValaCCodeIdentifier* _tmp937_; ValaCCodeUnaryExpression* _tmp938_; ValaCCodeUnaryExpression* _tmp939_; + ValaCCodeUnaryExpression* _tmp940_; + ValaCCodeUnaryExpression* _tmp941_; ValaCCodeIdentifier* counter = NULL; - const gchar* _tmp940_; - gchar* _tmp941_; - gchar* _tmp942_; - ValaCCodeIdentifier* _tmp943_; - ValaCCodeIdentifier* _tmp944_; - ValaCCodeFunction* _tmp945_; - ValaCCodeFunction* _tmp946_; - ValaCCodeIdentifier* _tmp947_; - ValaCCodeUnaryExpression* _tmp948_; - ValaCCodeUnaryExpression* _tmp949_; + const gchar* _tmp942_; + gchar* _tmp943_; + gchar* _tmp944_; + ValaCCodeIdentifier* _tmp945_; + ValaCCodeIdentifier* _tmp946_; + ValaCCodeFunction* _tmp947_; + ValaCCodeFunction* _tmp948_; + ValaCCodeIdentifier* _tmp949_; + ValaCCodeUnaryExpression* _tmp950_; + ValaCCodeUnaryExpression* _tmp951_; ValaCCodeIdentifier* timer = NULL; - const gchar* _tmp950_; - gchar* _tmp951_; - gchar* _tmp952_; - ValaCCodeIdentifier* _tmp953_; - ValaCCodeIdentifier* _tmp954_; - ValaCCodeFunctionCall* cont_call = NULL; + const gchar* _tmp952_; + gchar* _tmp953_; + gchar* _tmp954_; ValaCCodeIdentifier* _tmp955_; ValaCCodeIdentifier* _tmp956_; - ValaCCodeFunctionCall* _tmp957_; - ValaCCodeFunctionCall* _tmp958_; + ValaCCodeFunctionCall* cont_call = NULL; + ValaCCodeIdentifier* _tmp957_; + ValaCCodeIdentifier* _tmp958_; ValaCCodeFunctionCall* _tmp959_; - ValaCCodeIdentifier* _tmp960_; - ValaCCodeFunction* _tmp961_; - ValaCCodeFunction* _tmp962_; - ValaCCodeFunctionCall* _tmp963_; + ValaCCodeFunctionCall* _tmp960_; + ValaCCodeFunctionCall* _tmp961_; + ValaCCodeIdentifier* _tmp962_; + ValaCCodeFunction* _tmp963_; ValaCCodeFunction* _tmp964_; - ValaCCodeFunction* _tmp965_; - _tmp926_ = real_name; - _tmp927_ = g_strdup_printf ("_vala_prof_%s", _tmp926_); - prefix = _tmp927_; - _tmp928_ = prefix; - _tmp929_ = g_strconcat (_tmp928_, "_level", NULL); - _tmp930_ = _tmp929_; - _tmp931_ = vala_ccode_identifier_new (_tmp930_); + ValaCCodeFunctionCall* _tmp965_; + ValaCCodeFunction* _tmp966_; + ValaCCodeFunction* _tmp967_; + _tmp928_ = real_name; + _tmp929_ = g_strdup_printf ("_vala_prof_%s", _tmp928_); + prefix = _tmp929_; + _tmp930_ = prefix; + _tmp931_ = g_strconcat (_tmp930_, "_level", NULL); _tmp932_ = _tmp931_; - _g_free0 (_tmp930_); - level = _tmp932_; - _tmp933_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp933_ = vala_ccode_identifier_new (_tmp932_); _tmp934_ = _tmp933_; - _tmp935_ = level; - _tmp936_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_POSTFIX_INCREMENT, (ValaCCodeExpression*) _tmp935_); - _tmp937_ = _tmp936_; - _tmp938_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_LOGICAL_NEGATION, (ValaCCodeExpression*) _tmp937_); + _g_free0 (_tmp932_); + level = _tmp934_; + _tmp935_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp936_ = _tmp935_; + _tmp937_ = level; + _tmp938_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_POSTFIX_INCREMENT, (ValaCCodeExpression*) _tmp937_); _tmp939_ = _tmp938_; - vala_ccode_function_open_if (_tmp934_, (ValaCCodeExpression*) _tmp939_); + _tmp940_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_LOGICAL_NEGATION, (ValaCCodeExpression*) _tmp939_); + _tmp941_ = _tmp940_; + vala_ccode_function_open_if (_tmp936_, (ValaCCodeExpression*) _tmp941_); + _vala_ccode_node_unref0 (_tmp941_); _vala_ccode_node_unref0 (_tmp939_); - _vala_ccode_node_unref0 (_tmp937_); - _tmp940_ = prefix; - _tmp941_ = g_strconcat (_tmp940_, "_counter", NULL); - _tmp942_ = _tmp941_; - _tmp943_ = vala_ccode_identifier_new (_tmp942_); + _tmp942_ = prefix; + _tmp943_ = g_strconcat (_tmp942_, "_counter", NULL); _tmp944_ = _tmp943_; - _g_free0 (_tmp942_); - counter = _tmp944_; - _tmp945_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp945_ = vala_ccode_identifier_new (_tmp944_); _tmp946_ = _tmp945_; - _tmp947_ = counter; - _tmp948_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_POSTFIX_INCREMENT, (ValaCCodeExpression*) _tmp947_); - _tmp949_ = _tmp948_; - vala_ccode_function_add_expression (_tmp946_, (ValaCCodeExpression*) _tmp949_); - _vala_ccode_node_unref0 (_tmp949_); - _tmp950_ = prefix; - _tmp951_ = g_strconcat (_tmp950_, "_timer", NULL); - _tmp952_ = _tmp951_; - _tmp953_ = vala_ccode_identifier_new (_tmp952_); + _g_free0 (_tmp944_); + counter = _tmp946_; + _tmp947_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp948_ = _tmp947_; + _tmp949_ = counter; + _tmp950_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_POSTFIX_INCREMENT, (ValaCCodeExpression*) _tmp949_); + _tmp951_ = _tmp950_; + vala_ccode_function_add_expression (_tmp948_, (ValaCCodeExpression*) _tmp951_); + _vala_ccode_node_unref0 (_tmp951_); + _tmp952_ = prefix; + _tmp953_ = g_strconcat (_tmp952_, "_timer", NULL); _tmp954_ = _tmp953_; - _g_free0 (_tmp952_); - timer = _tmp954_; - _tmp955_ = vala_ccode_identifier_new ("g_timer_continue"); + _tmp955_ = vala_ccode_identifier_new (_tmp954_); _tmp956_ = _tmp955_; - _tmp957_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp956_); + _g_free0 (_tmp954_); + timer = _tmp956_; + _tmp957_ = vala_ccode_identifier_new ("g_timer_continue"); _tmp958_ = _tmp957_; - _vala_ccode_node_unref0 (_tmp956_); - cont_call = _tmp958_; - _tmp959_ = cont_call; - _tmp960_ = timer; - vala_ccode_function_call_add_argument (_tmp959_, (ValaCCodeExpression*) _tmp960_); - _tmp961_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); - _tmp962_ = _tmp961_; - _tmp963_ = cont_call; - vala_ccode_function_add_expression (_tmp962_, (ValaCCodeExpression*) _tmp963_); - _tmp964_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); - _tmp965_ = _tmp964_; - vala_ccode_function_close (_tmp965_); + _tmp959_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp958_); + _tmp960_ = _tmp959_; + _vala_ccode_node_unref0 (_tmp958_); + cont_call = _tmp960_; + _tmp961_ = cont_call; + _tmp962_ = timer; + vala_ccode_function_call_add_argument (_tmp961_, (ValaCCodeExpression*) _tmp962_); + _tmp963_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp964_ = _tmp963_; + _tmp965_ = cont_call; + vala_ccode_function_add_expression (_tmp964_, (ValaCCodeExpression*) _tmp965_); + _tmp966_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp967_ = _tmp966_; + vala_ccode_function_close (_tmp967_); _vala_ccode_node_unref0 (cont_call); _vala_ccode_node_unref0 (timer); _vala_ccode_node_unref0 (counter); _vala_ccode_node_unref0 (level); _g_free0 (prefix); } - _tmp966_ = vala_subroutine_get_body ((ValaSubroutine*) m); - _tmp967_ = _tmp966_; - if (_tmp967_ != NULL) { - ValaBlock* _tmp968_; - ValaBlock* _tmp969_; - ValaCCodeBlock* _tmp970_; - _tmp968_ = vala_subroutine_get_body ((ValaSubroutine*) m); - _tmp969_ = _tmp968_; - vala_code_node_emit ((ValaCodeNode*) _tmp969_, (ValaCodeGenerator*) self); - _tmp970_ = co_switch_block; - if (_tmp970_ != NULL) { + _tmp968_ = vala_subroutine_get_body ((ValaSubroutine*) m); + _tmp969_ = _tmp968_; + if (_tmp969_ != NULL) { + ValaBlock* _tmp970_; + ValaBlock* _tmp971_; + ValaCCodeBlock* _tmp972_; + _tmp970_ = vala_subroutine_get_body ((ValaSubroutine*) m); + _tmp971_ = _tmp970_; + vala_code_node_emit ((ValaCodeNode*) _tmp971_, (ValaCodeGenerator*) self); + _tmp972_ = co_switch_block; + if (_tmp972_ != NULL) { ValaCCodeBlock* old_block = NULL; - ValaCCodeFunction* _tmp971_; - ValaCCodeFunction* _tmp972_; - ValaCCodeBlock* _tmp973_; - ValaCCodeBlock* _tmp974_; + ValaCCodeFunction* _tmp973_; + ValaCCodeFunction* _tmp974_; ValaCCodeBlock* _tmp975_; - ValaCCodeFunction* _tmp976_; - ValaCCodeFunction* _tmp977_; - ValaCCodeBlock* _tmp978_; - ValaCCodeFunction* _tmp992_; - ValaCCodeFunction* _tmp993_; + ValaCCodeBlock* _tmp976_; + ValaCCodeBlock* _tmp977_; + ValaCCodeFunction* _tmp978_; + ValaCCodeFunction* _tmp979_; + ValaCCodeBlock* _tmp980_; ValaCCodeFunction* _tmp994_; ValaCCodeFunction* _tmp995_; - ValaCCodeIdentifier* _tmp996_; - ValaCCodeIdentifier* _tmp997_; - ValaCCodeFunctionCall* _tmp998_; - ValaCCodeFunctionCall* _tmp999_; - ValaCCodeFunction* _tmp1000_; - ValaCCodeFunction* _tmp1001_; - ValaCCodeBlock* _tmp1002_; - _tmp971_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); - _tmp972_ = _tmp971_; - _tmp973_ = vala_ccode_function_get_current_block (_tmp972_); + ValaCCodeFunction* _tmp996_; + ValaCCodeFunction* _tmp997_; + ValaCCodeIdentifier* _tmp998_; + ValaCCodeIdentifier* _tmp999_; + ValaCCodeFunctionCall* _tmp1000_; + ValaCCodeFunctionCall* _tmp1001_; + ValaCCodeFunction* _tmp1002_; + ValaCCodeFunction* _tmp1003_; + ValaCCodeBlock* _tmp1004_; + _tmp973_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); _tmp974_ = _tmp973_; - _tmp975_ = _vala_ccode_node_ref0 (_tmp974_); - old_block = _tmp975_; - _tmp976_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); - _tmp977_ = _tmp976_; - _tmp978_ = co_switch_block; - vala_ccode_function_set_current_block (_tmp977_, _tmp978_); + _tmp975_ = vala_ccode_function_get_current_block (_tmp974_); + _tmp976_ = _tmp975_; + _tmp977_ = _vala_ccode_node_ref0 (_tmp976_); + old_block = _tmp977_; + _tmp978_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp979_ = _tmp978_; + _tmp980_ = co_switch_block; + vala_ccode_function_set_current_block (_tmp979_, _tmp980_); { gint state = 0; state = 1; { - gboolean _tmp979_ = FALSE; - _tmp979_ = TRUE; + gboolean _tmp981_ = FALSE; + _tmp981_ = TRUE; while (TRUE) { - ValaCCodeBaseModuleEmitContext* _tmp981_; - ValaCCodeFunction* _tmp982_; - ValaCCodeFunction* _tmp983_; - gchar* _tmp984_; - gchar* _tmp985_; - ValaCCodeConstant* _tmp986_; - ValaCCodeConstant* _tmp987_; - ValaCCodeFunction* _tmp988_; - ValaCCodeFunction* _tmp989_; - gchar* _tmp990_; - gchar* _tmp991_; - if (!_tmp979_) { - gint _tmp980_; - _tmp980_ = state; - state = _tmp980_ + 1; + ValaCCodeBaseModuleEmitContext* _tmp983_; + ValaCCodeFunction* _tmp984_; + ValaCCodeFunction* _tmp985_; + gchar* _tmp986_; + gchar* _tmp987_; + ValaCCodeConstant* _tmp988_; + ValaCCodeConstant* _tmp989_; + ValaCCodeFunction* _tmp990_; + ValaCCodeFunction* _tmp991_; + gchar* _tmp992_; + gchar* _tmp993_; + if (!_tmp981_) { + gint _tmp982_; + _tmp982_ = state; + state = _tmp982_ + 1; } - _tmp979_ = FALSE; - _tmp981_ = ((ValaCCodeBaseModule*) self)->emit_context; - if (!(state < _tmp981_->next_coroutine_state)) { + _tmp981_ = FALSE; + _tmp983_ = ((ValaCCodeBaseModule*) self)->emit_context; + if (!(state < _tmp983_->next_coroutine_state)) { break; } - _tmp982_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); - _tmp983_ = _tmp982_; - _tmp984_ = g_strdup_printf ("%i", state); + _tmp984_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); _tmp985_ = _tmp984_; - _tmp986_ = vala_ccode_constant_new (_tmp985_); + _tmp986_ = g_strdup_printf ("%i", state); _tmp987_ = _tmp986_; - vala_ccode_function_add_case (_tmp983_, (ValaCCodeExpression*) _tmp987_); - _vala_ccode_node_unref0 (_tmp987_); - _g_free0 (_tmp985_); - _tmp988_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp988_ = vala_ccode_constant_new (_tmp987_); _tmp989_ = _tmp988_; - _tmp990_ = g_strdup_printf ("_state_%d", state); + vala_ccode_function_add_case (_tmp985_, (ValaCCodeExpression*) _tmp989_); + _vala_ccode_node_unref0 (_tmp989_); + _g_free0 (_tmp987_); + _tmp990_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); _tmp991_ = _tmp990_; - vala_ccode_function_add_goto (_tmp989_, _tmp991_); - _g_free0 (_tmp991_); + _tmp992_ = g_strdup_printf ("_state_%d", state); + _tmp993_ = _tmp992_; + vala_ccode_function_add_goto (_tmp991_, _tmp993_); + _g_free0 (_tmp993_); } } } - _tmp992_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); - _tmp993_ = _tmp992_; - vala_ccode_function_add_default (_tmp993_); _tmp994_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); _tmp995_ = _tmp994_; - _tmp996_ = vala_ccode_identifier_new ("g_assert_not_reached"); + vala_ccode_function_add_default (_tmp995_); + _tmp996_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); _tmp997_ = _tmp996_; - _tmp998_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp997_); + _tmp998_ = vala_ccode_identifier_new ("g_assert_not_reached"); _tmp999_ = _tmp998_; - vala_ccode_function_add_expression (_tmp995_, (ValaCCodeExpression*) _tmp999_); - _vala_ccode_node_unref0 (_tmp999_); - _vala_ccode_node_unref0 (_tmp997_); - _tmp1000_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp1000_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp999_); _tmp1001_ = _tmp1000_; - _tmp1002_ = old_block; - vala_ccode_function_set_current_block (_tmp1001_, _tmp1002_); + vala_ccode_function_add_expression (_tmp997_, (ValaCCodeExpression*) _tmp1001_); + _vala_ccode_node_unref0 (_tmp1001_); + _vala_ccode_node_unref0 (_tmp999_); + _tmp1002_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp1003_ = _tmp1002_; + _tmp1004_ = old_block; + vala_ccode_function_set_current_block (_tmp1003_, _tmp1004_); co_switch_block = NULL; _vala_ccode_node_unref0 (old_block); } } if (profile) { - ValaDataType* _tmp1004_; - ValaDataType* _tmp1005_; - _tmp1004_ = vala_callable_get_return_type ((ValaCallable*) m); - _tmp1005_ = _tmp1004_; - _tmp1003_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp1005_, VALA_TYPE_VOID_TYPE); + ValaDataType* _tmp1006_; + ValaDataType* _tmp1007_; + _tmp1006_ = vala_callable_get_return_type ((ValaCallable*) m); + _tmp1007_ = _tmp1006_; + _tmp1005_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp1007_, VALA_TYPE_VOID_TYPE); } else { - _tmp1003_ = FALSE; + _tmp1005_ = FALSE; } - if (_tmp1003_) { + if (_tmp1005_) { gchar* prefix = NULL; - const gchar* _tmp1006_; - gchar* _tmp1007_; - ValaCCodeIdentifier* level = NULL; const gchar* _tmp1008_; gchar* _tmp1009_; - gchar* _tmp1010_; - ValaCCodeIdentifier* _tmp1011_; - ValaCCodeIdentifier* _tmp1012_; - ValaCCodeFunction* _tmp1013_; - ValaCCodeFunction* _tmp1014_; - ValaCCodeIdentifier* _tmp1015_; - ValaCCodeUnaryExpression* _tmp1016_; - ValaCCodeUnaryExpression* _tmp1017_; + ValaCCodeIdentifier* level = NULL; + const gchar* _tmp1010_; + gchar* _tmp1011_; + gchar* _tmp1012_; + ValaCCodeIdentifier* _tmp1013_; + ValaCCodeIdentifier* _tmp1014_; + ValaCCodeFunction* _tmp1015_; + ValaCCodeFunction* _tmp1016_; + ValaCCodeIdentifier* _tmp1017_; ValaCCodeUnaryExpression* _tmp1018_; ValaCCodeUnaryExpression* _tmp1019_; + ValaCCodeUnaryExpression* _tmp1020_; + ValaCCodeUnaryExpression* _tmp1021_; ValaCCodeIdentifier* timer = NULL; - const gchar* _tmp1020_; - gchar* _tmp1021_; - gchar* _tmp1022_; - ValaCCodeIdentifier* _tmp1023_; - ValaCCodeIdentifier* _tmp1024_; - ValaCCodeFunctionCall* stop_call = NULL; + const gchar* _tmp1022_; + gchar* _tmp1023_; + gchar* _tmp1024_; ValaCCodeIdentifier* _tmp1025_; ValaCCodeIdentifier* _tmp1026_; - ValaCCodeFunctionCall* _tmp1027_; - ValaCCodeFunctionCall* _tmp1028_; + ValaCCodeFunctionCall* stop_call = NULL; + ValaCCodeIdentifier* _tmp1027_; + ValaCCodeIdentifier* _tmp1028_; ValaCCodeFunctionCall* _tmp1029_; - ValaCCodeIdentifier* _tmp1030_; - ValaCCodeFunction* _tmp1031_; - ValaCCodeFunction* _tmp1032_; - ValaCCodeFunctionCall* _tmp1033_; + ValaCCodeFunctionCall* _tmp1030_; + ValaCCodeFunctionCall* _tmp1031_; + ValaCCodeIdentifier* _tmp1032_; + ValaCCodeFunction* _tmp1033_; ValaCCodeFunction* _tmp1034_; - ValaCCodeFunction* _tmp1035_; - _tmp1006_ = real_name; - _tmp1007_ = g_strdup_printf ("_vala_prof_%s", _tmp1006_); - prefix = _tmp1007_; - _tmp1008_ = prefix; - _tmp1009_ = g_strconcat (_tmp1008_, "_level", NULL); - _tmp1010_ = _tmp1009_; - _tmp1011_ = vala_ccode_identifier_new (_tmp1010_); + ValaCCodeFunctionCall* _tmp1035_; + ValaCCodeFunction* _tmp1036_; + ValaCCodeFunction* _tmp1037_; + _tmp1008_ = real_name; + _tmp1009_ = g_strdup_printf ("_vala_prof_%s", _tmp1008_); + prefix = _tmp1009_; + _tmp1010_ = prefix; + _tmp1011_ = g_strconcat (_tmp1010_, "_level", NULL); _tmp1012_ = _tmp1011_; - _g_free0 (_tmp1010_); - level = _tmp1012_; - _tmp1013_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp1013_ = vala_ccode_identifier_new (_tmp1012_); _tmp1014_ = _tmp1013_; - _tmp1015_ = level; - _tmp1016_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_PREFIX_DECREMENT, (ValaCCodeExpression*) _tmp1015_); - _tmp1017_ = _tmp1016_; - _tmp1018_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_LOGICAL_NEGATION, (ValaCCodeExpression*) _tmp1017_); + _g_free0 (_tmp1012_); + level = _tmp1014_; + _tmp1015_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp1016_ = _tmp1015_; + _tmp1017_ = level; + _tmp1018_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_PREFIX_DECREMENT, (ValaCCodeExpression*) _tmp1017_); _tmp1019_ = _tmp1018_; - vala_ccode_function_open_if (_tmp1014_, (ValaCCodeExpression*) _tmp1019_); + _tmp1020_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_LOGICAL_NEGATION, (ValaCCodeExpression*) _tmp1019_); + _tmp1021_ = _tmp1020_; + vala_ccode_function_open_if (_tmp1016_, (ValaCCodeExpression*) _tmp1021_); + _vala_ccode_node_unref0 (_tmp1021_); _vala_ccode_node_unref0 (_tmp1019_); - _vala_ccode_node_unref0 (_tmp1017_); - _tmp1020_ = prefix; - _tmp1021_ = g_strconcat (_tmp1020_, "_timer", NULL); - _tmp1022_ = _tmp1021_; - _tmp1023_ = vala_ccode_identifier_new (_tmp1022_); + _tmp1022_ = prefix; + _tmp1023_ = g_strconcat (_tmp1022_, "_timer", NULL); _tmp1024_ = _tmp1023_; - _g_free0 (_tmp1022_); - timer = _tmp1024_; - _tmp1025_ = vala_ccode_identifier_new ("g_timer_stop"); + _tmp1025_ = vala_ccode_identifier_new (_tmp1024_); _tmp1026_ = _tmp1025_; - _tmp1027_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp1026_); + _g_free0 (_tmp1024_); + timer = _tmp1026_; + _tmp1027_ = vala_ccode_identifier_new ("g_timer_stop"); _tmp1028_ = _tmp1027_; - _vala_ccode_node_unref0 (_tmp1026_); - stop_call = _tmp1028_; - _tmp1029_ = stop_call; - _tmp1030_ = timer; - vala_ccode_function_call_add_argument (_tmp1029_, (ValaCCodeExpression*) _tmp1030_); - _tmp1031_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); - _tmp1032_ = _tmp1031_; - _tmp1033_ = stop_call; - vala_ccode_function_add_expression (_tmp1032_, (ValaCCodeExpression*) _tmp1033_); - _tmp1034_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); - _tmp1035_ = _tmp1034_; - vala_ccode_function_close (_tmp1035_); + _tmp1029_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp1028_); + _tmp1030_ = _tmp1029_; + _vala_ccode_node_unref0 (_tmp1028_); + stop_call = _tmp1030_; + _tmp1031_ = stop_call; + _tmp1032_ = timer; + vala_ccode_function_call_add_argument (_tmp1031_, (ValaCCodeExpression*) _tmp1032_); + _tmp1033_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp1034_ = _tmp1033_; + _tmp1035_ = stop_call; + vala_ccode_function_add_expression (_tmp1034_, (ValaCCodeExpression*) _tmp1035_); + _tmp1036_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp1037_ = _tmp1036_; + vala_ccode_function_close (_tmp1037_); _vala_ccode_node_unref0 (stop_call); _vala_ccode_node_unref0 (timer); _vala_ccode_node_unref0 (level); _g_free0 (prefix); } - _tmp1037_ = vala_method_get_is_abstract (m); - _tmp1038_ = _tmp1037_; - if (!_tmp1038_) { - _tmp1036_ = TRUE; + _tmp1039_ = vala_method_get_is_abstract (m); + _tmp1040_ = _tmp1039_; + if (!_tmp1040_) { + _tmp1038_ = TRUE; } else { - gboolean _tmp1039_ = FALSE; - gboolean _tmp1040_; - gboolean _tmp1041_; - _tmp1040_ = vala_method_get_is_abstract (m); - _tmp1041_ = _tmp1040_; - if (_tmp1041_) { - ValaTypeSymbol* _tmp1042_; - ValaTypeSymbol* _tmp1043_; - _tmp1042_ = vala_ccode_base_module_get_current_type_symbol ((ValaCCodeBaseModule*) self); - _tmp1043_ = _tmp1042_; - _tmp1039_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp1043_, VALA_TYPE_CLASS); + gboolean _tmp1041_ = FALSE; + gboolean _tmp1042_; + gboolean _tmp1043_; + _tmp1042_ = vala_method_get_is_abstract (m); + _tmp1043_ = _tmp1042_; + if (_tmp1043_) { + ValaTypeSymbol* _tmp1044_; + ValaTypeSymbol* _tmp1045_; + _tmp1044_ = vala_ccode_base_module_get_current_type_symbol ((ValaCCodeBaseModule*) self); + _tmp1045_ = _tmp1044_; + _tmp1041_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp1045_, VALA_TYPE_CLASS); } else { - _tmp1039_ = FALSE; + _tmp1041_ = FALSE; } - _tmp1036_ = _tmp1039_; + _tmp1038_ = _tmp1041_; } - if (_tmp1036_) { - ValaBlock* _tmp1044_; - ValaBlock* _tmp1045_; - _tmp1044_ = vala_subroutine_get_body ((ValaSubroutine*) m); - _tmp1045_ = _tmp1044_; - if (_tmp1045_ != NULL) { - gboolean _tmp1046_; - gboolean _tmp1047_; - gboolean _tmp1066_ = FALSE; - ValaDataType* _tmp1067_; - ValaDataType* _tmp1068_; - ValaCCodeFile* _tmp1096_; - ValaCCodeFunction* _tmp1097_; - ValaCCodeFunction* _tmp1098_; - _tmp1046_ = vala_ccode_base_module_get_current_method_inner_error ((ValaCCodeBaseModule*) self); - _tmp1047_ = _tmp1046_; - if (_tmp1047_) { - ValaCCodeFile* _tmp1048_; - gboolean _tmp1049_; - gboolean _tmp1050_; - _tmp1048_ = ((ValaCCodeBaseModule*) self)->cfile; - vala_ccode_file_add_include (_tmp1048_, "glib.h", FALSE); - _tmp1049_ = vala_method_get_coroutine (m); - _tmp1050_ = _tmp1049_; - if (_tmp1050_) { - ValaCCodeStruct* _tmp1051_; - gint _tmp1052_; - gint _tmp1053_; - gchar* _tmp1054_; - gchar* _tmp1055_; - _tmp1051_ = ((ValaCCodeBaseModule*) self)->closure_struct; - _tmp1052_ = vala_ccode_base_module_get_current_inner_error_id ((ValaCCodeBaseModule*) self); - _tmp1053_ = _tmp1052_; - _tmp1054_ = g_strdup_printf ("_inner_error%d_", _tmp1053_); + if (_tmp1038_) { + ValaBlock* _tmp1046_; + ValaBlock* _tmp1047_; + _tmp1046_ = vala_subroutine_get_body ((ValaSubroutine*) m); + _tmp1047_ = _tmp1046_; + if (_tmp1047_ != NULL) { + gboolean _tmp1048_; + gboolean _tmp1049_; + gboolean _tmp1068_ = FALSE; + ValaDataType* _tmp1069_; + ValaDataType* _tmp1070_; + ValaCCodeFile* _tmp1098_; + ValaCCodeFunction* _tmp1099_; + ValaCCodeFunction* _tmp1100_; + _tmp1048_ = vala_ccode_base_module_get_current_method_inner_error ((ValaCCodeBaseModule*) self); + _tmp1049_ = _tmp1048_; + if (_tmp1049_) { + ValaCCodeFile* _tmp1050_; + gboolean _tmp1051_; + gboolean _tmp1052_; + _tmp1050_ = ((ValaCCodeBaseModule*) self)->cfile; + vala_ccode_file_add_include (_tmp1050_, "glib.h", FALSE); + _tmp1051_ = vala_method_get_coroutine (m); + _tmp1052_ = _tmp1051_; + if (_tmp1052_) { + ValaCCodeStruct* _tmp1053_; + gint _tmp1054_; + gint _tmp1055_; + gchar* _tmp1056_; + gchar* _tmp1057_; + _tmp1053_ = ((ValaCCodeBaseModule*) self)->closure_struct; + _tmp1054_ = vala_ccode_base_module_get_current_inner_error_id ((ValaCCodeBaseModule*) self); _tmp1055_ = _tmp1054_; - vala_ccode_struct_add_field (_tmp1051_, "GError*", _tmp1055_, 0, NULL); - _g_free0 (_tmp1055_); - } else { - ValaCCodeFunction* _tmp1056_; - ValaCCodeFunction* _tmp1057_; - gint _tmp1058_; - gint _tmp1059_; - gchar* _tmp1060_; - gchar* _tmp1061_; - ValaCCodeConstant* _tmp1062_; - ValaCCodeConstant* _tmp1063_; - ValaCCodeVariableDeclarator* _tmp1064_; - ValaCCodeVariableDeclarator* _tmp1065_; - _tmp1056_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp1056_ = g_strdup_printf ("_inner_error%d_", _tmp1055_); _tmp1057_ = _tmp1056_; - _tmp1058_ = vala_ccode_base_module_get_current_inner_error_id ((ValaCCodeBaseModule*) self); + vala_ccode_struct_add_field (_tmp1053_, "GError*", _tmp1057_, 0, NULL); + _g_free0 (_tmp1057_); + } else { + ValaCCodeFunction* _tmp1058_; + ValaCCodeFunction* _tmp1059_; + gint _tmp1060_; + gint _tmp1061_; + gchar* _tmp1062_; + gchar* _tmp1063_; + ValaCCodeConstant* _tmp1064_; + ValaCCodeConstant* _tmp1065_; + ValaCCodeVariableDeclarator* _tmp1066_; + ValaCCodeVariableDeclarator* _tmp1067_; + _tmp1058_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); _tmp1059_ = _tmp1058_; - _tmp1060_ = g_strdup_printf ("_inner_error%d_", _tmp1059_); + _tmp1060_ = vala_ccode_base_module_get_current_inner_error_id ((ValaCCodeBaseModule*) self); _tmp1061_ = _tmp1060_; - _tmp1062_ = vala_ccode_constant_new ("NULL"); + _tmp1062_ = g_strdup_printf ("_inner_error%d_", _tmp1061_); _tmp1063_ = _tmp1062_; - _tmp1064_ = vala_ccode_variable_declarator_new_zero (_tmp1061_, (ValaCCodeExpression*) _tmp1063_, NULL); + _tmp1064_ = vala_ccode_constant_new ("NULL"); _tmp1065_ = _tmp1064_; - vala_ccode_function_add_declaration (_tmp1057_, "GError*", (ValaCCodeDeclarator*) _tmp1065_, 0); + _tmp1066_ = vala_ccode_variable_declarator_new_zero (_tmp1063_, (ValaCCodeExpression*) _tmp1065_, NULL); + _tmp1067_ = _tmp1066_; + vala_ccode_function_add_declaration (_tmp1059_, "GError*", (ValaCCodeDeclarator*) _tmp1067_, 0); + _vala_ccode_node_unref0 (_tmp1067_); _vala_ccode_node_unref0 (_tmp1065_); - _vala_ccode_node_unref0 (_tmp1063_); - _g_free0 (_tmp1061_); + _g_free0 (_tmp1063_); } } - _tmp1067_ = vala_callable_get_return_type ((ValaCallable*) m); - _tmp1068_ = _tmp1067_; - if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp1068_, VALA_TYPE_VOID_TYPE)) { - gboolean _tmp1069_; - gboolean _tmp1070_; - _tmp1069_ = vala_method_get_coroutine (m); - _tmp1070_ = _tmp1069_; - _tmp1066_ = _tmp1070_; + _tmp1069_ = vala_callable_get_return_type ((ValaCallable*) m); + _tmp1070_ = _tmp1069_; + if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp1070_, VALA_TYPE_VOID_TYPE)) { + gboolean _tmp1071_; + gboolean _tmp1072_; + _tmp1071_ = vala_method_get_coroutine (m); + _tmp1072_ = _tmp1071_; + _tmp1068_ = _tmp1072_; } else { - _tmp1066_ = FALSE; + _tmp1068_ = FALSE; } - if (_tmp1066_) { + if (_tmp1068_) { vala_ccode_method_module_complete_async (self); } if (G_TYPE_CHECK_INSTANCE_TYPE (m, VALA_TYPE_CREATION_METHOD)) { - gboolean _tmp1071_ = FALSE; - ValaTypeSymbol* _tmp1072_; - ValaTypeSymbol* _tmp1073_; - _tmp1072_ = vala_ccode_base_module_get_current_type_symbol ((ValaCCodeBaseModule*) self); - _tmp1073_ = _tmp1072_; - if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp1073_, VALA_TYPE_CLASS)) { - gboolean _tmp1074_; - gboolean _tmp1075_; - _tmp1074_ = vala_method_get_coroutine (m); - _tmp1075_ = _tmp1074_; - _tmp1071_ = !_tmp1075_; + gboolean _tmp1073_ = FALSE; + ValaTypeSymbol* _tmp1074_; + ValaTypeSymbol* _tmp1075_; + _tmp1074_ = vala_ccode_base_module_get_current_type_symbol ((ValaCCodeBaseModule*) self); + _tmp1075_ = _tmp1074_; + if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp1075_, VALA_TYPE_CLASS)) { + gboolean _tmp1076_; + gboolean _tmp1077_; + _tmp1076_ = vala_method_get_coroutine (m); + _tmp1077_ = _tmp1076_; + _tmp1073_ = !_tmp1077_; } else { - _tmp1071_ = FALSE; + _tmp1073_ = FALSE; } - if (_tmp1071_) { + if (_tmp1073_) { ValaCCodeExpression* cresult = NULL; - ValaCCodeIdentifier* _tmp1076_; - gchar* _tmp1077_; - gchar* _tmp1078_; - gboolean _tmp1079_; - ValaCCodeFunction* _tmp1084_; - ValaCCodeFunction* _tmp1085_; - ValaCCodeExpression* _tmp1086_; - _tmp1076_ = vala_ccode_identifier_new ("self"); - cresult = (ValaCCodeExpression*) _tmp1076_; - _tmp1077_ = vala_get_ccode_type ((ValaCodeNode*) m); - _tmp1078_ = _tmp1077_; - _tmp1079_ = _tmp1078_ != NULL; - _g_free0 (_tmp1078_); - if (_tmp1079_) { - ValaCCodeExpression* _tmp1080_; - gchar* _tmp1081_; - gchar* _tmp1082_; - ValaCCodeCastExpression* _tmp1083_; - _tmp1080_ = cresult; - _tmp1081_ = vala_get_ccode_type ((ValaCodeNode*) m); - _tmp1082_ = _tmp1081_; - _tmp1083_ = vala_ccode_cast_expression_new (_tmp1080_, _tmp1082_); + ValaCCodeIdentifier* _tmp1078_; + gchar* _tmp1079_; + gchar* _tmp1080_; + gboolean _tmp1081_; + ValaCCodeFunction* _tmp1086_; + ValaCCodeFunction* _tmp1087_; + ValaCCodeExpression* _tmp1088_; + _tmp1078_ = vala_ccode_identifier_new ("self"); + cresult = (ValaCCodeExpression*) _tmp1078_; + _tmp1079_ = vala_get_ccode_type ((ValaCodeNode*) m); + _tmp1080_ = _tmp1079_; + _tmp1081_ = _tmp1080_ != NULL; + _g_free0 (_tmp1080_); + if (_tmp1081_) { + ValaCCodeExpression* _tmp1082_; + gchar* _tmp1083_; + gchar* _tmp1084_; + ValaCCodeCastExpression* _tmp1085_; + _tmp1082_ = cresult; + _tmp1083_ = vala_get_ccode_type ((ValaCodeNode*) m); + _tmp1084_ = _tmp1083_; + _tmp1085_ = vala_ccode_cast_expression_new (_tmp1082_, _tmp1084_); _vala_ccode_node_unref0 (cresult); - cresult = (ValaCCodeExpression*) _tmp1083_; - _g_free0 (_tmp1082_); + cresult = (ValaCCodeExpression*) _tmp1085_; + _g_free0 (_tmp1084_); } - _tmp1084_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); - _tmp1085_ = _tmp1084_; - _tmp1086_ = cresult; - vala_ccode_function_add_return (_tmp1085_, _tmp1086_); + _tmp1086_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp1087_ = _tmp1086_; + _tmp1088_ = cresult; + vala_ccode_function_add_return (_tmp1087_, _tmp1088_); _vala_ccode_node_unref0 (cresult); } else { - gboolean _tmp1087_ = FALSE; - ValaTypeSymbol* _tmp1088_; - ValaTypeSymbol* _tmp1089_; - _tmp1088_ = vala_ccode_base_module_get_current_type_symbol ((ValaCCodeBaseModule*) self); - _tmp1089_ = _tmp1088_; - if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp1089_, VALA_TYPE_STRUCT)) { - ValaTypeSymbol* _tmp1090_; - ValaTypeSymbol* _tmp1091_; - _tmp1090_ = vala_ccode_base_module_get_current_type_symbol ((ValaCCodeBaseModule*) self); - _tmp1091_ = _tmp1090_; - _tmp1087_ = vala_struct_is_simple_type (G_TYPE_CHECK_INSTANCE_CAST (_tmp1091_, VALA_TYPE_STRUCT, ValaStruct)); + gboolean _tmp1089_ = FALSE; + ValaTypeSymbol* _tmp1090_; + ValaTypeSymbol* _tmp1091_; + _tmp1090_ = vala_ccode_base_module_get_current_type_symbol ((ValaCCodeBaseModule*) self); + _tmp1091_ = _tmp1090_; + if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp1091_, VALA_TYPE_STRUCT)) { + ValaTypeSymbol* _tmp1092_; + ValaTypeSymbol* _tmp1093_; + _tmp1092_ = vala_ccode_base_module_get_current_type_symbol ((ValaCCodeBaseModule*) self); + _tmp1093_ = _tmp1092_; + _tmp1089_ = vala_struct_is_simple_type (G_TYPE_CHECK_INSTANCE_CAST (_tmp1093_, VALA_TYPE_STRUCT, ValaStruct)); } else { - _tmp1087_ = FALSE; + _tmp1089_ = FALSE; } - if (_tmp1087_) { - ValaCCodeFunction* _tmp1092_; - ValaCCodeFunction* _tmp1093_; - ValaCCodeIdentifier* _tmp1094_; - ValaCCodeIdentifier* _tmp1095_; - _tmp1092_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); - _tmp1093_ = _tmp1092_; - _tmp1094_ = vala_ccode_identifier_new ("self"); + if (_tmp1089_) { + ValaCCodeFunction* _tmp1094_; + ValaCCodeFunction* _tmp1095_; + ValaCCodeIdentifier* _tmp1096_; + ValaCCodeIdentifier* _tmp1097_; + _tmp1094_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); _tmp1095_ = _tmp1094_; - vala_ccode_function_add_return (_tmp1093_, (ValaCCodeExpression*) _tmp1095_); - _vala_ccode_node_unref0 (_tmp1095_); + _tmp1096_ = vala_ccode_identifier_new ("self"); + _tmp1097_ = _tmp1096_; + vala_ccode_function_add_return (_tmp1095_, (ValaCCodeExpression*) _tmp1097_); + _vala_ccode_node_unref0 (_tmp1097_); } } } - _tmp1096_ = ((ValaCCodeBaseModule*) self)->cfile; - _tmp1097_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); - _tmp1098_ = _tmp1097_; - vala_ccode_file_add_function (_tmp1096_, _tmp1098_); + _tmp1098_ = ((ValaCCodeBaseModule*) self)->cfile; + _tmp1099_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp1100_ = _tmp1099_; + vala_ccode_file_add_function (_tmp1098_, _tmp1100_); } } - _tmp1100_ = vala_method_get_is_abstract (m); - _tmp1101_ = _tmp1100_; - if (_tmp1101_) { - ValaTypeSymbol* _tmp1102_; - ValaTypeSymbol* _tmp1103_; - _tmp1102_ = vala_ccode_base_module_get_current_type_symbol ((ValaCCodeBaseModule*) self); - _tmp1103_ = _tmp1102_; - _tmp1099_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp1103_, VALA_TYPE_CLASS); + _tmp1102_ = vala_method_get_is_abstract (m); + _tmp1103_ = _tmp1102_; + if (_tmp1103_) { + ValaTypeSymbol* _tmp1104_; + ValaTypeSymbol* _tmp1105_; + _tmp1104_ = vala_ccode_base_module_get_current_type_symbol ((ValaCCodeBaseModule*) self); + _tmp1105_ = _tmp1104_; + _tmp1101_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp1105_, VALA_TYPE_CLASS); } else { - _tmp1099_ = FALSE; + _tmp1101_ = FALSE; } - if (_tmp1099_) { + if (_tmp1101_) { ValaCCodeFunctionCall* cerrorcall = NULL; - ValaCCodeIdentifier* _tmp1104_; - ValaCCodeIdentifier* _tmp1105_; - ValaCCodeFunctionCall* _tmp1106_; - ValaCCodeFunctionCall* _tmp1107_; - ValaTypeSymbol* _tmp1108_; - ValaTypeSymbol* _tmp1109_; - gboolean _tmp1110_; - gboolean _tmp1111_; - ValaCCodeFunction* _tmp1141_; - ValaCCodeFunction* _tmp1142_; - ValaCCodeFunctionCall* _tmp1143_; - ValaDataType* _tmp1144_; - ValaCCodeFile* _tmp1145_; - ValaCCodeFunction* _tmp1146_; - ValaCCodeFunction* _tmp1147_; - _tmp1104_ = vala_ccode_identifier_new ("g_critical"); - _tmp1105_ = _tmp1104_; - _tmp1106_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp1105_); + ValaCCodeIdentifier* _tmp1106_; + ValaCCodeIdentifier* _tmp1107_; + ValaCCodeFunctionCall* _tmp1108_; + ValaCCodeFunctionCall* _tmp1109_; + ValaTypeSymbol* _tmp1110_; + ValaTypeSymbol* _tmp1111_; + gboolean _tmp1112_; + gboolean _tmp1113_; + ValaCCodeFunction* _tmp1143_; + ValaCCodeFunction* _tmp1144_; + ValaCCodeFunctionCall* _tmp1145_; + ValaDataType* _tmp1146_; + ValaCCodeFile* _tmp1147_; + ValaCCodeFunction* _tmp1148_; + ValaCCodeFunction* _tmp1149_; + _tmp1106_ = vala_ccode_identifier_new ("g_critical"); _tmp1107_ = _tmp1106_; - _vala_ccode_node_unref0 (_tmp1105_); - cerrorcall = _tmp1107_; - _tmp1108_ = vala_ccode_base_module_get_current_type_symbol ((ValaCCodeBaseModule*) self); + _tmp1108_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp1107_); _tmp1109_ = _tmp1108_; - _tmp1110_ = vala_class_get_is_compact (G_TYPE_CHECK_INSTANCE_CAST (_tmp1109_, VALA_TYPE_CLASS, ValaClass)); + _vala_ccode_node_unref0 (_tmp1107_); + cerrorcall = _tmp1109_; + _tmp1110_ = vala_ccode_base_module_get_current_type_symbol ((ValaCCodeBaseModule*) self); _tmp1111_ = _tmp1110_; - if (!_tmp1111_) { + _tmp1112_ = vala_class_get_is_compact (G_TYPE_CHECK_INSTANCE_CAST (_tmp1111_, VALA_TYPE_CLASS, ValaClass)); + _tmp1113_ = _tmp1112_; + if (!_tmp1113_) { ValaCCodeFunctionCall* type_from_instance_call = NULL; - ValaCCodeIdentifier* _tmp1112_; - ValaCCodeIdentifier* _tmp1113_; - ValaCCodeFunctionCall* _tmp1114_; - ValaCCodeFunctionCall* _tmp1115_; + ValaCCodeIdentifier* _tmp1114_; + ValaCCodeIdentifier* _tmp1115_; ValaCCodeFunctionCall* _tmp1116_; - ValaCCodeIdentifier* _tmp1117_; - ValaCCodeIdentifier* _tmp1118_; - ValaCCodeFunctionCall* type_name_call = NULL; + ValaCCodeFunctionCall* _tmp1117_; + ValaCCodeFunctionCall* _tmp1118_; ValaCCodeIdentifier* _tmp1119_; ValaCCodeIdentifier* _tmp1120_; - ValaCCodeFunctionCall* _tmp1121_; - ValaCCodeFunctionCall* _tmp1122_; + ValaCCodeFunctionCall* type_name_call = NULL; + ValaCCodeIdentifier* _tmp1121_; + ValaCCodeIdentifier* _tmp1122_; ValaCCodeFunctionCall* _tmp1123_; ValaCCodeFunctionCall* _tmp1124_; ValaCCodeFunctionCall* _tmp1125_; - gchar* _tmp1126_; - gchar* _tmp1127_; + ValaCCodeFunctionCall* _tmp1126_; + ValaCCodeFunctionCall* _tmp1127_; gchar* _tmp1128_; gchar* _tmp1129_; - ValaCCodeConstant* _tmp1130_; - ValaCCodeConstant* _tmp1131_; - ValaCCodeFunctionCall* _tmp1132_; - ValaCCodeFunctionCall* _tmp1133_; - _tmp1112_ = vala_ccode_identifier_new ("G_TYPE_FROM_INSTANCE"); - _tmp1113_ = _tmp1112_; - _tmp1114_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp1113_); + gchar* _tmp1130_; + gchar* _tmp1131_; + ValaCCodeConstant* _tmp1132_; + ValaCCodeConstant* _tmp1133_; + ValaCCodeFunctionCall* _tmp1134_; + ValaCCodeFunctionCall* _tmp1135_; + _tmp1114_ = vala_ccode_identifier_new ("G_TYPE_FROM_INSTANCE"); _tmp1115_ = _tmp1114_; - _vala_ccode_node_unref0 (_tmp1113_); - type_from_instance_call = _tmp1115_; - _tmp1116_ = type_from_instance_call; - _tmp1117_ = vala_ccode_identifier_new ("self"); - _tmp1118_ = _tmp1117_; - vala_ccode_function_call_add_argument (_tmp1116_, (ValaCCodeExpression*) _tmp1118_); - _vala_ccode_node_unref0 (_tmp1118_); - _tmp1119_ = vala_ccode_identifier_new ("g_type_name"); + _tmp1116_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp1115_); + _tmp1117_ = _tmp1116_; + _vala_ccode_node_unref0 (_tmp1115_); + type_from_instance_call = _tmp1117_; + _tmp1118_ = type_from_instance_call; + _tmp1119_ = vala_ccode_identifier_new ("self"); _tmp1120_ = _tmp1119_; - _tmp1121_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp1120_); - _tmp1122_ = _tmp1121_; + vala_ccode_function_call_add_argument (_tmp1118_, (ValaCCodeExpression*) _tmp1120_); _vala_ccode_node_unref0 (_tmp1120_); - type_name_call = _tmp1122_; - _tmp1123_ = type_name_call; - _tmp1124_ = type_from_instance_call; - vala_ccode_function_call_add_argument (_tmp1123_, (ValaCCodeExpression*) _tmp1124_); - _tmp1125_ = cerrorcall; - _tmp1126_ = vala_get_ccode_name ((ValaCodeNode*) m); - _tmp1127_ = _tmp1126_; - _tmp1128_ = g_strdup_printf ("\"Type `%%s' does not implement abstract method `%s'\"", _tmp1127_); + _tmp1121_ = vala_ccode_identifier_new ("g_type_name"); + _tmp1122_ = _tmp1121_; + _tmp1123_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp1122_); + _tmp1124_ = _tmp1123_; + _vala_ccode_node_unref0 (_tmp1122_); + type_name_call = _tmp1124_; + _tmp1125_ = type_name_call; + _tmp1126_ = type_from_instance_call; + vala_ccode_function_call_add_argument (_tmp1125_, (ValaCCodeExpression*) _tmp1126_); + _tmp1127_ = cerrorcall; + _tmp1128_ = vala_get_ccode_name ((ValaCodeNode*) m); _tmp1129_ = _tmp1128_; - _tmp1130_ = vala_ccode_constant_new (_tmp1129_); + _tmp1130_ = g_strdup_printf ("\"Type `%%s' does not implement abstract method `%s'\"", _tmp1129_); _tmp1131_ = _tmp1130_; - vala_ccode_function_call_add_argument (_tmp1125_, (ValaCCodeExpression*) _tmp1131_); - _vala_ccode_node_unref0 (_tmp1131_); + _tmp1132_ = vala_ccode_constant_new (_tmp1131_); + _tmp1133_ = _tmp1132_; + vala_ccode_function_call_add_argument (_tmp1127_, (ValaCCodeExpression*) _tmp1133_); + _vala_ccode_node_unref0 (_tmp1133_); + _g_free0 (_tmp1131_); _g_free0 (_tmp1129_); - _g_free0 (_tmp1127_); - _tmp1132_ = cerrorcall; - _tmp1133_ = type_name_call; - vala_ccode_function_call_add_argument (_tmp1132_, (ValaCCodeExpression*) _tmp1133_); + _tmp1134_ = cerrorcall; + _tmp1135_ = type_name_call; + vala_ccode_function_call_add_argument (_tmp1134_, (ValaCCodeExpression*) _tmp1135_); _vala_ccode_node_unref0 (type_name_call); _vala_ccode_node_unref0 (type_from_instance_call); } else { - ValaCCodeFunctionCall* _tmp1134_; - gchar* _tmp1135_; - gchar* _tmp1136_; + ValaCCodeFunctionCall* _tmp1136_; gchar* _tmp1137_; gchar* _tmp1138_; - ValaCCodeConstant* _tmp1139_; - ValaCCodeConstant* _tmp1140_; - _tmp1134_ = cerrorcall; - _tmp1135_ = vala_get_ccode_name ((ValaCodeNode*) m); - _tmp1136_ = _tmp1135_; - _tmp1137_ = g_strdup_printf ("\"Abstract method `%s' is not implemented\"", _tmp1136_); + gchar* _tmp1139_; + gchar* _tmp1140_; + ValaCCodeConstant* _tmp1141_; + ValaCCodeConstant* _tmp1142_; + _tmp1136_ = cerrorcall; + _tmp1137_ = vala_get_ccode_name ((ValaCodeNode*) m); _tmp1138_ = _tmp1137_; - _tmp1139_ = vala_ccode_constant_new (_tmp1138_); + _tmp1139_ = g_strdup_printf ("\"Abstract method `%s' is not implemented\"", _tmp1138_); _tmp1140_ = _tmp1139_; - vala_ccode_function_call_add_argument (_tmp1134_, (ValaCCodeExpression*) _tmp1140_); - _vala_ccode_node_unref0 (_tmp1140_); + _tmp1141_ = vala_ccode_constant_new (_tmp1140_); + _tmp1142_ = _tmp1141_; + vala_ccode_function_call_add_argument (_tmp1136_, (ValaCCodeExpression*) _tmp1142_); + _vala_ccode_node_unref0 (_tmp1142_); + _g_free0 (_tmp1140_); _g_free0 (_tmp1138_); - _g_free0 (_tmp1136_); } - _tmp1141_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); - _tmp1142_ = _tmp1141_; - _tmp1143_ = cerrorcall; - vala_ccode_function_add_expression (_tmp1142_, (ValaCCodeExpression*) _tmp1143_); - _tmp1144_ = creturn_type; - vala_ccode_base_module_return_default_value ((ValaCCodeBaseModule*) self, _tmp1144_, FALSE); - _tmp1145_ = ((ValaCCodeBaseModule*) self)->cfile; - _tmp1146_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); - _tmp1147_ = _tmp1146_; - vala_ccode_file_add_function (_tmp1145_, _tmp1147_); + _tmp1143_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp1144_ = _tmp1143_; + _tmp1145_ = cerrorcall; + vala_ccode_function_add_expression (_tmp1144_, (ValaCCodeExpression*) _tmp1145_); + _tmp1146_ = creturn_type; + vala_ccode_base_module_return_default_value ((ValaCCodeBaseModule*) self, _tmp1146_, FALSE); + _tmp1147_ = ((ValaCCodeBaseModule*) self)->cfile; + _tmp1148_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp1149_ = _tmp1148_; + vala_ccode_file_add_function (_tmp1147_, _tmp1149_); _vala_ccode_node_unref0 (cerrorcall); } - _tmp1151_ = vala_ccode_base_module_get_current_method_return ((ValaCCodeBaseModule*) self); - _tmp1152_ = _tmp1151_; - if (_tmp1152_) { - ValaDataType* _tmp1153_; - ValaDataType* _tmp1154_; - _tmp1153_ = vala_callable_get_return_type ((ValaCallable*) m); - _tmp1154_ = _tmp1153_; - _tmp1150_ = !G_TYPE_CHECK_INSTANCE_TYPE (_tmp1154_, VALA_TYPE_VOID_TYPE); - } else { - _tmp1150_ = FALSE; - } - if (_tmp1150_) { + _tmp1153_ = vala_ccode_base_module_get_current_method_return ((ValaCCodeBaseModule*) self); + _tmp1154_ = _tmp1153_; + if (_tmp1154_) { ValaDataType* _tmp1155_; ValaDataType* _tmp1156_; _tmp1155_ = vala_callable_get_return_type ((ValaCallable*) m); _tmp1156_ = _tmp1155_; - _tmp1149_ = !vala_data_type_is_real_non_null_struct_type (_tmp1156_); + _tmp1152_ = !G_TYPE_CHECK_INSTANCE_TYPE (_tmp1156_, VALA_TYPE_VOID_TYPE); } else { - _tmp1149_ = FALSE; + _tmp1152_ = FALSE; } - if (_tmp1149_) { - gboolean _tmp1157_; - gboolean _tmp1158_; - _tmp1157_ = vala_method_get_coroutine (m); + if (_tmp1152_) { + ValaDataType* _tmp1157_; + ValaDataType* _tmp1158_; + _tmp1157_ = vala_callable_get_return_type ((ValaCallable*) m); _tmp1158_ = _tmp1157_; - _tmp1148_ = !_tmp1158_; + _tmp1151_ = !vala_data_type_is_real_non_null_struct_type (_tmp1158_); } else { - _tmp1148_ = FALSE; + _tmp1151_ = FALSE; } - if (_tmp1148_) { + if (_tmp1151_) { + gboolean _tmp1159_; + gboolean _tmp1160_; + _tmp1159_ = vala_method_get_coroutine (m); + _tmp1160_ = _tmp1159_; + _tmp1150_ = !_tmp1160_; + } else { + _tmp1150_ = FALSE; + } + if (_tmp1150_) { ValaCCodeVariableDeclarator* vardecl = NULL; - ValaDataType* _tmp1159_; - ValaDataType* _tmp1160_; - ValaCCodeExpression* _tmp1161_; - ValaCCodeExpression* _tmp1162_; - ValaCCodeVariableDeclarator* _tmp1163_; - ValaCCodeVariableDeclarator* _tmp1164_; + ValaDataType* _tmp1161_; + ValaDataType* _tmp1162_; + ValaCCodeExpression* _tmp1163_; + ValaCCodeExpression* _tmp1164_; ValaCCodeVariableDeclarator* _tmp1165_; - ValaCCodeFunction* _tmp1166_; - ValaCCodeFunction* _tmp1167_; - ValaDataType* _tmp1168_; - ValaDataType* _tmp1169_; - gchar* _tmp1170_; - gchar* _tmp1171_; - ValaCCodeVariableDeclarator* _tmp1172_; - _tmp1159_ = vala_callable_get_return_type ((ValaCallable*) m); - _tmp1160_ = _tmp1159_; - _tmp1161_ = vala_ccode_base_module_default_value_for_type ((ValaCCodeBaseModule*) self, _tmp1160_, TRUE, FALSE); + ValaCCodeVariableDeclarator* _tmp1166_; + ValaCCodeVariableDeclarator* _tmp1167_; + ValaCCodeFunction* _tmp1168_; + ValaCCodeFunction* _tmp1169_; + ValaDataType* _tmp1170_; + ValaDataType* _tmp1171_; + gchar* _tmp1172_; + gchar* _tmp1173_; + ValaCCodeVariableDeclarator* _tmp1174_; + _tmp1161_ = vala_callable_get_return_type ((ValaCallable*) m); _tmp1162_ = _tmp1161_; - _tmp1163_ = vala_ccode_variable_declarator_new ("result", _tmp1162_, NULL); + _tmp1163_ = vala_ccode_base_module_default_value_for_type ((ValaCCodeBaseModule*) self, _tmp1162_, TRUE, FALSE); _tmp1164_ = _tmp1163_; - _vala_ccode_node_unref0 (_tmp1162_); - vardecl = _tmp1164_; - _tmp1165_ = vardecl; - vala_ccode_variable_declarator_set_init0 (_tmp1165_, TRUE); - _tmp1166_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); - _tmp1167_ = _tmp1166_; - _tmp1168_ = vala_callable_get_return_type ((ValaCallable*) m); + _tmp1165_ = vala_ccode_variable_declarator_new ("result", _tmp1164_, NULL); + _tmp1166_ = _tmp1165_; + _vala_ccode_node_unref0 (_tmp1164_); + vardecl = _tmp1166_; + _tmp1167_ = vardecl; + vala_ccode_variable_declarator_set_init0 (_tmp1167_, TRUE); + _tmp1168_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); _tmp1169_ = _tmp1168_; - _tmp1170_ = vala_get_ccode_name ((ValaCodeNode*) _tmp1169_); + _tmp1170_ = vala_callable_get_return_type ((ValaCallable*) m); _tmp1171_ = _tmp1170_; - _tmp1172_ = vardecl; - vala_ccode_function_add_declaration (_tmp1167_, _tmp1171_, (ValaCCodeDeclarator*) _tmp1172_, 0); - _g_free0 (_tmp1171_); + _tmp1172_ = vala_get_ccode_name ((ValaCodeNode*) _tmp1171_); + _tmp1173_ = _tmp1172_; + _tmp1174_ = vardecl; + vala_ccode_function_add_declaration (_tmp1169_, _tmp1173_, (ValaCCodeDeclarator*) _tmp1174_, 0); + _g_free0 (_tmp1173_); _vala_ccode_node_unref0 (vardecl); } vala_ccode_base_module_pop_context ((ValaCCodeBaseModule*) self); - _tmp1177_ = vala_method_get_is_abstract (m); - _tmp1178_ = _tmp1177_; - if (_tmp1178_) { - _tmp1176_ = TRUE; + _tmp1179_ = vala_method_get_is_abstract (m); + _tmp1180_ = _tmp1179_; + if (_tmp1180_) { + _tmp1178_ = TRUE; } else { - gboolean _tmp1179_; - gboolean _tmp1180_; - _tmp1179_ = vala_method_get_is_virtual (m); - _tmp1180_ = _tmp1179_; - _tmp1176_ = _tmp1180_; - } - if (_tmp1176_) { gboolean _tmp1181_; gboolean _tmp1182_; - _tmp1181_ = vala_method_get_coroutine (m); + _tmp1181_ = vala_method_get_is_virtual (m); _tmp1182_ = _tmp1181_; - _tmp1175_ = !_tmp1182_; + _tmp1178_ = _tmp1182_; + } + if (_tmp1178_) { + gboolean _tmp1183_; + gboolean _tmp1184_; + _tmp1183_ = vala_method_get_coroutine (m); + _tmp1184_ = _tmp1183_; + _tmp1177_ = !_tmp1184_; } else { - _tmp1175_ = FALSE; + _tmp1177_ = FALSE; } - if (_tmp1175_) { - _tmp1174_ = !vala_get_ccode_no_wrapper (m); + if (_tmp1177_) { + _tmp1176_ = !vala_get_ccode_no_wrapper (m); } else { - _tmp1174_ = FALSE; + _tmp1176_ = FALSE; } - if (_tmp1174_) { - ValaSignal* _tmp1183_; - ValaSignal* _tmp1184_; - _tmp1183_ = vala_method_get_signal_reference (m); - _tmp1184_ = _tmp1183_; - _tmp1173_ = _tmp1184_ == NULL; + if (_tmp1176_) { + ValaSignal* _tmp1185_; + ValaSignal* _tmp1186_; + _tmp1185_ = vala_method_get_signal_reference (m); + _tmp1186_ = _tmp1185_; + _tmp1175_ = _tmp1186_ == NULL; } else { - _tmp1173_ = FALSE; + _tmp1175_ = FALSE; } - if (_tmp1173_) { - GHashFunc _tmp1185_; - GEqualFunc _tmp1186_; - GEqualFunc _tmp1187_; - ValaHashMap* _tmp1188_; + if (_tmp1175_) { + GHashFunc _tmp1187_; + GEqualFunc _tmp1188_; + GEqualFunc _tmp1189_; + ValaHashMap* _tmp1190_; ValaHashMap* carg_map = NULL; - GHashFunc _tmp1189_; - GEqualFunc _tmp1190_; - GEqualFunc _tmp1191_; - ValaHashMap* _tmp1192_; - ValaDataType* _tmp1193_; + GHashFunc _tmp1191_; + GEqualFunc _tmp1192_; + GEqualFunc _tmp1193_; ValaHashMap* _tmp1194_; - ValaHashMap* _tmp1195_; - _tmp1185_ = g_direct_hash; - _tmp1186_ = g_direct_equal; - _tmp1187_ = g_direct_equal; - _tmp1188_ = vala_hash_map_new (G_TYPE_INT, NULL, NULL, VALA_TYPE_CCODE_PARAMETER, (GBoxedCopyFunc) vala_ccode_node_ref, (GDestroyNotify) vala_ccode_node_unref, _tmp1185_, _tmp1186_, _tmp1187_); + ValaDataType* _tmp1195_; + ValaHashMap* _tmp1196_; + ValaHashMap* _tmp1197_; + _tmp1187_ = g_direct_hash; + _tmp1188_ = g_direct_equal; + _tmp1189_ = g_direct_equal; + _tmp1190_ = vala_hash_map_new (G_TYPE_INT, NULL, NULL, VALA_TYPE_CCODE_PARAMETER, (GBoxedCopyFunc) vala_ccode_node_ref, (GDestroyNotify) vala_ccode_node_unref, _tmp1187_, _tmp1188_, _tmp1189_); _vala_map_unref0 (cparam_map); - cparam_map = _tmp1188_; - _tmp1189_ = g_direct_hash; - _tmp1190_ = g_direct_equal; - _tmp1191_ = g_direct_equal; - _tmp1192_ = vala_hash_map_new (G_TYPE_INT, NULL, NULL, VALA_TYPE_CCODE_EXPRESSION, (GBoxedCopyFunc) vala_ccode_node_ref, (GDestroyNotify) vala_ccode_node_unref, _tmp1189_, _tmp1190_, _tmp1191_); - carg_map = _tmp1192_; - _tmp1193_ = creturn_type; - _tmp1194_ = cparam_map; - _tmp1195_ = carg_map; - vala_ccode_method_module_generate_vfunc (self, m, _tmp1193_, (ValaMap*) _tmp1194_, (ValaMap*) _tmp1195_, "", 3); + cparam_map = _tmp1190_; + _tmp1191_ = g_direct_hash; + _tmp1192_ = g_direct_equal; + _tmp1193_ = g_direct_equal; + _tmp1194_ = vala_hash_map_new (G_TYPE_INT, NULL, NULL, VALA_TYPE_CCODE_EXPRESSION, (GBoxedCopyFunc) vala_ccode_node_ref, (GDestroyNotify) vala_ccode_node_unref, _tmp1191_, _tmp1192_, _tmp1193_); + carg_map = _tmp1194_; + _tmp1195_ = creturn_type; + _tmp1196_ = cparam_map; + _tmp1197_ = carg_map; + vala_ccode_method_module_generate_vfunc (self, m, _tmp1195_, (ValaMap*) _tmp1196_, (ValaMap*) _tmp1197_, "", 3); _vala_map_unref0 (carg_map); } - _tmp1196_ = vala_method_get_entry_point (m); - _tmp1197_ = _tmp1196_; - if (_tmp1197_) { + _tmp1198_ = vala_method_get_entry_point (m); + _tmp1199_ = _tmp1198_; + if (_tmp1199_) { ValaCCodeFunction* cmain = NULL; - ValaCCodeFunction* _tmp1198_; - ValaCCodeFunction* _tmp1199_; ValaCCodeFunction* _tmp1200_; - ValaCCodeLineDirective* _tmp1201_; - ValaCCodeLineDirective* _tmp1202_; - ValaCCodeFunction* _tmp1203_; - ValaCCodeParameter* _tmp1204_; - ValaCCodeParameter* _tmp1205_; - ValaCCodeFunction* _tmp1206_; + ValaCCodeFunction* _tmp1201_; + ValaCCodeFunction* _tmp1202_; + ValaCCodeLineDirective* _tmp1203_; + ValaCCodeLineDirective* _tmp1204_; + ValaCCodeFunction* _tmp1205_; + ValaCCodeParameter* _tmp1206_; ValaCCodeParameter* _tmp1207_; - ValaCCodeParameter* _tmp1208_; - ValaCCodeFunction* _tmp1209_; - ValaCodeContext* _tmp1210_; - ValaCodeContext* _tmp1211_; - ValaProfile _tmp1212_; - ValaProfile _tmp1213_; + ValaCCodeFunction* _tmp1208_; + ValaCCodeParameter* _tmp1209_; + ValaCCodeParameter* _tmp1210_; + ValaCCodeFunction* _tmp1211_; + ValaCodeContext* _tmp1212_; + ValaCodeContext* _tmp1213_; + ValaProfile _tmp1214_; + ValaProfile _tmp1215_; ValaCCodeFunctionCall* main_call = NULL; - ValaCCodeFunction* _tmp1232_; - const gchar* _tmp1233_; - const gchar* _tmp1234_; - ValaCCodeIdentifier* _tmp1235_; - ValaCCodeIdentifier* _tmp1236_; - ValaCCodeFunctionCall* _tmp1237_; - ValaCCodeFunctionCall* _tmp1238_; - ValaList* _tmp1239_; - gint _tmp1240_; - gint _tmp1241_; - ValaDataType* _tmp1248_; - ValaDataType* _tmp1249_; - ValaCCodeFile* _tmp1260_; - ValaCCodeFunction* _tmp1261_; - _tmp1198_ = vala_ccode_function_new ("main", "int"); - cmain = _tmp1198_; - _tmp1199_ = cmain; - _tmp1200_ = function; - _tmp1201_ = vala_ccode_node_get_line ((ValaCCodeNode*) _tmp1200_); - _tmp1202_ = _tmp1201_; - vala_ccode_node_set_line ((ValaCCodeNode*) _tmp1199_, _tmp1202_); - _tmp1203_ = cmain; - _tmp1204_ = vala_ccode_parameter_new ("argc", "int"); - _tmp1205_ = _tmp1204_; - vala_ccode_function_add_parameter (_tmp1203_, _tmp1205_); - _vala_ccode_node_unref0 (_tmp1205_); - _tmp1206_ = cmain; - _tmp1207_ = vala_ccode_parameter_new ("argv", "char **"); - _tmp1208_ = _tmp1207_; - vala_ccode_function_add_parameter (_tmp1206_, _tmp1208_); - _vala_ccode_node_unref0 (_tmp1208_); - _tmp1209_ = cmain; - vala_ccode_base_module_push_function ((ValaCCodeBaseModule*) self, _tmp1209_); - _tmp1210_ = vala_ccode_base_module_get_context ((ValaCCodeBaseModule*) self); - _tmp1211_ = _tmp1210_; - _tmp1212_ = vala_code_context_get_profile (_tmp1211_); + ValaCCodeFunction* _tmp1234_; + const gchar* _tmp1235_; + const gchar* _tmp1236_; + ValaCCodeIdentifier* _tmp1237_; + ValaCCodeIdentifier* _tmp1238_; + ValaCCodeFunctionCall* _tmp1239_; + ValaCCodeFunctionCall* _tmp1240_; + ValaList* _tmp1241_; + gint _tmp1242_; + gint _tmp1243_; + ValaDataType* _tmp1250_; + ValaDataType* _tmp1251_; + ValaCCodeFile* _tmp1262_; + ValaCCodeFunction* _tmp1263_; + _tmp1200_ = vala_ccode_function_new ("main", "int"); + cmain = _tmp1200_; + _tmp1201_ = cmain; + _tmp1202_ = function; + _tmp1203_ = vala_ccode_node_get_line ((ValaCCodeNode*) _tmp1202_); + _tmp1204_ = _tmp1203_; + vala_ccode_node_set_line ((ValaCCodeNode*) _tmp1201_, _tmp1204_); + _tmp1205_ = cmain; + _tmp1206_ = vala_ccode_parameter_new ("argc", "int"); + _tmp1207_ = _tmp1206_; + vala_ccode_function_add_parameter (_tmp1205_, _tmp1207_); + _vala_ccode_node_unref0 (_tmp1207_); + _tmp1208_ = cmain; + _tmp1209_ = vala_ccode_parameter_new ("argv", "char **"); + _tmp1210_ = _tmp1209_; + vala_ccode_function_add_parameter (_tmp1208_, _tmp1210_); + _vala_ccode_node_unref0 (_tmp1210_); + _tmp1211_ = cmain; + vala_ccode_base_module_push_function ((ValaCCodeBaseModule*) self, _tmp1211_); + _tmp1212_ = vala_ccode_base_module_get_context ((ValaCCodeBaseModule*) self); _tmp1213_ = _tmp1212_; - if (_tmp1213_ == VALA_PROFILE_GOBJECT) { - ValaCodeContext* _tmp1214_; - ValaCodeContext* _tmp1215_; - gboolean _tmp1216_; - gboolean _tmp1217_; - _tmp1214_ = vala_ccode_base_module_get_context ((ValaCCodeBaseModule*) self); - _tmp1215_ = _tmp1214_; - _tmp1216_ = vala_code_context_get_mem_profiler (_tmp1215_); + _tmp1214_ = vala_code_context_get_profile (_tmp1213_); + _tmp1215_ = _tmp1214_; + if (_tmp1215_ == VALA_PROFILE_GOBJECT) { + ValaCodeContext* _tmp1216_; + ValaCodeContext* _tmp1217_; + gboolean _tmp1218_; + gboolean _tmp1219_; + _tmp1216_ = vala_ccode_base_module_get_context ((ValaCCodeBaseModule*) self); _tmp1217_ = _tmp1216_; - if (_tmp1217_) { + _tmp1218_ = vala_code_context_get_mem_profiler (_tmp1217_); + _tmp1219_ = _tmp1218_; + if (_tmp1219_) { ValaCCodeFunctionCall* mem_profiler_init_call = NULL; - ValaCCodeIdentifier* _tmp1218_; - ValaCCodeIdentifier* _tmp1219_; - ValaCCodeFunctionCall* _tmp1220_; - ValaCCodeFunctionCall* _tmp1221_; + ValaCCodeIdentifier* _tmp1220_; + ValaCCodeIdentifier* _tmp1221_; ValaCCodeFunctionCall* _tmp1222_; - ValaCCodeFunction* _tmp1223_; - ValaCCodeLineDirective* _tmp1224_; - ValaCCodeLineDirective* _tmp1225_; - ValaCCodeFunctionCall* _tmp1226_; - ValaCCodeConstant* _tmp1227_; - ValaCCodeConstant* _tmp1228_; - ValaCCodeFunction* _tmp1229_; - ValaCCodeFunction* _tmp1230_; - ValaCCodeFunctionCall* _tmp1231_; - _tmp1218_ = vala_ccode_identifier_new ("g_mem_set_vtable"); - _tmp1219_ = _tmp1218_; - _tmp1220_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp1219_); + ValaCCodeFunctionCall* _tmp1223_; + ValaCCodeFunctionCall* _tmp1224_; + ValaCCodeFunction* _tmp1225_; + ValaCCodeLineDirective* _tmp1226_; + ValaCCodeLineDirective* _tmp1227_; + ValaCCodeFunctionCall* _tmp1228_; + ValaCCodeConstant* _tmp1229_; + ValaCCodeConstant* _tmp1230_; + ValaCCodeFunction* _tmp1231_; + ValaCCodeFunction* _tmp1232_; + ValaCCodeFunctionCall* _tmp1233_; + _tmp1220_ = vala_ccode_identifier_new ("g_mem_set_vtable"); _tmp1221_ = _tmp1220_; - _vala_ccode_node_unref0 (_tmp1219_); - mem_profiler_init_call = _tmp1221_; - _tmp1222_ = mem_profiler_init_call; - _tmp1223_ = cmain; - _tmp1224_ = vala_ccode_node_get_line ((ValaCCodeNode*) _tmp1223_); - _tmp1225_ = _tmp1224_; - vala_ccode_node_set_line ((ValaCCodeNode*) _tmp1222_, _tmp1225_); - _tmp1226_ = mem_profiler_init_call; - _tmp1227_ = vala_ccode_constant_new ("glib_mem_profiler_table"); - _tmp1228_ = _tmp1227_; - vala_ccode_function_call_add_argument (_tmp1226_, (ValaCCodeExpression*) _tmp1228_); - _vala_ccode_node_unref0 (_tmp1228_); - _tmp1229_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp1222_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp1221_); + _tmp1223_ = _tmp1222_; + _vala_ccode_node_unref0 (_tmp1221_); + mem_profiler_init_call = _tmp1223_; + _tmp1224_ = mem_profiler_init_call; + _tmp1225_ = cmain; + _tmp1226_ = vala_ccode_node_get_line ((ValaCCodeNode*) _tmp1225_); + _tmp1227_ = _tmp1226_; + vala_ccode_node_set_line ((ValaCCodeNode*) _tmp1224_, _tmp1227_); + _tmp1228_ = mem_profiler_init_call; + _tmp1229_ = vala_ccode_constant_new ("glib_mem_profiler_table"); _tmp1230_ = _tmp1229_; - _tmp1231_ = mem_profiler_init_call; - vala_ccode_function_add_expression (_tmp1230_, (ValaCCodeExpression*) _tmp1231_); + vala_ccode_function_call_add_argument (_tmp1228_, (ValaCCodeExpression*) _tmp1230_); + _vala_ccode_node_unref0 (_tmp1230_); + _tmp1231_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp1232_ = _tmp1231_; + _tmp1233_ = mem_profiler_init_call; + vala_ccode_function_add_expression (_tmp1232_, (ValaCCodeExpression*) _tmp1233_); _vala_ccode_node_unref0 (mem_profiler_init_call); } } - _tmp1232_ = function; - _tmp1233_ = vala_ccode_function_get_name (_tmp1232_); - _tmp1234_ = _tmp1233_; - _tmp1235_ = vala_ccode_identifier_new (_tmp1234_); + _tmp1234_ = function; + _tmp1235_ = vala_ccode_function_get_name (_tmp1234_); _tmp1236_ = _tmp1235_; - _tmp1237_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp1236_); + _tmp1237_ = vala_ccode_identifier_new (_tmp1236_); _tmp1238_ = _tmp1237_; - _vala_ccode_node_unref0 (_tmp1236_); - main_call = _tmp1238_; - _tmp1239_ = vala_callable_get_parameters ((ValaCallable*) m); - _tmp1240_ = vala_collection_get_size ((ValaCollection*) _tmp1239_); - _tmp1241_ = _tmp1240_; - if (_tmp1241_ == 1) { - ValaCCodeFunctionCall* _tmp1242_; - ValaCCodeIdentifier* _tmp1243_; - ValaCCodeIdentifier* _tmp1244_; - ValaCCodeFunctionCall* _tmp1245_; + _tmp1239_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp1238_); + _tmp1240_ = _tmp1239_; + _vala_ccode_node_unref0 (_tmp1238_); + main_call = _tmp1240_; + _tmp1241_ = vala_callable_get_parameters ((ValaCallable*) m); + _tmp1242_ = vala_collection_get_size ((ValaCollection*) _tmp1241_); + _tmp1243_ = _tmp1242_; + if (_tmp1243_ == 1) { + ValaCCodeFunctionCall* _tmp1244_; + ValaCCodeIdentifier* _tmp1245_; ValaCCodeIdentifier* _tmp1246_; - ValaCCodeIdentifier* _tmp1247_; - _tmp1242_ = main_call; - _tmp1243_ = vala_ccode_identifier_new ("argv"); - _tmp1244_ = _tmp1243_; - vala_ccode_function_call_add_argument (_tmp1242_, (ValaCCodeExpression*) _tmp1244_); - _vala_ccode_node_unref0 (_tmp1244_); - _tmp1245_ = main_call; - _tmp1246_ = vala_ccode_identifier_new ("argc"); - _tmp1247_ = _tmp1246_; - vala_ccode_function_call_add_argument (_tmp1245_, (ValaCCodeExpression*) _tmp1247_); - _vala_ccode_node_unref0 (_tmp1247_); + ValaCCodeFunctionCall* _tmp1247_; + ValaCCodeIdentifier* _tmp1248_; + ValaCCodeIdentifier* _tmp1249_; + _tmp1244_ = main_call; + _tmp1245_ = vala_ccode_identifier_new ("argv"); + _tmp1246_ = _tmp1245_; + vala_ccode_function_call_add_argument (_tmp1244_, (ValaCCodeExpression*) _tmp1246_); + _vala_ccode_node_unref0 (_tmp1246_); + _tmp1247_ = main_call; + _tmp1248_ = vala_ccode_identifier_new ("argc"); + _tmp1249_ = _tmp1248_; + vala_ccode_function_call_add_argument (_tmp1247_, (ValaCCodeExpression*) _tmp1249_); + _vala_ccode_node_unref0 (_tmp1249_); } - _tmp1248_ = vala_callable_get_return_type ((ValaCallable*) m); - _tmp1249_ = _tmp1248_; - if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp1249_, VALA_TYPE_VOID_TYPE)) { - ValaCCodeFunction* _tmp1250_; - ValaCCodeFunction* _tmp1251_; - ValaCCodeFunctionCall* _tmp1252_; + _tmp1250_ = vala_callable_get_return_type ((ValaCallable*) m); + _tmp1251_ = _tmp1250_; + if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp1251_, VALA_TYPE_VOID_TYPE)) { + ValaCCodeFunction* _tmp1252_; ValaCCodeFunction* _tmp1253_; - ValaCCodeFunction* _tmp1254_; - ValaCCodeConstant* _tmp1255_; - ValaCCodeConstant* _tmp1256_; - _tmp1250_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); - _tmp1251_ = _tmp1250_; - _tmp1252_ = main_call; - vala_ccode_function_add_expression (_tmp1251_, (ValaCCodeExpression*) _tmp1252_); - _tmp1253_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); - _tmp1254_ = _tmp1253_; - _tmp1255_ = vala_ccode_constant_new ("0"); + ValaCCodeFunctionCall* _tmp1254_; + ValaCCodeFunction* _tmp1255_; + ValaCCodeFunction* _tmp1256_; + ValaCCodeConstant* _tmp1257_; + ValaCCodeConstant* _tmp1258_; + _tmp1252_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp1253_ = _tmp1252_; + _tmp1254_ = main_call; + vala_ccode_function_add_expression (_tmp1253_, (ValaCCodeExpression*) _tmp1254_); + _tmp1255_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); _tmp1256_ = _tmp1255_; - vala_ccode_function_add_return (_tmp1254_, (ValaCCodeExpression*) _tmp1256_); - _vala_ccode_node_unref0 (_tmp1256_); - } else { - ValaCCodeFunction* _tmp1257_; - ValaCCodeFunction* _tmp1258_; - ValaCCodeFunctionCall* _tmp1259_; - _tmp1257_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp1257_ = vala_ccode_constant_new ("0"); _tmp1258_ = _tmp1257_; - _tmp1259_ = main_call; - vala_ccode_function_add_return (_tmp1258_, (ValaCCodeExpression*) _tmp1259_); + vala_ccode_function_add_return (_tmp1256_, (ValaCCodeExpression*) _tmp1258_); + _vala_ccode_node_unref0 (_tmp1258_); + } else { + ValaCCodeFunction* _tmp1259_; + ValaCCodeFunction* _tmp1260_; + ValaCCodeFunctionCall* _tmp1261_; + _tmp1259_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp1260_ = _tmp1259_; + _tmp1261_ = main_call; + vala_ccode_function_add_return (_tmp1260_, (ValaCCodeExpression*) _tmp1261_); } vala_ccode_base_module_pop_function ((ValaCCodeBaseModule*) self); - _tmp1260_ = ((ValaCCodeBaseModule*) self)->cfile; - _tmp1261_ = cmain; - vala_ccode_file_add_function (_tmp1260_, _tmp1261_); + _tmp1262_ = ((ValaCCodeBaseModule*) self)->cfile; + _tmp1263_ = cmain; + vala_ccode_file_add_function (_tmp1262_, _tmp1263_); _vala_ccode_node_unref0 (main_call); _vala_ccode_node_unref0 (cmain); } diff -Nru vala-0.48.20/codegen/valaccodemethodmodule.vala vala-0.48.22/codegen/valaccodemethodmodule.vala --- vala-0.48.20/codegen/valaccodemethodmodule.vala 2021-12-02 13:10:08.000000000 +0000 +++ vala-0.48.22/codegen/valaccodemethodmodule.vala 2022-01-09 09:11:49.000000000 +0000 @@ -667,7 +667,7 @@ var vardecl = new CCodeVariableDeclarator ("self", default_value_for_type (creturn_type, true)); vardecl.init0 = true; ccode.add_declaration (get_ccode_name (creturn_type), vardecl); - } else { + } else if (!((CreationMethod) m).chain_up) { // memset needs string.h cfile.add_include ("string.h"); var czero = new CCodeFunctionCall (new CCodeIdentifier ("memset")); diff -Nru vala-0.48.20/codegen/valacodegen.h vala-0.48.22/codegen/valacodegen.h --- vala-0.48.20/codegen/valacodegen.h 2021-12-02 13:42:49.000000000 +0000 +++ vala-0.48.22/codegen/valacodegen.h 2022-01-09 12:57:32.000000000 +0000 @@ -1630,6 +1630,8 @@ ValaCCodeExpression* destroy_notify); void vala_append_array_length (ValaExpression* expr, ValaCCodeExpression* size); +void vala_set_array_length (ValaExpression* expr, + ValaCCodeExpression* size); ValaList* vala_get_array_lengths (ValaExpression* expr); gboolean vala_get_lvalue (ValaTargetValue* value); gboolean vala_get_non_null (ValaTargetValue* value); diff -Nru vala-0.48.20/codegen/valaglibvalue.c vala-0.48.22/codegen/valaglibvalue.c --- vala-0.48.20/codegen/valaglibvalue.c 2021-12-02 13:42:49.000000000 +0000 +++ vala-0.48.22/codegen/valaglibvalue.c 2022-01-09 12:57:31.000000000 +0000 @@ -530,6 +530,47 @@ vala_glib_value_append_array_length_cvalue (_tmp9_, size); } +void +vala_set_array_length (ValaExpression* expr, + ValaCCodeExpression* size) +{ + ValaGLibValue* glib_value = NULL; + ValaTargetValue* _tmp0_; + ValaTargetValue* _tmp1_; + ValaGLibValue* _tmp2_; + ValaGLibValue* _tmp10_; + g_return_if_fail (expr != NULL); + g_return_if_fail (size != NULL); + _tmp0_ = vala_expression_get_target_value (expr); + _tmp1_ = _tmp0_; + glib_value = G_TYPE_CHECK_INSTANCE_CAST (_tmp1_, VALA_TYPE_GLIB_VALUE, ValaGLibValue); + _tmp2_ = glib_value; + if (_tmp2_ == NULL) { + ValaDataType* _tmp3_; + ValaDataType* _tmp4_; + ValaGLibValue* _tmp5_; + ValaGLibValue* _tmp6_; + ValaTargetValue* _tmp7_; + ValaTargetValue* _tmp8_; + _tmp3_ = vala_expression_get_value_type (expr); + _tmp4_ = _tmp3_; + _tmp5_ = vala_glib_value_new (_tmp4_, NULL, FALSE); + _tmp6_ = _tmp5_; + vala_expression_set_target_value (expr, (ValaTargetValue*) _tmp6_); + _vala_target_value_unref0 (_tmp6_); + _tmp7_ = vala_expression_get_target_value (expr); + _tmp8_ = _tmp7_; + glib_value = G_TYPE_CHECK_INSTANCE_CAST (_tmp8_, VALA_TYPE_GLIB_VALUE, ValaGLibValue); + } else { + ValaGLibValue* _tmp9_; + _tmp9_ = glib_value; + _vala_iterable_unref0 (_tmp9_->array_length_cvalues); + _tmp9_->array_length_cvalues = NULL; + } + _tmp10_ = glib_value; + vala_glib_value_append_array_length_cvalue (_tmp10_, size); +} + ValaList* vala_get_array_lengths (ValaExpression* expr) { diff -Nru vala-0.48.20/codegen/valaglibvalue.vala vala-0.48.22/codegen/valaglibvalue.vala --- vala-0.48.20/codegen/valaglibvalue.vala 2021-11-17 17:20:44.000000000 +0000 +++ vala-0.48.22/codegen/valaglibvalue.vala 2022-01-09 08:44:30.000000000 +0000 @@ -142,6 +142,17 @@ glib_value.append_array_length_cvalue (size); } + public static void set_array_length (Expression expr, CCodeExpression size) { + unowned GLibValue? glib_value = (GLibValue) expr.target_value; + if (glib_value == null) { + expr.target_value = new GLibValue (expr.value_type); + glib_value = (GLibValue) expr.target_value; + } else { + glib_value.array_length_cvalues = null; + } + glib_value.append_array_length_cvalue (size); + } + public static unowned List? get_array_lengths (Expression expr) { unowned GLibValue? glib_value = (GLibValue) expr.target_value; if (glib_value == null) { diff -Nru vala-0.48.20/codegen/valagtkmodule.c vala-0.48.22/codegen/valagtkmodule.c --- vala-0.48.20/codegen/valagtkmodule.c 2021-12-02 13:42:49.000000000 +0000 +++ vala-0.48.22/codegen/valagtkmodule.c 2022-01-09 12:57:31.000000000 +0000 @@ -565,128 +565,120 @@ _tmp17_ = reader; current_token = vala_markup_reader_read_token (_tmp17_, NULL, NULL); while (TRUE) { - ValaMarkupTokenType _tmp18_; - gboolean _tmp19_ = FALSE; - ValaMarkupTokenType _tmp20_; - ValaMarkupReader* _tmp57_; - _tmp18_ = current_token; - if (!(_tmp18_ != VALA_MARKUP_TOKEN_TYPE_EOF)) { + gboolean _tmp18_ = FALSE; + ValaMarkupReader* _tmp53_; + if (!(current_token != VALA_MARKUP_TOKEN_TYPE_EOF)) { break; } - _tmp20_ = current_token; - if (_tmp20_ == VALA_MARKUP_TOKEN_TYPE_START_ELEMENT) { - ValaMarkupReader* _tmp21_; - const gchar* _tmp22_; - const gchar* _tmp23_; - _tmp21_ = reader; - _tmp22_ = vala_markup_reader_get_name (_tmp21_); - _tmp23_ = _tmp22_; - _tmp19_ = g_strcmp0 (_tmp23_, "gresource") == 0; + if (current_token == VALA_MARKUP_TOKEN_TYPE_START_ELEMENT) { + ValaMarkupReader* _tmp19_; + const gchar* _tmp20_; + const gchar* _tmp21_; + _tmp19_ = reader; + _tmp20_ = vala_markup_reader_get_name (_tmp19_); + _tmp21_ = _tmp20_; + _tmp18_ = g_strcmp0 (_tmp21_, "gresource") == 0; } else { - _tmp19_ = FALSE; + _tmp18_ = FALSE; } - if (_tmp19_) { - ValaMarkupReader* _tmp24_; - gchar* _tmp25_; - _tmp24_ = reader; - _tmp25_ = vala_markup_reader_get_attribute (_tmp24_, "prefix"); + if (_tmp18_) { + ValaMarkupReader* _tmp22_; + gchar* _tmp23_; + _tmp22_ = reader; + _tmp23_ = vala_markup_reader_get_attribute (_tmp22_, "prefix"); _g_free0 (prefix); - prefix = _tmp25_; + prefix = _tmp23_; } else { - gboolean _tmp26_ = FALSE; - ValaMarkupTokenType _tmp27_; - _tmp27_ = current_token; - if (_tmp27_ == VALA_MARKUP_TOKEN_TYPE_START_ELEMENT) { - ValaMarkupReader* _tmp28_; - const gchar* _tmp29_; - const gchar* _tmp30_; - _tmp28_ = reader; - _tmp29_ = vala_markup_reader_get_name (_tmp28_); - _tmp30_ = _tmp29_; - _tmp26_ = g_strcmp0 (_tmp30_, "file") == 0; + gboolean _tmp24_ = FALSE; + if (current_token == VALA_MARKUP_TOKEN_TYPE_START_ELEMENT) { + ValaMarkupReader* _tmp25_; + const gchar* _tmp26_; + const gchar* _tmp27_; + _tmp25_ = reader; + _tmp26_ = vala_markup_reader_get_name (_tmp25_); + _tmp27_ = _tmp26_; + _tmp24_ = g_strcmp0 (_tmp27_, "file") == 0; } else { - _tmp26_ = FALSE; + _tmp24_ = FALSE; } - if (_tmp26_) { - ValaMarkupReader* _tmp31_; - gchar* _tmp32_; - _tmp31_ = reader; - _tmp32_ = vala_markup_reader_get_attribute (_tmp31_, "alias"); + if (_tmp24_) { + ValaMarkupReader* _tmp28_; + gchar* _tmp29_; + _tmp28_ = reader; + _tmp29_ = vala_markup_reader_get_attribute (_tmp28_, "alias"); _g_free0 (alias); - alias = _tmp32_; + alias = _tmp29_; state = 1; } else { - gboolean _tmp33_ = FALSE; + gboolean _tmp30_ = FALSE; if (state == 1) { - ValaMarkupTokenType _tmp34_; - _tmp34_ = current_token; - _tmp33_ = _tmp34_ == VALA_MARKUP_TOKEN_TYPE_TEXT; + _tmp30_ = current_token == VALA_MARKUP_TOKEN_TYPE_TEXT; } else { - _tmp33_ = FALSE; + _tmp30_ = FALSE; } - if (_tmp33_) { + if (_tmp30_) { gchar* name = NULL; - ValaMarkupReader* _tmp35_; - const gchar* _tmp36_; - const gchar* _tmp37_; - gchar* _tmp38_; + ValaMarkupReader* _tmp31_; + const gchar* _tmp32_; + const gchar* _tmp33_; + gchar* _tmp34_; gchar* filename = NULL; - ValaCodeContext* _tmp39_; - ValaCodeContext* _tmp40_; - const gchar* _tmp41_; - const gchar* _tmp42_; - gchar* _tmp43_; - const gchar* _tmp44_; - ValaHashMap* _tmp51_; + ValaCodeContext* _tmp35_; + ValaCodeContext* _tmp36_; + const gchar* _tmp37_; + const gchar* _tmp38_; + gchar* _tmp39_; + const gchar* _tmp40_; + ValaHashMap* _tmp47_; + const gchar* _tmp48_; + const gchar* _tmp49_; + gchar* _tmp50_; + gchar* _tmp51_; const gchar* _tmp52_; - const gchar* _tmp53_; - gchar* _tmp54_; - gchar* _tmp55_; - const gchar* _tmp56_; - _tmp35_ = reader; - _tmp36_ = vala_markup_reader_get_content (_tmp35_); - _tmp37_ = _tmp36_; - _tmp38_ = g_strdup (_tmp37_); - name = _tmp38_; - _tmp39_ = vala_ccode_base_module_get_context ((ValaCCodeBaseModule*) self); - _tmp40_ = _tmp39_; - _tmp41_ = gresource; - _tmp42_ = name; - _tmp43_ = vala_code_context_get_gresource_path (_tmp40_, _tmp41_, _tmp42_); - filename = _tmp43_; - _tmp44_ = alias; - if (_tmp44_ != NULL) { - ValaHashMap* _tmp45_; + _tmp31_ = reader; + _tmp32_ = vala_markup_reader_get_content (_tmp31_); + _tmp33_ = _tmp32_; + _tmp34_ = g_strdup (_tmp33_); + name = _tmp34_; + _tmp35_ = vala_ccode_base_module_get_context ((ValaCCodeBaseModule*) self); + _tmp36_ = _tmp35_; + _tmp37_ = gresource; + _tmp38_ = name; + _tmp39_ = vala_code_context_get_gresource_path (_tmp36_, _tmp37_, _tmp38_); + filename = _tmp39_; + _tmp40_ = alias; + if (_tmp40_ != NULL) { + ValaHashMap* _tmp41_; + const gchar* _tmp42_; + const gchar* _tmp43_; + gchar* _tmp44_; + gchar* _tmp45_; const gchar* _tmp46_; - const gchar* _tmp47_; - gchar* _tmp48_; - gchar* _tmp49_; - const gchar* _tmp50_; - _tmp45_ = self->priv->gresource_to_file_map; - _tmp46_ = prefix; - _tmp47_ = alias; - _tmp48_ = g_build_filename (_tmp46_, _tmp47_, NULL); - _tmp49_ = _tmp48_; - _tmp50_ = filename; - vala_map_set ((ValaMap*) _tmp45_, _tmp49_, _tmp50_); - _g_free0 (_tmp49_); + _tmp41_ = self->priv->gresource_to_file_map; + _tmp42_ = prefix; + _tmp43_ = alias; + _tmp44_ = g_build_filename (_tmp42_, _tmp43_, NULL); + _tmp45_ = _tmp44_; + _tmp46_ = filename; + vala_map_set ((ValaMap*) _tmp41_, _tmp45_, _tmp46_); + _g_free0 (_tmp45_); } - _tmp51_ = self->priv->gresource_to_file_map; - _tmp52_ = prefix; - _tmp53_ = name; - _tmp54_ = g_build_filename (_tmp52_, _tmp53_, NULL); - _tmp55_ = _tmp54_; - _tmp56_ = filename; - vala_map_set ((ValaMap*) _tmp51_, _tmp55_, _tmp56_); - _g_free0 (_tmp55_); + _tmp47_ = self->priv->gresource_to_file_map; + _tmp48_ = prefix; + _tmp49_ = name; + _tmp50_ = g_build_filename (_tmp48_, _tmp49_, NULL); + _tmp51_ = _tmp50_; + _tmp52_ = filename; + vala_map_set ((ValaMap*) _tmp47_, _tmp51_, _tmp52_); + _g_free0 (_tmp51_); state = 0; _g_free0 (filename); _g_free0 (name); } } } - _tmp57_ = reader; - current_token = vala_markup_reader_read_token (_tmp57_, NULL, NULL); + _tmp53_ = reader; + current_token = vala_markup_reader_read_token (_tmp53_, NULL, NULL); } _g_free0 (alias); _g_free0 (prefix); @@ -891,277 +883,271 @@ _tmp19_ = reader; current_token = vala_markup_reader_read_token (_tmp19_, NULL, NULL); while (TRUE) { - ValaMarkupTokenType _tmp20_; const gchar* current_name = NULL; - ValaMarkupReader* _tmp21_; + ValaMarkupReader* _tmp20_; + const gchar* _tmp21_; const gchar* _tmp22_; - const gchar* _tmp23_; - gboolean _tmp24_ = FALSE; - ValaMarkupTokenType _tmp25_; - ValaMarkupReader* _tmp104_; - _tmp20_ = current_token; - if (!(_tmp20_ != VALA_MARKUP_TOKEN_TYPE_EOF)) { + gboolean _tmp23_ = FALSE; + ValaMarkupReader* _tmp101_; + if (!(current_token != VALA_MARKUP_TOKEN_TYPE_EOF)) { break; } - _tmp21_ = reader; - _tmp22_ = vala_markup_reader_get_name (_tmp21_); - _tmp23_ = _tmp22_; - current_name = _tmp23_; - _tmp25_ = current_token; - if (_tmp25_ == VALA_MARKUP_TOKEN_TYPE_START_ELEMENT) { - gboolean _tmp26_ = FALSE; - const gchar* _tmp27_; - _tmp27_ = current_name; - if (g_strcmp0 (_tmp27_, "object") == 0) { - _tmp26_ = TRUE; + _tmp20_ = reader; + _tmp21_ = vala_markup_reader_get_name (_tmp20_); + _tmp22_ = _tmp21_; + current_name = _tmp22_; + if (current_token == VALA_MARKUP_TOKEN_TYPE_START_ELEMENT) { + gboolean _tmp24_ = FALSE; + const gchar* _tmp25_; + _tmp25_ = current_name; + if (g_strcmp0 (_tmp25_, "object") == 0) { + _tmp24_ = TRUE; } else { - const gchar* _tmp28_; - _tmp28_ = current_name; - _tmp26_ = g_strcmp0 (_tmp28_, "template") == 0; + const gchar* _tmp26_; + _tmp26_ = current_name; + _tmp24_ = g_strcmp0 (_tmp26_, "template") == 0; } - _tmp24_ = _tmp26_; + _tmp23_ = _tmp24_; } else { - _tmp24_ = FALSE; + _tmp23_ = FALSE; } - if (_tmp24_) { - const gchar* _tmp29_; - ValaClass* _tmp37_; - ValaClass* _tmp51_; + if (_tmp23_) { + const gchar* _tmp27_; + ValaClass* _tmp35_; + ValaClass* _tmp49_; _vala_code_node_unref0 (current_class); current_class = NULL; - _tmp29_ = current_name; - if (g_strcmp0 (_tmp29_, "object") == 0) { + _tmp27_ = current_name; + if (g_strcmp0 (_tmp27_, "object") == 0) { gchar* type_id = NULL; - ValaMarkupReader* _tmp30_; - gchar* _tmp31_; - const gchar* _tmp32_; - _tmp30_ = reader; - _tmp31_ = vala_markup_reader_get_attribute (_tmp30_, "type-func"); - type_id = _tmp31_; - _tmp32_ = type_id; - if (_tmp32_ != NULL) { - ValaHashMap* _tmp33_; - const gchar* _tmp34_; - gpointer _tmp35_; - _tmp33_ = self->priv->type_id_to_vala_map; - _tmp34_ = type_id; - _tmp35_ = vala_map_get ((ValaMap*) _tmp33_, _tmp34_); + ValaMarkupReader* _tmp28_; + gchar* _tmp29_; + const gchar* _tmp30_; + _tmp28_ = reader; + _tmp29_ = vala_markup_reader_get_attribute (_tmp28_, "type-func"); + type_id = _tmp29_; + _tmp30_ = type_id; + if (_tmp30_ != NULL) { + ValaHashMap* _tmp31_; + const gchar* _tmp32_; + gpointer _tmp33_; + _tmp31_ = self->priv->type_id_to_vala_map; + _tmp32_ = type_id; + _tmp33_ = vala_map_get ((ValaMap*) _tmp31_, _tmp32_); _vala_code_node_unref0 (current_class); - current_class = (ValaClass*) _tmp35_; + current_class = (ValaClass*) _tmp33_; } _g_free0 (type_id); } else { - const gchar* _tmp36_; - _tmp36_ = current_name; - if (g_strcmp0 (_tmp36_, "template") == 0) { + const gchar* _tmp34_; + _tmp34_ = current_name; + if (g_strcmp0 (_tmp34_, "template") == 0) { template_tag_found = TRUE; } } - _tmp37_ = current_class; - if (_tmp37_ == NULL) { + _tmp35_ = current_class; + if (_tmp35_ == NULL) { gchar* class_name = NULL; - ValaMarkupReader* _tmp38_; - gchar* _tmp39_; - const gchar* _tmp40_; - ValaHashMap* _tmp48_; - const gchar* _tmp49_; - gpointer _tmp50_; - _tmp38_ = reader; - _tmp39_ = vala_markup_reader_get_attribute (_tmp38_, "class"); - class_name = _tmp39_; - _tmp40_ = class_name; - if (_tmp40_ == NULL) { - ValaSourceReference* _tmp41_; - ValaSourceReference* _tmp42_; - const gchar* _tmp43_; - const gchar* _tmp44_; - gchar* _tmp45_; - gchar* _tmp46_; - ValaMarkupReader* _tmp47_; - _tmp41_ = vala_code_node_get_source_reference (node); - _tmp42_ = _tmp41_; - _tmp43_ = current_name; - _tmp44_ = ui_file; - _tmp45_ = g_strdup_printf ("Invalid %s in ui file `%s'", _tmp43_, _tmp44_); - _tmp46_ = _tmp45_; - vala_report_error (_tmp42_, _tmp46_); - _g_free0 (_tmp46_); - _tmp47_ = reader; - current_token = vala_markup_reader_read_token (_tmp47_, NULL, NULL); + ValaMarkupReader* _tmp36_; + gchar* _tmp37_; + const gchar* _tmp38_; + ValaHashMap* _tmp46_; + const gchar* _tmp47_; + gpointer _tmp48_; + _tmp36_ = reader; + _tmp37_ = vala_markup_reader_get_attribute (_tmp36_, "class"); + class_name = _tmp37_; + _tmp38_ = class_name; + if (_tmp38_ == NULL) { + ValaSourceReference* _tmp39_; + ValaSourceReference* _tmp40_; + const gchar* _tmp41_; + const gchar* _tmp42_; + gchar* _tmp43_; + gchar* _tmp44_; + ValaMarkupReader* _tmp45_; + _tmp39_ = vala_code_node_get_source_reference (node); + _tmp40_ = _tmp39_; + _tmp41_ = current_name; + _tmp42_ = ui_file; + _tmp43_ = g_strdup_printf ("Invalid %s in ui file `%s'", _tmp41_, _tmp42_); + _tmp44_ = _tmp43_; + vala_report_error (_tmp40_, _tmp44_); + _g_free0 (_tmp44_); + _tmp45_ = reader; + current_token = vala_markup_reader_read_token (_tmp45_, NULL, NULL); _g_free0 (class_name); continue; } - _tmp48_ = self->priv->cclass_to_vala_map; - _tmp49_ = class_name; - _tmp50_ = vala_map_get ((ValaMap*) _tmp48_, _tmp49_); + _tmp46_ = self->priv->cclass_to_vala_map; + _tmp47_ = class_name; + _tmp48_ = vala_map_get ((ValaMap*) _tmp46_, _tmp47_); _vala_code_node_unref0 (current_class); - current_class = (ValaClass*) _tmp50_; + current_class = (ValaClass*) _tmp48_; _g_free0 (class_name); } - _tmp51_ = current_class; - if (_tmp51_ != NULL) { + _tmp49_ = current_class; + if (_tmp49_ != NULL) { gchar* child_name = NULL; - ValaMarkupReader* _tmp52_; - gchar* _tmp53_; - const gchar* _tmp54_; - _tmp52_ = reader; - _tmp53_ = vala_markup_reader_get_attribute (_tmp52_, "id"); - child_name = _tmp53_; - _tmp54_ = child_name; - if (_tmp54_ != NULL) { - ValaHashMap* _tmp55_; - const gchar* _tmp56_; - ValaClass* _tmp57_; - _tmp55_ = self->priv->current_child_to_class_map; - _tmp56_ = child_name; - _tmp57_ = current_class; - vala_map_set ((ValaMap*) _tmp55_, _tmp56_, _tmp57_); + ValaMarkupReader* _tmp50_; + gchar* _tmp51_; + const gchar* _tmp52_; + _tmp50_ = reader; + _tmp51_ = vala_markup_reader_get_attribute (_tmp50_, "id"); + child_name = _tmp51_; + _tmp52_ = child_name; + if (_tmp52_ != NULL) { + ValaHashMap* _tmp53_; + const gchar* _tmp54_; + ValaClass* _tmp55_; + _tmp53_ = self->priv->current_child_to_class_map; + _tmp54_ = child_name; + _tmp55_ = current_class; + vala_map_set ((ValaMap*) _tmp53_, _tmp54_, _tmp55_); } _g_free0 (child_name); } } else { - gboolean _tmp58_ = FALSE; - gboolean _tmp59_ = FALSE; - ValaClass* _tmp60_; - _tmp60_ = current_class; - if (_tmp60_ != NULL) { - ValaMarkupTokenType _tmp61_; - _tmp61_ = current_token; - _tmp59_ = _tmp61_ == VALA_MARKUP_TOKEN_TYPE_START_ELEMENT; + gboolean _tmp56_ = FALSE; + gboolean _tmp57_ = FALSE; + ValaClass* _tmp58_; + _tmp58_ = current_class; + if (_tmp58_ != NULL) { + _tmp57_ = current_token == VALA_MARKUP_TOKEN_TYPE_START_ELEMENT; } else { - _tmp59_ = FALSE; + _tmp57_ = FALSE; } - if (_tmp59_) { - const gchar* _tmp62_; - _tmp62_ = current_name; - _tmp58_ = g_strcmp0 (_tmp62_, "signal") == 0; + if (_tmp57_) { + const gchar* _tmp59_; + _tmp59_ = current_name; + _tmp56_ = g_strcmp0 (_tmp59_, "signal") == 0; } else { - _tmp58_ = FALSE; + _tmp56_ = FALSE; } - if (_tmp58_) { + if (_tmp56_) { gchar* signal_name = NULL; - ValaMarkupReader* _tmp63_; - gchar* _tmp64_; + ValaMarkupReader* _tmp60_; + gchar* _tmp61_; gchar* handler_name = NULL; - ValaMarkupReader* _tmp65_; - gchar* _tmp66_; - ValaClass* _tmp67_; - _tmp63_ = reader; - _tmp64_ = vala_markup_reader_get_attribute (_tmp63_, "name"); - signal_name = _tmp64_; - _tmp65_ = reader; - _tmp66_ = vala_markup_reader_get_attribute (_tmp65_, "handler"); - handler_name = _tmp66_; - _tmp67_ = current_class; - if (_tmp67_ != NULL) { - gboolean _tmp68_ = FALSE; - const gchar* _tmp69_; + ValaMarkupReader* _tmp62_; + gchar* _tmp63_; + ValaClass* _tmp64_; + _tmp60_ = reader; + _tmp61_ = vala_markup_reader_get_attribute (_tmp60_, "name"); + signal_name = _tmp61_; + _tmp62_ = reader; + _tmp63_ = vala_markup_reader_get_attribute (_tmp62_, "handler"); + handler_name = _tmp63_; + _tmp64_ = current_class; + if (_tmp64_ != NULL) { + gboolean _tmp65_ = FALSE; + const gchar* _tmp66_; gint sep_idx = 0; - const gchar* _tmp90_; + const gchar* _tmp87_; ValaSignal* sig = NULL; - ValaClass* _tmp93_; - const gchar* _tmp94_; - gchar* _tmp95_; - gchar* _tmp96_; - ValaSymbol* _tmp97_; - ValaSignal* _tmp98_; - ValaSignal* _tmp99_; - ValaSignal* _tmp100_; - _tmp69_ = signal_name; - if (_tmp69_ == NULL) { - _tmp68_ = TRUE; + ValaClass* _tmp90_; + const gchar* _tmp91_; + gchar* _tmp92_; + gchar* _tmp93_; + ValaSymbol* _tmp94_; + ValaSignal* _tmp95_; + ValaSignal* _tmp96_; + ValaSignal* _tmp97_; + _tmp66_ = signal_name; + if (_tmp66_ == NULL) { + _tmp65_ = TRUE; } else { - const gchar* _tmp70_; - _tmp70_ = handler_name; - _tmp68_ = _tmp70_ == NULL; + const gchar* _tmp67_; + _tmp67_ = handler_name; + _tmp65_ = _tmp67_ == NULL; } - if (_tmp68_) { - const gchar* _tmp71_; - ValaMarkupReader* _tmp89_; - _tmp71_ = signal_name; - if (_tmp71_ != NULL) { - ValaSourceReference* _tmp72_; - ValaSourceReference* _tmp73_; - const gchar* _tmp74_; - const gchar* _tmp75_; - gchar* _tmp76_; - gchar* _tmp77_; - _tmp72_ = vala_code_node_get_source_reference (node); - _tmp73_ = _tmp72_; - _tmp74_ = signal_name; - _tmp75_ = ui_file; - _tmp76_ = g_strdup_printf ("Invalid signal `%s' without handler in ui file `%s'", _tmp74_, _tmp75_); - _tmp77_ = _tmp76_; - vala_report_error (_tmp73_, _tmp77_); - _g_free0 (_tmp77_); + if (_tmp65_) { + const gchar* _tmp68_; + ValaMarkupReader* _tmp86_; + _tmp68_ = signal_name; + if (_tmp68_ != NULL) { + ValaSourceReference* _tmp69_; + ValaSourceReference* _tmp70_; + const gchar* _tmp71_; + const gchar* _tmp72_; + gchar* _tmp73_; + gchar* _tmp74_; + _tmp69_ = vala_code_node_get_source_reference (node); + _tmp70_ = _tmp69_; + _tmp71_ = signal_name; + _tmp72_ = ui_file; + _tmp73_ = g_strdup_printf ("Invalid signal `%s' without handler in ui file `%s'", _tmp71_, _tmp72_); + _tmp74_ = _tmp73_; + vala_report_error (_tmp70_, _tmp74_); + _g_free0 (_tmp74_); } else { - const gchar* _tmp78_; - _tmp78_ = handler_name; - if (_tmp78_ != NULL) { - ValaSourceReference* _tmp79_; - ValaSourceReference* _tmp80_; - const gchar* _tmp81_; - gchar* _tmp82_; - gchar* _tmp83_; - _tmp79_ = vala_code_node_get_source_reference (node); + const gchar* _tmp75_; + _tmp75_ = handler_name; + if (_tmp75_ != NULL) { + ValaSourceReference* _tmp76_; + ValaSourceReference* _tmp77_; + const gchar* _tmp78_; + gchar* _tmp79_; + gchar* _tmp80_; + _tmp76_ = vala_code_node_get_source_reference (node); + _tmp77_ = _tmp76_; + _tmp78_ = ui_file; + _tmp79_ = g_strdup_printf ("Invalid signal without name in ui file `%s'", _tmp78_); _tmp80_ = _tmp79_; - _tmp81_ = ui_file; - _tmp82_ = g_strdup_printf ("Invalid signal without name in ui file `%s'", _tmp81_); - _tmp83_ = _tmp82_; - vala_report_error (_tmp80_, _tmp83_); - _g_free0 (_tmp83_); + vala_report_error (_tmp77_, _tmp80_); + _g_free0 (_tmp80_); } else { - ValaSourceReference* _tmp84_; - ValaSourceReference* _tmp85_; - const gchar* _tmp86_; - gchar* _tmp87_; - gchar* _tmp88_; - _tmp84_ = vala_code_node_get_source_reference (node); + ValaSourceReference* _tmp81_; + ValaSourceReference* _tmp82_; + const gchar* _tmp83_; + gchar* _tmp84_; + gchar* _tmp85_; + _tmp81_ = vala_code_node_get_source_reference (node); + _tmp82_ = _tmp81_; + _tmp83_ = ui_file; + _tmp84_ = g_strdup_printf ("Invalid signal without name and handler in ui file `%s'", _tmp83_); _tmp85_ = _tmp84_; - _tmp86_ = ui_file; - _tmp87_ = g_strdup_printf ("Invalid signal without name and handler in ui file `%s'", _tmp86_); - _tmp88_ = _tmp87_; - vala_report_error (_tmp85_, _tmp88_); - _g_free0 (_tmp88_); + vala_report_error (_tmp82_, _tmp85_); + _g_free0 (_tmp85_); } } - _tmp89_ = reader; - current_token = vala_markup_reader_read_token (_tmp89_, NULL, NULL); + _tmp86_ = reader; + current_token = vala_markup_reader_read_token (_tmp86_, NULL, NULL); _g_free0 (handler_name); _g_free0 (signal_name); continue; } - _tmp90_ = signal_name; - sep_idx = string_index_of (_tmp90_, "::", 0); + _tmp87_ = signal_name; + sep_idx = string_index_of (_tmp87_, "::", 0); if (sep_idx >= 0) { - const gchar* _tmp91_; - gchar* _tmp92_; - _tmp91_ = signal_name; - _tmp92_ = string_substring (_tmp91_, (glong) 0, (glong) sep_idx); + const gchar* _tmp88_; + gchar* _tmp89_; + _tmp88_ = signal_name; + _tmp89_ = string_substring (_tmp88_, (glong) 0, (glong) sep_idx); _g_free0 (signal_name); - signal_name = _tmp92_; + signal_name = _tmp89_; } - _tmp93_ = current_class; - _tmp94_ = signal_name; - _tmp95_ = string_replace (_tmp94_, "-", "_"); - _tmp96_ = _tmp95_; - _tmp97_ = vala_semantic_analyzer_symbol_lookup_inherited ((ValaSymbol*) _tmp93_, _tmp96_); - _tmp98_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp97_, VALA_TYPE_SIGNAL) ? ((ValaSignal*) _tmp97_) : NULL; - if (_tmp98_ == NULL) { - _vala_code_node_unref0 (_tmp97_); + _tmp90_ = current_class; + _tmp91_ = signal_name; + _tmp92_ = string_replace (_tmp91_, "-", "_"); + _tmp93_ = _tmp92_; + _tmp94_ = vala_semantic_analyzer_symbol_lookup_inherited ((ValaSymbol*) _tmp90_, _tmp93_); + _tmp95_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp94_, VALA_TYPE_SIGNAL) ? ((ValaSignal*) _tmp94_) : NULL; + if (_tmp95_ == NULL) { + _vala_code_node_unref0 (_tmp94_); } - _tmp99_ = _tmp98_; - _g_free0 (_tmp96_); - sig = _tmp99_; - _tmp100_ = sig; - if (_tmp100_ != NULL) { - ValaHashMap* _tmp101_; - const gchar* _tmp102_; - ValaSignal* _tmp103_; - _tmp101_ = self->priv->current_handler_to_signal_map; - _tmp102_ = handler_name; - _tmp103_ = sig; - vala_map_set ((ValaMap*) _tmp101_, _tmp102_, _tmp103_); + _tmp96_ = _tmp95_; + _g_free0 (_tmp93_); + sig = _tmp96_; + _tmp97_ = sig; + if (_tmp97_ != NULL) { + ValaHashMap* _tmp98_; + const gchar* _tmp99_; + ValaSignal* _tmp100_; + _tmp98_ = self->priv->current_handler_to_signal_map; + _tmp99_ = handler_name; + _tmp100_ = sig; + vala_map_set ((ValaMap*) _tmp98_, _tmp99_, _tmp100_); } _vala_code_node_unref0 (sig); } @@ -1169,20 +1155,20 @@ _g_free0 (signal_name); } } - _tmp104_ = reader; - current_token = vala_markup_reader_read_token (_tmp104_, NULL, NULL); + _tmp101_ = reader; + current_token = vala_markup_reader_read_token (_tmp101_, NULL, NULL); } if (!template_tag_found) { - ValaSourceReference* _tmp105_; - ValaSourceReference* _tmp106_; - gchar* _tmp107_; - gchar* _tmp108_; - _tmp105_ = vala_code_node_get_source_reference (node); - _tmp106_ = _tmp105_; - _tmp107_ = g_strdup_printf ("ui resource `%s' does not describe a valid composite template", ui_resource); - _tmp108_ = _tmp107_; - vala_report_error (_tmp106_, _tmp108_); - _g_free0 (_tmp108_); + ValaSourceReference* _tmp102_; + ValaSourceReference* _tmp103_; + gchar* _tmp104_; + gchar* _tmp105_; + _tmp102_ = vala_code_node_get_source_reference (node); + _tmp103_ = _tmp102_; + _tmp104_ = g_strdup_printf ("ui resource `%s' does not describe a valid composite template", ui_resource); + _tmp105_ = _tmp104_; + vala_report_error (_tmp103_, _tmp105_); + _g_free0 (_tmp105_); } _vala_code_node_unref0 (current_class); _vala_markup_reader_unref0 (reader); diff -Nru vala-0.48.20/codegen/valagtypemodule.c vala-0.48.22/codegen/valagtypemodule.c --- vala-0.48.20/codegen/valagtypemodule.c 2021-12-02 13:42:49.000000000 +0000 +++ vala-0.48.22/codegen/valagtypemodule.c 2022-01-09 12:57:32.000000000 +0000 @@ -2553,15 +2553,13 @@ gchar* _tmp15_; gchar* _tmp16_; gchar* _tmp17_; - ValaCCodeModifiers _tmp18_; _tmp12_ = vala_variable_get_variable_type ((ValaVariable*) f); _tmp13_ = _tmp12_; _tmp14_ = vala_get_ccode_name ((ValaCodeNode*) _tmp13_); _tmp15_ = _tmp14_; _tmp16_ = vala_get_ccode_name ((ValaCodeNode*) f); _tmp17_ = _tmp16_; - _tmp18_ = modifiers; - vala_ccode_struct_add_field (type_struct, _tmp15_, _tmp17_, _tmp18_, NULL); + vala_ccode_struct_add_field (type_struct, _tmp15_, _tmp17_, modifiers, NULL); _g_free0 (_tmp17_); _g_free0 (_tmp15_); } diff -Nru vala-0.48.20/codegen/valagvariantmodule.c vala-0.48.22/codegen/valagvariantmodule.c --- vala-0.48.20/codegen/valagvariantmodule.c 2021-12-02 13:42:49.000000000 +0000 +++ vala-0.48.22/codegen/valagvariantmodule.c 2022-01-09 12:57:32.000000000 +0000 @@ -38,6 +38,7 @@ #define _vala_ccode_node_unref0(var) ((var == NULL) ? NULL : (var = (vala_ccode_node_unref (var), NULL))) #define _vala_code_node_unref0(var) ((var == NULL) ? NULL : (var = (vala_code_node_unref (var), NULL))) #define _vala_target_value_unref0(var) ((var == NULL) ? NULL : (var = (vala_target_value_unref (var), NULL))) +#define _vala_ccode_base_module_emit_context_unref0(var) ((var == NULL) ? NULL : (var = (vala_ccode_base_module_emit_context_unref (var), NULL))) #define _vala_iterable_unref0(var) ((var == NULL) ? NULL : (var = (vala_iterable_unref (var), NULL))) struct _ValaGVariantModulePrivate { @@ -381,30 +382,32 @@ ValaDataType* _tmp61_; ValaDataType* _tmp66_; ValaDataType* _tmp103_; - ValaCCodeFunction* _tmp112_; + ValaCCodeBaseModuleEmitContext* _tmp112_; + ValaCCodeBaseModuleEmitContext* _tmp113_; + ValaCCodeFunction* _tmp114_; ValaCCodeExpression* type_expr = NULL; ValaGVariantModuleBasicTypeInfo basic_type = {0}; - ValaGVariantModuleBasicTypeInfo _tmp113_ = {0}; + ValaGVariantModuleBasicTypeInfo _tmp115_ = {0}; gboolean is_basic_type = FALSE; - gboolean _tmp114_; - gboolean _tmp115_; + gboolean _tmp116_; + gboolean _tmp117_; ValaCCodeExpression* func_result = NULL; - ValaDataType* _tmp180_; - ValaCCodeIdentifier* _tmp181_; - ValaCCodeIdentifier* _tmp182_; + ValaDataType* _tmp182_; ValaCCodeIdentifier* _tmp183_; ValaCCodeIdentifier* _tmp184_; - ValaCCodeExpression* _tmp185_; - ValaCCodeExpression* _tmp186_; - gboolean _tmp187_; - gboolean _tmp188_; - ValaCCodeFile* _tmp252_; - ValaCCodeFunction* _tmp253_; + ValaCCodeIdentifier* _tmp185_; + ValaCCodeIdentifier* _tmp186_; + ValaCCodeExpression* _tmp187_; + ValaCCodeExpression* _tmp188_; + gboolean _tmp189_; + gboolean _tmp190_; ValaCCodeFile* _tmp254_; ValaCCodeFunction* _tmp255_; - ValaTargetValue* _tmp256_; - ValaTargetValue* _tmp257_; + ValaCCodeFile* _tmp256_; + ValaCCodeFunction* _tmp257_; ValaTargetValue* _tmp258_; + ValaTargetValue* _tmp259_; + ValaTargetValue* _tmp260_; self = (ValaGVariantModule*) base; g_return_if_fail (expr != NULL); _tmp0_ = vala_cast_expression_get_inner (expr); @@ -675,384 +678,389 @@ _tmp111_ = ccall; vala_ccode_function_add_expression (_tmp110_, (ValaCCodeExpression*) _tmp111_); } - _tmp112_ = cfunc; - vala_ccode_base_module_push_function ((ValaCCodeBaseModule*) self, _tmp112_); + _tmp112_ = vala_ccode_base_module_emit_context_new (NULL); + _tmp113_ = _tmp112_; + vala_ccode_base_module_push_context ((ValaCCodeBaseModule*) self, _tmp113_); + _vala_ccode_base_module_emit_context_unref0 (_tmp113_); + _tmp114_ = cfunc; + vala_ccode_base_module_push_function ((ValaCCodeBaseModule*) self, _tmp114_); type_expr = NULL; - basic_type = _tmp113_; + basic_type = _tmp115_; is_basic_type = FALSE; - _tmp114_ = vala_cast_expression_get_is_silent_cast (expr); - _tmp115_ = _tmp114_; - if (_tmp115_) { + _tmp116_ = vala_cast_expression_get_is_silent_cast (expr); + _tmp117_ = _tmp116_; + if (_tmp117_) { gchar* signature = NULL; - ValaDataType* _tmp116_; - gchar* _tmp117_; - const gchar* _tmp118_; - ValaGVariantModuleBasicTypeInfo _tmp119_ = {0}; - gboolean _tmp120_; + ValaDataType* _tmp118_; + gchar* _tmp119_; + const gchar* _tmp120_; + ValaGVariantModuleBasicTypeInfo _tmp121_ = {0}; + gboolean _tmp122_; ValaCCodeFunctionCall* ccheck = NULL; - ValaCCodeIdentifier* _tmp121_; - ValaCCodeIdentifier* _tmp122_; - ValaCCodeFunctionCall* _tmp123_; - ValaCCodeFunctionCall* _tmp124_; + ValaCCodeIdentifier* _tmp123_; + ValaCCodeIdentifier* _tmp124_; ValaCCodeFunctionCall* _tmp125_; - ValaCCodeIdentifier* _tmp126_; - ValaCCodeIdentifier* _tmp127_; - ValaCCodeFunctionCall* _tmp171_; - ValaCCodeExpression* _tmp172_; - ValaCCodeFunction* _tmp173_; - ValaCCodeFunction* _tmp174_; - ValaCCodeIdentifier* _tmp175_; - ValaCCodeIdentifier* _tmp176_; - ValaCCodeFunctionCall* _tmp177_; - ValaCCodeBinaryExpression* _tmp178_; - ValaCCodeBinaryExpression* _tmp179_; - _tmp116_ = target_type; - _tmp117_ = vala_data_type_get_type_signature (_tmp116_, NULL); - signature = _tmp117_; - _tmp118_ = signature; - _tmp120_ = vala_gvariant_module_get_basic_type_info (self, _tmp118_, &_tmp119_); - basic_type = _tmp119_; - is_basic_type = _tmp120_; - _tmp121_ = vala_ccode_identifier_new ("g_variant_is_of_type"); - _tmp122_ = _tmp121_; - _tmp123_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp122_); + ValaCCodeFunctionCall* _tmp126_; + ValaCCodeFunctionCall* _tmp127_; + ValaCCodeIdentifier* _tmp128_; + ValaCCodeIdentifier* _tmp129_; + ValaCCodeFunctionCall* _tmp173_; + ValaCCodeExpression* _tmp174_; + ValaCCodeFunction* _tmp175_; + ValaCCodeFunction* _tmp176_; + ValaCCodeIdentifier* _tmp177_; + ValaCCodeIdentifier* _tmp178_; + ValaCCodeFunctionCall* _tmp179_; + ValaCCodeBinaryExpression* _tmp180_; + ValaCCodeBinaryExpression* _tmp181_; + _tmp118_ = target_type; + _tmp119_ = vala_data_type_get_type_signature (_tmp118_, NULL); + signature = _tmp119_; + _tmp120_ = signature; + _tmp122_ = vala_gvariant_module_get_basic_type_info (self, _tmp120_, &_tmp121_); + basic_type = _tmp121_; + is_basic_type = _tmp122_; + _tmp123_ = vala_ccode_identifier_new ("g_variant_is_of_type"); _tmp124_ = _tmp123_; - _vala_ccode_node_unref0 (_tmp122_); - ccheck = _tmp124_; - _tmp125_ = ccheck; - _tmp126_ = vala_ccode_identifier_new ("value"); - _tmp127_ = _tmp126_; - vala_ccode_function_call_add_argument (_tmp125_, (ValaCCodeExpression*) _tmp127_); - _vala_ccode_node_unref0 (_tmp127_); + _tmp125_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp124_); + _tmp126_ = _tmp125_; + _vala_ccode_node_unref0 (_tmp124_); + ccheck = _tmp126_; + _tmp127_ = ccheck; + _tmp128_ = vala_ccode_identifier_new ("value"); + _tmp129_ = _tmp128_; + vala_ccode_function_call_add_argument (_tmp127_, (ValaCCodeExpression*) _tmp129_); + _vala_ccode_node_unref0 (_tmp129_); if (is_basic_type) { - ValaGVariantModuleBasicTypeInfo _tmp128_; - const gchar* _tmp129_; - gchar* _tmp130_; - gchar* _tmp131_; + ValaGVariantModuleBasicTypeInfo _tmp130_; + const gchar* _tmp131_; gchar* _tmp132_; gchar* _tmp133_; - ValaCCodeIdentifier* _tmp134_; - _tmp128_ = basic_type; - _tmp129_ = _tmp128_.type_name; - _tmp130_ = g_ascii_strup (_tmp129_, (gssize) -1); - _tmp131_ = _tmp130_; - _tmp132_ = g_strconcat ("G_VARIANT_TYPE_", _tmp131_, NULL); + gchar* _tmp134_; + gchar* _tmp135_; + ValaCCodeIdentifier* _tmp136_; + _tmp130_ = basic_type; + _tmp131_ = _tmp130_.type_name; + _tmp132_ = g_ascii_strup (_tmp131_, (gssize) -1); _tmp133_ = _tmp132_; - _tmp134_ = vala_ccode_identifier_new (_tmp133_); + _tmp134_ = g_strconcat ("G_VARIANT_TYPE_", _tmp133_, NULL); + _tmp135_ = _tmp134_; + _tmp136_ = vala_ccode_identifier_new (_tmp135_); _vala_ccode_node_unref0 (type_expr); - type_expr = (ValaCCodeExpression*) _tmp134_; + type_expr = (ValaCCodeExpression*) _tmp136_; + _g_free0 (_tmp135_); _g_free0 (_tmp133_); - _g_free0 (_tmp131_); } else { ValaObjectType* gvariant_type_type = NULL; - ValaSymbol* _tmp135_; - ValaScope* _tmp136_; - ValaScope* _tmp137_; - ValaSymbol* _tmp138_; - ValaSymbol* _tmp139_; - ValaScope* _tmp140_; - ValaScope* _tmp141_; - ValaSymbol* _tmp142_; - ValaClass* _tmp143_; - ValaObjectType* _tmp144_; - ValaObjectType* _tmp145_; - ValaLocalVariable* type_temp = NULL; + ValaSymbol* _tmp137_; + ValaScope* _tmp138_; + ValaScope* _tmp139_; + ValaSymbol* _tmp140_; + ValaSymbol* _tmp141_; + ValaScope* _tmp142_; + ValaScope* _tmp143_; + ValaSymbol* _tmp144_; + ValaClass* _tmp145_; ValaObjectType* _tmp146_; - ValaLocalVariable* _tmp147_; - ValaLocalVariable* _tmp148_; - ValaCCodeIdentifier* _tmp149_; - ValaCCodeIdentifier* _tmp150_; - ValaCCodeFunctionCall* _tmp151_; - ValaCCodeExpression* _tmp152_; - const gchar* _tmp153_; - gchar* _tmp154_; - gchar* _tmp155_; - ValaCCodeIdentifier* _tmp156_; - ValaCCodeIdentifier* _tmp157_; - ValaLocalVariable* _tmp158_; - ValaTargetValue* _tmp159_; - ValaTargetValue* _tmp160_; - ValaObjectType* _tmp161_; - ValaCCodeExpression* _tmp162_; - ValaGLibValue* _tmp163_; - ValaGLibValue* _tmp164_; - ValaSourceReference* _tmp165_; - ValaSourceReference* _tmp166_; - ValaLocalVariable* _tmp167_; - const gchar* _tmp168_; - const gchar* _tmp169_; - ValaCCodeExpression* _tmp170_; - _tmp135_ = ((ValaCCodeBaseModule*) self)->root_symbol; - _tmp136_ = vala_symbol_get_scope (_tmp135_); - _tmp137_ = _tmp136_; - _tmp138_ = vala_scope_lookup (_tmp137_, "GLib"); + ValaObjectType* _tmp147_; + ValaLocalVariable* type_temp = NULL; + ValaObjectType* _tmp148_; + ValaLocalVariable* _tmp149_; + ValaLocalVariable* _tmp150_; + ValaCCodeIdentifier* _tmp151_; + ValaCCodeIdentifier* _tmp152_; + ValaCCodeFunctionCall* _tmp153_; + ValaCCodeExpression* _tmp154_; + const gchar* _tmp155_; + gchar* _tmp156_; + gchar* _tmp157_; + ValaCCodeIdentifier* _tmp158_; + ValaCCodeIdentifier* _tmp159_; + ValaLocalVariable* _tmp160_; + ValaTargetValue* _tmp161_; + ValaTargetValue* _tmp162_; + ValaObjectType* _tmp163_; + ValaCCodeExpression* _tmp164_; + ValaGLibValue* _tmp165_; + ValaGLibValue* _tmp166_; + ValaSourceReference* _tmp167_; + ValaSourceReference* _tmp168_; + ValaLocalVariable* _tmp169_; + const gchar* _tmp170_; + const gchar* _tmp171_; + ValaCCodeExpression* _tmp172_; + _tmp137_ = ((ValaCCodeBaseModule*) self)->root_symbol; + _tmp138_ = vala_symbol_get_scope (_tmp137_); _tmp139_ = _tmp138_; - _tmp140_ = vala_symbol_get_scope (_tmp139_); + _tmp140_ = vala_scope_lookup (_tmp139_, "GLib"); _tmp141_ = _tmp140_; - _tmp142_ = vala_scope_lookup (_tmp141_, "VariantType"); - _tmp143_ = G_TYPE_CHECK_INSTANCE_CAST (_tmp142_, VALA_TYPE_CLASS, ValaClass); - _tmp144_ = vala_object_type_new ((ValaObjectTypeSymbol*) _tmp143_); - _tmp145_ = _tmp144_; - _vala_code_node_unref0 (_tmp143_); - _vala_code_node_unref0 (_tmp139_); - gvariant_type_type = _tmp145_; - _tmp146_ = gvariant_type_type; - _tmp147_ = vala_ccode_base_module_get_temp_variable ((ValaCCodeBaseModule*) self, (ValaDataType*) _tmp146_, TRUE, (ValaCodeNode*) expr, TRUE); - type_temp = _tmp147_; - _tmp148_ = type_temp; - vala_ccode_base_module_emit_temp_var ((ValaCCodeBaseModule*) self, _tmp148_, FALSE); - _tmp149_ = vala_ccode_identifier_new ("g_variant_type_new"); - _tmp150_ = _tmp149_; - _tmp151_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp150_); + _tmp142_ = vala_symbol_get_scope (_tmp141_); + _tmp143_ = _tmp142_; + _tmp144_ = vala_scope_lookup (_tmp143_, "VariantType"); + _tmp145_ = G_TYPE_CHECK_INSTANCE_CAST (_tmp144_, VALA_TYPE_CLASS, ValaClass); + _tmp146_ = vala_object_type_new ((ValaObjectTypeSymbol*) _tmp145_); + _tmp147_ = _tmp146_; + _vala_code_node_unref0 (_tmp145_); + _vala_code_node_unref0 (_tmp141_); + gvariant_type_type = _tmp147_; + _tmp148_ = gvariant_type_type; + _tmp149_ = vala_ccode_base_module_get_temp_variable ((ValaCCodeBaseModule*) self, (ValaDataType*) _tmp148_, TRUE, (ValaCodeNode*) expr, TRUE); + type_temp = _tmp149_; + _tmp150_ = type_temp; + vala_ccode_base_module_emit_temp_var ((ValaCCodeBaseModule*) self, _tmp150_, FALSE); + _tmp151_ = vala_ccode_identifier_new ("g_variant_type_new"); + _tmp152_ = _tmp151_; + _tmp153_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp152_); _vala_ccode_node_unref0 (type_expr); - type_expr = (ValaCCodeExpression*) _tmp151_; - _vala_ccode_node_unref0 (_tmp150_); - _tmp152_ = type_expr; - _tmp153_ = signature; - _tmp154_ = g_strdup_printf ("\"%s\"", _tmp153_); - _tmp155_ = _tmp154_; - _tmp156_ = vala_ccode_identifier_new (_tmp155_); + type_expr = (ValaCCodeExpression*) _tmp153_; + _vala_ccode_node_unref0 (_tmp152_); + _tmp154_ = type_expr; + _tmp155_ = signature; + _tmp156_ = g_strdup_printf ("\"%s\"", _tmp155_); _tmp157_ = _tmp156_; - vala_ccode_function_call_add_argument (G_TYPE_CHECK_INSTANCE_CAST (_tmp152_, VALA_TYPE_CCODE_FUNCTION_CALL, ValaCCodeFunctionCall), (ValaCCodeExpression*) _tmp157_); - _vala_ccode_node_unref0 (_tmp157_); - _g_free0 (_tmp155_); - _tmp158_ = type_temp; - _tmp159_ = vala_ccode_base_module_get_local_cvalue ((ValaCCodeBaseModule*) self, _tmp158_); - _tmp160_ = _tmp159_; - _tmp161_ = gvariant_type_type; - _tmp162_ = type_expr; - _tmp163_ = vala_glib_value_new ((ValaDataType*) _tmp161_, _tmp162_, FALSE); - _tmp164_ = _tmp163_; - _tmp165_ = vala_code_node_get_source_reference ((ValaCodeNode*) expr); + _tmp158_ = vala_ccode_identifier_new (_tmp157_); + _tmp159_ = _tmp158_; + vala_ccode_function_call_add_argument (G_TYPE_CHECK_INSTANCE_CAST (_tmp154_, VALA_TYPE_CCODE_FUNCTION_CALL, ValaCCodeFunctionCall), (ValaCCodeExpression*) _tmp159_); + _vala_ccode_node_unref0 (_tmp159_); + _g_free0 (_tmp157_); + _tmp160_ = type_temp; + _tmp161_ = vala_ccode_base_module_get_local_cvalue ((ValaCCodeBaseModule*) self, _tmp160_); + _tmp162_ = _tmp161_; + _tmp163_ = gvariant_type_type; + _tmp164_ = type_expr; + _tmp165_ = vala_glib_value_new ((ValaDataType*) _tmp163_, _tmp164_, FALSE); _tmp166_ = _tmp165_; - vala_ccode_base_module_store_value ((ValaCCodeBaseModule*) self, _tmp160_, (ValaTargetValue*) _tmp164_, _tmp166_); - _vala_target_value_unref0 (_tmp164_); - _vala_target_value_unref0 (_tmp160_); - _tmp167_ = type_temp; - _tmp168_ = vala_symbol_get_name ((ValaSymbol*) _tmp167_); - _tmp169_ = _tmp168_; - _tmp170_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, _tmp169_); + _tmp167_ = vala_code_node_get_source_reference ((ValaCodeNode*) expr); + _tmp168_ = _tmp167_; + vala_ccode_base_module_store_value ((ValaCCodeBaseModule*) self, _tmp162_, (ValaTargetValue*) _tmp166_, _tmp168_); + _vala_target_value_unref0 (_tmp166_); + _vala_target_value_unref0 (_tmp162_); + _tmp169_ = type_temp; + _tmp170_ = vala_symbol_get_name ((ValaSymbol*) _tmp169_); + _tmp171_ = _tmp170_; + _tmp172_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, _tmp171_); _vala_ccode_node_unref0 (type_expr); - type_expr = _tmp170_; + type_expr = _tmp172_; _vala_code_node_unref0 (type_temp); _vala_code_node_unref0 (gvariant_type_type); } - _tmp171_ = ccheck; - _tmp172_ = type_expr; - vala_ccode_function_call_add_argument (_tmp171_, _tmp172_); - _tmp173_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); - _tmp174_ = _tmp173_; - _tmp175_ = vala_ccode_identifier_new ("value"); + _tmp173_ = ccheck; + _tmp174_ = type_expr; + vala_ccode_function_call_add_argument (_tmp173_, _tmp174_); + _tmp175_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); _tmp176_ = _tmp175_; - _tmp177_ = ccheck; - _tmp178_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_AND, (ValaCCodeExpression*) _tmp176_, (ValaCCodeExpression*) _tmp177_); - _tmp179_ = _tmp178_; - vala_ccode_function_open_if (_tmp174_, (ValaCCodeExpression*) _tmp179_); - _vala_ccode_node_unref0 (_tmp179_); - _vala_ccode_node_unref0 (_tmp176_); + _tmp177_ = vala_ccode_identifier_new ("value"); + _tmp178_ = _tmp177_; + _tmp179_ = ccheck; + _tmp180_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_AND, (ValaCCodeExpression*) _tmp178_, (ValaCCodeExpression*) _tmp179_); + _tmp181_ = _tmp180_; + vala_ccode_function_open_if (_tmp176_, (ValaCCodeExpression*) _tmp181_); + _vala_ccode_node_unref0 (_tmp181_); + _vala_ccode_node_unref0 (_tmp178_); _vala_ccode_node_unref0 (ccheck); _g_free0 (signature); } - _tmp180_ = target_type; - _tmp181_ = vala_ccode_identifier_new ("value"); - _tmp182_ = _tmp181_; - _tmp183_ = vala_ccode_identifier_new ("*result"); + _tmp182_ = target_type; + _tmp183_ = vala_ccode_identifier_new ("value"); _tmp184_ = _tmp183_; - _tmp185_ = vala_ccode_base_module_deserialize_expression ((ValaCCodeBaseModule*) self, _tmp180_, (ValaCCodeExpression*) _tmp182_, (ValaCCodeExpression*) _tmp184_, NULL, NULL); + _tmp185_ = vala_ccode_identifier_new ("*result"); _tmp186_ = _tmp185_; - _vala_ccode_node_unref0 (_tmp184_); - _vala_ccode_node_unref0 (_tmp182_); - func_result = _tmp186_; - _tmp187_ = vala_cast_expression_get_is_silent_cast (expr); + _tmp187_ = vala_ccode_base_module_deserialize_expression ((ValaCCodeBaseModule*) self, _tmp182_, (ValaCCodeExpression*) _tmp184_, (ValaCCodeExpression*) _tmp186_, NULL, NULL); _tmp188_ = _tmp187_; - if (_tmp188_) { - gboolean _tmp189_ = FALSE; - ValaCCodeFunction* _tmp226_; - ValaCCodeFunction* _tmp227_; - ValaCCodeFunction* _tmp237_; - ValaCCodeFunction* _tmp238_; - ValaCCodeConstant* _tmp239_; - ValaCCodeConstant* _tmp240_; - ValaCCodeFunction* _tmp241_; - ValaCCodeFunction* _tmp242_; + _vala_ccode_node_unref0 (_tmp186_); + _vala_ccode_node_unref0 (_tmp184_); + func_result = _tmp188_; + _tmp189_ = vala_cast_expression_get_is_silent_cast (expr); + _tmp190_ = _tmp189_; + if (_tmp190_) { + gboolean _tmp191_ = FALSE; + ValaCCodeFunction* _tmp228_; + ValaCCodeFunction* _tmp229_; + ValaCCodeFunction* _tmp239_; + ValaCCodeFunction* _tmp240_; + ValaCCodeConstant* _tmp241_; + ValaCCodeConstant* _tmp242_; + ValaCCodeFunction* _tmp243_; + ValaCCodeFunction* _tmp244_; if (is_basic_type) { - ValaGVariantModuleBasicTypeInfo _tmp190_; - _tmp190_ = basic_type; - _tmp189_ = _tmp190_.is_string; + ValaGVariantModuleBasicTypeInfo _tmp192_; + _tmp192_ = basic_type; + _tmp191_ = _tmp192_.is_string; } else { - _tmp189_ = FALSE; + _tmp191_ = FALSE; } - if (_tmp189_) { - ValaCCodeFunction* _tmp191_; - ValaCCodeFunction* _tmp192_; - ValaCCodeExpression* _tmp193_; - _tmp191_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); - _tmp192_ = _tmp191_; - _tmp193_ = func_result; - vala_ccode_function_add_return (_tmp192_, _tmp193_); + if (_tmp191_) { + ValaCCodeFunction* _tmp193_; + ValaCCodeFunction* _tmp194_; + ValaCCodeExpression* _tmp195_; + _tmp193_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp194_ = _tmp193_; + _tmp195_ = func_result; + vala_ccode_function_add_return (_tmp194_, _tmp195_); } else { ValaDataType* temp_type = NULL; - ValaDataType* _tmp203_; - ValaDataType* _tmp204_; ValaDataType* _tmp205_; ValaDataType* _tmp206_; ValaDataType* _tmp207_; - ValaTargetValue* temp_value = NULL; + ValaDataType* _tmp208_; ValaDataType* _tmp209_; - ValaTargetValue* _tmp210_; - ValaTargetValue* _tmp211_; - ValaDataType* _tmp212_; - ValaCCodeExpression* _tmp213_; - ValaGLibValue* _tmp214_; - ValaGLibValue* _tmp215_; - ValaSourceReference* _tmp216_; - ValaSourceReference* _tmp217_; - ValaCCodeFunction* _tmp218_; - ValaCCodeFunction* _tmp219_; - ValaTargetValue* _tmp220_; - ValaDataType* _tmp221_; - ValaDataType* _tmp222_; - ValaTargetValue* _tmp223_; - ValaTargetValue* _tmp224_; - ValaCCodeExpression* _tmp225_; + ValaTargetValue* temp_value = NULL; + ValaDataType* _tmp211_; + ValaTargetValue* _tmp212_; + ValaTargetValue* _tmp213_; + ValaDataType* _tmp214_; + ValaCCodeExpression* _tmp215_; + ValaGLibValue* _tmp216_; + ValaGLibValue* _tmp217_; + ValaSourceReference* _tmp218_; + ValaSourceReference* _tmp219_; + ValaCCodeFunction* _tmp220_; + ValaCCodeFunction* _tmp221_; + ValaTargetValue* _tmp222_; + ValaDataType* _tmp223_; + ValaDataType* _tmp224_; + ValaTargetValue* _tmp225_; + ValaTargetValue* _tmp226_; + ValaCCodeExpression* _tmp227_; if (!is_basic_type) { ValaCCodeFunctionCall* type_free = NULL; - ValaCCodeIdentifier* _tmp194_; - ValaCCodeIdentifier* _tmp195_; - ValaCCodeFunctionCall* _tmp196_; - ValaCCodeFunctionCall* _tmp197_; + ValaCCodeIdentifier* _tmp196_; + ValaCCodeIdentifier* _tmp197_; ValaCCodeFunctionCall* _tmp198_; - ValaCCodeExpression* _tmp199_; - ValaCCodeFunction* _tmp200_; - ValaCCodeFunction* _tmp201_; - ValaCCodeFunctionCall* _tmp202_; - _tmp194_ = vala_ccode_identifier_new ("g_variant_type_free"); - _tmp195_ = _tmp194_; - _tmp196_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp195_); + ValaCCodeFunctionCall* _tmp199_; + ValaCCodeFunctionCall* _tmp200_; + ValaCCodeExpression* _tmp201_; + ValaCCodeFunction* _tmp202_; + ValaCCodeFunction* _tmp203_; + ValaCCodeFunctionCall* _tmp204_; + _tmp196_ = vala_ccode_identifier_new ("g_variant_type_free"); _tmp197_ = _tmp196_; - _vala_ccode_node_unref0 (_tmp195_); - type_free = _tmp197_; - _tmp198_ = type_free; - _tmp199_ = type_expr; - vala_ccode_function_call_add_argument (_tmp198_, _tmp199_); - _tmp200_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); - _tmp201_ = _tmp200_; - _tmp202_ = type_free; - vala_ccode_function_add_expression (_tmp201_, (ValaCCodeExpression*) _tmp202_); + _tmp198_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp197_); + _tmp199_ = _tmp198_; + _vala_ccode_node_unref0 (_tmp197_); + type_free = _tmp199_; + _tmp200_ = type_free; + _tmp201_ = type_expr; + vala_ccode_function_call_add_argument (_tmp200_, _tmp201_); + _tmp202_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp203_ = _tmp202_; + _tmp204_ = type_free; + vala_ccode_function_add_expression (_tmp203_, (ValaCCodeExpression*) _tmp204_); _vala_ccode_node_unref0 (type_free); } - _tmp203_ = vala_expression_get_target_type ((ValaExpression*) expr); - _tmp204_ = _tmp203_; - _tmp205_ = vala_data_type_copy (_tmp204_); - temp_type = _tmp205_; - _tmp206_ = vala_expression_get_target_type ((ValaExpression*) expr); - _tmp207_ = _tmp206_; - if (!vala_data_type_is_real_struct_type (_tmp207_)) { - ValaDataType* _tmp208_; - _tmp208_ = temp_type; - vala_data_type_set_nullable (_tmp208_, FALSE); + _tmp205_ = vala_expression_get_target_type ((ValaExpression*) expr); + _tmp206_ = _tmp205_; + _tmp207_ = vala_data_type_copy (_tmp206_); + temp_type = _tmp207_; + _tmp208_ = vala_expression_get_target_type ((ValaExpression*) expr); + _tmp209_ = _tmp208_; + if (!vala_data_type_is_real_struct_type (_tmp209_)) { + ValaDataType* _tmp210_; + _tmp210_ = temp_type; + vala_data_type_set_nullable (_tmp210_, FALSE); } - _tmp209_ = temp_type; - _tmp210_ = vala_ccode_base_module_create_temp_value ((ValaCCodeBaseModule*) self, _tmp209_, FALSE, (ValaCodeNode*) expr, NULL); - temp_value = _tmp210_; - _tmp211_ = temp_value; - _tmp212_ = temp_type; - _tmp213_ = func_result; - _tmp214_ = vala_glib_value_new (_tmp212_, _tmp213_, FALSE); - _tmp215_ = _tmp214_; - _tmp216_ = vala_code_node_get_source_reference ((ValaCodeNode*) expr); + _tmp211_ = temp_type; + _tmp212_ = vala_ccode_base_module_create_temp_value ((ValaCCodeBaseModule*) self, _tmp211_, FALSE, (ValaCodeNode*) expr, NULL); + temp_value = _tmp212_; + _tmp213_ = temp_value; + _tmp214_ = temp_type; + _tmp215_ = func_result; + _tmp216_ = vala_glib_value_new (_tmp214_, _tmp215_, FALSE); _tmp217_ = _tmp216_; - vala_ccode_base_module_store_value ((ValaCCodeBaseModule*) self, _tmp211_, (ValaTargetValue*) _tmp215_, _tmp217_); - _vala_target_value_unref0 (_tmp215_); - _tmp218_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp218_ = vala_code_node_get_source_reference ((ValaCodeNode*) expr); _tmp219_ = _tmp218_; - _tmp220_ = temp_value; - _tmp221_ = vala_expression_get_target_type ((ValaExpression*) expr); - _tmp222_ = _tmp221_; - _tmp223_ = vala_ccode_base_module_transform_value ((ValaCCodeBaseModule*) self, _tmp220_, _tmp222_, (ValaCodeNode*) expr); + vala_ccode_base_module_store_value ((ValaCCodeBaseModule*) self, _tmp213_, (ValaTargetValue*) _tmp217_, _tmp219_); + _vala_target_value_unref0 (_tmp217_); + _tmp220_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp221_ = _tmp220_; + _tmp222_ = temp_value; + _tmp223_ = vala_expression_get_target_type ((ValaExpression*) expr); _tmp224_ = _tmp223_; - _tmp225_ = vala_get_cvalue_ (_tmp224_); - vala_ccode_function_add_return (_tmp219_, _tmp225_); - _vala_target_value_unref0 (_tmp224_); + _tmp225_ = vala_ccode_base_module_transform_value ((ValaCCodeBaseModule*) self, _tmp222_, _tmp224_, (ValaCodeNode*) expr); + _tmp226_ = _tmp225_; + _tmp227_ = vala_get_cvalue_ (_tmp226_); + vala_ccode_function_add_return (_tmp221_, _tmp227_); + _vala_target_value_unref0 (_tmp226_); _vala_target_value_unref0 (temp_value); _vala_code_node_unref0 (temp_type); } - _tmp226_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); - _tmp227_ = _tmp226_; - vala_ccode_function_add_else (_tmp227_); + _tmp228_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp229_ = _tmp228_; + vala_ccode_function_add_else (_tmp229_); if (!is_basic_type) { ValaCCodeFunctionCall* type_free = NULL; - ValaCCodeIdentifier* _tmp228_; - ValaCCodeIdentifier* _tmp229_; - ValaCCodeFunctionCall* _tmp230_; - ValaCCodeFunctionCall* _tmp231_; + ValaCCodeIdentifier* _tmp230_; + ValaCCodeIdentifier* _tmp231_; ValaCCodeFunctionCall* _tmp232_; - ValaCCodeExpression* _tmp233_; - ValaCCodeFunction* _tmp234_; - ValaCCodeFunction* _tmp235_; - ValaCCodeFunctionCall* _tmp236_; - _tmp228_ = vala_ccode_identifier_new ("g_variant_type_free"); - _tmp229_ = _tmp228_; - _tmp230_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp229_); + ValaCCodeFunctionCall* _tmp233_; + ValaCCodeFunctionCall* _tmp234_; + ValaCCodeExpression* _tmp235_; + ValaCCodeFunction* _tmp236_; + ValaCCodeFunction* _tmp237_; + ValaCCodeFunctionCall* _tmp238_; + _tmp230_ = vala_ccode_identifier_new ("g_variant_type_free"); _tmp231_ = _tmp230_; - _vala_ccode_node_unref0 (_tmp229_); - type_free = _tmp231_; - _tmp232_ = type_free; - _tmp233_ = type_expr; - vala_ccode_function_call_add_argument (_tmp232_, _tmp233_); - _tmp234_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); - _tmp235_ = _tmp234_; - _tmp236_ = type_free; - vala_ccode_function_add_expression (_tmp235_, (ValaCCodeExpression*) _tmp236_); + _tmp232_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp231_); + _tmp233_ = _tmp232_; + _vala_ccode_node_unref0 (_tmp231_); + type_free = _tmp233_; + _tmp234_ = type_free; + _tmp235_ = type_expr; + vala_ccode_function_call_add_argument (_tmp234_, _tmp235_); + _tmp236_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp237_ = _tmp236_; + _tmp238_ = type_free; + vala_ccode_function_add_expression (_tmp237_, (ValaCCodeExpression*) _tmp238_); _vala_ccode_node_unref0 (type_free); } - _tmp237_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); - _tmp238_ = _tmp237_; - _tmp239_ = vala_ccode_constant_new ("NULL"); + _tmp239_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); _tmp240_ = _tmp239_; - vala_ccode_function_add_return (_tmp238_, (ValaCCodeExpression*) _tmp240_); - _vala_ccode_node_unref0 (_tmp240_); - _tmp241_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp241_ = vala_ccode_constant_new ("NULL"); _tmp242_ = _tmp241_; - vala_ccode_function_close (_tmp242_); + vala_ccode_function_add_return (_tmp240_, (ValaCCodeExpression*) _tmp242_); + _vala_ccode_node_unref0 (_tmp242_); + _tmp243_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp244_ = _tmp243_; + vala_ccode_function_close (_tmp244_); } else { - ValaDataType* _tmp243_; - _tmp243_ = target_type; - if (vala_data_type_is_real_non_null_struct_type (_tmp243_)) { - ValaCCodeFunction* _tmp244_; - ValaCCodeFunction* _tmp245_; - ValaCCodeIdentifier* _tmp246_; - ValaCCodeIdentifier* _tmp247_; - ValaCCodeExpression* _tmp248_; - _tmp244_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); - _tmp245_ = _tmp244_; - _tmp246_ = vala_ccode_identifier_new ("*result"); + ValaDataType* _tmp245_; + _tmp245_ = target_type; + if (vala_data_type_is_real_non_null_struct_type (_tmp245_)) { + ValaCCodeFunction* _tmp246_; + ValaCCodeFunction* _tmp247_; + ValaCCodeIdentifier* _tmp248_; + ValaCCodeIdentifier* _tmp249_; + ValaCCodeExpression* _tmp250_; + _tmp246_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); _tmp247_ = _tmp246_; - _tmp248_ = func_result; - vala_ccode_function_add_assignment (_tmp245_, (ValaCCodeExpression*) _tmp247_, _tmp248_); - _vala_ccode_node_unref0 (_tmp247_); + _tmp248_ = vala_ccode_identifier_new ("*result"); + _tmp249_ = _tmp248_; + _tmp250_ = func_result; + vala_ccode_function_add_assignment (_tmp247_, (ValaCCodeExpression*) _tmp249_, _tmp250_); + _vala_ccode_node_unref0 (_tmp249_); } else { - ValaCCodeFunction* _tmp249_; - ValaCCodeFunction* _tmp250_; - ValaCCodeExpression* _tmp251_; - _tmp249_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); - _tmp250_ = _tmp249_; - _tmp251_ = func_result; - vala_ccode_function_add_return (_tmp250_, _tmp251_); + ValaCCodeFunction* _tmp251_; + ValaCCodeFunction* _tmp252_; + ValaCCodeExpression* _tmp253_; + _tmp251_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); + _tmp252_ = _tmp251_; + _tmp253_ = func_result; + vala_ccode_function_add_return (_tmp252_, _tmp253_); } } vala_ccode_base_module_pop_function ((ValaCCodeBaseModule*) self); - _tmp252_ = ((ValaCCodeBaseModule*) self)->cfile; - _tmp253_ = cfunc; - vala_ccode_file_add_function_declaration (_tmp252_, _tmp253_); + vala_ccode_base_module_pop_context ((ValaCCodeBaseModule*) self); _tmp254_ = ((ValaCCodeBaseModule*) self)->cfile; _tmp255_ = cfunc; - vala_ccode_file_add_function (_tmp254_, _tmp255_); - _tmp256_ = _result_; - _tmp257_ = vala_ccode_base_module_load_temp_value ((ValaCCodeBaseModule*) self, _tmp256_); - _tmp258_ = _tmp257_; - vala_expression_set_target_value ((ValaExpression*) expr, _tmp258_); - _vala_target_value_unref0 (_tmp258_); + vala_ccode_file_add_function_declaration (_tmp254_, _tmp255_); + _tmp256_ = ((ValaCCodeBaseModule*) self)->cfile; + _tmp257_ = cfunc; + vala_ccode_file_add_function (_tmp256_, _tmp257_); + _tmp258_ = _result_; + _tmp259_ = vala_ccode_base_module_load_temp_value ((ValaCCodeBaseModule*) self, _tmp258_); + _tmp260_ = _tmp259_; + vala_expression_set_target_value ((ValaExpression*) expr, _tmp260_); + _vala_target_value_unref0 (_tmp260_); _vala_ccode_node_unref0 (func_result); _vala_ccode_node_unref0 (type_expr); _vala_ccode_node_unref0 (cfunc); diff -Nru vala-0.48.20/codegen/valagvariantmodule.vala vala-0.48.22/codegen/valagvariantmodule.vala --- vala-0.48.20/codegen/valagvariantmodule.vala 2021-12-02 13:10:08.000000000 +0000 +++ vala-0.48.22/codegen/valagvariantmodule.vala 2022-01-09 09:12:38.000000000 +0000 @@ -158,6 +158,7 @@ ccode.add_expression (ccall); } + push_context (new EmitContext ()); push_function (cfunc); CCodeExpression type_expr = null; @@ -217,6 +218,7 @@ } pop_function (); + pop_context (); cfile.add_function_declaration (cfunc); cfile.add_function (cfunc); diff -Nru vala-0.48.20/compiler/valacompiler.c vala-0.48.22/compiler/valacompiler.c --- vala-0.48.20/compiler/valacompiler.c 2021-12-02 13:43:01.000000000 +0000 +++ vala-0.48.22/compiler/valacompiler.c 2022-01-09 12:57:43.000000000 +0000 @@ -567,9 +567,11 @@ { ValaCodeContext* _tmp0_; ValaCodeContext* _tmp1_; - ValaReportColored _tmp2_; - gboolean _tmp14_ = FALSE; - gboolean _tmp15_ = FALSE; + gboolean _tmp11_ = FALSE; + gboolean _tmp12_ = FALSE; + ValaCodeContext* _tmp23_; + ValaCodeContext* _tmp24_; + ValaCodeContext* _tmp25_; ValaCodeContext* _tmp26_; ValaCodeContext* _tmp27_; ValaCodeContext* _tmp28_; @@ -577,139 +579,136 @@ ValaCodeContext* _tmp30_; ValaCodeContext* _tmp31_; ValaCodeContext* _tmp32_; - ValaCodeContext* _tmp33_; - ValaCodeContext* _tmp34_; + ValaReport* _tmp33_; + ValaReport* _tmp34_; ValaCodeContext* _tmp35_; ValaReport* _tmp36_; ValaReport* _tmp37_; ValaCodeContext* _tmp38_; - ValaReport* _tmp39_; - ValaReport* _tmp40_; - ValaCodeContext* _tmp41_; - ValaCodeContext* _tmp42_; + ValaCodeContext* _tmp39_; + ValaCodeContext* _tmp40_; + gboolean _tmp41_ = FALSE; ValaCodeContext* _tmp43_; - gboolean _tmp44_ = FALSE; - ValaCodeContext* _tmp46_; - ValaCodeContext* _tmp47_; - ValaCodeContext* _tmp48_; - const gchar* _tmp49_; - gboolean _tmp50_ = FALSE; + ValaCodeContext* _tmp44_; + ValaCodeContext* _tmp45_; + const gchar* _tmp46_; + gboolean _tmp47_ = FALSE; + const gchar* _tmp48_; + ValaCodeContext* _tmp49_; + ValaCodeContext* _tmp50_; const gchar* _tmp51_; ValaCodeContext* _tmp52_; - ValaCodeContext* _tmp53_; - const gchar* _tmp54_; - ValaCodeContext* _tmp55_; - const gchar* _tmp56_; - ValaCodeContext* _tmp57_; - const gchar* _tmp58_; - ValaCodeContext* _tmp59_; + const gchar* _tmp53_; + ValaCodeContext* _tmp54_; + const gchar* _tmp55_; + ValaCodeContext* _tmp56_; + const gchar* _tmp57_; + gboolean _tmp58_ = FALSE; + const gchar* _tmp59_; const gchar* _tmp60_; - gboolean _tmp61_ = FALSE; - const gchar* _tmp62_; - const gchar* _tmp63_; - const gchar* _tmp71_; + const gchar* _tmp68_; + ValaCodeContext* _tmp77_; + gchar** _tmp78_; + gint _tmp78__length1; + ValaCodeContext* _tmp79_; ValaCodeContext* _tmp80_; gchar** _tmp81_; gint _tmp81__length1; ValaCodeContext* _tmp82_; - ValaCodeContext* _tmp83_; - gchar** _tmp84_; - gint _tmp84__length1; + gchar** _tmp83_; + gint _tmp83__length1; + ValaCodeContext* _tmp84_; ValaCodeContext* _tmp85_; - gchar** _tmp86_; - gint _tmp86__length1; - ValaCodeContext* _tmp87_; - ValaCodeContext* _tmp88_; - ValaCodeContext* _tmp89_; - gboolean _tmp90_ = FALSE; - const gchar* _tmp91_; + ValaCodeContext* _tmp86_; + gboolean _tmp87_ = FALSE; + const gchar* _tmp88_; + const gchar* _tmp101_; + ValaCodeContext* _tmp102_; + ValaCodeContext* _tmp103_; const gchar* _tmp104_; ValaCodeContext* _tmp105_; - ValaCodeContext* _tmp106_; - const gchar* _tmp107_; - ValaCodeContext* _tmp108_; - const gchar* _tmp109_; - ValaCodeContext* _tmp113_; - const gchar* _tmp114_; - gchar** _tmp115_; - gint _tmp115__length1; - ValaCodeContext* _tmp120_; - ValaProfile _tmp121_; - ValaProfile _tmp122_; - gchar** _tmp132_; - gint _tmp132__length1; - gchar** _tmp137_; - gint _tmp137__length1; - ValaCodeContext* _tmp148_; - gchar** _tmp149_; - gint _tmp149__length1; + const gchar* _tmp106_; + ValaCodeContext* _tmp110_; + const gchar* _tmp111_; + gchar** _tmp112_; + gint _tmp112__length1; + ValaCodeContext* _tmp117_; + ValaProfile _tmp118_; + ValaProfile _tmp119_; + gchar** _tmp129_; + gint _tmp129__length1; + gchar** _tmp134_; + gint _tmp134__length1; + ValaCodeContext* _tmp145_; + gchar** _tmp146_; + gint _tmp146__length1; + ValaCodeContext* _tmp147_; + gchar** _tmp148_; + gint _tmp148__length1; + gboolean _tmp149_ = FALSE; ValaCodeContext* _tmp150_; - gchar** _tmp151_; - gint _tmp151__length1; - gboolean _tmp152_ = FALSE; - ValaCodeContext* _tmp153_; - ValaReport* _tmp154_; - ValaReport* _tmp155_; - ValaCodeContext* _tmp160_; - ValaProfile _tmp161_; - ValaProfile _tmp162_; + ValaReport* _tmp151_; + ValaReport* _tmp152_; + ValaCodeContext* _tmp157_; + ValaProfile _tmp158_; + ValaProfile _tmp159_; gboolean has_c_files = FALSE; gboolean has_h_files = FALSE; - gchar** _tmp169_; - gint _tmp169__length1; - gboolean _tmp175_ = FALSE; - gboolean _tmp177_ = FALSE; - ValaCodeContext* _tmp178_; - ValaReport* _tmp179_; - ValaReport* _tmp180_; + gchar** _tmp166_; + gint _tmp166__length1; + gboolean _tmp172_ = FALSE; + gboolean _tmp174_ = FALSE; + ValaCodeContext* _tmp175_; + ValaReport* _tmp176_; + ValaReport* _tmp177_; ValaParser* parser = NULL; - ValaParser* _tmp209_; - ValaParser* _tmp210_; - ValaCodeContext* _tmp211_; + ValaParser* _tmp206_; + ValaParser* _tmp207_; + ValaCodeContext* _tmp208_; ValaGenieParser* genie_parser = NULL; - ValaGenieParser* _tmp212_; - ValaGenieParser* _tmp213_; - ValaCodeContext* _tmp214_; + ValaGenieParser* _tmp209_; + ValaGenieParser* _tmp210_; + ValaCodeContext* _tmp211_; ValaGirParser* gir_parser = NULL; - ValaGirParser* _tmp215_; - ValaGirParser* _tmp216_; - ValaCodeContext* _tmp217_; - gboolean _tmp218_ = FALSE; - ValaCodeContext* _tmp219_; - ValaReport* _tmp220_; - ValaReport* _tmp221_; - const gchar* _tmp226_; - ValaCodeContext* _tmp231_; - gboolean _tmp232_ = FALSE; - ValaCodeContext* _tmp233_; - ValaReport* _tmp234_; - ValaReport* _tmp235_; - gboolean _tmp240_ = FALSE; - gboolean _tmp241_ = FALSE; - const gchar* _tmp247_; - gboolean _tmp252_ = FALSE; - ValaCodeContext* _tmp253_; - ValaReport* _tmp254_; - ValaReport* _tmp255_; + ValaGirParser* _tmp212_; + ValaGirParser* _tmp213_; + ValaCodeContext* _tmp214_; + gboolean _tmp215_ = FALSE; + ValaCodeContext* _tmp216_; + ValaReport* _tmp217_; + ValaReport* _tmp218_; + const gchar* _tmp223_; + ValaCodeContext* _tmp228_; + gboolean _tmp229_ = FALSE; + ValaCodeContext* _tmp230_; + ValaReport* _tmp231_; + ValaReport* _tmp232_; + gboolean _tmp237_ = FALSE; + gboolean _tmp238_ = FALSE; + const gchar* _tmp244_; + gboolean _tmp249_ = FALSE; + ValaCodeContext* _tmp250_; + ValaReport* _tmp251_; + ValaReport* _tmp252_; + ValaCodeContext* _tmp257_; + ValaCodeGenerator* _tmp258_; + ValaCodeGenerator* _tmp259_; ValaCodeContext* _tmp260_; - ValaCodeGenerator* _tmp261_; - ValaCodeGenerator* _tmp262_; - ValaCodeContext* _tmp263_; - gboolean _tmp264_ = FALSE; - ValaCodeContext* _tmp265_; - ValaReport* _tmp266_; - ValaReport* _tmp267_; - gboolean _tmp272_ = FALSE; - const gchar* _tmp273_; - const gchar* _tmp277_; - const gchar* _tmp324_; - const gchar* _tmp337_; + gboolean _tmp261_ = FALSE; + ValaCodeContext* _tmp262_; + ValaReport* _tmp263_; + ValaReport* _tmp264_; + gboolean _tmp269_ = FALSE; + const gchar* _tmp270_; + const gchar* _tmp274_; + const gchar* _tmp321_; + const gchar* _tmp334_; + const gchar* _tmp377_; const gchar* _tmp380_; - const gchar* _tmp383_; - gboolean _tmp386_ = FALSE; - ValaCodeContext* _tmp387_; - ValaReport* _tmp388_; - ValaReport* _tmp389_; + gboolean _tmp383_ = FALSE; + ValaCodeContext* _tmp384_; + ValaReport* _tmp385_; + ValaReport* _tmp386_; gint result = 0; g_return_val_if_fail (self != NULL, 0); _tmp0_ = vala_code_context_new (); @@ -720,401 +719,396 @@ if (vala_compiler_disable_colored_output) { vala_compiler_colored_output = VALA_REPORT_COLORED_NEVER; } - _tmp2_ = vala_compiler_colored_output; - if (_tmp2_ != VALA_REPORT_COLORED_NEVER) { + if (vala_compiler_colored_output != VALA_REPORT_COLORED_NEVER) { const gchar* env_colors = NULL; + const gchar* _tmp2_; const gchar* _tmp3_; - const gchar* _tmp4_; - _tmp3_ = g_getenv ("VALA_COLORS"); - env_colors = _tmp3_; - _tmp4_ = env_colors; - if (_tmp4_ != NULL) { - ValaCodeContext* _tmp5_; + _tmp2_ = g_getenv ("VALA_COLORS"); + env_colors = _tmp2_; + _tmp3_ = env_colors; + if (_tmp3_ != NULL) { + ValaCodeContext* _tmp4_; + ValaReport* _tmp5_; ValaReport* _tmp6_; - ValaReport* _tmp7_; - const gchar* _tmp8_; - ValaReportColored _tmp9_; - _tmp5_ = self->priv->context; - _tmp6_ = vala_code_context_get_report (_tmp5_); - _tmp7_ = _tmp6_; - _tmp8_ = env_colors; - _tmp9_ = vala_compiler_colored_output; - vala_report_set_colors (_tmp7_, _tmp8_, _tmp9_); + const gchar* _tmp7_; + _tmp4_ = self->priv->context; + _tmp5_ = vala_code_context_get_report (_tmp4_); + _tmp6_ = _tmp5_; + _tmp7_ = env_colors; + vala_report_set_colors (_tmp6_, _tmp7_, vala_compiler_colored_output); } else { - ValaCodeContext* _tmp10_; - ValaReport* _tmp11_; - ValaReport* _tmp12_; - ValaReportColored _tmp13_; - _tmp10_ = self->priv->context; - _tmp11_ = vala_code_context_get_report (_tmp10_); - _tmp12_ = _tmp11_; - _tmp13_ = vala_compiler_colored_output; - vala_report_set_colors (_tmp12_, VALA_COMPILER_DEFAULT_COLORS, _tmp13_); + ValaCodeContext* _tmp8_; + ValaReport* _tmp9_; + ValaReport* _tmp10_; + _tmp8_ = self->priv->context; + _tmp9_ = vala_code_context_get_report (_tmp8_); + _tmp10_ = _tmp9_; + vala_report_set_colors (_tmp10_, VALA_COMPILER_DEFAULT_COLORS, vala_compiler_colored_output); } } if (!vala_compiler_ccode_only) { - _tmp15_ = !vala_compiler_compile_only; + _tmp12_ = !vala_compiler_compile_only; } else { - _tmp15_ = FALSE; + _tmp12_ = FALSE; } - if (_tmp15_) { - const gchar* _tmp16_; - _tmp16_ = vala_compiler_output; - _tmp14_ = _tmp16_ == NULL; - } else { - _tmp14_ = FALSE; - } - if (_tmp14_) { - gchar** _tmp17_; - gint _tmp17__length1; - const gchar* _tmp18_; - _tmp17_ = vala_compiler_sources; - _tmp17__length1 = _vala_array_length (vala_compiler_sources); - _tmp18_ = _tmp17_[0]; - if (string_last_index_of_char (_tmp18_, (gunichar) '.', 0) != -1) { + if (_tmp12_) { + const gchar* _tmp13_; + _tmp13_ = vala_compiler_output; + _tmp11_ = _tmp13_ == NULL; + } else { + _tmp11_ = FALSE; + } + if (_tmp11_) { + gchar** _tmp14_; + gint _tmp14__length1; + const gchar* _tmp15_; + _tmp14_ = vala_compiler_sources; + _tmp14__length1 = _vala_array_length (vala_compiler_sources); + _tmp15_ = _tmp14_[0]; + if (string_last_index_of_char (_tmp15_, (gunichar) '.', 0) != -1) { gint dot = 0; - gchar** _tmp19_; - gint _tmp19__length1; - const gchar* _tmp20_; - gchar** _tmp21_; - gint _tmp21__length1; - const gchar* _tmp22_; - gchar* _tmp23_; - gchar* _tmp24_; - gchar* _tmp25_; - _tmp19_ = vala_compiler_sources; - _tmp19__length1 = _vala_array_length (vala_compiler_sources); - _tmp20_ = _tmp19_[0]; - dot = string_last_index_of_char (_tmp20_, (gunichar) '.', 0); - _tmp21_ = vala_compiler_sources; - _tmp21__length1 = _vala_array_length (vala_compiler_sources); - _tmp22_ = _tmp21_[0]; - _tmp23_ = string_substring (_tmp22_, (glong) 0, (glong) dot); - _tmp24_ = _tmp23_; - _tmp25_ = g_path_get_basename (_tmp24_); + gchar** _tmp16_; + gint _tmp16__length1; + const gchar* _tmp17_; + gchar** _tmp18_; + gint _tmp18__length1; + const gchar* _tmp19_; + gchar* _tmp20_; + gchar* _tmp21_; + gchar* _tmp22_; + _tmp16_ = vala_compiler_sources; + _tmp16__length1 = _vala_array_length (vala_compiler_sources); + _tmp17_ = _tmp16_[0]; + dot = string_last_index_of_char (_tmp17_, (gunichar) '.', 0); + _tmp18_ = vala_compiler_sources; + _tmp18__length1 = _vala_array_length (vala_compiler_sources); + _tmp19_ = _tmp18_[0]; + _tmp20_ = string_substring (_tmp19_, (glong) 0, (glong) dot); + _tmp21_ = _tmp20_; + _tmp22_ = g_path_get_basename (_tmp21_); _g_free0 (vala_compiler_output); - vala_compiler_output = _tmp25_; - _g_free0 (_tmp24_); + vala_compiler_output = _tmp22_; + _g_free0 (_tmp21_); } } + _tmp23_ = self->priv->context; + vala_code_context_set_assert (_tmp23_, !vala_compiler_disable_assert); + _tmp24_ = self->priv->context; + vala_code_context_set_checking (_tmp24_, vala_compiler_enable_checking); + _tmp25_ = self->priv->context; + vala_code_context_set_deprecated (_tmp25_, vala_compiler_deprecated); _tmp26_ = self->priv->context; - vala_code_context_set_assert (_tmp26_, !vala_compiler_disable_assert); + vala_code_context_set_since_check (_tmp26_, !vala_compiler_disable_since_check); _tmp27_ = self->priv->context; - vala_code_context_set_checking (_tmp27_, vala_compiler_enable_checking); + vala_code_context_set_hide_internal (_tmp27_, vala_compiler_hide_internal); _tmp28_ = self->priv->context; - vala_code_context_set_deprecated (_tmp28_, vala_compiler_deprecated); + vala_code_context_set_experimental (_tmp28_, vala_compiler_experimental); _tmp29_ = self->priv->context; - vala_code_context_set_since_check (_tmp29_, !vala_compiler_disable_since_check); + vala_code_context_set_experimental_non_null (_tmp29_, vala_compiler_experimental_non_null); _tmp30_ = self->priv->context; - vala_code_context_set_hide_internal (_tmp30_, vala_compiler_hide_internal); + vala_code_context_set_gobject_tracing (_tmp30_, vala_compiler_gobject_tracing); _tmp31_ = self->priv->context; - vala_code_context_set_experimental (_tmp31_, vala_compiler_experimental); + vala_code_context_set_keep_going (_tmp31_, vala_compiler_keep_going); _tmp32_ = self->priv->context; - vala_code_context_set_experimental_non_null (_tmp32_, vala_compiler_experimental_non_null); - _tmp33_ = self->priv->context; - vala_code_context_set_gobject_tracing (_tmp33_, vala_compiler_gobject_tracing); - _tmp34_ = self->priv->context; - vala_code_context_set_keep_going (_tmp34_, vala_compiler_keep_going); + _tmp33_ = vala_code_context_get_report (_tmp32_); + _tmp34_ = _tmp33_; + vala_report_set_enable_warnings (_tmp34_, !vala_compiler_disable_warnings); _tmp35_ = self->priv->context; _tmp36_ = vala_code_context_get_report (_tmp35_); _tmp37_ = _tmp36_; - vala_report_set_enable_warnings (_tmp37_, !vala_compiler_disable_warnings); + vala_report_set_verbose_errors (_tmp37_, !vala_compiler_quiet_mode); _tmp38_ = self->priv->context; - _tmp39_ = vala_code_context_get_report (_tmp38_); - _tmp40_ = _tmp39_; - vala_report_set_verbose_errors (_tmp40_, !vala_compiler_quiet_mode); - _tmp41_ = self->priv->context; - vala_code_context_set_verbose_mode (_tmp41_, vala_compiler_verbose_mode); - _tmp42_ = self->priv->context; - vala_code_context_set_version_header (_tmp42_, !vala_compiler_disable_version_header); - _tmp43_ = self->priv->context; - vala_code_context_set_ccode_only (_tmp43_, vala_compiler_ccode_only); + vala_code_context_set_verbose_mode (_tmp38_, vala_compiler_verbose_mode); + _tmp39_ = self->priv->context; + vala_code_context_set_version_header (_tmp39_, !vala_compiler_disable_version_header); + _tmp40_ = self->priv->context; + vala_code_context_set_ccode_only (_tmp40_, vala_compiler_ccode_only); if (vala_compiler_ccode_only) { - gchar** _tmp45_; - gint _tmp45__length1; - _tmp45_ = vala_compiler_cc_options; - _tmp45__length1 = _vala_array_length (vala_compiler_cc_options); - _tmp44_ = _tmp45_ != NULL; + gchar** _tmp42_; + gint _tmp42__length1; + _tmp42_ = vala_compiler_cc_options; + _tmp42__length1 = _vala_array_length (vala_compiler_cc_options); + _tmp41_ = _tmp42_ != NULL; } else { - _tmp44_ = FALSE; + _tmp41_ = FALSE; } - if (_tmp44_) { + if (_tmp41_) { vala_report_warning (NULL, "-X has no effect when -C or --ccode is set"); } - _tmp46_ = self->priv->context; - vala_code_context_set_abi_stability (_tmp46_, vala_compiler_abi_stability); - _tmp47_ = self->priv->context; - vala_code_context_set_compile_only (_tmp47_, vala_compiler_compile_only); - _tmp48_ = self->priv->context; - _tmp49_ = vala_compiler_header_filename; - vala_code_context_set_header_filename (_tmp48_, _tmp49_); - _tmp51_ = vala_compiler_header_filename; - if (_tmp51_ == NULL) { - _tmp50_ = vala_compiler_use_header; + _tmp43_ = self->priv->context; + vala_code_context_set_abi_stability (_tmp43_, vala_compiler_abi_stability); + _tmp44_ = self->priv->context; + vala_code_context_set_compile_only (_tmp44_, vala_compiler_compile_only); + _tmp45_ = self->priv->context; + _tmp46_ = vala_compiler_header_filename; + vala_code_context_set_header_filename (_tmp45_, _tmp46_); + _tmp48_ = vala_compiler_header_filename; + if (_tmp48_ == NULL) { + _tmp47_ = vala_compiler_use_header; } else { - _tmp50_ = FALSE; + _tmp47_ = FALSE; } - if (_tmp50_) { + if (_tmp47_) { vala_report_error (NULL, "--use-header may only be used in combination with --header"); } + _tmp49_ = self->priv->context; + vala_code_context_set_use_header (_tmp49_, vala_compiler_use_header); + _tmp50_ = self->priv->context; + _tmp51_ = vala_compiler_internal_header_filename; + vala_code_context_set_internal_header_filename (_tmp50_, _tmp51_); _tmp52_ = self->priv->context; - vala_code_context_set_use_header (_tmp52_, vala_compiler_use_header); - _tmp53_ = self->priv->context; - _tmp54_ = vala_compiler_internal_header_filename; - vala_code_context_set_internal_header_filename (_tmp53_, _tmp54_); - _tmp55_ = self->priv->context; - _tmp56_ = vala_compiler_symbols_filename; - vala_code_context_set_symbols_filename (_tmp55_, _tmp56_); - _tmp57_ = self->priv->context; - _tmp58_ = vala_compiler_includedir; - vala_code_context_set_includedir (_tmp57_, _tmp58_); - _tmp59_ = self->priv->context; - _tmp60_ = vala_compiler_output; - vala_code_context_set_output (_tmp59_, _tmp60_); - _tmp62_ = vala_compiler_output; - if (_tmp62_ != NULL) { - _tmp61_ = vala_compiler_ccode_only; + _tmp53_ = vala_compiler_symbols_filename; + vala_code_context_set_symbols_filename (_tmp52_, _tmp53_); + _tmp54_ = self->priv->context; + _tmp55_ = vala_compiler_includedir; + vala_code_context_set_includedir (_tmp54_, _tmp55_); + _tmp56_ = self->priv->context; + _tmp57_ = vala_compiler_output; + vala_code_context_set_output (_tmp56_, _tmp57_); + _tmp59_ = vala_compiler_output; + if (_tmp59_ != NULL) { + _tmp58_ = vala_compiler_ccode_only; } else { - _tmp61_ = FALSE; + _tmp58_ = FALSE; } - if (_tmp61_) { + if (_tmp58_) { vala_report_warning (NULL, "--output and -o have no effect when -C or --ccode is set"); } - _tmp63_ = vala_compiler_basedir; - if (_tmp63_ == NULL) { + _tmp60_ = vala_compiler_basedir; + if (_tmp60_ == NULL) { + ValaCodeContext* _tmp61_; + gchar* _tmp62_; + gchar* _tmp63_; + _tmp61_ = self->priv->context; + _tmp62_ = vala_code_context_realpath ("."); + _tmp63_ = _tmp62_; + vala_code_context_set_basedir (_tmp61_, _tmp63_); + _g_free0 (_tmp63_); + } else { ValaCodeContext* _tmp64_; - gchar* _tmp65_; + const gchar* _tmp65_; gchar* _tmp66_; + gchar* _tmp67_; _tmp64_ = self->priv->context; - _tmp65_ = vala_code_context_realpath ("."); - _tmp66_ = _tmp65_; - vala_code_context_set_basedir (_tmp64_, _tmp66_); - _g_free0 (_tmp66_); - } else { - ValaCodeContext* _tmp67_; - const gchar* _tmp68_; - gchar* _tmp69_; - gchar* _tmp70_; - _tmp67_ = self->priv->context; - _tmp68_ = vala_compiler_basedir; - _tmp69_ = vala_code_context_realpath (_tmp68_); - _tmp70_ = _tmp69_; - vala_code_context_set_basedir (_tmp67_, _tmp70_); - _g_free0 (_tmp70_); - } - _tmp71_ = vala_compiler_directory; - if (_tmp71_ != NULL) { - ValaCodeContext* _tmp72_; - const gchar* _tmp73_; - gchar* _tmp74_; - gchar* _tmp75_; - _tmp72_ = self->priv->context; - _tmp73_ = vala_compiler_directory; - _tmp74_ = vala_code_context_realpath (_tmp73_); - _tmp75_ = _tmp74_; - vala_code_context_set_directory (_tmp72_, _tmp75_); - _g_free0 (_tmp75_); - } else { - ValaCodeContext* _tmp76_; - ValaCodeContext* _tmp77_; - const gchar* _tmp78_; - const gchar* _tmp79_; - _tmp76_ = self->priv->context; - _tmp77_ = self->priv->context; - _tmp78_ = vala_code_context_get_basedir (_tmp77_); - _tmp79_ = _tmp78_; - vala_code_context_set_directory (_tmp76_, _tmp79_); - } + _tmp65_ = vala_compiler_basedir; + _tmp66_ = vala_code_context_realpath (_tmp65_); + _tmp67_ = _tmp66_; + vala_code_context_set_basedir (_tmp64_, _tmp67_); + _g_free0 (_tmp67_); + } + _tmp68_ = vala_compiler_directory; + if (_tmp68_ != NULL) { + ValaCodeContext* _tmp69_; + const gchar* _tmp70_; + gchar* _tmp71_; + gchar* _tmp72_; + _tmp69_ = self->priv->context; + _tmp70_ = vala_compiler_directory; + _tmp71_ = vala_code_context_realpath (_tmp70_); + _tmp72_ = _tmp71_; + vala_code_context_set_directory (_tmp69_, _tmp72_); + _g_free0 (_tmp72_); + } else { + ValaCodeContext* _tmp73_; + ValaCodeContext* _tmp74_; + const gchar* _tmp75_; + const gchar* _tmp76_; + _tmp73_ = self->priv->context; + _tmp74_ = self->priv->context; + _tmp75_ = vala_code_context_get_basedir (_tmp74_); + _tmp76_ = _tmp75_; + vala_code_context_set_directory (_tmp73_, _tmp76_); + } + _tmp77_ = self->priv->context; + _tmp78_ = vala_compiler_vapi_directories; + _tmp78__length1 = _vala_array_length (vala_compiler_vapi_directories); + vala_code_context_set_vapi_directories (_tmp77_, _tmp78_, _tmp78__length1); + _tmp79_ = self->priv->context; + vala_code_context_set_vapi_comments (_tmp79_, vala_compiler_vapi_comments); _tmp80_ = self->priv->context; - _tmp81_ = vala_compiler_vapi_directories; - _tmp81__length1 = _vala_array_length (vala_compiler_vapi_directories); - vala_code_context_set_vapi_directories (_tmp80_, _tmp81_, _tmp81__length1); + _tmp81_ = vala_compiler_gir_directories; + _tmp81__length1 = _vala_array_length (vala_compiler_gir_directories); + vala_code_context_set_gir_directories (_tmp80_, _tmp81_, _tmp81__length1); _tmp82_ = self->priv->context; - vala_code_context_set_vapi_comments (_tmp82_, vala_compiler_vapi_comments); - _tmp83_ = self->priv->context; - _tmp84_ = vala_compiler_gir_directories; - _tmp84__length1 = _vala_array_length (vala_compiler_gir_directories); - vala_code_context_set_gir_directories (_tmp83_, _tmp84_, _tmp84__length1); + _tmp83_ = vala_compiler_metadata_directories; + _tmp83__length1 = _vala_array_length (vala_compiler_metadata_directories); + vala_code_context_set_metadata_directories (_tmp82_, _tmp83_, _tmp83__length1); + _tmp84_ = self->priv->context; + vala_code_context_set_debug (_tmp84_, vala_compiler_debug); _tmp85_ = self->priv->context; - _tmp86_ = vala_compiler_metadata_directories; - _tmp86__length1 = _vala_array_length (vala_compiler_metadata_directories); - vala_code_context_set_metadata_directories (_tmp85_, _tmp86_, _tmp86__length1); - _tmp87_ = self->priv->context; - vala_code_context_set_debug (_tmp87_, vala_compiler_debug); - _tmp88_ = self->priv->context; - vala_code_context_set_mem_profiler (_tmp88_, vala_compiler_mem_profiler); - _tmp89_ = self->priv->context; - vala_code_context_set_save_temps (_tmp89_, vala_compiler_save_temps); + vala_code_context_set_mem_profiler (_tmp85_, vala_compiler_mem_profiler); + _tmp86_ = self->priv->context; + vala_code_context_set_save_temps (_tmp86_, vala_compiler_save_temps); if (vala_compiler_ccode_only) { - _tmp90_ = vala_compiler_save_temps; + _tmp87_ = vala_compiler_save_temps; } else { - _tmp90_ = FALSE; + _tmp87_ = FALSE; } - if (_tmp90_) { + if (_tmp87_) { vala_report_warning (NULL, "--save-temps has no effect when -C or --ccode is set"); } - _tmp91_ = vala_compiler_profile; - if (g_strcmp0 (_tmp91_, "posix") == 0) { - ValaCodeContext* _tmp92_; - ValaCodeContext* _tmp93_; - _tmp92_ = self->priv->context; - vala_code_context_set_profile (_tmp92_, VALA_PROFILE_POSIX); - _tmp93_ = self->priv->context; - vala_code_context_add_define (_tmp93_, "POSIX"); - } else { - gboolean _tmp94_ = FALSE; - gboolean _tmp95_ = FALSE; - const gchar* _tmp96_; - _tmp96_ = vala_compiler_profile; - if (g_strcmp0 (_tmp96_, "gobject-2.0") == 0) { - _tmp95_ = TRUE; + _tmp88_ = vala_compiler_profile; + if (g_strcmp0 (_tmp88_, "posix") == 0) { + ValaCodeContext* _tmp89_; + ValaCodeContext* _tmp90_; + _tmp89_ = self->priv->context; + vala_code_context_set_profile (_tmp89_, VALA_PROFILE_POSIX); + _tmp90_ = self->priv->context; + vala_code_context_add_define (_tmp90_, "POSIX"); + } else { + gboolean _tmp91_ = FALSE; + gboolean _tmp92_ = FALSE; + const gchar* _tmp93_; + _tmp93_ = vala_compiler_profile; + if (g_strcmp0 (_tmp93_, "gobject-2.0") == 0) { + _tmp92_ = TRUE; } else { - const gchar* _tmp97_; - _tmp97_ = vala_compiler_profile; - _tmp95_ = g_strcmp0 (_tmp97_, "gobject") == 0; + const gchar* _tmp94_; + _tmp94_ = vala_compiler_profile; + _tmp92_ = g_strcmp0 (_tmp94_, "gobject") == 0; } - if (_tmp95_) { - _tmp94_ = TRUE; + if (_tmp92_) { + _tmp91_ = TRUE; + } else { + const gchar* _tmp95_; + _tmp95_ = vala_compiler_profile; + _tmp91_ = _tmp95_ == NULL; + } + if (_tmp91_) { + ValaCodeContext* _tmp96_; + ValaCodeContext* _tmp97_; + _tmp96_ = self->priv->context; + vala_code_context_set_profile (_tmp96_, VALA_PROFILE_GOBJECT); + _tmp97_ = self->priv->context; + vala_code_context_add_define (_tmp97_, "GOBJECT"); } else { const gchar* _tmp98_; + gchar* _tmp99_; + gchar* _tmp100_; _tmp98_ = vala_compiler_profile; - _tmp94_ = _tmp98_ == NULL; - } - if (_tmp94_) { - ValaCodeContext* _tmp99_; - ValaCodeContext* _tmp100_; - _tmp99_ = self->priv->context; - vala_code_context_set_profile (_tmp99_, VALA_PROFILE_GOBJECT); - _tmp100_ = self->priv->context; - vala_code_context_add_define (_tmp100_, "GOBJECT"); - } else { - const gchar* _tmp101_; - gchar* _tmp102_; - gchar* _tmp103_; - _tmp101_ = vala_compiler_profile; - _tmp102_ = g_strdup_printf ("Unknown profile %s", _tmp101_); - _tmp103_ = _tmp102_; - vala_report_error (NULL, _tmp103_); - _g_free0 (_tmp103_); + _tmp99_ = g_strdup_printf ("Unknown profile %s", _tmp98_); + _tmp100_ = _tmp99_; + vala_report_error (NULL, _tmp100_); + _g_free0 (_tmp100_); } } - _tmp104_ = vala_compiler_fast_vapi_filename; - vala_compiler_nostdpkg = vala_compiler_nostdpkg | (_tmp104_ != NULL); + _tmp101_ = vala_compiler_fast_vapi_filename; + vala_compiler_nostdpkg = vala_compiler_nostdpkg | (_tmp101_ != NULL); + _tmp102_ = self->priv->context; + vala_code_context_set_nostdpkg (_tmp102_, vala_compiler_nostdpkg); + _tmp103_ = self->priv->context; + _tmp104_ = vala_compiler_entry_point; + vala_code_context_set_entry_point_name (_tmp103_, _tmp104_); _tmp105_ = self->priv->context; - vala_code_context_set_nostdpkg (_tmp105_, vala_compiler_nostdpkg); - _tmp106_ = self->priv->context; - _tmp107_ = vala_compiler_entry_point; - vala_code_context_set_entry_point_name (_tmp106_, _tmp107_); - _tmp108_ = self->priv->context; - vala_code_context_set_run_output (_tmp108_, vala_compiler_run_output); - _tmp109_ = vala_compiler_pkg_config_command; - if (_tmp109_ == NULL) { - const gchar* _tmp110_ = NULL; - const gchar* _tmp111_; - gchar* _tmp112_; - _tmp111_ = g_getenv ("PKG_CONFIG"); - _tmp110_ = _tmp111_; - if (_tmp110_ == NULL) { - _tmp110_ = "pkg-config"; + vala_code_context_set_run_output (_tmp105_, vala_compiler_run_output); + _tmp106_ = vala_compiler_pkg_config_command; + if (_tmp106_ == NULL) { + const gchar* _tmp107_ = NULL; + const gchar* _tmp108_; + gchar* _tmp109_; + _tmp108_ = g_getenv ("PKG_CONFIG"); + _tmp107_ = _tmp108_; + if (_tmp107_ == NULL) { + _tmp107_ = "pkg-config"; } - _tmp112_ = g_strdup (_tmp110_); + _tmp109_ = g_strdup (_tmp107_); _g_free0 (vala_compiler_pkg_config_command); - vala_compiler_pkg_config_command = _tmp112_; + vala_compiler_pkg_config_command = _tmp109_; } - _tmp113_ = self->priv->context; - _tmp114_ = vala_compiler_pkg_config_command; - vala_code_context_set_pkg_config_command (_tmp113_, _tmp114_); - _tmp115_ = vala_compiler_defines; - _tmp115__length1 = _vala_array_length (vala_compiler_defines); - if (_tmp115_ != NULL) { - gchar** _tmp116_; - gint _tmp116__length1; - _tmp116_ = vala_compiler_defines; - _tmp116__length1 = _vala_array_length (vala_compiler_defines); + _tmp110_ = self->priv->context; + _tmp111_ = vala_compiler_pkg_config_command; + vala_code_context_set_pkg_config_command (_tmp110_, _tmp111_); + _tmp112_ = vala_compiler_defines; + _tmp112__length1 = _vala_array_length (vala_compiler_defines); + if (_tmp112_ != NULL) { + gchar** _tmp113_; + gint _tmp113__length1; + _tmp113_ = vala_compiler_defines; + _tmp113__length1 = _vala_array_length (vala_compiler_defines); { gchar** define_collection = NULL; gint define_collection_length1 = 0; gint _define_collection_size_ = 0; gint define_it = 0; - define_collection = _tmp116_; - define_collection_length1 = _tmp116__length1; + define_collection = _tmp113_; + define_collection_length1 = _tmp113__length1; for (define_it = 0; define_it < define_collection_length1; define_it = define_it + 1) { - gchar* _tmp117_; + gchar* _tmp114_; gchar* define = NULL; - _tmp117_ = g_strdup (define_collection[define_it]); - define = _tmp117_; + _tmp114_ = g_strdup (define_collection[define_it]); + define = _tmp114_; { - ValaCodeContext* _tmp118_; - const gchar* _tmp119_; - _tmp118_ = self->priv->context; - _tmp119_ = define; - vala_code_context_add_define (_tmp118_, _tmp119_); + ValaCodeContext* _tmp115_; + const gchar* _tmp116_; + _tmp115_ = self->priv->context; + _tmp116_ = define; + vala_code_context_add_define (_tmp115_, _tmp116_); _g_free0 (define); } } } } - _tmp120_ = self->priv->context; - _tmp121_ = vala_code_context_get_profile (_tmp120_); - _tmp122_ = _tmp121_; - if (_tmp122_ == VALA_PROFILE_POSIX) { + _tmp117_ = self->priv->context; + _tmp118_ = vala_code_context_get_profile (_tmp117_); + _tmp119_ = _tmp118_; + if (_tmp119_ == VALA_PROFILE_POSIX) { if (!vala_compiler_nostdpkg) { - ValaCodeContext* _tmp123_; - _tmp123_ = self->priv->context; - vala_code_context_add_external_package (_tmp123_, "posix"); - } - } else { - ValaCodeContext* _tmp124_; - ValaProfile _tmp125_; - ValaProfile _tmp126_; - _tmp124_ = self->priv->context; - _tmp125_ = vala_code_context_get_profile (_tmp124_); - _tmp126_ = _tmp125_; - if (_tmp126_ == VALA_PROFILE_GOBJECT) { - const gchar* _tmp127_; - _tmp127_ = vala_compiler_target_glib; - if (_tmp127_ != NULL) { - ValaCodeContext* _tmp128_; - const gchar* _tmp129_; - _tmp128_ = self->priv->context; - _tmp129_ = vala_compiler_target_glib; - vala_code_context_set_target_glib_version (_tmp128_, _tmp129_); + ValaCodeContext* _tmp120_; + _tmp120_ = self->priv->context; + vala_code_context_add_external_package (_tmp120_, "posix"); + } + } else { + ValaCodeContext* _tmp121_; + ValaProfile _tmp122_; + ValaProfile _tmp123_; + _tmp121_ = self->priv->context; + _tmp122_ = vala_code_context_get_profile (_tmp121_); + _tmp123_ = _tmp122_; + if (_tmp123_ == VALA_PROFILE_GOBJECT) { + const gchar* _tmp124_; + _tmp124_ = vala_compiler_target_glib; + if (_tmp124_ != NULL) { + ValaCodeContext* _tmp125_; + const gchar* _tmp126_; + _tmp125_ = self->priv->context; + _tmp126_ = vala_compiler_target_glib; + vala_code_context_set_target_glib_version (_tmp125_, _tmp126_); } if (!vala_compiler_nostdpkg) { - ValaCodeContext* _tmp130_; - ValaCodeContext* _tmp131_; - _tmp130_ = self->priv->context; - vala_code_context_add_external_package (_tmp130_, "glib-2.0"); - _tmp131_ = self->priv->context; - vala_code_context_add_external_package (_tmp131_, "gobject-2.0"); + ValaCodeContext* _tmp127_; + ValaCodeContext* _tmp128_; + _tmp127_ = self->priv->context; + vala_code_context_add_external_package (_tmp127_, "glib-2.0"); + _tmp128_ = self->priv->context; + vala_code_context_add_external_package (_tmp128_, "gobject-2.0"); } } } - _tmp132_ = vala_compiler_packages; - _tmp132__length1 = _vala_array_length (vala_compiler_packages); - if (_tmp132_ != NULL) { - gchar** _tmp133_; - gint _tmp133__length1; - _tmp133_ = vala_compiler_packages; - _tmp133__length1 = _vala_array_length (vala_compiler_packages); + _tmp129_ = vala_compiler_packages; + _tmp129__length1 = _vala_array_length (vala_compiler_packages); + if (_tmp129_ != NULL) { + gchar** _tmp130_; + gint _tmp130__length1; + _tmp130_ = vala_compiler_packages; + _tmp130__length1 = _vala_array_length (vala_compiler_packages); { gchar** package_collection = NULL; gint package_collection_length1 = 0; gint _package_collection_size_ = 0; gint package_it = 0; - package_collection = _tmp133_; - package_collection_length1 = _tmp133__length1; + package_collection = _tmp130_; + package_collection_length1 = _tmp130__length1; for (package_it = 0; package_it < package_collection_length1; package_it = package_it + 1) { - gchar* _tmp134_; + gchar* _tmp131_; gchar* package = NULL; - _tmp134_ = g_strdup (package_collection[package_it]); - package = _tmp134_; + _tmp131_ = g_strdup (package_collection[package_it]); + package = _tmp131_; { - ValaCodeContext* _tmp135_; - const gchar* _tmp136_; - _tmp135_ = self->priv->context; - _tmp136_ = package; - vala_code_context_add_external_package (_tmp135_, _tmp136_); + ValaCodeContext* _tmp132_; + const gchar* _tmp133_; + _tmp132_ = self->priv->context; + _tmp133_ = package; + vala_code_context_add_external_package (_tmp132_, _tmp133_); _g_free0 (package); } } @@ -1122,139 +1116,139 @@ vala_compiler_packages = (_vala_array_free (vala_compiler_packages, _vala_array_length (vala_compiler_packages), (GDestroyNotify) g_free), NULL); vala_compiler_packages = NULL; } - _tmp137_ = vala_compiler_fast_vapis; - _tmp137__length1 = _vala_array_length (vala_compiler_fast_vapis); - if (_tmp137_ != NULL) { - gchar** _tmp138_; - gint _tmp138__length1; - ValaCodeContext* _tmp147_; - _tmp138_ = vala_compiler_fast_vapis; - _tmp138__length1 = _vala_array_length (vala_compiler_fast_vapis); + _tmp134_ = vala_compiler_fast_vapis; + _tmp134__length1 = _vala_array_length (vala_compiler_fast_vapis); + if (_tmp134_ != NULL) { + gchar** _tmp135_; + gint _tmp135__length1; + ValaCodeContext* _tmp144_; + _tmp135_ = vala_compiler_fast_vapis; + _tmp135__length1 = _vala_array_length (vala_compiler_fast_vapis); { gchar** vapi_collection = NULL; gint vapi_collection_length1 = 0; gint _vapi_collection_size_ = 0; gint vapi_it = 0; - vapi_collection = _tmp138_; - vapi_collection_length1 = _tmp138__length1; + vapi_collection = _tmp135_; + vapi_collection_length1 = _tmp135__length1; for (vapi_it = 0; vapi_it < vapi_collection_length1; vapi_it = vapi_it + 1) { - gchar* _tmp139_; + gchar* _tmp136_; gchar* vapi = NULL; - _tmp139_ = g_strdup (vapi_collection[vapi_it]); - vapi = _tmp139_; + _tmp136_ = g_strdup (vapi_collection[vapi_it]); + vapi = _tmp136_; { gchar* rpath = NULL; - const gchar* _tmp140_; - gchar* _tmp141_; + const gchar* _tmp137_; + gchar* _tmp138_; ValaSourceFile* source_file = NULL; + ValaCodeContext* _tmp139_; + const gchar* _tmp140_; + ValaSourceFile* _tmp141_; ValaCodeContext* _tmp142_; - const gchar* _tmp143_; - ValaSourceFile* _tmp144_; - ValaCodeContext* _tmp145_; - ValaSourceFile* _tmp146_; - _tmp140_ = vapi; - _tmp141_ = vala_code_context_realpath (_tmp140_); - rpath = _tmp141_; + ValaSourceFile* _tmp143_; + _tmp137_ = vapi; + _tmp138_ = vala_code_context_realpath (_tmp137_); + rpath = _tmp138_; + _tmp139_ = self->priv->context; + _tmp140_ = rpath; + _tmp141_ = vala_source_file_new (_tmp139_, VALA_SOURCE_FILE_TYPE_FAST, _tmp140_, NULL, FALSE); + source_file = _tmp141_; _tmp142_ = self->priv->context; - _tmp143_ = rpath; - _tmp144_ = vala_source_file_new (_tmp142_, VALA_SOURCE_FILE_TYPE_FAST, _tmp143_, NULL, FALSE); - source_file = _tmp144_; - _tmp145_ = self->priv->context; - _tmp146_ = source_file; - vala_code_context_add_source_file (_tmp145_, _tmp146_); + _tmp143_ = source_file; + vala_code_context_add_source_file (_tmp142_, _tmp143_); _vala_source_file_unref0 (source_file); _g_free0 (rpath); _g_free0 (vapi); } } } - _tmp147_ = self->priv->context; - vala_code_context_set_use_fast_vapi (_tmp147_, TRUE); + _tmp144_ = self->priv->context; + vala_code_context_set_use_fast_vapi (_tmp144_, TRUE); } - _tmp148_ = self->priv->context; - _tmp149_ = vala_compiler_gresources; - _tmp149__length1 = _vala_array_length (vala_compiler_gresources); - vala_code_context_set_gresources (_tmp148_, _tmp149_, _tmp149__length1); + _tmp145_ = self->priv->context; + _tmp146_ = vala_compiler_gresources; + _tmp146__length1 = _vala_array_length (vala_compiler_gresources); + vala_code_context_set_gresources (_tmp145_, _tmp146_, _tmp146__length1); + _tmp147_ = self->priv->context; + _tmp148_ = vala_compiler_gresources_directories; + _tmp148__length1 = _vala_array_length (vala_compiler_gresources_directories); + vala_code_context_set_gresources_directories (_tmp147_, _tmp148_, _tmp148__length1); _tmp150_ = self->priv->context; - _tmp151_ = vala_compiler_gresources_directories; - _tmp151__length1 = _vala_array_length (vala_compiler_gresources_directories); - vala_code_context_set_gresources_directories (_tmp150_, _tmp151_, _tmp151__length1); - _tmp153_ = self->priv->context; - _tmp154_ = vala_code_context_get_report (_tmp153_); - _tmp155_ = _tmp154_; - if (vala_report_get_errors (_tmp155_) > 0) { - _tmp152_ = TRUE; + _tmp151_ = vala_code_context_get_report (_tmp150_); + _tmp152_ = _tmp151_; + if (vala_report_get_errors (_tmp152_) > 0) { + _tmp149_ = TRUE; } else { - gboolean _tmp156_ = FALSE; + gboolean _tmp153_ = FALSE; if (vala_compiler_fatal_warnings) { - ValaCodeContext* _tmp157_; - ValaReport* _tmp158_; - ValaReport* _tmp159_; - _tmp157_ = self->priv->context; - _tmp158_ = vala_code_context_get_report (_tmp157_); - _tmp159_ = _tmp158_; - _tmp156_ = vala_report_get_warnings (_tmp159_) > 0; + ValaCodeContext* _tmp154_; + ValaReport* _tmp155_; + ValaReport* _tmp156_; + _tmp154_ = self->priv->context; + _tmp155_ = vala_code_context_get_report (_tmp154_); + _tmp156_ = _tmp155_; + _tmp153_ = vala_report_get_warnings (_tmp156_) > 0; } else { - _tmp156_ = FALSE; + _tmp153_ = FALSE; } - _tmp152_ = _tmp156_; + _tmp149_ = _tmp153_; } - if (_tmp152_) { + if (_tmp149_) { result = vala_compiler_quit (self); return result; } - _tmp160_ = self->priv->context; - _tmp161_ = vala_code_context_get_profile (_tmp160_); - _tmp162_ = _tmp161_; - if (_tmp162_ == VALA_PROFILE_GOBJECT) { + _tmp157_ = self->priv->context; + _tmp158_ = vala_code_context_get_profile (_tmp157_); + _tmp159_ = _tmp158_; + if (_tmp159_ == VALA_PROFILE_GOBJECT) { + ValaCodeContext* _tmp160_; + ValaGDBusServerModule* _tmp161_; + ValaGDBusServerModule* _tmp162_; + _tmp160_ = self->priv->context; + _tmp161_ = vala_gd_bus_server_module_new (); + _tmp162_ = _tmp161_; + vala_code_context_set_codegen (_tmp160_, (ValaCodeGenerator*) _tmp162_); + _vala_code_visitor_unref0 (_tmp162_); + } else { ValaCodeContext* _tmp163_; - ValaGDBusServerModule* _tmp164_; - ValaGDBusServerModule* _tmp165_; + ValaCCodeDelegateModule* _tmp164_; + ValaCCodeDelegateModule* _tmp165_; _tmp163_ = self->priv->context; - _tmp164_ = vala_gd_bus_server_module_new (); + _tmp164_ = vala_ccode_delegate_module_new (); _tmp165_ = _tmp164_; vala_code_context_set_codegen (_tmp163_, (ValaCodeGenerator*) _tmp165_); _vala_code_visitor_unref0 (_tmp165_); - } else { - ValaCodeContext* _tmp166_; - ValaCCodeDelegateModule* _tmp167_; - ValaCCodeDelegateModule* _tmp168_; - _tmp166_ = self->priv->context; - _tmp167_ = vala_ccode_delegate_module_new (); - _tmp168_ = _tmp167_; - vala_code_context_set_codegen (_tmp166_, (ValaCodeGenerator*) _tmp168_); - _vala_code_visitor_unref0 (_tmp168_); } has_c_files = FALSE; has_h_files = FALSE; - _tmp169_ = vala_compiler_sources; - _tmp169__length1 = _vala_array_length (vala_compiler_sources); + _tmp166_ = vala_compiler_sources; + _tmp166__length1 = _vala_array_length (vala_compiler_sources); { gchar** source_collection = NULL; gint source_collection_length1 = 0; gint _source_collection_size_ = 0; gint source_it = 0; - source_collection = _tmp169_; - source_collection_length1 = _tmp169__length1; + source_collection = _tmp166_; + source_collection_length1 = _tmp166__length1; for (source_it = 0; source_it < source_collection_length1; source_it = source_it + 1) { - gchar* _tmp170_; + gchar* _tmp167_; gchar* source = NULL; - _tmp170_ = g_strdup (source_collection[source_it]); - source = _tmp170_; + _tmp167_ = g_strdup (source_collection[source_it]); + source = _tmp167_; { - ValaCodeContext* _tmp171_; - const gchar* _tmp172_; - _tmp171_ = self->priv->context; - _tmp172_ = source; - if (vala_code_context_add_source_filename (_tmp171_, _tmp172_, vala_compiler_run_output, TRUE)) { - const gchar* _tmp173_; - _tmp173_ = source; - if (g_str_has_suffix (_tmp173_, ".c")) { + ValaCodeContext* _tmp168_; + const gchar* _tmp169_; + _tmp168_ = self->priv->context; + _tmp169_ = source; + if (vala_code_context_add_source_filename (_tmp168_, _tmp169_, vala_compiler_run_output, TRUE)) { + const gchar* _tmp170_; + _tmp170_ = source; + if (g_str_has_suffix (_tmp170_, ".c")) { has_c_files = TRUE; } else { - const gchar* _tmp174_; - _tmp174_ = source; - if (g_str_has_suffix (_tmp174_, ".h")) { + const gchar* _tmp171_; + _tmp171_ = source; + if (g_str_has_suffix (_tmp171_, ".h")) { has_h_files = TRUE; } } @@ -1266,85 +1260,85 @@ vala_compiler_sources = (_vala_array_free (vala_compiler_sources, _vala_array_length (vala_compiler_sources), (GDestroyNotify) g_free), NULL); vala_compiler_sources = NULL; if (vala_compiler_ccode_only) { - gboolean _tmp176_ = FALSE; + gboolean _tmp173_ = FALSE; if (has_c_files) { - _tmp176_ = TRUE; + _tmp173_ = TRUE; } else { - _tmp176_ = has_h_files; + _tmp173_ = has_h_files; } - _tmp175_ = _tmp176_; + _tmp172_ = _tmp173_; } else { - _tmp175_ = FALSE; + _tmp172_ = FALSE; } - if (_tmp175_) { + if (_tmp172_) { vala_report_warning (NULL, "C header and source files are ignored when -C or --ccode is set"); } - _tmp178_ = self->priv->context; - _tmp179_ = vala_code_context_get_report (_tmp178_); - _tmp180_ = _tmp179_; - if (vala_report_get_errors (_tmp180_) > 0) { - _tmp177_ = TRUE; + _tmp175_ = self->priv->context; + _tmp176_ = vala_code_context_get_report (_tmp175_); + _tmp177_ = _tmp176_; + if (vala_report_get_errors (_tmp177_) > 0) { + _tmp174_ = TRUE; } else { - gboolean _tmp181_ = FALSE; + gboolean _tmp178_ = FALSE; if (vala_compiler_fatal_warnings) { - ValaCodeContext* _tmp182_; - ValaReport* _tmp183_; - ValaReport* _tmp184_; - _tmp182_ = self->priv->context; - _tmp183_ = vala_code_context_get_report (_tmp182_); - _tmp184_ = _tmp183_; - _tmp181_ = vala_report_get_warnings (_tmp184_) > 0; + ValaCodeContext* _tmp179_; + ValaReport* _tmp180_; + ValaReport* _tmp181_; + _tmp179_ = self->priv->context; + _tmp180_ = vala_code_context_get_report (_tmp179_); + _tmp181_ = _tmp180_; + _tmp178_ = vala_report_get_warnings (_tmp181_) > 0; } else { - _tmp181_ = FALSE; + _tmp178_ = FALSE; } - _tmp177_ = _tmp181_; + _tmp174_ = _tmp178_; } - if (_tmp177_) { + if (_tmp174_) { result = vala_compiler_quit (self); return result; } if (vala_compiler_list_sources) { { ValaList* _file_list = NULL; - ValaCodeContext* _tmp185_; - ValaList* _tmp186_; - ValaList* _tmp187_; + ValaCodeContext* _tmp182_; + ValaList* _tmp183_; + ValaList* _tmp184_; gint _file_size = 0; - ValaList* _tmp188_; - gint _tmp189_; - gint _tmp190_; + ValaList* _tmp185_; + gint _tmp186_; + gint _tmp187_; gint _file_index = 0; - _tmp185_ = self->priv->context; - _tmp186_ = vala_code_context_get_source_files (_tmp185_); - _tmp187_ = _vala_iterable_ref0 (_tmp186_); - _file_list = _tmp187_; - _tmp188_ = _file_list; - _tmp189_ = vala_collection_get_size ((ValaCollection*) _tmp188_); - _tmp190_ = _tmp189_; - _file_size = _tmp190_; + _tmp182_ = self->priv->context; + _tmp183_ = vala_code_context_get_source_files (_tmp182_); + _tmp184_ = _vala_iterable_ref0 (_tmp183_); + _file_list = _tmp184_; + _tmp185_ = _file_list; + _tmp186_ = vala_collection_get_size ((ValaCollection*) _tmp185_); + _tmp187_ = _tmp186_; + _file_size = _tmp187_; _file_index = -1; while (TRUE) { - gint _tmp191_; - gint _tmp192_; + gint _tmp188_; + gint _tmp189_; ValaSourceFile* file = NULL; - ValaList* _tmp193_; - gpointer _tmp194_; - ValaSourceFile* _tmp195_; - const gchar* _tmp196_; - const gchar* _tmp197_; + ValaList* _tmp190_; + gpointer _tmp191_; + ValaSourceFile* _tmp192_; + const gchar* _tmp193_; + const gchar* _tmp194_; _file_index = _file_index + 1; - _tmp191_ = _file_index; - _tmp192_ = _file_size; - if (!(_tmp191_ < _tmp192_)) { + _tmp188_ = _file_index; + _tmp189_ = _file_size; + if (!(_tmp188_ < _tmp189_)) { break; } - _tmp193_ = _file_list; - _tmp194_ = vala_list_get (_tmp193_, _file_index); - file = (ValaSourceFile*) _tmp194_; - _tmp195_ = file; - _tmp196_ = vala_source_file_get_filename (_tmp195_); - _tmp197_ = _tmp196_; - g_print ("%s\n", _tmp197_); + _tmp190_ = _file_list; + _tmp191_ = vala_list_get (_tmp190_, _file_index); + file = (ValaSourceFile*) _tmp191_; + _tmp192_ = file; + _tmp193_ = vala_source_file_get_filename (_tmp192_); + _tmp194_ = _tmp193_; + g_print ("%s\n", _tmp194_); _vala_source_file_unref0 (file); } _vala_iterable_unref0 (_file_list); @@ -1352,41 +1346,41 @@ if (!vala_compiler_ccode_only) { { ValaList* _filename_list = NULL; - ValaCodeContext* _tmp198_; - ValaList* _tmp199_; - ValaList* _tmp200_; + ValaCodeContext* _tmp195_; + ValaList* _tmp196_; + ValaList* _tmp197_; gint _filename_size = 0; - ValaList* _tmp201_; - gint _tmp202_; - gint _tmp203_; + ValaList* _tmp198_; + gint _tmp199_; + gint _tmp200_; gint _filename_index = 0; - _tmp198_ = self->priv->context; - _tmp199_ = vala_code_context_get_c_source_files (_tmp198_); - _tmp200_ = _vala_iterable_ref0 (_tmp199_); - _filename_list = _tmp200_; - _tmp201_ = _filename_list; - _tmp202_ = vala_collection_get_size ((ValaCollection*) _tmp201_); - _tmp203_ = _tmp202_; - _filename_size = _tmp203_; + _tmp195_ = self->priv->context; + _tmp196_ = vala_code_context_get_c_source_files (_tmp195_); + _tmp197_ = _vala_iterable_ref0 (_tmp196_); + _filename_list = _tmp197_; + _tmp198_ = _filename_list; + _tmp199_ = vala_collection_get_size ((ValaCollection*) _tmp198_); + _tmp200_ = _tmp199_; + _filename_size = _tmp200_; _filename_index = -1; while (TRUE) { - gint _tmp204_; - gint _tmp205_; + gint _tmp201_; + gint _tmp202_; gchar* filename = NULL; - ValaList* _tmp206_; - gpointer _tmp207_; - const gchar* _tmp208_; + ValaList* _tmp203_; + gpointer _tmp204_; + const gchar* _tmp205_; _filename_index = _filename_index + 1; - _tmp204_ = _filename_index; - _tmp205_ = _filename_size; - if (!(_tmp204_ < _tmp205_)) { + _tmp201_ = _filename_index; + _tmp202_ = _filename_size; + if (!(_tmp201_ < _tmp202_)) { break; } - _tmp206_ = _filename_list; - _tmp207_ = vala_list_get (_tmp206_, _filename_index); - filename = (gchar*) _tmp207_; - _tmp208_ = filename; - g_print ("%s\n", _tmp208_); + _tmp203_ = _filename_list; + _tmp204_ = vala_list_get (_tmp203_, _filename_index); + filename = (gchar*) _tmp204_; + _tmp205_ = filename; + g_print ("%s\n", _tmp205_); _g_free0 (filename); } _vala_iterable_unref0 (_filename_list); @@ -1395,61 +1389,61 @@ result = 0; return result; } - _tmp209_ = vala_parser_new (); - parser = _tmp209_; - _tmp210_ = parser; + _tmp206_ = vala_parser_new (); + parser = _tmp206_; + _tmp207_ = parser; + _tmp208_ = self->priv->context; + vala_parser_parse (_tmp207_, _tmp208_); + _tmp209_ = vala_genie_parser_new (); + genie_parser = _tmp209_; + _tmp210_ = genie_parser; _tmp211_ = self->priv->context; - vala_parser_parse (_tmp210_, _tmp211_); - _tmp212_ = vala_genie_parser_new (); - genie_parser = _tmp212_; - _tmp213_ = genie_parser; + vala_genie_parser_parse (_tmp210_, _tmp211_); + _tmp212_ = vala_gir_parser_new (); + gir_parser = _tmp212_; + _tmp213_ = gir_parser; _tmp214_ = self->priv->context; - vala_genie_parser_parse (_tmp213_, _tmp214_); - _tmp215_ = vala_gir_parser_new (); - gir_parser = _tmp215_; - _tmp216_ = gir_parser; - _tmp217_ = self->priv->context; - vala_gir_parser_parse (_tmp216_, _tmp217_); - _tmp219_ = self->priv->context; - _tmp220_ = vala_code_context_get_report (_tmp219_); - _tmp221_ = _tmp220_; - if (vala_report_get_errors (_tmp221_) > 0) { - _tmp218_ = TRUE; + vala_gir_parser_parse (_tmp213_, _tmp214_); + _tmp216_ = self->priv->context; + _tmp217_ = vala_code_context_get_report (_tmp216_); + _tmp218_ = _tmp217_; + if (vala_report_get_errors (_tmp218_) > 0) { + _tmp215_ = TRUE; } else { - gboolean _tmp222_ = FALSE; + gboolean _tmp219_ = FALSE; if (vala_compiler_fatal_warnings) { - ValaCodeContext* _tmp223_; - ValaReport* _tmp224_; - ValaReport* _tmp225_; - _tmp223_ = self->priv->context; - _tmp224_ = vala_code_context_get_report (_tmp223_); - _tmp225_ = _tmp224_; - _tmp222_ = vala_report_get_warnings (_tmp225_) > 0; + ValaCodeContext* _tmp220_; + ValaReport* _tmp221_; + ValaReport* _tmp222_; + _tmp220_ = self->priv->context; + _tmp221_ = vala_code_context_get_report (_tmp220_); + _tmp222_ = _tmp221_; + _tmp219_ = vala_report_get_warnings (_tmp222_) > 0; } else { - _tmp222_ = FALSE; + _tmp219_ = FALSE; } - _tmp218_ = _tmp222_; + _tmp215_ = _tmp219_; } - if (_tmp218_) { + if (_tmp215_) { result = vala_compiler_quit (self); _vala_code_visitor_unref0 (gir_parser); _vala_code_visitor_unref0 (genie_parser); _vala_code_visitor_unref0 (parser); return result; } - _tmp226_ = vala_compiler_fast_vapi_filename; - if (_tmp226_ != NULL) { + _tmp223_ = vala_compiler_fast_vapi_filename; + if (_tmp223_ != NULL) { ValaCodeWriter* interface_writer = NULL; - ValaCodeWriter* _tmp227_; - ValaCodeWriter* _tmp228_; - ValaCodeContext* _tmp229_; - const gchar* _tmp230_; - _tmp227_ = vala_code_writer_new (VALA_CODE_WRITER_TYPE_FAST); - interface_writer = _tmp227_; - _tmp228_ = interface_writer; - _tmp229_ = self->priv->context; - _tmp230_ = vala_compiler_fast_vapi_filename; - vala_code_writer_write_file (_tmp228_, _tmp229_, _tmp230_); + ValaCodeWriter* _tmp224_; + ValaCodeWriter* _tmp225_; + ValaCodeContext* _tmp226_; + const gchar* _tmp227_; + _tmp224_ = vala_code_writer_new (VALA_CODE_WRITER_TYPE_FAST); + interface_writer = _tmp224_; + _tmp225_ = interface_writer; + _tmp226_ = self->priv->context; + _tmp227_ = vala_compiler_fast_vapi_filename; + vala_code_writer_write_file (_tmp225_, _tmp226_, _tmp227_); result = vala_compiler_quit (self); _vala_code_visitor_unref0 (interface_writer); _vala_code_visitor_unref0 (gir_parser); @@ -1457,29 +1451,29 @@ _vala_code_visitor_unref0 (parser); return result; } - _tmp231_ = self->priv->context; - vala_code_context_check (_tmp231_); - _tmp233_ = self->priv->context; - _tmp234_ = vala_code_context_get_report (_tmp233_); - _tmp235_ = _tmp234_; - if (vala_report_get_errors (_tmp235_) > 0) { - _tmp232_ = TRUE; + _tmp228_ = self->priv->context; + vala_code_context_check (_tmp228_); + _tmp230_ = self->priv->context; + _tmp231_ = vala_code_context_get_report (_tmp230_); + _tmp232_ = _tmp231_; + if (vala_report_get_errors (_tmp232_) > 0) { + _tmp229_ = TRUE; } else { - gboolean _tmp236_ = FALSE; + gboolean _tmp233_ = FALSE; if (vala_compiler_fatal_warnings) { - ValaCodeContext* _tmp237_; - ValaReport* _tmp238_; - ValaReport* _tmp239_; - _tmp237_ = self->priv->context; - _tmp238_ = vala_code_context_get_report (_tmp237_); - _tmp239_ = _tmp238_; - _tmp236_ = vala_report_get_warnings (_tmp239_) > 0; + ValaCodeContext* _tmp234_; + ValaReport* _tmp235_; + ValaReport* _tmp236_; + _tmp234_ = self->priv->context; + _tmp235_ = vala_code_context_get_report (_tmp234_); + _tmp236_ = _tmp235_; + _tmp233_ = vala_report_get_warnings (_tmp236_) > 0; } else { - _tmp236_ = FALSE; + _tmp233_ = FALSE; } - _tmp232_ = _tmp236_; + _tmp229_ = _tmp233_; } - if (_tmp232_) { + if (_tmp229_) { result = vala_compiler_quit (self); _vala_code_visitor_unref0 (gir_parser); _vala_code_visitor_unref0 (genie_parser); @@ -1487,262 +1481,262 @@ return result; } if (!vala_compiler_ccode_only) { - _tmp241_ = !vala_compiler_compile_only; + _tmp238_ = !vala_compiler_compile_only; } else { - _tmp241_ = FALSE; + _tmp238_ = FALSE; } - if (_tmp241_) { - const gchar* _tmp242_; - _tmp242_ = vala_compiler_library; - _tmp240_ = _tmp242_ == NULL; + if (_tmp238_) { + const gchar* _tmp239_; + _tmp239_ = vala_compiler_library; + _tmp237_ = _tmp239_ == NULL; } else { - _tmp240_ = FALSE; + _tmp237_ = FALSE; } - if (_tmp240_) { - gboolean _tmp243_ = FALSE; + if (_tmp237_) { + gboolean _tmp240_ = FALSE; if (!has_c_files) { - ValaCodeContext* _tmp244_; - ValaMethod* _tmp245_; - ValaMethod* _tmp246_; - _tmp244_ = self->priv->context; - _tmp245_ = vala_code_context_get_entry_point (_tmp244_); - _tmp246_ = _tmp245_; - _tmp243_ = _tmp246_ == NULL; + ValaCodeContext* _tmp241_; + ValaMethod* _tmp242_; + ValaMethod* _tmp243_; + _tmp241_ = self->priv->context; + _tmp242_ = vala_code_context_get_entry_point (_tmp241_); + _tmp243_ = _tmp242_; + _tmp240_ = _tmp243_ == NULL; } else { - _tmp243_ = FALSE; + _tmp240_ = FALSE; } - if (_tmp243_) { + if (_tmp240_) { vala_report_error (NULL, "program does not contain a static `main' method"); } } - _tmp247_ = vala_compiler_dump_tree; - if (_tmp247_ != NULL) { + _tmp244_ = vala_compiler_dump_tree; + if (_tmp244_ != NULL) { ValaCodeWriter* code_writer = NULL; - ValaCodeWriter* _tmp248_; - ValaCodeWriter* _tmp249_; - ValaCodeContext* _tmp250_; - const gchar* _tmp251_; - _tmp248_ = vala_code_writer_new (VALA_CODE_WRITER_TYPE_DUMP); - code_writer = _tmp248_; - _tmp249_ = code_writer; - _tmp250_ = self->priv->context; - _tmp251_ = vala_compiler_dump_tree; - vala_code_writer_write_file (_tmp249_, _tmp250_, _tmp251_); + ValaCodeWriter* _tmp245_; + ValaCodeWriter* _tmp246_; + ValaCodeContext* _tmp247_; + const gchar* _tmp248_; + _tmp245_ = vala_code_writer_new (VALA_CODE_WRITER_TYPE_DUMP); + code_writer = _tmp245_; + _tmp246_ = code_writer; + _tmp247_ = self->priv->context; + _tmp248_ = vala_compiler_dump_tree; + vala_code_writer_write_file (_tmp246_, _tmp247_, _tmp248_); _vala_code_visitor_unref0 (code_writer); } - _tmp253_ = self->priv->context; - _tmp254_ = vala_code_context_get_report (_tmp253_); - _tmp255_ = _tmp254_; - if (vala_report_get_errors (_tmp255_) > 0) { - _tmp252_ = TRUE; + _tmp250_ = self->priv->context; + _tmp251_ = vala_code_context_get_report (_tmp250_); + _tmp252_ = _tmp251_; + if (vala_report_get_errors (_tmp252_) > 0) { + _tmp249_ = TRUE; } else { - gboolean _tmp256_ = FALSE; + gboolean _tmp253_ = FALSE; if (vala_compiler_fatal_warnings) { - ValaCodeContext* _tmp257_; - ValaReport* _tmp258_; - ValaReport* _tmp259_; - _tmp257_ = self->priv->context; - _tmp258_ = vala_code_context_get_report (_tmp257_); - _tmp259_ = _tmp258_; - _tmp256_ = vala_report_get_warnings (_tmp259_) > 0; + ValaCodeContext* _tmp254_; + ValaReport* _tmp255_; + ValaReport* _tmp256_; + _tmp254_ = self->priv->context; + _tmp255_ = vala_code_context_get_report (_tmp254_); + _tmp256_ = _tmp255_; + _tmp253_ = vala_report_get_warnings (_tmp256_) > 0; } else { - _tmp256_ = FALSE; + _tmp253_ = FALSE; } - _tmp252_ = _tmp256_; + _tmp249_ = _tmp253_; } - if (_tmp252_) { + if (_tmp249_) { result = vala_compiler_quit (self); _vala_code_visitor_unref0 (gir_parser); _vala_code_visitor_unref0 (genie_parser); _vala_code_visitor_unref0 (parser); return result; } + _tmp257_ = self->priv->context; + _tmp258_ = vala_code_context_get_codegen (_tmp257_); + _tmp259_ = _tmp258_; _tmp260_ = self->priv->context; - _tmp261_ = vala_code_context_get_codegen (_tmp260_); - _tmp262_ = _tmp261_; - _tmp263_ = self->priv->context; - vala_code_generator_emit (_tmp262_, _tmp263_); - _tmp265_ = self->priv->context; - _tmp266_ = vala_code_context_get_report (_tmp265_); - _tmp267_ = _tmp266_; - if (vala_report_get_errors (_tmp267_) > 0) { - _tmp264_ = TRUE; + vala_code_generator_emit (_tmp259_, _tmp260_); + _tmp262_ = self->priv->context; + _tmp263_ = vala_code_context_get_report (_tmp262_); + _tmp264_ = _tmp263_; + if (vala_report_get_errors (_tmp264_) > 0) { + _tmp261_ = TRUE; } else { - gboolean _tmp268_ = FALSE; + gboolean _tmp265_ = FALSE; if (vala_compiler_fatal_warnings) { - ValaCodeContext* _tmp269_; - ValaReport* _tmp270_; - ValaReport* _tmp271_; - _tmp269_ = self->priv->context; - _tmp270_ = vala_code_context_get_report (_tmp269_); - _tmp271_ = _tmp270_; - _tmp268_ = vala_report_get_warnings (_tmp271_) > 0; + ValaCodeContext* _tmp266_; + ValaReport* _tmp267_; + ValaReport* _tmp268_; + _tmp266_ = self->priv->context; + _tmp267_ = vala_code_context_get_report (_tmp266_); + _tmp268_ = _tmp267_; + _tmp265_ = vala_report_get_warnings (_tmp268_) > 0; } else { - _tmp268_ = FALSE; + _tmp265_ = FALSE; } - _tmp264_ = _tmp268_; + _tmp261_ = _tmp265_; } - if (_tmp264_) { + if (_tmp261_) { result = vala_compiler_quit (self); _vala_code_visitor_unref0 (gir_parser); _vala_code_visitor_unref0 (genie_parser); _vala_code_visitor_unref0 (parser); return result; } - _tmp273_ = vala_compiler_vapi_filename; - if (_tmp273_ == NULL) { - const gchar* _tmp274_; - _tmp274_ = vala_compiler_library; - _tmp272_ = _tmp274_ != NULL; - } else { - _tmp272_ = FALSE; - } - if (_tmp272_) { - const gchar* _tmp275_; - gchar* _tmp276_; - _tmp275_ = vala_compiler_library; - _tmp276_ = g_strdup_printf ("%s.vapi", _tmp275_); + _tmp270_ = vala_compiler_vapi_filename; + if (_tmp270_ == NULL) { + const gchar* _tmp271_; + _tmp271_ = vala_compiler_library; + _tmp269_ = _tmp271_ != NULL; + } else { + _tmp269_ = FALSE; + } + if (_tmp269_) { + const gchar* _tmp272_; + gchar* _tmp273_; + _tmp272_ = vala_compiler_library; + _tmp273_ = g_strdup_printf ("%s.vapi", _tmp272_); _g_free0 (vala_compiler_vapi_filename); - vala_compiler_vapi_filename = _tmp276_; + vala_compiler_vapi_filename = _tmp273_; } - _tmp277_ = vala_compiler_library; - if (_tmp277_ != NULL) { - const gchar* _tmp278_; - _tmp278_ = vala_compiler_gir; - if (_tmp278_ != NULL) { - ValaCodeContext* _tmp279_; - ValaProfile _tmp280_; - ValaProfile _tmp281_; - _tmp279_ = self->priv->context; - _tmp280_ = vala_code_context_get_profile (_tmp279_); - _tmp281_ = _tmp280_; - if (_tmp281_ == VALA_PROFILE_GOBJECT) { + _tmp274_ = vala_compiler_library; + if (_tmp274_ != NULL) { + const gchar* _tmp275_; + _tmp275_ = vala_compiler_gir; + if (_tmp275_ != NULL) { + ValaCodeContext* _tmp276_; + ValaProfile _tmp277_; + ValaProfile _tmp278_; + _tmp276_ = self->priv->context; + _tmp277_ = vala_code_context_get_profile (_tmp276_); + _tmp278_ = _tmp277_; + if (_tmp278_ == VALA_PROFILE_GOBJECT) { gchar* gir_base = NULL; - const gchar* _tmp282_; - gchar* _tmp283_; + const gchar* _tmp279_; + gchar* _tmp280_; glong gir_len = 0L; - const gchar* _tmp284_; - gint _tmp285_; - gint _tmp286_; + const gchar* _tmp281_; + gint _tmp282_; + gint _tmp283_; gint last_hyphen = 0; - const gchar* _tmp287_; - gboolean _tmp288_ = FALSE; - _tmp282_ = vala_compiler_gir; - _tmp283_ = g_path_get_basename (_tmp282_); - gir_base = _tmp283_; + const gchar* _tmp284_; + gboolean _tmp285_ = FALSE; + _tmp279_ = vala_compiler_gir; + _tmp280_ = g_path_get_basename (_tmp279_); + gir_base = _tmp280_; + _tmp281_ = gir_base; + _tmp282_ = strlen (_tmp281_); + _tmp283_ = _tmp282_; + gir_len = (glong) _tmp283_; _tmp284_ = gir_base; - _tmp285_ = strlen (_tmp284_); - _tmp286_ = _tmp285_; - gir_len = (glong) _tmp286_; - _tmp287_ = gir_base; - last_hyphen = string_last_index_of_char (_tmp287_, (gunichar) '-', 0); + last_hyphen = string_last_index_of_char (_tmp284_, (gunichar) '-', 0); if (last_hyphen == -1) { - _tmp288_ = TRUE; + _tmp285_ = TRUE; } else { - const gchar* _tmp289_; - _tmp289_ = gir_base; - _tmp288_ = !g_str_has_suffix (_tmp289_, ".gir"); + const gchar* _tmp286_; + _tmp286_ = gir_base; + _tmp285_ = !g_str_has_suffix (_tmp286_, ".gir"); } - if (_tmp288_) { - const gchar* _tmp290_; - gchar* _tmp291_; - gchar* _tmp292_; - _tmp290_ = vala_compiler_gir; - _tmp291_ = g_strdup_printf ("GIR file name `%s' is not well-formed, expected NAME-VERSION.gir", _tmp290_); - _tmp292_ = _tmp291_; - vala_report_error (NULL, _tmp292_); - _g_free0 (_tmp292_); + if (_tmp285_) { + const gchar* _tmp287_; + gchar* _tmp288_; + gchar* _tmp289_; + _tmp287_ = vala_compiler_gir; + _tmp288_ = g_strdup_printf ("GIR file name `%s' is not well-formed, expected NAME-VERSION.gir", _tmp287_); + _tmp289_ = _tmp288_; + vala_report_error (NULL, _tmp289_); + _g_free0 (_tmp289_); } else { gchar* gir_namespace = NULL; - const gchar* _tmp293_; - gchar* _tmp294_; + const gchar* _tmp290_; + gchar* _tmp291_; gchar* gir_version = NULL; - const gchar* _tmp295_; - gchar* _tmp296_; - const gchar* _tmp297_; - gboolean _tmp298_ = FALSE; - gboolean _tmp299_ = FALSE; - gboolean _tmp300_ = FALSE; - const gchar* _tmp301_; - _tmp293_ = gir_base; - _tmp294_ = string_substring (_tmp293_, (glong) 0, (glong) last_hyphen); - gir_namespace = _tmp294_; - _tmp295_ = gir_base; - _tmp296_ = string_substring (_tmp295_, (glong) (last_hyphen + 1), (gir_len - last_hyphen) - 5); - gir_version = _tmp296_; - _tmp297_ = gir_version; - g_strcanon (_tmp297_, "0123456789.", '?'); - _tmp301_ = gir_namespace; - if (g_strcmp0 (_tmp301_, "") == 0) { - _tmp300_ = TRUE; + const gchar* _tmp292_; + gchar* _tmp293_; + const gchar* _tmp294_; + gboolean _tmp295_ = FALSE; + gboolean _tmp296_ = FALSE; + gboolean _tmp297_ = FALSE; + const gchar* _tmp298_; + _tmp290_ = gir_base; + _tmp291_ = string_substring (_tmp290_, (glong) 0, (glong) last_hyphen); + gir_namespace = _tmp291_; + _tmp292_ = gir_base; + _tmp293_ = string_substring (_tmp292_, (glong) (last_hyphen + 1), (gir_len - last_hyphen) - 5); + gir_version = _tmp293_; + _tmp294_ = gir_version; + g_strcanon (_tmp294_, "0123456789.", '?'); + _tmp298_ = gir_namespace; + if (g_strcmp0 (_tmp298_, "") == 0) { + _tmp297_ = TRUE; } else { - const gchar* _tmp302_; - _tmp302_ = gir_version; - _tmp300_ = g_strcmp0 (_tmp302_, "") == 0; + const gchar* _tmp299_; + _tmp299_ = gir_version; + _tmp297_ = g_strcmp0 (_tmp299_, "") == 0; } - if (_tmp300_) { - _tmp299_ = TRUE; + if (_tmp297_) { + _tmp296_ = TRUE; } else { - const gchar* _tmp303_; - _tmp303_ = gir_version; - _tmp299_ = !g_ascii_isdigit (string_get (_tmp303_, (glong) 0)); + const gchar* _tmp300_; + _tmp300_ = gir_version; + _tmp296_ = !g_ascii_isdigit (string_get (_tmp300_, (glong) 0)); } - if (_tmp299_) { - _tmp298_ = TRUE; + if (_tmp296_) { + _tmp295_ = TRUE; } else { - const gchar* _tmp304_; - _tmp304_ = gir_version; - _tmp298_ = string_contains (_tmp304_, "?"); + const gchar* _tmp301_; + _tmp301_ = gir_version; + _tmp295_ = string_contains (_tmp301_, "?"); } - if (_tmp298_) { - const gchar* _tmp305_; - gchar* _tmp306_; - gchar* _tmp307_; - _tmp305_ = vala_compiler_gir; - _tmp306_ = g_strdup_printf ("GIR file name `%s' is not well-formed, expected NAME-VERSION.gir", _tmp305_); - _tmp307_ = _tmp306_; - vala_report_error (NULL, _tmp307_); - _g_free0 (_tmp307_); + if (_tmp295_) { + const gchar* _tmp302_; + gchar* _tmp303_; + gchar* _tmp304_; + _tmp302_ = vala_compiler_gir; + _tmp303_ = g_strdup_printf ("GIR file name `%s' is not well-formed, expected NAME-VERSION.gir", _tmp302_); + _tmp304_ = _tmp303_; + vala_report_error (NULL, _tmp304_); + _g_free0 (_tmp304_); } else { ValaGIRWriter* gir_writer = NULL; - ValaGIRWriter* _tmp308_; + ValaGIRWriter* _tmp305_; gchar* gir_directory = NULL; - gchar* _tmp309_; - const gchar* _tmp310_; - ValaGIRWriter* _tmp315_; - ValaCodeContext* _tmp316_; + gchar* _tmp306_; + const gchar* _tmp307_; + ValaGIRWriter* _tmp312_; + ValaCodeContext* _tmp313_; + const gchar* _tmp314_; + const gchar* _tmp315_; + const gchar* _tmp316_; const gchar* _tmp317_; const gchar* _tmp318_; const gchar* _tmp319_; - const gchar* _tmp320_; - const gchar* _tmp321_; - const gchar* _tmp322_; - _tmp308_ = vala_gir_writer_new (); - gir_writer = _tmp308_; - _tmp309_ = g_strdup ("."); - gir_directory = _tmp309_; - _tmp310_ = vala_compiler_directory; - if (_tmp310_ != NULL) { - ValaCodeContext* _tmp311_; - const gchar* _tmp312_; - const gchar* _tmp313_; - gchar* _tmp314_; - _tmp311_ = self->priv->context; - _tmp312_ = vala_code_context_get_directory (_tmp311_); - _tmp313_ = _tmp312_; - _tmp314_ = g_strdup (_tmp313_); + _tmp305_ = vala_gir_writer_new (); + gir_writer = _tmp305_; + _tmp306_ = g_strdup ("."); + gir_directory = _tmp306_; + _tmp307_ = vala_compiler_directory; + if (_tmp307_ != NULL) { + ValaCodeContext* _tmp308_; + const gchar* _tmp309_; + const gchar* _tmp310_; + gchar* _tmp311_; + _tmp308_ = self->priv->context; + _tmp309_ = vala_code_context_get_directory (_tmp308_); + _tmp310_ = _tmp309_; + _tmp311_ = g_strdup (_tmp310_); _g_free0 (gir_directory); - gir_directory = _tmp314_; + gir_directory = _tmp311_; } - _tmp315_ = gir_writer; - _tmp316_ = self->priv->context; - _tmp317_ = gir_directory; - _tmp318_ = vala_compiler_gir; - _tmp319_ = gir_namespace; - _tmp320_ = gir_version; - _tmp321_ = vala_compiler_library; - _tmp322_ = vala_compiler_shared_library; - vala_gir_writer_write_file (_tmp315_, _tmp316_, _tmp317_, _tmp318_, _tmp319_, _tmp320_, _tmp321_, _tmp322_); + _tmp312_ = gir_writer; + _tmp313_ = self->priv->context; + _tmp314_ = gir_directory; + _tmp315_ = vala_compiler_gir; + _tmp316_ = gir_namespace; + _tmp317_ = gir_version; + _tmp318_ = vala_compiler_library; + _tmp319_ = vala_compiler_shared_library; + vala_gir_writer_write_file (_tmp312_, _tmp313_, _tmp314_, _tmp315_, _tmp316_, _tmp317_, _tmp318_, _tmp319_); _g_free0 (gir_directory); _vala_code_visitor_unref0 (gir_writer); } @@ -1757,79 +1751,79 @@ _g_free0 (vala_compiler_library); vala_compiler_library = NULL; } else { - const gchar* _tmp323_; - _tmp323_ = vala_compiler_gir; - if (_tmp323_ != NULL) { + const gchar* _tmp320_; + _tmp320_ = vala_compiler_gir; + if (_tmp320_ != NULL) { vala_report_warning (NULL, "--gir has no effect without --library"); _g_free0 (vala_compiler_gir); vala_compiler_gir = NULL; } } - _tmp324_ = vala_compiler_vapi_filename; - if (_tmp324_ != NULL) { + _tmp321_ = vala_compiler_vapi_filename; + if (_tmp321_ != NULL) { ValaCodeWriter* interface_writer = NULL; - ValaCodeWriter* _tmp325_; - gboolean _tmp326_ = FALSE; - const gchar* _tmp327_; - ValaCodeWriter* _tmp334_; - ValaCodeContext* _tmp335_; - const gchar* _tmp336_; - _tmp325_ = vala_code_writer_new (VALA_CODE_WRITER_TYPE_EXTERNAL); - interface_writer = _tmp325_; - _tmp327_ = vala_compiler_directory; - if (_tmp327_ != NULL) { - const gchar* _tmp328_; - _tmp328_ = vala_compiler_vapi_filename; - _tmp326_ = !g_path_is_absolute (_tmp328_); + ValaCodeWriter* _tmp322_; + gboolean _tmp323_ = FALSE; + const gchar* _tmp324_; + ValaCodeWriter* _tmp331_; + ValaCodeContext* _tmp332_; + const gchar* _tmp333_; + _tmp322_ = vala_code_writer_new (VALA_CODE_WRITER_TYPE_EXTERNAL); + interface_writer = _tmp322_; + _tmp324_ = vala_compiler_directory; + if (_tmp324_ != NULL) { + const gchar* _tmp325_; + _tmp325_ = vala_compiler_vapi_filename; + _tmp323_ = !g_path_is_absolute (_tmp325_); } else { - _tmp326_ = FALSE; + _tmp323_ = FALSE; } - if (_tmp326_) { - ValaCodeContext* _tmp329_; - const gchar* _tmp330_; - const gchar* _tmp331_; - const gchar* _tmp332_; - gchar* _tmp333_; - _tmp329_ = self->priv->context; - _tmp330_ = vala_code_context_get_directory (_tmp329_); - _tmp331_ = _tmp330_; - _tmp332_ = vala_compiler_vapi_filename; - _tmp333_ = g_strdup_printf ("%s%c%s", _tmp331_, (gint) G_DIR_SEPARATOR, _tmp332_); + if (_tmp323_) { + ValaCodeContext* _tmp326_; + const gchar* _tmp327_; + const gchar* _tmp328_; + const gchar* _tmp329_; + gchar* _tmp330_; + _tmp326_ = self->priv->context; + _tmp327_ = vala_code_context_get_directory (_tmp326_); + _tmp328_ = _tmp327_; + _tmp329_ = vala_compiler_vapi_filename; + _tmp330_ = g_strdup_printf ("%s%c%s", _tmp328_, (gint) G_DIR_SEPARATOR, _tmp329_); _g_free0 (vala_compiler_vapi_filename); - vala_compiler_vapi_filename = _tmp333_; + vala_compiler_vapi_filename = _tmp330_; } - _tmp334_ = interface_writer; - _tmp335_ = self->priv->context; - _tmp336_ = vala_compiler_vapi_filename; - vala_code_writer_write_file (_tmp334_, _tmp335_, _tmp336_); + _tmp331_ = interface_writer; + _tmp332_ = self->priv->context; + _tmp333_ = vala_compiler_vapi_filename; + vala_code_writer_write_file (_tmp331_, _tmp332_, _tmp333_); _vala_code_visitor_unref0 (interface_writer); } - _tmp337_ = vala_compiler_internal_vapi_filename; - if (_tmp337_ != NULL) { - gboolean _tmp338_ = FALSE; - const gchar* _tmp339_; + _tmp334_ = vala_compiler_internal_vapi_filename; + if (_tmp334_ != NULL) { + gboolean _tmp335_ = FALSE; + const gchar* _tmp336_; ValaCodeWriter* interface_writer = NULL; - ValaCodeWriter* _tmp341_; - ValaCodeContext* _tmp342_; - const gchar* _tmp343_; - const gchar* _tmp344_; + ValaCodeWriter* _tmp338_; + ValaCodeContext* _tmp339_; + const gchar* _tmp340_; + const gchar* _tmp341_; gchar* vapi_filename = NULL; + const gchar* _tmp364_; + gchar* _tmp365_; + gboolean _tmp366_ = FALSE; const gchar* _tmp367_; - gchar* _tmp368_; - gboolean _tmp369_ = FALSE; - const gchar* _tmp370_; - ValaCodeWriter* _tmp377_; - ValaCodeContext* _tmp378_; - const gchar* _tmp379_; - _tmp339_ = vala_compiler_internal_header_filename; - if (_tmp339_ == NULL) { - _tmp338_ = TRUE; + ValaCodeWriter* _tmp374_; + ValaCodeContext* _tmp375_; + const gchar* _tmp376_; + _tmp336_ = vala_compiler_internal_header_filename; + if (_tmp336_ == NULL) { + _tmp335_ = TRUE; } else { - const gchar* _tmp340_; - _tmp340_ = vala_compiler_header_filename; - _tmp338_ = _tmp340_ == NULL; + const gchar* _tmp337_; + _tmp337_ = vala_compiler_header_filename; + _tmp335_ = _tmp337_ == NULL; } - if (_tmp338_) { + if (_tmp335_) { vala_report_error (NULL, "--internal-vapi may only be used in combination with --header and --in" \ "ternal-header"); result = vala_compiler_quit (self); @@ -1838,139 +1832,139 @@ _vala_code_visitor_unref0 (parser); return result; } - _tmp341_ = vala_code_writer_new (VALA_CODE_WRITER_TYPE_INTERNAL); - interface_writer = _tmp341_; - _tmp342_ = self->priv->context; - _tmp343_ = vala_code_context_get_includedir (_tmp342_); - _tmp344_ = _tmp343_; - if (_tmp344_ != NULL) { + _tmp338_ = vala_code_writer_new (VALA_CODE_WRITER_TYPE_INTERNAL); + interface_writer = _tmp338_; + _tmp339_ = self->priv->context; + _tmp340_ = vala_code_context_get_includedir (_tmp339_); + _tmp341_ = _tmp340_; + if (_tmp341_ != NULL) { gchar* prefixed_header_filename = NULL; - ValaCodeContext* _tmp345_; - const gchar* _tmp346_; - const gchar* _tmp347_; - const gchar* _tmp348_; + ValaCodeContext* _tmp342_; + const gchar* _tmp343_; + const gchar* _tmp344_; + const gchar* _tmp345_; + gchar* _tmp346_; + gchar* _tmp347_; + gchar* _tmp348_; gchar* _tmp349_; - gchar* _tmp350_; - gchar* _tmp351_; - gchar* _tmp352_; gchar* prefixed_internal_header_filename = NULL; - ValaCodeContext* _tmp353_; - const gchar* _tmp354_; - const gchar* _tmp355_; - const gchar* _tmp356_; + ValaCodeContext* _tmp350_; + const gchar* _tmp351_; + const gchar* _tmp352_; + const gchar* _tmp353_; + gchar* _tmp354_; + gchar* _tmp355_; + gchar* _tmp356_; gchar* _tmp357_; - gchar* _tmp358_; - gchar* _tmp359_; - gchar* _tmp360_; - ValaCodeWriter* _tmp361_; - const gchar* _tmp362_; - const gchar* _tmp363_; - _tmp345_ = self->priv->context; - _tmp346_ = vala_code_context_get_includedir (_tmp345_); + ValaCodeWriter* _tmp358_; + const gchar* _tmp359_; + const gchar* _tmp360_; + _tmp342_ = self->priv->context; + _tmp343_ = vala_code_context_get_includedir (_tmp342_); + _tmp344_ = _tmp343_; + _tmp345_ = vala_compiler_header_filename; + _tmp346_ = g_path_get_basename (_tmp345_); _tmp347_ = _tmp346_; - _tmp348_ = vala_compiler_header_filename; - _tmp349_ = g_path_get_basename (_tmp348_); - _tmp350_ = _tmp349_; - _tmp351_ = g_build_path ("/", _tmp347_, _tmp350_, NULL); + _tmp348_ = g_build_path ("/", _tmp344_, _tmp347_, NULL); + _tmp349_ = _tmp348_; + _g_free0 (_tmp347_); + prefixed_header_filename = _tmp349_; + _tmp350_ = self->priv->context; + _tmp351_ = vala_code_context_get_includedir (_tmp350_); _tmp352_ = _tmp351_; - _g_free0 (_tmp350_); - prefixed_header_filename = _tmp352_; - _tmp353_ = self->priv->context; - _tmp354_ = vala_code_context_get_includedir (_tmp353_); + _tmp353_ = vala_compiler_internal_header_filename; + _tmp354_ = g_path_get_basename (_tmp353_); _tmp355_ = _tmp354_; - _tmp356_ = vala_compiler_internal_header_filename; - _tmp357_ = g_path_get_basename (_tmp356_); - _tmp358_ = _tmp357_; - _tmp359_ = g_build_path ("/", _tmp355_, _tmp358_, NULL); - _tmp360_ = _tmp359_; - _g_free0 (_tmp358_); - prefixed_internal_header_filename = _tmp360_; - _tmp361_ = interface_writer; - _tmp362_ = prefixed_header_filename; - _tmp363_ = prefixed_internal_header_filename; - vala_code_writer_set_cheader_override (_tmp361_, _tmp362_, _tmp363_); + _tmp356_ = g_build_path ("/", _tmp352_, _tmp355_, NULL); + _tmp357_ = _tmp356_; + _g_free0 (_tmp355_); + prefixed_internal_header_filename = _tmp357_; + _tmp358_ = interface_writer; + _tmp359_ = prefixed_header_filename; + _tmp360_ = prefixed_internal_header_filename; + vala_code_writer_set_cheader_override (_tmp358_, _tmp359_, _tmp360_); _g_free0 (prefixed_internal_header_filename); _g_free0 (prefixed_header_filename); } else { - ValaCodeWriter* _tmp364_; - const gchar* _tmp365_; - const gchar* _tmp366_; - _tmp364_ = interface_writer; - _tmp365_ = vala_compiler_header_filename; - _tmp366_ = vala_compiler_internal_header_filename; - vala_code_writer_set_cheader_override (_tmp364_, _tmp365_, _tmp366_); - } - _tmp367_ = vala_compiler_internal_vapi_filename; - _tmp368_ = g_strdup (_tmp367_); - vapi_filename = _tmp368_; - _tmp370_ = vala_compiler_directory; - if (_tmp370_ != NULL) { - const gchar* _tmp371_; - _tmp371_ = vapi_filename; - _tmp369_ = !g_path_is_absolute (_tmp371_); + ValaCodeWriter* _tmp361_; + const gchar* _tmp362_; + const gchar* _tmp363_; + _tmp361_ = interface_writer; + _tmp362_ = vala_compiler_header_filename; + _tmp363_ = vala_compiler_internal_header_filename; + vala_code_writer_set_cheader_override (_tmp361_, _tmp362_, _tmp363_); + } + _tmp364_ = vala_compiler_internal_vapi_filename; + _tmp365_ = g_strdup (_tmp364_); + vapi_filename = _tmp365_; + _tmp367_ = vala_compiler_directory; + if (_tmp367_ != NULL) { + const gchar* _tmp368_; + _tmp368_ = vapi_filename; + _tmp366_ = !g_path_is_absolute (_tmp368_); } else { - _tmp369_ = FALSE; + _tmp366_ = FALSE; } - if (_tmp369_) { - ValaCodeContext* _tmp372_; - const gchar* _tmp373_; - const gchar* _tmp374_; - const gchar* _tmp375_; - gchar* _tmp376_; - _tmp372_ = self->priv->context; - _tmp373_ = vala_code_context_get_directory (_tmp372_); - _tmp374_ = _tmp373_; - _tmp375_ = vapi_filename; - _tmp376_ = g_strdup_printf ("%s%c%s", _tmp374_, (gint) G_DIR_SEPARATOR, _tmp375_); + if (_tmp366_) { + ValaCodeContext* _tmp369_; + const gchar* _tmp370_; + const gchar* _tmp371_; + const gchar* _tmp372_; + gchar* _tmp373_; + _tmp369_ = self->priv->context; + _tmp370_ = vala_code_context_get_directory (_tmp369_); + _tmp371_ = _tmp370_; + _tmp372_ = vapi_filename; + _tmp373_ = g_strdup_printf ("%s%c%s", _tmp371_, (gint) G_DIR_SEPARATOR, _tmp372_); _g_free0 (vapi_filename); - vapi_filename = _tmp376_; + vapi_filename = _tmp373_; } - _tmp377_ = interface_writer; - _tmp378_ = self->priv->context; - _tmp379_ = vapi_filename; - vala_code_writer_write_file (_tmp377_, _tmp378_, _tmp379_); + _tmp374_ = interface_writer; + _tmp375_ = self->priv->context; + _tmp376_ = vapi_filename; + vala_code_writer_write_file (_tmp374_, _tmp375_, _tmp376_); _g_free0 (vala_compiler_internal_vapi_filename); vala_compiler_internal_vapi_filename = NULL; _g_free0 (vapi_filename); _vala_code_visitor_unref0 (interface_writer); } - _tmp380_ = vala_compiler_dependencies; + _tmp377_ = vala_compiler_dependencies; + if (_tmp377_ != NULL) { + ValaCodeContext* _tmp378_; + const gchar* _tmp379_; + _tmp378_ = self->priv->context; + _tmp379_ = vala_compiler_dependencies; + vala_code_context_write_dependencies (_tmp378_, _tmp379_); + } + _tmp380_ = vala_compiler_depfile; if (_tmp380_ != NULL) { ValaCodeContext* _tmp381_; const gchar* _tmp382_; _tmp381_ = self->priv->context; - _tmp382_ = vala_compiler_dependencies; - vala_code_context_write_dependencies (_tmp381_, _tmp382_); + _tmp382_ = vala_compiler_depfile; + vala_code_context_write_external_dependencies (_tmp381_, _tmp382_); } - _tmp383_ = vala_compiler_depfile; - if (_tmp383_ != NULL) { - ValaCodeContext* _tmp384_; - const gchar* _tmp385_; - _tmp384_ = self->priv->context; - _tmp385_ = vala_compiler_depfile; - vala_code_context_write_external_dependencies (_tmp384_, _tmp385_); - } - _tmp387_ = self->priv->context; - _tmp388_ = vala_code_context_get_report (_tmp387_); - _tmp389_ = _tmp388_; - if (vala_report_get_errors (_tmp389_) > 0) { - _tmp386_ = TRUE; + _tmp384_ = self->priv->context; + _tmp385_ = vala_code_context_get_report (_tmp384_); + _tmp386_ = _tmp385_; + if (vala_report_get_errors (_tmp386_) > 0) { + _tmp383_ = TRUE; } else { - gboolean _tmp390_ = FALSE; + gboolean _tmp387_ = FALSE; if (vala_compiler_fatal_warnings) { - ValaCodeContext* _tmp391_; - ValaReport* _tmp392_; - ValaReport* _tmp393_; - _tmp391_ = self->priv->context; - _tmp392_ = vala_code_context_get_report (_tmp391_); - _tmp393_ = _tmp392_; - _tmp390_ = vala_report_get_warnings (_tmp393_) > 0; + ValaCodeContext* _tmp388_; + ValaReport* _tmp389_; + ValaReport* _tmp390_; + _tmp388_ = self->priv->context; + _tmp389_ = vala_code_context_get_report (_tmp388_); + _tmp390_ = _tmp389_; + _tmp387_ = vala_report_get_warnings (_tmp390_) > 0; } else { - _tmp390_ = FALSE; + _tmp387_ = FALSE; } - _tmp386_ = _tmp390_; + _tmp383_ = _tmp387_; } - if (_tmp386_) { + if (_tmp383_) { result = vala_compiler_quit (self); _vala_code_visitor_unref0 (gir_parser); _vala_code_visitor_unref0 (genie_parser); @@ -1979,58 +1973,58 @@ } if (!vala_compiler_ccode_only) { ValaCCodeCompiler* ccompiler = NULL; - ValaCCodeCompiler* _tmp394_; - gboolean _tmp395_ = FALSE; - const gchar* _tmp396_; - gchar** _tmp400_; - gint _tmp400__length1; - _tmp394_ = vala_ccode_compiler_new (); - ccompiler = _tmp394_; - _tmp396_ = vala_compiler_cc_command; - if (_tmp396_ == NULL) { - const gchar* _tmp397_; - _tmp397_ = g_getenv ("CC"); - _tmp395_ = _tmp397_ != NULL; + ValaCCodeCompiler* _tmp391_; + gboolean _tmp392_ = FALSE; + const gchar* _tmp393_; + gchar** _tmp397_; + gint _tmp397__length1; + _tmp391_ = vala_ccode_compiler_new (); + ccompiler = _tmp391_; + _tmp393_ = vala_compiler_cc_command; + if (_tmp393_ == NULL) { + const gchar* _tmp394_; + _tmp394_ = g_getenv ("CC"); + _tmp392_ = _tmp394_ != NULL; } else { - _tmp395_ = FALSE; + _tmp392_ = FALSE; } - if (_tmp395_) { - const gchar* _tmp398_; - gchar* _tmp399_; - _tmp398_ = g_getenv ("CC"); - _tmp399_ = g_strdup (_tmp398_); + if (_tmp392_) { + const gchar* _tmp395_; + gchar* _tmp396_; + _tmp395_ = g_getenv ("CC"); + _tmp396_ = g_strdup (_tmp395_); _g_free0 (vala_compiler_cc_command); - vala_compiler_cc_command = _tmp399_; + vala_compiler_cc_command = _tmp396_; } - _tmp400_ = vala_compiler_cc_options; - _tmp400__length1 = _vala_array_length (vala_compiler_cc_options); - if (_tmp400_ == NULL) { - ValaCCodeCompiler* _tmp401_; - ValaCodeContext* _tmp402_; - const gchar* _tmp403_; - gchar** _tmp404_; - gchar** _tmp405_; - gint _tmp405__length1; - _tmp401_ = ccompiler; - _tmp402_ = self->priv->context; - _tmp403_ = vala_compiler_cc_command; - _tmp404_ = g_new0 (gchar*, 0 + 1); - _tmp405_ = _tmp404_; - _tmp405__length1 = 0; - vala_ccode_compiler_compile (_tmp401_, _tmp402_, _tmp403_, _tmp405_, (gint) 0); - _tmp405_ = (_vala_array_free (_tmp405_, _tmp405__length1, (GDestroyNotify) g_free), NULL); + _tmp397_ = vala_compiler_cc_options; + _tmp397__length1 = _vala_array_length (vala_compiler_cc_options); + if (_tmp397_ == NULL) { + ValaCCodeCompiler* _tmp398_; + ValaCodeContext* _tmp399_; + const gchar* _tmp400_; + gchar** _tmp401_; + gchar** _tmp402_; + gint _tmp402__length1; + _tmp398_ = ccompiler; + _tmp399_ = self->priv->context; + _tmp400_ = vala_compiler_cc_command; + _tmp401_ = g_new0 (gchar*, 0 + 1); + _tmp402_ = _tmp401_; + _tmp402__length1 = 0; + vala_ccode_compiler_compile (_tmp398_, _tmp399_, _tmp400_, _tmp402_, (gint) 0); + _tmp402_ = (_vala_array_free (_tmp402_, _tmp402__length1, (GDestroyNotify) g_free), NULL); } else { - ValaCCodeCompiler* _tmp406_; - ValaCodeContext* _tmp407_; - const gchar* _tmp408_; - gchar** _tmp409_; - gint _tmp409__length1; - _tmp406_ = ccompiler; - _tmp407_ = self->priv->context; - _tmp408_ = vala_compiler_cc_command; - _tmp409_ = vala_compiler_cc_options; - _tmp409__length1 = _vala_array_length (vala_compiler_cc_options); - vala_ccode_compiler_compile (_tmp406_, _tmp407_, _tmp408_, _tmp409_, (gint) _tmp409__length1); + ValaCCodeCompiler* _tmp403_; + ValaCodeContext* _tmp404_; + const gchar* _tmp405_; + gchar** _tmp406_; + gint _tmp406__length1; + _tmp403_ = ccompiler; + _tmp404_ = self->priv->context; + _tmp405_ = vala_compiler_cc_command; + _tmp406_ = vala_compiler_cc_options; + _tmp406__length1 = _vala_array_length (vala_compiler_cc_options); + vala_ccode_compiler_compile (_tmp403_, _tmp404_, _tmp405_, _tmp406_, (gint) _tmp406__length1); } _vala_ccode_compiler_unref0 (ccompiler); } diff -Nru vala-0.48.20/configure vala-0.48.22/configure --- vala-0.48.20/configure 2021-12-02 13:42:11.000000000 +0000 +++ vala-0.48.22/configure 2022-01-09 12:56:52.000000000 +0000 @@ -1,6 +1,6 @@ #! /bin/sh # Guess values for system-dependent variables and create Makefiles. -# Generated by GNU Autoconf 2.71 for vala 0.48.20. +# Generated by GNU Autoconf 2.71 for vala 0.48.22. # # Report bugs to . # @@ -681,8 +681,8 @@ # Identity of this package. PACKAGE_NAME='vala' PACKAGE_TARNAME='vala' -PACKAGE_VERSION='0.48.20' -PACKAGE_STRING='vala 0.48.20' +PACKAGE_VERSION='0.48.22' +PACKAGE_STRING='vala 0.48.22' PACKAGE_BUGREPORT='https://gitlab.gnome.org/GNOME/vala/issues' PACKAGE_URL='https://wiki.gnome.org/Projects/Vala' @@ -1478,7 +1478,7 @@ # Omit some internal or obsolete options to make the list less imposing. # This message is too long to be a string in the A/UX 3.1 sh. cat <<_ACEOF -\`configure' configures vala 0.48.20 to adapt to many kinds of systems. +\`configure' configures vala 0.48.22 to adapt to many kinds of systems. Usage: $0 [OPTION]... [VAR=VALUE]... @@ -1549,7 +1549,7 @@ if test -n "$ac_init_help"; then case $ac_init_help in - short | recursive ) echo "Configuration of vala 0.48.20:";; + short | recursive ) echo "Configuration of vala 0.48.22:";; esac cat <<\_ACEOF @@ -1683,7 +1683,7 @@ test -n "$ac_init_help" && exit $ac_status if $ac_init_version; then cat <<\_ACEOF -vala configure 0.48.20 +vala configure 0.48.22 generated by GNU Autoconf 2.71 Copyright (C) 2021 Free Software Foundation, Inc. @@ -1944,7 +1944,7 @@ This file contains any messages produced by compilers while running configure, to aid debugging if configure makes a mistake. -It was created by vala $as_me 0.48.20, which was +It was created by vala $as_me 0.48.22, which was generated by GNU Autoconf 2.71. Invocation command line was $ $0$ac_configure_args_raw @@ -3218,7 +3218,7 @@ # Define the identity of the package. PACKAGE='vala' - VERSION='0.48.20' + VERSION='0.48.22' printf "%s\n" "#define PACKAGE \"$PACKAGE\"" >>confdefs.h @@ -14579,7 +14579,7 @@ # report actual input values of CONFIG_FILES etc. instead of their # values after options handling. ac_log=" -This file was extended by vala $as_me 0.48.20, which was +This file was extended by vala $as_me 0.48.22, which was generated by GNU Autoconf 2.71. Invocation command line was CONFIG_FILES = $CONFIG_FILES @@ -14648,7 +14648,7 @@ cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 ac_cs_config='$ac_cs_config_escaped' ac_cs_version="\\ -vala config.status 0.48.20 +vala config.status 0.48.22 configured by $0, generated by GNU Autoconf 2.71, with options \\"\$ac_cs_config\\" diff -Nru vala-0.48.20/debian/changelog vala-0.48.22/debian/changelog --- vala-0.48.20/debian/changelog 2021-12-02 15:21:02.000000000 +0000 +++ vala-0.48.22/debian/changelog 2022-01-09 15:31:50.000000000 +0000 @@ -1,8 +1,8 @@ -vala (0.48.20-0ubuntu1~16.04~valateam0) xenial; urgency=high +vala (0.48.22-0ubuntu1~16.04~valateam0) xenial; urgency=high * New upstream release - -- Rico Tzschichholz Thu, 02 Dec 2021 16:21:02 +0100 + -- Rico Tzschichholz Sun, 09 Jan 2022 16:31:50 +0100 vala (0.48.16-1) unstable; urgency=medium diff -Nru vala-0.48.20/doc/valac.1 vala-0.48.22/doc/valac.1 --- vala-0.48.20/doc/valac.1 2021-12-02 13:12:10.000000000 +0000 +++ vala-0.48.22/doc/valac.1 2022-01-09 12:54:32.000000000 +0000 @@ -1,5 +1,5 @@ .\" DO NOT MODIFY THIS FILE! It was generated by help2man 1.48.5. -.TH VALAC "1" "December 2021" "Vala 0.48.20" "User Commands" +.TH VALAC "1" "January 2022" "Vala 0.48.22" "User Commands" .SH NAME valac \- compiler that translates Vala source code into C source and header files .SH SYNOPSIS diff -Nru vala-0.48.20/doc/valadoc.1 vala-0.48.22/doc/valadoc.1 --- vala-0.48.20/doc/valadoc.1 2021-12-02 13:12:13.000000000 +0000 +++ vala-0.48.22/doc/valadoc.1 2022-01-09 12:54:37.000000000 +0000 @@ -1,5 +1,5 @@ .\" DO NOT MODIFY THIS FILE! It was generated by help2man 1.48.5. -.TH VALADOC "1" "December 2021" "Valadoc 0.48.20" "User Commands" +.TH VALADOC "1" "January 2022" "Valadoc 0.48.22" "User Commands" .SH NAME valadoc \- Vala Documentation Tool .SH SYNOPSIS diff -Nru vala-0.48.20/doc/vala-gen-introspect.1 vala-0.48.22/doc/vala-gen-introspect.1 --- vala-0.48.20/doc/vala-gen-introspect.1 2021-12-02 13:12:16.000000000 +0000 +++ vala-0.48.22/doc/vala-gen-introspect.1 2022-01-09 12:54:41.000000000 +0000 @@ -1,5 +1,5 @@ .\" DO NOT MODIFY THIS FILE! It was generated by help2man 1.48.5. -.TH VALA-GEN-INTROSPECT "1" "December 2021" "gen-introspect 0.48.20" "User Commands" +.TH VALA-GEN-INTROSPECT "1" "January 2022" "gen-introspect 0.48.22" "User Commands" .SH NAME vala-gen-introspect \- generate a GI file for GObject and glib based packages .SH SYNOPSIS diff -Nru vala-0.48.20/doc/vapigen.1 vala-0.48.22/doc/vapigen.1 --- vala-0.48.20/doc/vapigen.1 2021-12-02 13:12:19.000000000 +0000 +++ vala-0.48.22/doc/vapigen.1 2022-01-09 12:54:44.000000000 +0000 @@ -1,5 +1,5 @@ .\" DO NOT MODIFY THIS FILE! It was generated by help2man 1.48.5. -.TH VAPIGEN "1" "December 2021" "Vala API Generator 0.48.20" "User Commands" +.TH VAPIGEN "1" "January 2022" "Vala API Generator 0.48.22" "User Commands" .SH NAME vapigen \- generate a Vala API .SH SYNOPSIS diff -Nru vala-0.48.20/libvaladoc/api/node.c vala-0.48.22/libvaladoc/api/node.c --- vala-0.48.20/libvaladoc/api/node.c 2021-12-02 13:43:08.000000000 +0000 +++ vala-0.48.22/libvaladoc/api/node.c 2022-01-09 12:57:51.000000000 +0000 @@ -591,9 +591,7 @@ ValadocApiNodeType type = 0; type = type_collection[type_it]; { - ValadocApiNodeType _tmp0_; - _tmp0_ = type; - if (valadoc_api_node_has_visible_children_by_type (self, _tmp0_, settings)) { + if (valadoc_api_node_has_visible_children_by_type (self, type, settings)) { result = TRUE; return result; } @@ -694,9 +692,7 @@ ValadocApiNodeType type = 0; type = type_collection[type_it]; { - ValadocApiNodeType _tmp0_; - _tmp0_ = type; - if (valadoc_api_node_has_children_by_type (self, _tmp0_)) { + if (valadoc_api_node_has_children_by_type (self, type)) { result = TRUE; return result; } @@ -824,15 +820,13 @@ type = type_collection[type_it]; { ValaArrayList* _tmp2_; - ValadocApiNodeType _tmp3_; + ValaList* _tmp3_; ValaList* _tmp4_; - ValaList* _tmp5_; _tmp2_ = children; - _tmp3_ = type; - _tmp4_ = valadoc_api_node_get_children_by_type (self, _tmp3_, filtered); - _tmp5_ = _tmp4_; - vala_collection_add_all ((ValaCollection*) _tmp2_, (ValaCollection*) _tmp5_); - _vala_iterable_unref0 (_tmp5_); + _tmp3_ = valadoc_api_node_get_children_by_type (self, type, filtered); + _tmp4_ = _tmp3_; + vala_collection_add_all ((ValaCollection*) _tmp2_, (ValaCollection*) _tmp4_); + _vala_iterable_unref0 (_tmp4_); } } } @@ -944,9 +938,7 @@ ValadocApiNodeType type = 0; type = type_collection[type_it]; { - ValadocApiNodeType _tmp0_; - _tmp0_ = type; - valadoc_api_node_accept_children_by_type (self, _tmp0_, visitor, filtered); + valadoc_api_node_accept_children_by_type (self, type, visitor, filtered); } } } diff -Nru vala-0.48.20/libvaladoc/api/parameter.c vala-0.48.22/libvaladoc/api/parameter.c --- vala-0.48.20/libvaladoc/api/parameter.c 2021-12-02 13:43:08.000000000 +0000 +++ vala-0.48.22/libvaladoc/api/parameter.c 2022-01-09 12:57:51.000000000 +0000 @@ -265,10 +265,8 @@ valadoc_api_parameter_get_is_out (ValadocApiParameter* self) { gboolean result; - ValaParameterDirection _tmp0_; g_return_val_if_fail (self != NULL, FALSE); - _tmp0_ = self->priv->type; - result = _tmp0_ == VALA_PARAMETER_DIRECTION_OUT; + result = self->priv->type == VALA_PARAMETER_DIRECTION_OUT; return result; } @@ -276,10 +274,8 @@ valadoc_api_parameter_get_is_ref (ValadocApiParameter* self) { gboolean result; - ValaParameterDirection _tmp0_; g_return_val_if_fail (self != NULL, FALSE); - _tmp0_ = self->priv->type; - result = _tmp0_ == VALA_PARAMETER_DIRECTION_REF; + result = self->priv->type == VALA_PARAMETER_DIRECTION_REF; return result; } diff -Nru vala-0.48.20/libvaladoc/api/propertyaccessor.c vala-0.48.22/libvaladoc/api/propertyaccessor.c --- vala-0.48.20/libvaladoc/api/propertyaccessor.c 2021-12-02 13:43:08.000000000 +0000 +++ vala-0.48.22/libvaladoc/api/propertyaccessor.c 2022-01-09 12:57:51.000000000 +0000 @@ -217,10 +217,8 @@ valadoc_api_property_accessor_get_is_owned (ValadocApiPropertyAccessor* self) { gboolean result; - ValadocApiOwnership _tmp0_; g_return_val_if_fail (self != NULL, FALSE); - _tmp0_ = self->priv->ownership; - result = _tmp0_ == VALADOC_API_OWNERSHIP_OWNED; + result = self->priv->ownership == VALADOC_API_OWNERSHIP_OWNED; return result; } diff -Nru vala-0.48.20/libvaladoc/api/signaturebuilder.c vala-0.48.22/libvaladoc/api/signaturebuilder.c --- vala-0.48.20/libvaladoc/api/signaturebuilder.c 2021-12-02 13:43:08.000000000 +0000 +++ vala-0.48.22/libvaladoc/api/signaturebuilder.c 2022-01-09 12:57:51.000000000 +0000 @@ -403,15 +403,14 @@ ValadocContentRunStyle style = 0; gboolean _tmp0_ = FALSE; ValadocContentRun* inner = NULL; - ValadocContentRunStyle _tmp3_; - ValadocContentRun* _tmp4_; + ValadocContentRun* _tmp3_; + ValaList* _tmp4_; ValaList* _tmp5_; - ValaList* _tmp6_; + const gchar* _tmp6_; const gchar* _tmp7_; - const gchar* _tmp8_; + ValadocContentSymbolLink* _tmp8_; ValadocContentSymbolLink* _tmp9_; - ValadocContentSymbolLink* _tmp10_; - ValadocApiSignatureBuilder* _tmp11_; + ValadocApiSignatureBuilder* _tmp10_; ValadocApiSignatureBuilder* result = NULL; g_return_val_if_fail (self != NULL, NULL); g_return_val_if_fail (node != NULL, NULL); @@ -428,19 +427,18 @@ if (_tmp0_) { style = VALADOC_CONTENT_RUN_STYLE_LANG_BASIC_TYPE; } - _tmp3_ = style; - _tmp4_ = valadoc_content_run_new (_tmp3_); - inner = _tmp4_; - _tmp5_ = valadoc_content_inline_content_get_content ((ValadocContentInlineContent*) inner); - _tmp6_ = _tmp5_; - _tmp7_ = valadoc_api_node_get_name (node); - _tmp8_ = _tmp7_; - _tmp9_ = valadoc_content_symbol_link_new (node, _tmp8_); - _tmp10_ = _tmp9_; - vala_collection_add ((ValaCollection*) _tmp6_, (ValadocContentInline*) _tmp10_); - _g_object_unref0 (_tmp10_); - _tmp11_ = valadoc_api_signature_builder_append_content (self, (ValadocContentInline*) inner, spaced); - result = _tmp11_; + _tmp3_ = valadoc_content_run_new (style); + inner = _tmp3_; + _tmp4_ = valadoc_content_inline_content_get_content ((ValadocContentInlineContent*) inner); + _tmp5_ = _tmp4_; + _tmp6_ = valadoc_api_node_get_name (node); + _tmp7_ = _tmp6_; + _tmp8_ = valadoc_content_symbol_link_new (node, _tmp7_); + _tmp9_ = _tmp8_; + vala_collection_add ((ValaCollection*) _tmp5_, (ValadocContentInline*) _tmp9_); + _g_object_unref0 (_tmp9_); + _tmp10_ = valadoc_api_signature_builder_append_content (self, (ValadocContentInline*) inner, spaced); + result = _tmp10_; _g_object_unref0 (inner); return result; } diff -Nru vala-0.48.20/libvaladoc/api/symbol.c vala-0.48.22/libvaladoc/api/symbol.c --- vala-0.48.20/libvaladoc/api/symbol.c 2021-12-02 13:43:08.000000000 +0000 +++ vala-0.48.22/libvaladoc/api/symbol.c 2022-01-09 12:57:51.000000000 +0000 @@ -450,10 +450,8 @@ valadoc_api_symbol_get_accessibility (ValadocApiSymbol* self) { ValaSymbolAccessibility result; - ValaSymbolAccessibility _tmp0_; g_return_val_if_fail (self != NULL, 0); - _tmp0_ = self->priv->_accessibility; - result = _tmp0_; + result = self->priv->_accessibility; return result; } diff -Nru vala-0.48.20/libvaladoc/api/typereference.c vala-0.48.22/libvaladoc/api/typereference.c --- vala-0.48.20/libvaladoc/api/typereference.c 2021-12-02 13:43:08.000000000 +0000 +++ vala-0.48.22/libvaladoc/api/typereference.c 2022-01-09 12:57:51.000000000 +0000 @@ -288,10 +288,8 @@ valadoc_api_typereference_get_is_owned (ValadocApiTypeReference* self) { gboolean result; - ValadocApiOwnership _tmp0_; g_return_val_if_fail (self != NULL, FALSE); - _tmp0_ = self->priv->ownership; - result = _tmp0_ == VALADOC_API_OWNERSHIP_OWNED; + result = self->priv->ownership == VALADOC_API_OWNERSHIP_OWNED; return result; } @@ -299,10 +297,8 @@ valadoc_api_typereference_get_is_weak (ValadocApiTypeReference* self) { gboolean result; - ValadocApiOwnership _tmp0_; g_return_val_if_fail (self != NULL, FALSE); - _tmp0_ = self->priv->ownership; - result = _tmp0_ == VALADOC_API_OWNERSHIP_WEAK; + result = self->priv->ownership == VALADOC_API_OWNERSHIP_WEAK; return result; } @@ -310,10 +306,8 @@ valadoc_api_typereference_get_is_unowned (ValadocApiTypeReference* self) { gboolean result; - ValadocApiOwnership _tmp0_; g_return_val_if_fail (self != NULL, FALSE); - _tmp0_ = self->priv->ownership; - result = _tmp0_ == VALADOC_API_OWNERSHIP_UNOWNED; + result = self->priv->ownership == VALADOC_API_OWNERSHIP_UNOWNED; return result; } diff -Nru vala-0.48.20/libvaladoc/content/embedded.c vala-0.48.22/libvaladoc/content/embedded.c --- vala-0.48.20/libvaladoc/content/embedded.c 2021-12-02 13:43:08.000000000 +0000 +++ vala-0.48.22/libvaladoc/content/embedded.c 2022-01-09 12:57:51.000000000 +0000 @@ -151,10 +151,8 @@ { ValadocContentHorizontalAlign result; ValadocContentEmbedded* self; - ValadocContentHorizontalAlign _tmp0_; self = (ValadocContentEmbedded*) base; - _tmp0_ = self->priv->_horizontal_align; - result = _tmp0_; + result = self->priv->_horizontal_align; return result; } @@ -177,10 +175,8 @@ { ValadocContentVerticalAlign result; ValadocContentEmbedded* self; - ValadocContentVerticalAlign _tmp0_; self = (ValadocContentEmbedded*) base; - _tmp0_ = self->priv->_vertical_align; - result = _tmp0_; + result = self->priv->_vertical_align; return result; } diff -Nru vala-0.48.20/libvaladoc/content/list.c vala-0.48.22/libvaladoc/content/list.c --- vala-0.48.20/libvaladoc/content/list.c 2021-12-02 13:43:08.000000000 +0000 +++ vala-0.48.22/libvaladoc/content/list.c 2022-01-09 12:57:51.000000000 +0000 @@ -299,10 +299,8 @@ valadoc_content_list_get_bullet (ValadocContentList* self) { ValadocContentListBullet result; - ValadocContentListBullet _tmp0_; g_return_val_if_fail (self != NULL, 0); - _tmp0_ = self->priv->_bullet; - result = _tmp0_; + result = self->priv->_bullet; return result; } diff -Nru vala-0.48.20/libvaladoc/content/paragraph.c vala-0.48.22/libvaladoc/content/paragraph.c --- vala-0.48.20/libvaladoc/content/paragraph.c 2021-12-02 13:43:08.000000000 +0000 +++ vala-0.48.22/libvaladoc/content/paragraph.c 2022-01-09 12:57:51.000000000 +0000 @@ -91,10 +91,8 @@ { ValadocContentHorizontalAlign result; ValadocContentParagraph* self; - ValadocContentHorizontalAlign _tmp0_; self = (ValadocContentParagraph*) base; - _tmp0_ = self->priv->_horizontal_align; - result = _tmp0_; + result = self->priv->_horizontal_align; return result; } @@ -117,10 +115,8 @@ { ValadocContentVerticalAlign result; ValadocContentParagraph* self; - ValadocContentVerticalAlign _tmp0_; self = (ValadocContentParagraph*) base; - _tmp0_ = self->priv->_vertical_align; - result = _tmp0_; + result = self->priv->_vertical_align; return result; } diff -Nru vala-0.48.20/libvaladoc/content/run.c vala-0.48.22/libvaladoc/content/run.c --- vala-0.48.20/libvaladoc/content/run.c 2021-12-02 13:43:08.000000000 +0000 +++ vala-0.48.22/libvaladoc/content/run.c 2022-01-09 12:57:51.000000000 +0000 @@ -495,10 +495,8 @@ valadoc_content_run_get_style (ValadocContentRun* self) { ValadocContentRunStyle result; - ValadocContentRunStyle _tmp0_; g_return_val_if_fail (self != NULL, 0); - _tmp0_ = self->priv->_style; - result = _tmp0_; + result = self->priv->_style; return result; } diff -Nru vala-0.48.20/libvaladoc/content/sourcecode.c vala-0.48.22/libvaladoc/content/sourcecode.c --- vala-0.48.20/libvaladoc/content/sourcecode.c 2021-12-02 13:43:08.000000000 +0000 +++ vala-0.48.22/libvaladoc/content/sourcecode.c 2022-01-09 12:57:51.000000000 +0000 @@ -406,10 +406,8 @@ valadoc_content_source_code_get_language (ValadocContentSourceCode* self) { ValadocContentSourceCodeLanguage result; - ValadocContentSourceCodeLanguage _tmp0_; g_return_val_if_fail (self != NULL, 0); - _tmp0_ = self->priv->_language; - result = _tmp0_; + result = self->priv->_language; return result; } @@ -988,10 +986,9 @@ gchar* _tmp5_; gchar* _tmp6_; gboolean _tmp7_; - const gchar* _tmp40_; + const gchar* _tmp39_; + gchar* _tmp40_; gchar* _tmp41_; - gchar* _tmp42_; - ValadocContentSourceCodeLanguage _tmp43_; self = (ValadocContentSourceCode*) base; g_return_if_fail (api_root != NULL); g_return_if_fail (container != NULL); @@ -1066,7 +1063,6 @@ gint _tmp25__length1; const gchar* _tmp26_; gboolean _tmp27_ = FALSE; - ValadocContentSourceCodeLanguage _tmp28_; _tmp20_ = start; _tmp21_ = g_strstrip (_tmp20_); _tmp22_ = g_ascii_strdown (_tmp21_, (gssize) -1); @@ -1081,125 +1077,119 @@ _tmp24_ = ""; } valadoc_content_source_code_set_code (self, _tmp24_); - _tmp28_ = self->priv->_language; - if (_tmp28_ == VALADOC_CONTENT_SOURCE_CODE_LANGUAGE_UNKNOWN) { - const gchar* _tmp29_; - _tmp29_ = name; - _tmp27_ = g_strcmp0 (_tmp29_, "none") != 0; + if (self->priv->_language == VALADOC_CONTENT_SOURCE_CODE_LANGUAGE_UNKNOWN) { + const gchar* _tmp28_; + _tmp28_ = name; + _tmp27_ = g_strcmp0 (_tmp28_, "none") != 0; } else { _tmp27_ = FALSE; } if (_tmp27_) { - gchar* _tmp30_ = NULL; + gchar* _tmp29_ = NULL; gchar* node_segment = NULL; - gchar* _tmp35_; - const gchar* _tmp36_; + gchar* _tmp34_; + const gchar* _tmp35_; + gchar* _tmp36_; gchar* _tmp37_; - gchar* _tmp38_; - const gchar* _tmp39_; + const gchar* _tmp38_; if (VALADOC_API_IS_PACKAGE (container)) { - gchar* _tmp31_; - _tmp31_ = g_strdup (""); - _g_free0 (_tmp30_); - _tmp30_ = _tmp31_; + gchar* _tmp30_; + _tmp30_ = g_strdup (""); + _g_free0 (_tmp29_); + _tmp29_ = _tmp30_; } else { + gchar* _tmp31_; gchar* _tmp32_; gchar* _tmp33_; - gchar* _tmp34_; - _tmp32_ = valadoc_api_node_get_full_name (container); - _tmp33_ = _tmp32_; - _tmp34_ = g_strconcat (_tmp33_, ": ", NULL); - _g_free0 (_tmp30_); - _tmp30_ = _tmp34_; - _g_free0 (_tmp33_); + _tmp31_ = valadoc_api_node_get_full_name (container); + _tmp32_ = _tmp31_; + _tmp33_ = g_strconcat (_tmp32_, ": ", NULL); + _g_free0 (_tmp29_); + _tmp29_ = _tmp33_; + _g_free0 (_tmp32_); } - _tmp35_ = g_strdup (_tmp30_); - node_segment = _tmp35_; - _tmp36_ = node_segment; - _tmp37_ = g_strdup_printf ("%s: %s{{{", file_path, _tmp36_); - _tmp38_ = _tmp37_; - _tmp39_ = name; - valadoc_error_reporter_simple_warning (reporter, _tmp38_, "Unsupported programming language '%s'", _tmp39_); - _g_free0 (_tmp38_); + _tmp34_ = g_strdup (_tmp29_); + node_segment = _tmp34_; + _tmp35_ = node_segment; + _tmp36_ = g_strdup_printf ("%s: %s{{{", file_path, _tmp35_); + _tmp37_ = _tmp36_; + _tmp38_ = name; + valadoc_error_reporter_simple_warning (reporter, _tmp37_, "Unsupported programming language '%s'", _tmp38_); + _g_free0 (_tmp37_); _g_free0 (node_segment); - _g_free0 (_tmp30_); + _g_free0 (_tmp29_); } _g_free0 (name); } } } - _tmp40_ = self->priv->_code; - _tmp41_ = valadoc_content_source_code_strip_code (self, _tmp40_); - _tmp42_ = _tmp41_; - valadoc_content_source_code_set_code (self, _tmp42_); - _g_free0 (_tmp42_); - _tmp43_ = self->priv->_language; - if (_tmp43_ == VALADOC_CONTENT_SOURCE_CODE_LANGUAGE_VALA) { - ValadocHighlighterHighlighter* _tmp44_; - ValadocHighlighterHighlighter* _tmp45_; - const gchar* _tmp46_; - ValadocContentRun* _tmp47_; - ValadocContentRun* _tmp48_; - _tmp44_ = valadoc_api_tree_get_highlighter (api_root); - _tmp45_ = _tmp44_; - _tmp46_ = self->priv->_code; - _tmp47_ = valadoc_highlighter_highlighter_highlight_vala (_tmp45_, _tmp46_); - _tmp48_ = _tmp47_; - valadoc_content_source_code_set_highlighted_code (self, _tmp48_); - _g_object_unref0 (_tmp48_); + _tmp39_ = self->priv->_code; + _tmp40_ = valadoc_content_source_code_strip_code (self, _tmp39_); + _tmp41_ = _tmp40_; + valadoc_content_source_code_set_code (self, _tmp41_); + _g_free0 (_tmp41_); + if (self->priv->_language == VALADOC_CONTENT_SOURCE_CODE_LANGUAGE_VALA) { + ValadocHighlighterHighlighter* _tmp42_; + ValadocHighlighterHighlighter* _tmp43_; + const gchar* _tmp44_; + ValadocContentRun* _tmp45_; + ValadocContentRun* _tmp46_; + _tmp42_ = valadoc_api_tree_get_highlighter (api_root); + _tmp43_ = _tmp42_; + _tmp44_ = self->priv->_code; + _tmp45_ = valadoc_highlighter_highlighter_highlight_vala (_tmp43_, _tmp44_); + _tmp46_ = _tmp45_; + valadoc_content_source_code_set_highlighted_code (self, _tmp46_); + _g_object_unref0 (_tmp46_); } else { - ValadocContentSourceCodeLanguage _tmp49_; - _tmp49_ = self->priv->_language; - if (_tmp49_ == VALADOC_CONTENT_SOURCE_CODE_LANGUAGE_XML) { - ValadocHighlighterHighlighter* _tmp50_; - ValadocHighlighterHighlighter* _tmp51_; - const gchar* _tmp52_; - ValadocContentRun* _tmp53_; - ValadocContentRun* _tmp54_; - _tmp50_ = valadoc_api_tree_get_highlighter (api_root); + if (self->priv->_language == VALADOC_CONTENT_SOURCE_CODE_LANGUAGE_XML) { + ValadocHighlighterHighlighter* _tmp47_; + ValadocHighlighterHighlighter* _tmp48_; + const gchar* _tmp49_; + ValadocContentRun* _tmp50_; + ValadocContentRun* _tmp51_; + _tmp47_ = valadoc_api_tree_get_highlighter (api_root); + _tmp48_ = _tmp47_; + _tmp49_ = self->priv->_code; + _tmp50_ = valadoc_highlighter_highlighter_highlight_xml (_tmp48_, _tmp49_); _tmp51_ = _tmp50_; - _tmp52_ = self->priv->_code; - _tmp53_ = valadoc_highlighter_highlighter_highlight_xml (_tmp51_, _tmp52_); - _tmp54_ = _tmp53_; - valadoc_content_source_code_set_highlighted_code (self, _tmp54_); - _g_object_unref0 (_tmp54_); + valadoc_content_source_code_set_highlighted_code (self, _tmp51_); + _g_object_unref0 (_tmp51_); } else { - ValadocContentSourceCodeLanguage _tmp55_; - _tmp55_ = self->priv->_language; - if (_tmp55_ == VALADOC_CONTENT_SOURCE_CODE_LANGUAGE_C) { - ValadocHighlighterHighlighter* _tmp56_; - ValadocHighlighterHighlighter* _tmp57_; - const gchar* _tmp58_; - ValadocContentRun* _tmp59_; - ValadocContentRun* _tmp60_; - _tmp56_ = valadoc_api_tree_get_highlighter (api_root); - _tmp57_ = _tmp56_; - _tmp58_ = self->priv->_code; - _tmp59_ = valadoc_highlighter_highlighter_highlight_c (_tmp57_, _tmp58_); - _tmp60_ = _tmp59_; - valadoc_content_source_code_set_highlighted_code (self, _tmp60_); - _g_object_unref0 (_tmp60_); + if (self->priv->_language == VALADOC_CONTENT_SOURCE_CODE_LANGUAGE_C) { + ValadocHighlighterHighlighter* _tmp52_; + ValadocHighlighterHighlighter* _tmp53_; + const gchar* _tmp54_; + ValadocContentRun* _tmp55_; + ValadocContentRun* _tmp56_; + _tmp52_ = valadoc_api_tree_get_highlighter (api_root); + _tmp53_ = _tmp52_; + _tmp54_ = self->priv->_code; + _tmp55_ = valadoc_highlighter_highlighter_highlight_c (_tmp53_, _tmp54_); + _tmp56_ = _tmp55_; + valadoc_content_source_code_set_highlighted_code (self, _tmp56_); + _g_object_unref0 (_tmp56_); } else { - ValadocContentRun* _tmp61_; - ValadocContentRun* _tmp62_; - ValadocContentRun* _tmp63_; - ValaList* _tmp64_; - ValaList* _tmp65_; - const gchar* _tmp66_; - ValadocContentText* _tmp67_; - ValadocContentText* _tmp68_; - _tmp61_ = valadoc_content_run_new (VALADOC_CONTENT_RUN_STYLE_MONOSPACED); - _tmp62_ = _tmp61_; - valadoc_content_source_code_set_highlighted_code (self, _tmp62_); - _g_object_unref0 (_tmp62_); - _tmp63_ = self->priv->_highlighted_code; - _tmp64_ = valadoc_content_inline_content_get_content ((ValadocContentInlineContent*) _tmp63_); - _tmp65_ = _tmp64_; - _tmp66_ = self->priv->_code; - _tmp67_ = valadoc_content_text_new (_tmp66_); - _tmp68_ = _tmp67_; - vala_collection_add ((ValaCollection*) _tmp65_, (ValadocContentInline*) _tmp68_); - _g_object_unref0 (_tmp68_); + ValadocContentRun* _tmp57_; + ValadocContentRun* _tmp58_; + ValadocContentRun* _tmp59_; + ValaList* _tmp60_; + ValaList* _tmp61_; + const gchar* _tmp62_; + ValadocContentText* _tmp63_; + ValadocContentText* _tmp64_; + _tmp57_ = valadoc_content_run_new (VALADOC_CONTENT_RUN_STYLE_MONOSPACED); + _tmp58_ = _tmp57_; + valadoc_content_source_code_set_highlighted_code (self, _tmp58_); + _g_object_unref0 (_tmp58_); + _tmp59_ = self->priv->_highlighted_code; + _tmp60_ = valadoc_content_inline_content_get_content ((ValadocContentInlineContent*) _tmp59_); + _tmp61_ = _tmp60_; + _tmp62_ = self->priv->_code; + _tmp63_ = valadoc_content_text_new (_tmp62_); + _tmp64_ = _tmp63_; + vala_collection_add ((ValaCollection*) _tmp61_, (ValadocContentInline*) _tmp64_); + _g_object_unref0 (_tmp64_); } } } diff -Nru vala-0.48.20/libvaladoc/content/tablecell.c vala-0.48.22/libvaladoc/content/tablecell.c --- vala-0.48.20/libvaladoc/content/tablecell.c 2021-12-02 13:43:09.000000000 +0000 +++ vala-0.48.22/libvaladoc/content/tablecell.c 2022-01-09 12:57:51.000000000 +0000 @@ -95,10 +95,8 @@ { ValadocContentHorizontalAlign result; ValadocContentTableCell* self; - ValadocContentHorizontalAlign _tmp0_; self = (ValadocContentTableCell*) base; - _tmp0_ = self->priv->_horizontal_align; - result = _tmp0_; + result = self->priv->_horizontal_align; return result; } @@ -121,10 +119,8 @@ { ValadocContentVerticalAlign result; ValadocContentTableCell* self; - ValadocContentVerticalAlign _tmp0_; self = (ValadocContentTableCell*) base; - _tmp0_ = self->priv->_vertical_align; - result = _tmp0_; + result = self->priv->_vertical_align; return result; } diff -Nru vala-0.48.20/libvaladoc/documentation/gtkdoccommentparser.c vala-0.48.22/libvaladoc/documentation/gtkdoccommentparser.c --- vala-0.48.20/libvaladoc/documentation/gtkdoccommentparser.c 2021-12-02 13:43:08.000000000 +0000 +++ vala-0.48.22/libvaladoc/documentation/gtkdoccommentparser.c 2022-01-09 12:57:51.000000000 +0000 @@ -1014,13 +1014,12 @@ ValadocContentContentFactory* _tmp7_; ValadocContentParagraph* _tmp8_; ValadocGtkdocToken* _tmp9_; - ValadocGtkdocTokenType _tmp10_; - ValadocContentBlockContent* _tmp16_; + ValadocContentBlockContent* _tmp15_; + ValaList* _tmp16_; ValaList* _tmp17_; - ValaList* _tmp18_; - ValadocContentParagraph* _tmp19_; - ValadocContentBlockContent* _tmp20_; - ValadocContentTaglet* _tmp21_; + ValadocContentParagraph* _tmp18_; + ValadocContentBlockContent* _tmp19_; + ValadocContentTaglet* _tmp20_; ValadocContentTaglet* result = NULL; g_return_val_if_fail (self != NULL, NULL); g_return_val_if_fail (gir_comment != NULL, NULL); @@ -1048,30 +1047,29 @@ _tmp8_ = valadoc_content_content_factory_create_paragraph (_tmp7_); paragraph = _tmp8_; _tmp9_ = self->priv->current; - _tmp10_ = _tmp9_->type; - if (_tmp10_ == VALADOC_GTKDOC_TOKEN_TYPE_EOF) { - ValadocContentParagraph* _tmp11_; + if (_tmp9_->type == VALADOC_GTKDOC_TOKEN_TYPE_EOF) { + ValadocContentParagraph* _tmp10_; + ValaList* _tmp11_; ValaList* _tmp12_; - ValaList* _tmp13_; - ValadocContentRun* _tmp14_; - _tmp11_ = paragraph; - _tmp12_ = valadoc_content_inline_content_get_content ((ValadocContentInlineContent*) _tmp11_); - _tmp13_ = _tmp12_; - _tmp14_ = ic; - vala_collection_add ((ValaCollection*) _tmp13_, (ValadocContentInline*) _tmp14_); + ValadocContentRun* _tmp13_; + _tmp10_ = paragraph; + _tmp11_ = valadoc_content_inline_content_get_content ((ValadocContentInlineContent*) _tmp10_); + _tmp12_ = _tmp11_; + _tmp13_ = ic; + vala_collection_add ((ValaCollection*) _tmp12_, (ValadocContentInline*) _tmp13_); } else { - ValadocGtkdocToken* _tmp15_; - _tmp15_ = self->priv->current; - valadoc_gtkdoc_parser_report_unexpected_token (self, _tmp15_, ""); + ValadocGtkdocToken* _tmp14_; + _tmp14_ = self->priv->current; + valadoc_gtkdoc_parser_report_unexpected_token (self, _tmp14_, ""); } - _tmp16_ = taglet; - _tmp17_ = valadoc_content_block_content_get_content (_tmp16_); - _tmp18_ = _tmp17_; - _tmp19_ = paragraph; - vala_collection_add ((ValaCollection*) _tmp18_, (ValadocContentBlock*) _tmp19_); - _tmp20_ = taglet; - _tmp21_ = _g_object_ref0 (VALADOC_CONTENT_IS_TAGLET (_tmp20_) ? ((ValadocContentTaglet*) _tmp20_) : NULL); - result = _tmp21_; + _tmp15_ = taglet; + _tmp16_ = valadoc_content_block_content_get_content (_tmp15_); + _tmp17_ = _tmp16_; + _tmp18_ = paragraph; + vala_collection_add ((ValaCollection*) _tmp17_, (ValadocContentBlock*) _tmp18_); + _tmp19_ = taglet; + _tmp20_ = _g_object_ref0 (VALADOC_CONTENT_IS_TAGLET (_tmp19_) ? ((ValadocContentTaglet*) _tmp19_) : NULL); + result = _tmp20_; _g_object_unref0 (paragraph); _g_object_unref0 (taglet); _g_object_unref0 (ic); @@ -1094,10 +1092,9 @@ ValadocContentComment* comment = NULL; ValadocContentContentFactory* _tmp2_; ValadocContentComment* _tmp3_; - ValadocGtkdocToken* _tmp39_; - ValadocGtkdocTokenType _tmp40_; - ValadocContentComment* _tmp42_; - ValadocContentContentFactory* _tmp43_; + ValadocGtkdocToken* _tmp38_; + ValadocContentComment* _tmp40_; + ValadocContentContentFactory* _tmp41_; ValadocContentComment* result = NULL; g_return_val_if_fail (self != NULL, NULL); g_return_val_if_fail (gir_comment != NULL, NULL); @@ -1115,122 +1112,119 @@ while (TRUE) { gboolean _tmp4_ = FALSE; ValadocGtkdocToken* _tmp5_; - ValadocGtkdocTokenType _tmp6_; + ValadocGtkdocToken* _tmp8_; ValadocGtkdocToken* _tmp9_; - ValadocGtkdocToken* _tmp10_; ValadocContentRun* ic = NULL; - ValadocContentRun* _tmp11_; - gboolean _tmp12_ = FALSE; - ValadocContentRun* _tmp13_; + ValadocContentRun* _tmp10_; + gboolean _tmp11_ = FALSE; + ValadocContentRun* _tmp12_; ValaCollection* bc = NULL; - ValaCollection* _tmp29_; - gboolean _tmp30_ = FALSE; - ValaCollection* _tmp31_; + ValaCollection* _tmp28_; + gboolean _tmp29_ = FALSE; + ValaCollection* _tmp30_; _tmp5_ = self->priv->current; - _tmp6_ = _tmp5_->type; - if (_tmp6_ != VALADOC_GTKDOC_TOKEN_TYPE_EOF) { + if (_tmp5_->type != VALADOC_GTKDOC_TOKEN_TYPE_EOF) { + ValadocGtkdocToken* _tmp6_; ValadocGtkdocToken* _tmp7_; - ValadocGtkdocToken* _tmp8_; - _tmp7_ = tmp; - _tmp8_ = self->priv->current; - _tmp4_ = _tmp7_ != _tmp8_; + _tmp6_ = tmp; + _tmp7_ = self->priv->current; + _tmp4_ = _tmp6_ != _tmp7_; } else { _tmp4_ = FALSE; } if (!_tmp4_) { break; } - _tmp9_ = self->priv->current; - _tmp10_ = _valadoc_gtkdoc_token_ref0 (_tmp9_); + _tmp8_ = self->priv->current; + _tmp9_ = _valadoc_gtkdoc_token_ref0 (_tmp8_); _valadoc_gtkdoc_token_unref0 (tmp); - tmp = _tmp10_; - _tmp11_ = valadoc_gtkdoc_parser_parse_inline_content (self); - ic = _tmp11_; - _tmp13_ = ic; - if (_tmp13_ != NULL) { - ValadocContentRun* _tmp14_; + tmp = _tmp9_; + _tmp10_ = valadoc_gtkdoc_parser_parse_inline_content (self); + ic = _tmp10_; + _tmp12_ = ic; + if (_tmp12_ != NULL) { + ValadocContentRun* _tmp13_; + ValaList* _tmp14_; ValaList* _tmp15_; - ValaList* _tmp16_; + gint _tmp16_; gint _tmp17_; - gint _tmp18_; - _tmp14_ = ic; - _tmp15_ = valadoc_content_inline_content_get_content ((ValadocContentInlineContent*) _tmp14_); - _tmp16_ = _tmp15_; - _tmp17_ = vala_collection_get_size ((ValaCollection*) _tmp16_); - _tmp18_ = _tmp17_; - _tmp12_ = _tmp18_ > 0; + _tmp13_ = ic; + _tmp14_ = valadoc_content_inline_content_get_content ((ValadocContentInlineContent*) _tmp13_); + _tmp15_ = _tmp14_; + _tmp16_ = vala_collection_get_size ((ValaCollection*) _tmp15_); + _tmp17_ = _tmp16_; + _tmp11_ = _tmp17_ > 0; } else { - _tmp12_ = FALSE; + _tmp11_ = FALSE; } - if (_tmp12_) { + if (_tmp11_) { ValadocContentParagraph* p = NULL; - ValadocContentContentFactory* _tmp19_; + ValadocContentContentFactory* _tmp18_; + ValadocContentParagraph* _tmp19_; ValadocContentParagraph* _tmp20_; - ValadocContentParagraph* _tmp21_; + ValaList* _tmp21_; ValaList* _tmp22_; - ValaList* _tmp23_; - ValadocContentRun* _tmp24_; - ValadocContentComment* _tmp25_; + ValadocContentRun* _tmp23_; + ValadocContentComment* _tmp24_; + ValaList* _tmp25_; ValaList* _tmp26_; - ValaList* _tmp27_; - ValadocContentParagraph* _tmp28_; - _tmp19_ = self->priv->factory; - _tmp20_ = valadoc_content_content_factory_create_paragraph (_tmp19_); - p = _tmp20_; - _tmp21_ = p; - _tmp22_ = valadoc_content_inline_content_get_content ((ValadocContentInlineContent*) _tmp21_); - _tmp23_ = _tmp22_; - _tmp24_ = ic; - vala_collection_add ((ValaCollection*) _tmp23_, (ValadocContentInline*) _tmp24_); - _tmp25_ = comment; - _tmp26_ = valadoc_content_block_content_get_content ((ValadocContentBlockContent*) _tmp25_); - _tmp27_ = _tmp26_; - _tmp28_ = p; - vala_collection_add ((ValaCollection*) _tmp27_, (ValadocContentBlock*) _tmp28_); + ValadocContentParagraph* _tmp27_; + _tmp18_ = self->priv->factory; + _tmp19_ = valadoc_content_content_factory_create_paragraph (_tmp18_); + p = _tmp19_; + _tmp20_ = p; + _tmp21_ = valadoc_content_inline_content_get_content ((ValadocContentInlineContent*) _tmp20_); + _tmp22_ = _tmp21_; + _tmp23_ = ic; + vala_collection_add ((ValaCollection*) _tmp22_, (ValadocContentInline*) _tmp23_); + _tmp24_ = comment; + _tmp25_ = valadoc_content_block_content_get_content ((ValadocContentBlockContent*) _tmp24_); + _tmp26_ = _tmp25_; + _tmp27_ = p; + vala_collection_add ((ValaCollection*) _tmp26_, (ValadocContentBlock*) _tmp27_); _g_object_unref0 (p); } - _tmp29_ = valadoc_gtkdoc_parser_parse_block_content (self); - bc = _tmp29_; - _tmp31_ = bc; - if (_tmp31_ != NULL) { - ValaCollection* _tmp32_; + _tmp28_ = valadoc_gtkdoc_parser_parse_block_content (self); + bc = _tmp28_; + _tmp30_ = bc; + if (_tmp30_ != NULL) { + ValaCollection* _tmp31_; + gint _tmp32_; gint _tmp33_; - gint _tmp34_; - _tmp32_ = bc; - _tmp33_ = vala_collection_get_size (_tmp32_); - _tmp34_ = _tmp33_; - _tmp30_ = _tmp34_ > 0; + _tmp31_ = bc; + _tmp32_ = vala_collection_get_size (_tmp31_); + _tmp33_ = _tmp32_; + _tmp29_ = _tmp33_ > 0; } else { - _tmp30_ = FALSE; + _tmp29_ = FALSE; } - if (_tmp30_) { - ValadocContentComment* _tmp35_; + if (_tmp29_) { + ValadocContentComment* _tmp34_; + ValaList* _tmp35_; ValaList* _tmp36_; - ValaList* _tmp37_; - ValaCollection* _tmp38_; - _tmp35_ = comment; - _tmp36_ = valadoc_content_block_content_get_content ((ValadocContentBlockContent*) _tmp35_); - _tmp37_ = _tmp36_; - _tmp38_ = bc; - vala_collection_add_all ((ValaCollection*) _tmp37_, _tmp38_); + ValaCollection* _tmp37_; + _tmp34_ = comment; + _tmp35_ = valadoc_content_block_content_get_content ((ValadocContentBlockContent*) _tmp34_); + _tmp36_ = _tmp35_; + _tmp37_ = bc; + vala_collection_add_all ((ValaCollection*) _tmp36_, _tmp37_); } _vala_iterable_unref0 (bc); _g_object_unref0 (ic); } - _tmp39_ = self->priv->current; - _tmp40_ = _tmp39_->type; - if (_tmp40_ != VALADOC_GTKDOC_TOKEN_TYPE_EOF) { - ValadocGtkdocToken* _tmp41_; - _tmp41_ = self->priv->current; - valadoc_gtkdoc_parser_report_unexpected_token (self, _tmp41_, ""); + _tmp38_ = self->priv->current; + if (_tmp38_->type != VALADOC_GTKDOC_TOKEN_TYPE_EOF) { + ValadocGtkdocToken* _tmp39_; + _tmp39_ = self->priv->current; + valadoc_gtkdoc_parser_report_unexpected_token (self, _tmp39_, ""); result = NULL; _g_object_unref0 (comment); _valadoc_gtkdoc_token_unref0 (tmp); return result; } - _tmp42_ = comment; - _tmp43_ = self->priv->factory; - valadoc_importer_helper_extract_short_desc (_tmp42_, _tmp43_); + _tmp40_ = comment; + _tmp41_ = self->priv->factory; + valadoc_importer_helper_extract_short_desc (_tmp40_, _tmp41_); result = comment; _valadoc_gtkdoc_token_unref0 (tmp); return result; @@ -1259,28 +1253,26 @@ valadoc_gtkdoc_parser_ignore_current_xml_close (ValadocGtkdocParser* self) { ValadocGtkdocToken* _tmp0_; - ValadocGtkdocTokenType _tmp1_; gchar* name = NULL; - ValadocGtkdocToken* _tmp2_; - const gchar* _tmp3_; - gchar* _tmp4_; - ValaList* _tmp5_; - const gchar* _tmp6_; + ValadocGtkdocToken* _tmp1_; + const gchar* _tmp2_; + gchar* _tmp3_; + ValaList* _tmp4_; + const gchar* _tmp5_; gboolean result = FALSE; g_return_val_if_fail (self != NULL, FALSE); _tmp0_ = self->priv->current; - _tmp1_ = _tmp0_->type; - if (_tmp1_ != VALADOC_GTKDOC_TOKEN_TYPE_XML_CLOSE) { + if (_tmp0_->type != VALADOC_GTKDOC_TOKEN_TYPE_XML_CLOSE) { result = FALSE; return result; } - _tmp2_ = self->priv->current; - _tmp3_ = _tmp2_->content; - _tmp4_ = g_strdup (_tmp3_); - name = _tmp4_; - _tmp5_ = self->priv->stack; - _tmp6_ = name; - if (vala_collection_contains ((ValaCollection*) _tmp5_, _tmp6_) == FALSE) { + _tmp1_ = self->priv->current; + _tmp2_ = _tmp1_->content; + _tmp3_ = g_strdup (_tmp2_); + name = _tmp3_; + _tmp4_ = self->priv->stack; + _tmp5_ = name; + if (vala_collection_contains ((ValaCollection*) _tmp4_, _tmp5_) == FALSE) { result = TRUE; _g_free0 (name); return result; @@ -1297,37 +1289,33 @@ gboolean _tmp0_ = FALSE; gboolean _tmp1_ = FALSE; ValadocGtkdocToken* _tmp2_; - ValadocGtkdocTokenType _tmp3_; - ValaList* _tmp8_; + ValaList* _tmp6_; gboolean result = FALSE; g_return_val_if_fail (self != NULL, FALSE); g_return_val_if_fail (tagname != NULL, FALSE); _tmp2_ = self->priv->current; - _tmp3_ = _tmp2_->type; - if (_tmp3_ == VALADOC_GTKDOC_TOKEN_TYPE_XML_OPEN) { - ValadocGtkdocToken* _tmp4_; - const gchar* _tmp5_; - _tmp4_ = self->priv->current; - _tmp5_ = _tmp4_->content; - _tmp1_ = g_strcmp0 (_tmp5_, tagname) != 0; + if (_tmp2_->type == VALADOC_GTKDOC_TOKEN_TYPE_XML_OPEN) { + ValadocGtkdocToken* _tmp3_; + const gchar* _tmp4_; + _tmp3_ = self->priv->current; + _tmp4_ = _tmp3_->content; + _tmp1_ = g_strcmp0 (_tmp4_, tagname) != 0; } else { _tmp1_ = FALSE; } if (_tmp1_) { _tmp0_ = TRUE; } else { - ValadocGtkdocToken* _tmp6_; - ValadocGtkdocTokenType _tmp7_; - _tmp6_ = self->priv->current; - _tmp7_ = _tmp6_->type; - _tmp0_ = _tmp7_ != VALADOC_GTKDOC_TOKEN_TYPE_XML_OPEN; + ValadocGtkdocToken* _tmp5_; + _tmp5_ = self->priv->current; + _tmp0_ = _tmp5_->type != VALADOC_GTKDOC_TOKEN_TYPE_XML_OPEN; } if (_tmp0_) { result = FALSE; return result; } - _tmp8_ = self->priv->stack; - vala_list_insert (_tmp8_, 0, tagname); + _tmp6_ = self->priv->stack; + vala_list_insert (_tmp6_, 0, tagname); result = TRUE; return result; } @@ -1339,42 +1327,38 @@ gboolean _tmp0_ = FALSE; gboolean _tmp1_ = FALSE; ValadocGtkdocToken* _tmp2_; - ValadocGtkdocTokenType _tmp3_; - ValaList* _tmp8_; - gpointer _tmp9_; - gchar* _tmp10_; + ValaList* _tmp6_; + gpointer _tmp7_; + gchar* _tmp8_; gboolean result = FALSE; g_return_val_if_fail (self != NULL, FALSE); g_return_val_if_fail (tagname != NULL, FALSE); _tmp2_ = self->priv->current; - _tmp3_ = _tmp2_->type; - if (_tmp3_ == VALADOC_GTKDOC_TOKEN_TYPE_XML_CLOSE) { - ValadocGtkdocToken* _tmp4_; - const gchar* _tmp5_; - _tmp4_ = self->priv->current; - _tmp5_ = _tmp4_->content; - _tmp1_ = g_strcmp0 (_tmp5_, tagname) != 0; + if (_tmp2_->type == VALADOC_GTKDOC_TOKEN_TYPE_XML_CLOSE) { + ValadocGtkdocToken* _tmp3_; + const gchar* _tmp4_; + _tmp3_ = self->priv->current; + _tmp4_ = _tmp3_->content; + _tmp1_ = g_strcmp0 (_tmp4_, tagname) != 0; } else { _tmp1_ = FALSE; } if (_tmp1_) { _tmp0_ = TRUE; } else { - ValadocGtkdocToken* _tmp6_; - ValadocGtkdocTokenType _tmp7_; - _tmp6_ = self->priv->current; - _tmp7_ = _tmp6_->type; - _tmp0_ = _tmp7_ != VALADOC_GTKDOC_TOKEN_TYPE_XML_CLOSE; + ValadocGtkdocToken* _tmp5_; + _tmp5_ = self->priv->current; + _tmp0_ = _tmp5_->type != VALADOC_GTKDOC_TOKEN_TYPE_XML_CLOSE; } if (_tmp0_) { result = FALSE; return result; } - _tmp8_ = self->priv->stack; - _tmp9_ = vala_list_remove_at (_tmp8_, 0); - _tmp10_ = (gchar*) _tmp9_; - _vala_assert (g_strcmp0 (_tmp10_, tagname) == 0, "stack.remove_at (0) == tagname"); - _g_free0 (_tmp10_); + _tmp6_ = self->priv->stack; + _tmp7_ = vala_list_remove_at (_tmp6_, 0); + _tmp8_ = (gchar*) _tmp7_; + _vala_assert (g_strcmp0 (_tmp8_, tagname) == 0, "stack.remove_at (0) == tagname"); + _g_free0 (_tmp8_); result = TRUE; return result; } @@ -1386,43 +1370,37 @@ g_return_if_fail (self != NULL); while (TRUE) { ValadocGtkdocToken* _tmp0_; - ValadocGtkdocTokenType _tmp1_; _tmp0_ = self->priv->current; - _tmp1_ = _tmp0_->type; - if (_tmp1_ == VALADOC_GTKDOC_TOKEN_TYPE_SPACE) { + if (_tmp0_->type == VALADOC_GTKDOC_TOKEN_TYPE_SPACE) { + ValadocGtkdocToken* _tmp1_; ValadocGtkdocToken* _tmp2_; - ValadocGtkdocToken* _tmp3_; - _tmp2_ = valadoc_gtkdoc_parser_next (self); - _tmp3_ = _tmp2_; - _valadoc_gtkdoc_token_unref0 (_tmp3_); + _tmp1_ = valadoc_gtkdoc_parser_next (self); + _tmp2_ = _tmp1_; + _valadoc_gtkdoc_token_unref0 (_tmp2_); } else { - ValadocGtkdocToken* _tmp4_; - ValadocGtkdocTokenType _tmp5_; - _tmp4_ = self->priv->current; - _tmp5_ = _tmp4_->type; - if (_tmp5_ == VALADOC_GTKDOC_TOKEN_TYPE_NEWLINE) { - ValadocGtkdocToken* _tmp6_; - ValadocGtkdocToken* _tmp7_; - _tmp6_ = valadoc_gtkdoc_parser_next (self); - _tmp7_ = _tmp6_; - _valadoc_gtkdoc_token_unref0 (_tmp7_); + ValadocGtkdocToken* _tmp3_; + _tmp3_ = self->priv->current; + if (_tmp3_->type == VALADOC_GTKDOC_TOKEN_TYPE_NEWLINE) { + ValadocGtkdocToken* _tmp4_; + ValadocGtkdocToken* _tmp5_; + _tmp4_ = valadoc_gtkdoc_parser_next (self); + _tmp5_ = _tmp4_; + _valadoc_gtkdoc_token_unref0 (_tmp5_); } else { - gboolean _tmp8_ = FALSE; + gboolean _tmp6_ = FALSE; if (accept_paragraphs) { - ValadocGtkdocToken* _tmp9_; - ValadocGtkdocTokenType _tmp10_; - _tmp9_ = self->priv->current; - _tmp10_ = _tmp9_->type; - _tmp8_ = _tmp10_ == VALADOC_GTKDOC_TOKEN_TYPE_GTKDOC_PARAGRAPH; + ValadocGtkdocToken* _tmp7_; + _tmp7_ = self->priv->current; + _tmp6_ = _tmp7_->type == VALADOC_GTKDOC_TOKEN_TYPE_GTKDOC_PARAGRAPH; } else { - _tmp8_ = FALSE; + _tmp6_ = FALSE; } - if (_tmp8_) { - ValadocGtkdocToken* _tmp11_; - ValadocGtkdocToken* _tmp12_; - _tmp11_ = valadoc_gtkdoc_parser_next (self); - _tmp12_ = _tmp11_; - _valadoc_gtkdoc_token_unref0 (_tmp12_); + if (_tmp6_) { + ValadocGtkdocToken* _tmp8_; + ValadocGtkdocToken* _tmp9_; + _tmp8_ = valadoc_gtkdoc_parser_next (self); + _tmp9_ = _tmp8_; + _valadoc_gtkdoc_token_unref0 (_tmp9_); } else { break; } @@ -1442,13 +1420,13 @@ ValadocGtkdocToken* _tmp10_; ValadocGtkdocToken* _tmp11_; ValadocContentLink* link = NULL; - ValadocContentContentFactory* _tmp31_; - ValadocContentLink* _tmp32_; - ValadocContentLink* _tmp35_; - const gchar* _tmp36_; - GString* _tmp37_; - ValadocGtkdocToken* _tmp58_; - ValadocGtkdocToken* _tmp59_; + ValadocContentContentFactory* _tmp26_; + ValadocContentLink* _tmp27_; + ValadocContentLink* _tmp30_; + const gchar* _tmp31_; + GString* _tmp32_; + ValadocGtkdocToken* _tmp53_; + ValadocGtkdocToken* _tmp54_; ValadocContentInline* result = NULL; g_return_val_if_fail (self != NULL, NULL); g_return_val_if_fail (tagname != NULL, NULL); @@ -1492,137 +1470,127 @@ gboolean _tmp12_ = FALSE; gboolean _tmp13_ = FALSE; ValadocGtkdocToken* _tmp14_; - ValadocGtkdocTokenType _tmp15_; - ValadocGtkdocToken* _tmp20_; - ValadocGtkdocTokenType _tmp21_; - ValadocGtkdocToken* _tmp29_; - ValadocGtkdocToken* _tmp30_; + ValadocGtkdocToken* _tmp18_; + ValadocGtkdocToken* _tmp24_; + ValadocGtkdocToken* _tmp25_; _tmp14_ = self->priv->current; - _tmp15_ = _tmp14_->type; - if (_tmp15_ == VALADOC_GTKDOC_TOKEN_TYPE_XML_CLOSE) { - ValadocGtkdocToken* _tmp16_; - const gchar* _tmp17_; - _tmp16_ = self->priv->current; - _tmp17_ = _tmp16_->content; - _tmp13_ = g_strcmp0 (_tmp17_, tagname) == 0; + if (_tmp14_->type == VALADOC_GTKDOC_TOKEN_TYPE_XML_CLOSE) { + ValadocGtkdocToken* _tmp15_; + const gchar* _tmp16_; + _tmp15_ = self->priv->current; + _tmp16_ = _tmp15_->content; + _tmp13_ = g_strcmp0 (_tmp16_, tagname) == 0; } else { _tmp13_ = FALSE; } if (!_tmp13_) { - ValadocGtkdocToken* _tmp18_; - ValadocGtkdocTokenType _tmp19_; - _tmp18_ = self->priv->current; - _tmp19_ = _tmp18_->type; - _tmp12_ = _tmp19_ != VALADOC_GTKDOC_TOKEN_TYPE_EOF; + ValadocGtkdocToken* _tmp17_; + _tmp17_ = self->priv->current; + _tmp12_ = _tmp17_->type != VALADOC_GTKDOC_TOKEN_TYPE_EOF; } else { _tmp12_ = FALSE; } if (!_tmp12_) { break; } - _tmp20_ = self->priv->current; - _tmp21_ = _tmp20_->type; - if (_tmp21_ == VALADOC_GTKDOC_TOKEN_TYPE_XML_OPEN) { + _tmp18_ = self->priv->current; + if (_tmp18_->type == VALADOC_GTKDOC_TOKEN_TYPE_XML_OPEN) { } else { - ValadocGtkdocToken* _tmp22_; - ValadocGtkdocTokenType _tmp23_; - _tmp22_ = self->priv->current; - _tmp23_ = _tmp22_->type; - if (_tmp23_ == VALADOC_GTKDOC_TOKEN_TYPE_XML_CLOSE) { + ValadocGtkdocToken* _tmp19_; + _tmp19_ = self->priv->current; + if (_tmp19_->type == VALADOC_GTKDOC_TOKEN_TYPE_XML_CLOSE) { } else { - ValadocGtkdocToken* _tmp24_; - ValadocGtkdocTokenType _tmp25_; - _tmp24_ = self->priv->current; - _tmp25_ = _tmp24_->type; - if (_tmp25_ == VALADOC_GTKDOC_TOKEN_TYPE_XML_COMMENT) { + ValadocGtkdocToken* _tmp20_; + _tmp20_ = self->priv->current; + if (_tmp20_->type == VALADOC_GTKDOC_TOKEN_TYPE_XML_COMMENT) { } else { - GString* _tmp26_; - ValadocGtkdocToken* _tmp27_; - const gchar* _tmp28_; - _tmp26_ = builder; - _tmp27_ = self->priv->current; - _tmp28_ = _tmp27_->content; - g_string_append (_tmp26_, _tmp28_); + GString* _tmp21_; + ValadocGtkdocToken* _tmp22_; + const gchar* _tmp23_; + _tmp21_ = builder; + _tmp22_ = self->priv->current; + _tmp23_ = _tmp22_->content; + g_string_append (_tmp21_, _tmp23_); } } } - _tmp29_ = valadoc_gtkdoc_parser_next (self); - _tmp30_ = _tmp29_; - _valadoc_gtkdoc_token_unref0 (_tmp30_); - } - _tmp31_ = self->priv->factory; - _tmp32_ = valadoc_content_content_factory_create_link (_tmp31_); - link = _tmp32_; + _tmp24_ = valadoc_gtkdoc_parser_next (self); + _tmp25_ = _tmp24_; + _valadoc_gtkdoc_token_unref0 (_tmp25_); + } + _tmp26_ = self->priv->factory; + _tmp27_ = valadoc_content_content_factory_create_link (_tmp26_); + link = _tmp27_; if (is_internal) { + ValadocContentLink* _tmp28_; + ValadocImporterInternalIdRegistrar* _tmp29_; + _tmp28_ = link; + _tmp29_ = self->priv->id_registrar; + valadoc_content_link_set_id_registrar (_tmp28_, _tmp29_); + } + _tmp30_ = link; + _tmp31_ = url; + valadoc_content_link_set_url (_tmp30_, _tmp31_); + _tmp32_ = builder; + if (_tmp32_->len == ((gssize) 0)) { ValadocContentLink* _tmp33_; - ValadocImporterInternalIdRegistrar* _tmp34_; + ValaList* _tmp34_; + ValaList* _tmp35_; + ValadocContentContentFactory* _tmp36_; + const gchar* _tmp37_; + ValadocContentText* _tmp38_; + ValadocContentText* _tmp39_; _tmp33_ = link; - _tmp34_ = self->priv->id_registrar; - valadoc_content_link_set_id_registrar (_tmp33_, _tmp34_); - } - _tmp35_ = link; - _tmp36_ = url; - valadoc_content_link_set_url (_tmp35_, _tmp36_); - _tmp37_ = builder; - if (_tmp37_->len == ((gssize) 0)) { - ValadocContentLink* _tmp38_; - ValaList* _tmp39_; - ValaList* _tmp40_; - ValadocContentContentFactory* _tmp41_; - const gchar* _tmp42_; - ValadocContentText* _tmp43_; - ValadocContentText* _tmp44_; - _tmp38_ = link; - _tmp39_ = valadoc_content_inline_content_get_content ((ValadocContentInlineContent*) _tmp38_); - _tmp40_ = _tmp39_; - _tmp41_ = self->priv->factory; - _tmp42_ = url; - _tmp43_ = valadoc_content_content_factory_create_text (_tmp41_, _tmp42_); - _tmp44_ = _tmp43_; - vala_collection_add ((ValaCollection*) _tmp40_, (ValadocContentInline*) _tmp44_); - _g_object_unref0 (_tmp44_); + _tmp34_ = valadoc_content_inline_content_get_content ((ValadocContentInlineContent*) _tmp33_); + _tmp35_ = _tmp34_; + _tmp36_ = self->priv->factory; + _tmp37_ = url; + _tmp38_ = valadoc_content_content_factory_create_text (_tmp36_, _tmp37_); + _tmp39_ = _tmp38_; + vala_collection_add ((ValaCollection*) _tmp35_, (ValadocContentInline*) _tmp39_); + _g_object_unref0 (_tmp39_); } else { - ValadocContentLink* _tmp45_; - ValaList* _tmp46_; - ValaList* _tmp47_; - ValadocContentContentFactory* _tmp48_; - GString* _tmp49_; - const gchar* _tmp50_; + ValadocContentLink* _tmp40_; + ValaList* _tmp41_; + ValaList* _tmp42_; + ValadocContentContentFactory* _tmp43_; + GString* _tmp44_; + const gchar* _tmp45_; + gchar* _tmp46_; + gchar* _tmp47_; + ValadocContentText* _tmp48_; + ValadocContentText* _tmp49_; + _tmp40_ = link; + _tmp41_ = valadoc_content_inline_content_get_content ((ValadocContentInlineContent*) _tmp40_); + _tmp42_ = _tmp41_; + _tmp43_ = self->priv->factory; + _tmp44_ = builder; + _tmp45_ = _tmp44_->str; + _tmp46_ = valadoc_gtkdoc_parser_normalize (self, _tmp45_); + _tmp47_ = _tmp46_; + _tmp48_ = valadoc_content_content_factory_create_text (_tmp43_, _tmp47_); + _tmp49_ = _tmp48_; + vala_collection_add ((ValaCollection*) _tmp42_, (ValadocContentInline*) _tmp49_); + _g_object_unref0 (_tmp49_); + _g_free0 (_tmp47_); + } + if (!valadoc_gtkdoc_parser_check_xml_close_tag (self, tagname)) { + ValadocGtkdocToken* _tmp50_; gchar* _tmp51_; gchar* _tmp52_; - ValadocContentText* _tmp53_; - ValadocContentText* _tmp54_; - _tmp45_ = link; - _tmp46_ = valadoc_content_inline_content_get_content ((ValadocContentInlineContent*) _tmp45_); - _tmp47_ = _tmp46_; - _tmp48_ = self->priv->factory; - _tmp49_ = builder; - _tmp50_ = _tmp49_->str; - _tmp51_ = valadoc_gtkdoc_parser_normalize (self, _tmp50_); + _tmp50_ = self->priv->current; + _tmp51_ = g_strdup_printf ("", tagname); _tmp52_ = _tmp51_; - _tmp53_ = valadoc_content_content_factory_create_text (_tmp48_, _tmp52_); - _tmp54_ = _tmp53_; - vala_collection_add ((ValaCollection*) _tmp47_, (ValadocContentInline*) _tmp54_); - _g_object_unref0 (_tmp54_); + valadoc_gtkdoc_parser_report_unexpected_token (self, _tmp50_, _tmp52_); _g_free0 (_tmp52_); - } - if (!valadoc_gtkdoc_parser_check_xml_close_tag (self, tagname)) { - ValadocGtkdocToken* _tmp55_; - gchar* _tmp56_; - gchar* _tmp57_; - _tmp55_ = self->priv->current; - _tmp56_ = g_strdup_printf ("", tagname); - _tmp57_ = _tmp56_; - valadoc_gtkdoc_parser_report_unexpected_token (self, _tmp55_, _tmp57_); - _g_free0 (_tmp57_); result = (ValadocContentInline*) link; _g_free0 (url); _g_string_free0 (builder); return result; } - _tmp58_ = valadoc_gtkdoc_parser_next (self); - _tmp59_ = _tmp58_; - _valadoc_gtkdoc_token_unref0 (_tmp59_); + _tmp53_ = valadoc_gtkdoc_parser_next (self); + _tmp54_ = _tmp53_; + _valadoc_gtkdoc_token_unref0 (_tmp54_); result = (ValadocContentInline*) link; _g_free0 (url); _g_string_free0 (builder); @@ -1635,25 +1603,21 @@ { ValadocGtkdocToken* _tmp3_; ValadocGtkdocToken* _tmp4_; - ValadocGtkdocTokenType _tmp5_; - gboolean _tmp6_; + gboolean _tmp5_; ValadocContentInlineTaglet* taglet = NULL; - gboolean _tmp9_ = FALSE; - ValadocGtkdocToken* _tmp10_; - ValadocGtkdocTokenType _tmp11_; + gboolean _tmp8_ = FALSE; + ValadocGtkdocToken* _tmp9_; + gboolean _tmp19_ = FALSE; + gboolean _tmp20_ = FALSE; + gboolean _tmp21_ = FALSE; gboolean _tmp22_ = FALSE; gboolean _tmp23_ = FALSE; - gboolean _tmp24_ = FALSE; - gboolean _tmp25_ = FALSE; - gboolean _tmp26_ = FALSE; - ValadocGtkdocToken* _tmp27_; - ValadocGtkdocTokenType _tmp28_; + ValadocGtkdocToken* _tmp24_; + ValadocGtkdocToken* _tmp35_; + ValadocGtkdocToken* _tmp36_; + gboolean _tmp37_; + ValadocGtkdocToken* _tmp43_; ValadocGtkdocToken* _tmp44_; - ValadocGtkdocToken* _tmp45_; - ValadocGtkdocTokenType _tmp46_; - gboolean _tmp47_; - ValadocGtkdocToken* _tmp53_; - ValadocGtkdocToken* _tmp54_; ValadocContentInlineTaglet* result = NULL; g_return_val_if_fail (self != NULL, NULL); g_return_val_if_fail (tagname != NULL, NULL); @@ -1671,143 +1635,127 @@ } _tmp3_ = valadoc_gtkdoc_parser_next (self); _tmp4_ = _tmp3_; - _tmp5_ = _tmp4_->type; - _tmp6_ = _tmp5_ == VALADOC_GTKDOC_TOKEN_TYPE_SPACE; + _tmp5_ = _tmp4_->type == VALADOC_GTKDOC_TOKEN_TYPE_SPACE; _valadoc_gtkdoc_token_unref0 (_tmp4_); - if (_tmp6_) { + if (_tmp5_) { + ValadocGtkdocToken* _tmp6_; ValadocGtkdocToken* _tmp7_; - ValadocGtkdocToken* _tmp8_; - _tmp7_ = valadoc_gtkdoc_parser_next (self); - _tmp8_ = _tmp7_; - _valadoc_gtkdoc_token_unref0 (_tmp8_); + _tmp6_ = valadoc_gtkdoc_parser_next (self); + _tmp7_ = _tmp6_; + _valadoc_gtkdoc_token_unref0 (_tmp7_); } taglet = NULL; - _tmp10_ = self->priv->current; - _tmp11_ = _tmp10_->type; - if (_tmp11_ == VALADOC_GTKDOC_TOKEN_TYPE_WORD) { - ValadocGtkdocToken* _tmp12_; - const gchar* _tmp13_; - _tmp12_ = self->priv->current; - _tmp13_ = _tmp12_->content; - _tmp9_ = g_strcmp0 (_tmp13_, "struct") == 0; + _tmp9_ = self->priv->current; + if (_tmp9_->type == VALADOC_GTKDOC_TOKEN_TYPE_WORD) { + ValadocGtkdocToken* _tmp10_; + const gchar* _tmp11_; + _tmp10_ = self->priv->current; + _tmp11_ = _tmp10_->content; + _tmp8_ = g_strcmp0 (_tmp11_, "struct") == 0; } else { - _tmp9_ = FALSE; + _tmp8_ = FALSE; } - if (_tmp9_) { + if (_tmp8_) { + ValadocGtkdocToken* _tmp12_; + ValadocGtkdocToken* _tmp13_; ValadocGtkdocToken* _tmp14_; ValadocGtkdocToken* _tmp15_; - ValadocGtkdocToken* _tmp16_; - ValadocGtkdocToken* _tmp17_; - ValadocGtkdocTokenType _tmp18_; - gboolean _tmp19_; + gboolean _tmp16_; + _tmp12_ = valadoc_gtkdoc_parser_next (self); + _tmp13_ = _tmp12_; + _valadoc_gtkdoc_token_unref0 (_tmp13_); _tmp14_ = valadoc_gtkdoc_parser_next (self); _tmp15_ = _tmp14_; + _tmp16_ = _tmp15_->type == VALADOC_GTKDOC_TOKEN_TYPE_SPACE; _valadoc_gtkdoc_token_unref0 (_tmp15_); - _tmp16_ = valadoc_gtkdoc_parser_next (self); - _tmp17_ = _tmp16_; - _tmp18_ = _tmp17_->type; - _tmp19_ = _tmp18_ == VALADOC_GTKDOC_TOKEN_TYPE_SPACE; - _valadoc_gtkdoc_token_unref0 (_tmp17_); - if (_tmp19_) { - ValadocGtkdocToken* _tmp20_; - ValadocGtkdocToken* _tmp21_; - _tmp20_ = valadoc_gtkdoc_parser_next (self); - _tmp21_ = _tmp20_; - _valadoc_gtkdoc_token_unref0 (_tmp21_); + if (_tmp16_) { + ValadocGtkdocToken* _tmp17_; + ValadocGtkdocToken* _tmp18_; + _tmp17_ = valadoc_gtkdoc_parser_next (self); + _tmp18_ = _tmp17_; + _valadoc_gtkdoc_token_unref0 (_tmp18_); } } - _tmp27_ = self->priv->current; - _tmp28_ = _tmp27_->type; - if (_tmp28_ == VALADOC_GTKDOC_TOKEN_TYPE_GTKDOC_FUNCTION) { - _tmp26_ = TRUE; + _tmp24_ = self->priv->current; + if (_tmp24_->type == VALADOC_GTKDOC_TOKEN_TYPE_GTKDOC_FUNCTION) { + _tmp23_ = TRUE; } else { - ValadocGtkdocToken* _tmp29_; - ValadocGtkdocTokenType _tmp30_; - _tmp29_ = self->priv->current; - _tmp30_ = _tmp29_->type; - _tmp26_ = _tmp30_ == VALADOC_GTKDOC_TOKEN_TYPE_GTKDOC_CONST; + ValadocGtkdocToken* _tmp25_; + _tmp25_ = self->priv->current; + _tmp23_ = _tmp25_->type == VALADOC_GTKDOC_TOKEN_TYPE_GTKDOC_CONST; } - if (_tmp26_) { - _tmp25_ = TRUE; + if (_tmp23_) { + _tmp22_ = TRUE; } else { - ValadocGtkdocToken* _tmp31_; - ValadocGtkdocTokenType _tmp32_; - _tmp31_ = self->priv->current; - _tmp32_ = _tmp31_->type; - _tmp25_ = _tmp32_ == VALADOC_GTKDOC_TOKEN_TYPE_GTKDOC_TYPE; + ValadocGtkdocToken* _tmp26_; + _tmp26_ = self->priv->current; + _tmp22_ = _tmp26_->type == VALADOC_GTKDOC_TOKEN_TYPE_GTKDOC_TYPE; } - if (_tmp25_) { - _tmp24_ = TRUE; + if (_tmp22_) { + _tmp21_ = TRUE; } else { - ValadocGtkdocToken* _tmp33_; - ValadocGtkdocTokenType _tmp34_; - _tmp33_ = self->priv->current; - _tmp34_ = _tmp33_->type; - _tmp24_ = _tmp34_ == VALADOC_GTKDOC_TOKEN_TYPE_WORD; + ValadocGtkdocToken* _tmp27_; + _tmp27_ = self->priv->current; + _tmp21_ = _tmp27_->type == VALADOC_GTKDOC_TOKEN_TYPE_WORD; } - if (_tmp24_) { - _tmp23_ = TRUE; + if (_tmp21_) { + _tmp20_ = TRUE; } else { - ValadocGtkdocToken* _tmp35_; - ValadocGtkdocTokenType _tmp36_; - _tmp35_ = self->priv->current; - _tmp36_ = _tmp35_->type; - _tmp23_ = _tmp36_ == VALADOC_GTKDOC_TOKEN_TYPE_GTKDOC_PROPERTY; + ValadocGtkdocToken* _tmp28_; + _tmp28_ = self->priv->current; + _tmp20_ = _tmp28_->type == VALADOC_GTKDOC_TOKEN_TYPE_GTKDOC_PROPERTY; } - if (_tmp23_) { - _tmp22_ = TRUE; + if (_tmp20_) { + _tmp19_ = TRUE; } else { - ValadocGtkdocToken* _tmp37_; - ValadocGtkdocTokenType _tmp38_; - _tmp37_ = self->priv->current; - _tmp38_ = _tmp37_->type; - _tmp22_ = _tmp38_ == VALADOC_GTKDOC_TOKEN_TYPE_GTKDOC_SIGNAL; + ValadocGtkdocToken* _tmp29_; + _tmp29_ = self->priv->current; + _tmp19_ = _tmp29_->type == VALADOC_GTKDOC_TOKEN_TYPE_GTKDOC_SIGNAL; } - if (_tmp22_) { - ValadocGtkdocToken* _tmp39_; - const gchar* _tmp40_; - ValadocContentInline* _tmp41_; - ValadocContentInlineTaglet* _tmp42_; - ValadocContentInlineTaglet* _tmp43_; - _tmp39_ = self->priv->current; - _tmp40_ = _tmp39_->content; - _tmp41_ = valadoc_gtkdoc_parser_create_type_link (self, _tmp40_, FALSE); - _tmp42_ = VALADOC_CONTENT_IS_INLINE_TAGLET (_tmp41_) ? ((ValadocContentInlineTaglet*) _tmp41_) : NULL; - if (_tmp42_ == NULL) { - _g_object_unref0 (_tmp41_); + if (_tmp19_) { + ValadocGtkdocToken* _tmp30_; + const gchar* _tmp31_; + ValadocContentInline* _tmp32_; + ValadocContentInlineTaglet* _tmp33_; + ValadocContentInlineTaglet* _tmp34_; + _tmp30_ = self->priv->current; + _tmp31_ = _tmp30_->content; + _tmp32_ = valadoc_gtkdoc_parser_create_type_link (self, _tmp31_, FALSE); + _tmp33_ = VALADOC_CONTENT_IS_INLINE_TAGLET (_tmp32_) ? ((ValadocContentInlineTaglet*) _tmp32_) : NULL; + if (_tmp33_ == NULL) { + _g_object_unref0 (_tmp32_); } _g_object_unref0 (taglet); - taglet = _tmp42_; - _tmp43_ = taglet; - _vala_assert (_tmp43_ != NULL, "taglet != null"); - } - _tmp44_ = valadoc_gtkdoc_parser_next (self); - _tmp45_ = _tmp44_; - _tmp46_ = _tmp45_->type; - _tmp47_ = _tmp46_ == VALADOC_GTKDOC_TOKEN_TYPE_SPACE; - _valadoc_gtkdoc_token_unref0 (_tmp45_); - if (_tmp47_) { - ValadocGtkdocToken* _tmp48_; - ValadocGtkdocToken* _tmp49_; - _tmp48_ = valadoc_gtkdoc_parser_next (self); - _tmp49_ = _tmp48_; - _valadoc_gtkdoc_token_unref0 (_tmp49_); + taglet = _tmp33_; + _tmp34_ = taglet; + _vala_assert (_tmp34_ != NULL, "taglet != null"); + } + _tmp35_ = valadoc_gtkdoc_parser_next (self); + _tmp36_ = _tmp35_; + _tmp37_ = _tmp36_->type == VALADOC_GTKDOC_TOKEN_TYPE_SPACE; + _valadoc_gtkdoc_token_unref0 (_tmp36_); + if (_tmp37_) { + ValadocGtkdocToken* _tmp38_; + ValadocGtkdocToken* _tmp39_; + _tmp38_ = valadoc_gtkdoc_parser_next (self); + _tmp39_ = _tmp38_; + _valadoc_gtkdoc_token_unref0 (_tmp39_); } if (!valadoc_gtkdoc_parser_check_xml_close_tag (self, tagname)) { - ValadocGtkdocToken* _tmp50_; - gchar* _tmp51_; - gchar* _tmp52_; - _tmp50_ = self->priv->current; - _tmp51_ = g_strdup_printf ("", tagname); - _tmp52_ = _tmp51_; - valadoc_gtkdoc_parser_report_unexpected_token (self, _tmp50_, _tmp52_); - _g_free0 (_tmp52_); + ValadocGtkdocToken* _tmp40_; + gchar* _tmp41_; + gchar* _tmp42_; + _tmp40_ = self->priv->current; + _tmp41_ = g_strdup_printf ("", tagname); + _tmp42_ = _tmp41_; + valadoc_gtkdoc_parser_report_unexpected_token (self, _tmp40_, _tmp42_); + _g_free0 (_tmp42_); result = taglet; return result; } - _tmp53_ = valadoc_gtkdoc_parser_next (self); - _tmp54_ = _tmp53_; - _valadoc_gtkdoc_token_unref0 (_tmp54_); + _tmp43_ = valadoc_gtkdoc_parser_next (self); + _tmp44_ = _tmp43_; + _valadoc_gtkdoc_token_unref0 (_tmp44_); result = taglet; return result; } @@ -2091,9 +2039,9 @@ ValadocGtkdocToken* _tmp3_; ValadocGtkdocToken* _tmp4_; ValadocGtkdocToken* tmp = NULL; - ValadocGtkdocToken* _tmp42_; - ValadocGtkdocToken* _tmp43_; - ValadocContentBlockContent* _tmp44_; + ValadocGtkdocToken* _tmp40_; + ValadocGtkdocToken* _tmp41_; + ValadocContentBlockContent* _tmp42_; ValadocContentBlockContent* result = NULL; g_return_val_if_fail (self != NULL, NULL); g_return_val_if_fail (tagname != NULL, NULL); @@ -2118,125 +2066,121 @@ while (TRUE) { gboolean _tmp5_ = FALSE; ValadocGtkdocToken* _tmp6_; - ValadocGtkdocTokenType _tmp7_; - ValadocGtkdocToken* _tmp10_; - ValadocGtkdocToken* _tmp11_; + ValadocGtkdocToken* _tmp8_; + ValadocGtkdocToken* _tmp9_; ValadocContentRun* ic = NULL; + ValadocContentRun* _tmp10_; + gboolean _tmp11_ = FALSE; ValadocContentRun* _tmp12_; - gboolean _tmp13_ = FALSE; - ValadocContentRun* _tmp14_; ValaCollection* bc = NULL; + ValaCollection* _tmp27_; + gboolean _tmp28_ = FALSE; ValaCollection* _tmp29_; - gboolean _tmp30_ = FALSE; - ValaCollection* _tmp31_; _tmp6_ = self->priv->current; - _tmp7_ = _tmp6_->type; - if (_tmp7_ != VALADOC_GTKDOC_TOKEN_TYPE_XML_CLOSE) { - ValadocGtkdocToken* _tmp8_; - ValadocGtkdocTokenType _tmp9_; - _tmp8_ = self->priv->current; - _tmp9_ = _tmp8_->type; - _tmp5_ = _tmp9_ != VALADOC_GTKDOC_TOKEN_TYPE_EOF; + if (_tmp6_->type != VALADOC_GTKDOC_TOKEN_TYPE_XML_CLOSE) { + ValadocGtkdocToken* _tmp7_; + _tmp7_ = self->priv->current; + _tmp5_ = _tmp7_->type != VALADOC_GTKDOC_TOKEN_TYPE_EOF; } else { _tmp5_ = FALSE; } if (!_tmp5_) { break; } - _tmp10_ = self->priv->current; - _tmp11_ = _valadoc_gtkdoc_token_ref0 (_tmp10_); + _tmp8_ = self->priv->current; + _tmp9_ = _valadoc_gtkdoc_token_ref0 (_tmp8_); _valadoc_gtkdoc_token_unref0 (tmp); - tmp = _tmp11_; - _tmp12_ = valadoc_gtkdoc_parser_parse_inline_content (self); - ic = _tmp12_; - _tmp14_ = ic; - if (_tmp14_ != NULL) { - ValadocContentRun* _tmp15_; - ValaList* _tmp16_; - ValaList* _tmp17_; - gint _tmp18_; - gint _tmp19_; - _tmp15_ = ic; - _tmp16_ = valadoc_content_inline_content_get_content ((ValadocContentInlineContent*) _tmp15_); + tmp = _tmp9_; + _tmp10_ = valadoc_gtkdoc_parser_parse_inline_content (self); + ic = _tmp10_; + _tmp12_ = ic; + if (_tmp12_ != NULL) { + ValadocContentRun* _tmp13_; + ValaList* _tmp14_; + ValaList* _tmp15_; + gint _tmp16_; + gint _tmp17_; + _tmp13_ = ic; + _tmp14_ = valadoc_content_inline_content_get_content ((ValadocContentInlineContent*) _tmp13_); + _tmp15_ = _tmp14_; + _tmp16_ = vala_collection_get_size ((ValaCollection*) _tmp15_); _tmp17_ = _tmp16_; - _tmp18_ = vala_collection_get_size ((ValaCollection*) _tmp17_); - _tmp19_ = _tmp18_; - _tmp13_ = _tmp19_ > 0; + _tmp11_ = _tmp17_ > 0; } else { - _tmp13_ = FALSE; + _tmp11_ = FALSE; } - if (_tmp13_) { + if (_tmp11_) { ValadocContentParagraph* p = NULL; - ValadocContentContentFactory* _tmp20_; - ValadocContentParagraph* _tmp21_; - ValadocContentParagraph* _tmp22_; - ValaList* _tmp23_; + ValadocContentContentFactory* _tmp18_; + ValadocContentParagraph* _tmp19_; + ValadocContentParagraph* _tmp20_; + ValaList* _tmp21_; + ValaList* _tmp22_; + ValadocContentRun* _tmp23_; ValaList* _tmp24_; - ValadocContentRun* _tmp25_; - ValaList* _tmp26_; - ValaList* _tmp27_; - ValadocContentParagraph* _tmp28_; - _tmp20_ = self->priv->factory; - _tmp21_ = valadoc_content_content_factory_create_paragraph (_tmp20_); - p = _tmp21_; - _tmp22_ = p; - _tmp23_ = valadoc_content_inline_content_get_content ((ValadocContentInlineContent*) _tmp22_); - _tmp24_ = _tmp23_; - _tmp25_ = ic; - vala_collection_add ((ValaCollection*) _tmp24_, (ValadocContentInline*) _tmp25_); - _tmp26_ = valadoc_content_block_content_get_content (container); - _tmp27_ = _tmp26_; - _tmp28_ = p; - vala_collection_add ((ValaCollection*) _tmp27_, (ValadocContentBlock*) _tmp28_); + ValaList* _tmp25_; + ValadocContentParagraph* _tmp26_; + _tmp18_ = self->priv->factory; + _tmp19_ = valadoc_content_content_factory_create_paragraph (_tmp18_); + p = _tmp19_; + _tmp20_ = p; + _tmp21_ = valadoc_content_inline_content_get_content ((ValadocContentInlineContent*) _tmp20_); + _tmp22_ = _tmp21_; + _tmp23_ = ic; + vala_collection_add ((ValaCollection*) _tmp22_, (ValadocContentInline*) _tmp23_); + _tmp24_ = valadoc_content_block_content_get_content (container); + _tmp25_ = _tmp24_; + _tmp26_ = p; + vala_collection_add ((ValaCollection*) _tmp25_, (ValadocContentBlock*) _tmp26_); _g_object_unref0 (p); } - _tmp29_ = valadoc_gtkdoc_parser_parse_block_content (self); - bc = _tmp29_; - _tmp31_ = bc; - if (_tmp31_ != NULL) { - ValaCollection* _tmp32_; - gint _tmp33_; - gint _tmp34_; - _tmp32_ = bc; - _tmp33_ = vala_collection_get_size (_tmp32_); - _tmp34_ = _tmp33_; - _tmp30_ = _tmp34_ > 0; + _tmp27_ = valadoc_gtkdoc_parser_parse_block_content (self); + bc = _tmp27_; + _tmp29_ = bc; + if (_tmp29_ != NULL) { + ValaCollection* _tmp30_; + gint _tmp31_; + gint _tmp32_; + _tmp30_ = bc; + _tmp31_ = vala_collection_get_size (_tmp30_); + _tmp32_ = _tmp31_; + _tmp28_ = _tmp32_ > 0; } else { - _tmp30_ = FALSE; + _tmp28_ = FALSE; } - if (_tmp30_) { - ValaList* _tmp35_; - ValaList* _tmp36_; - ValaCollection* _tmp37_; - _tmp35_ = valadoc_content_block_content_get_content (container); - _tmp36_ = _tmp35_; - _tmp37_ = bc; - vala_collection_add_all ((ValaCollection*) _tmp36_, _tmp37_); + if (_tmp28_) { + ValaList* _tmp33_; + ValaList* _tmp34_; + ValaCollection* _tmp35_; + _tmp33_ = valadoc_content_block_content_get_content (container); + _tmp34_ = _tmp33_; + _tmp35_ = bc; + vala_collection_add_all ((ValaCollection*) _tmp34_, _tmp35_); } _vala_iterable_unref0 (bc); _g_object_unref0 (ic); } valadoc_gtkdoc_parser_parse_docbook_spaces (self, TRUE); if (!valadoc_gtkdoc_parser_check_xml_close_tag (self, tagname)) { - ValadocGtkdocToken* _tmp38_; - gchar* _tmp39_; - gchar* _tmp40_; - ValadocContentBlockContent* _tmp41_; - _tmp38_ = self->priv->current; - _tmp39_ = g_strdup_printf ("", tagname); - _tmp40_ = _tmp39_; - valadoc_gtkdoc_parser_report_unexpected_token (self, _tmp38_, _tmp40_); - _g_free0 (_tmp40_); - _tmp41_ = _g_object_ref0 (container); - result = _tmp41_; + ValadocGtkdocToken* _tmp36_; + gchar* _tmp37_; + gchar* _tmp38_; + ValadocContentBlockContent* _tmp39_; + _tmp36_ = self->priv->current; + _tmp37_ = g_strdup_printf ("", tagname); + _tmp38_ = _tmp37_; + valadoc_gtkdoc_parser_report_unexpected_token (self, _tmp36_, _tmp38_); + _g_free0 (_tmp38_); + _tmp39_ = _g_object_ref0 (container); + result = _tmp39_; _valadoc_gtkdoc_token_unref0 (tmp); return result; } - _tmp42_ = valadoc_gtkdoc_parser_next (self); - _tmp43_ = _tmp42_; - _valadoc_gtkdoc_token_unref0 (_tmp43_); - _tmp44_ = _g_object_ref0 (container); - result = _tmp44_; + _tmp40_ = valadoc_gtkdoc_parser_next (self); + _tmp41_ = _tmp40_; + _valadoc_gtkdoc_token_unref0 (_tmp41_); + _tmp42_ = _g_object_ref0 (container); + result = _tmp42_; _valadoc_gtkdoc_token_unref0 (tmp); return result; } @@ -2324,15 +2268,14 @@ ValaArrayList* _tmp6_; gboolean _tmp7_ = FALSE; ValadocGtkdocToken* _tmp8_; - ValadocGtkdocTokenType _tmp9_; ValadocContentList* list = NULL; - ValadocContentContentFactory* _tmp15_; + ValadocContentContentFactory* _tmp14_; + ValadocContentList* _tmp15_; ValadocContentList* _tmp16_; - ValadocContentList* _tmp17_; - ValaCollection* _tmp18_; - ValadocContentList* _tmp19_; - ValadocGtkdocToken* _tmp32_; - ValadocGtkdocToken* _tmp33_; + ValaCollection* _tmp17_; + ValadocContentList* _tmp18_; + ValadocGtkdocToken* _tmp30_; + ValadocGtkdocToken* _tmp31_; ValaCollection* result = NULL; g_return_val_if_fail (self != NULL, NULL); g_return_val_if_fail (tag_name != NULL, NULL); @@ -2356,81 +2299,78 @@ content = (ValaCollection*) _tmp6_; valadoc_gtkdoc_parser_parse_docbook_spaces (self, TRUE); _tmp8_ = self->priv->current; - _tmp9_ = _tmp8_->type; - if (_tmp9_ == VALADOC_GTKDOC_TOKEN_TYPE_XML_OPEN) { - ValadocGtkdocToken* _tmp10_; - const gchar* _tmp11_; - _tmp10_ = self->priv->current; - _tmp11_ = _tmp10_->content; - _tmp7_ = g_strcmp0 (_tmp11_, "title") == 0; + if (_tmp8_->type == VALADOC_GTKDOC_TOKEN_TYPE_XML_OPEN) { + ValadocGtkdocToken* _tmp9_; + const gchar* _tmp10_; + _tmp9_ = self->priv->current; + _tmp10_ = _tmp9_->content; + _tmp7_ = g_strcmp0 (_tmp10_, "title") == 0; } else { _tmp7_ = FALSE; } if (_tmp7_) { - ValaCollection* _tmp12_; + ValaCollection* _tmp11_; + ValadocContentParagraph* _tmp12_; ValadocContentParagraph* _tmp13_; - ValadocContentParagraph* _tmp14_; - _tmp12_ = content; - _tmp13_ = valadoc_gtkdoc_parser_parse_docbook_title (self); - _tmp14_ = _tmp13_; - valadoc_gtkdoc_parser_append_block_content_not_null (self, _tmp12_, (ValadocContentBlock*) _tmp14_); - _g_object_unref0 (_tmp14_); + _tmp11_ = content; + _tmp12_ = valadoc_gtkdoc_parser_parse_docbook_title (self); + _tmp13_ = _tmp12_; + valadoc_gtkdoc_parser_append_block_content_not_null (self, _tmp11_, (ValadocContentBlock*) _tmp13_); + _g_object_unref0 (_tmp13_); valadoc_gtkdoc_parser_parse_docbook_spaces (self, TRUE); } - _tmp15_ = self->priv->factory; - _tmp16_ = valadoc_content_content_factory_create_list (_tmp15_); - list = _tmp16_; - _tmp17_ = list; - valadoc_content_list_set_bullet (_tmp17_, bullet_type); - _tmp18_ = content; - _tmp19_ = list; - vala_collection_add (_tmp18_, (ValadocContentBlock*) _tmp19_); + _tmp14_ = self->priv->factory; + _tmp15_ = valadoc_content_content_factory_create_list (_tmp14_); + list = _tmp15_; + _tmp16_ = list; + valadoc_content_list_set_bullet (_tmp16_, bullet_type); + _tmp17_ = content; + _tmp18_ = list; + vala_collection_add (_tmp17_, (ValadocContentBlock*) _tmp18_); while (TRUE) { + ValadocGtkdocToken* _tmp19_; ValadocGtkdocToken* _tmp20_; - ValadocGtkdocTokenType _tmp21_; - ValadocGtkdocToken* _tmp22_; - const gchar* _tmp23_; - _tmp20_ = self->priv->current; - _tmp21_ = _tmp20_->type; - if (!(_tmp21_ == VALADOC_GTKDOC_TOKEN_TYPE_XML_OPEN)) { + const gchar* _tmp21_; + _tmp19_ = self->priv->current; + if (!(_tmp19_->type == VALADOC_GTKDOC_TOKEN_TYPE_XML_OPEN)) { break; } - _tmp22_ = self->priv->current; - _tmp23_ = _tmp22_->content; - if (g_strcmp0 (_tmp23_, "listitem") == 0) { - ValadocContentList* _tmp24_; - ValaList* _tmp25_; - ValaList* _tmp26_; - ValadocContentListItem* _tmp27_; - ValadocContentListItem* _tmp28_; - _tmp24_ = list; - _tmp25_ = valadoc_content_list_get_items (_tmp24_); + _tmp20_ = self->priv->current; + _tmp21_ = _tmp20_->content; + if (g_strcmp0 (_tmp21_, "listitem") == 0) { + ValadocContentList* _tmp22_; + ValaList* _tmp23_; + ValaList* _tmp24_; + ValadocContentListItem* _tmp25_; + ValadocContentListItem* _tmp26_; + _tmp22_ = list; + _tmp23_ = valadoc_content_list_get_items (_tmp22_); + _tmp24_ = _tmp23_; + _tmp25_ = valadoc_gtkdoc_parser_parse_docbook_listitem (self); _tmp26_ = _tmp25_; - _tmp27_ = valadoc_gtkdoc_parser_parse_docbook_listitem (self); - _tmp28_ = _tmp27_; - vala_collection_add ((ValaCollection*) _tmp26_, _tmp28_); - _g_object_unref0 (_tmp28_); + vala_collection_add ((ValaCollection*) _tmp24_, _tmp26_); + _g_object_unref0 (_tmp26_); } else { break; } valadoc_gtkdoc_parser_parse_docbook_spaces (self, TRUE); } if (!valadoc_gtkdoc_parser_check_xml_close_tag (self, tag_name)) { - ValadocGtkdocToken* _tmp29_; - gchar* _tmp30_; - gchar* _tmp31_; - _tmp29_ = self->priv->current; - _tmp30_ = g_strdup_printf ("", tag_name); - _tmp31_ = _tmp30_; - valadoc_gtkdoc_parser_report_unexpected_token (self, _tmp29_, _tmp31_); - _g_free0 (_tmp31_); + ValadocGtkdocToken* _tmp27_; + gchar* _tmp28_; + gchar* _tmp29_; + _tmp27_ = self->priv->current; + _tmp28_ = g_strdup_printf ("", tag_name); + _tmp29_ = _tmp28_; + valadoc_gtkdoc_parser_report_unexpected_token (self, _tmp27_, _tmp29_); + _g_free0 (_tmp29_); result = content; _g_object_unref0 (list); return result; } - _tmp32_ = valadoc_gtkdoc_parser_next (self); - _tmp33_ = _tmp32_; - _valadoc_gtkdoc_token_unref0 (_tmp33_); + _tmp30_ = valadoc_gtkdoc_parser_next (self); + _tmp31_ = _tmp30_; + _valadoc_gtkdoc_token_unref0 (_tmp31_); result = content; _g_object_unref0 (list); return result; @@ -2440,42 +2380,40 @@ valadoc_gtkdoc_parser_parse_gtkdoc_paragraph (ValadocGtkdocParser* self) { ValadocGtkdocToken* _tmp0_; - ValadocGtkdocTokenType _tmp1_; + ValadocGtkdocToken* _tmp2_; ValadocGtkdocToken* _tmp3_; - ValadocGtkdocToken* _tmp4_; ValadocContentParagraph* p = NULL; - ValadocContentContentFactory* _tmp5_; - ValadocContentParagraph* _tmp6_; + ValadocContentContentFactory* _tmp4_; + ValadocContentParagraph* _tmp5_; ValadocContentRun* run = NULL; - ValadocContentRun* _tmp7_; - ValadocContentParagraph* _tmp8_; + ValadocContentRun* _tmp6_; + ValadocContentParagraph* _tmp7_; + ValaList* _tmp8_; ValaList* _tmp9_; - ValaList* _tmp10_; - ValadocContentRun* _tmp11_; + ValadocContentRun* _tmp10_; ValadocContentParagraph* result = NULL; g_return_val_if_fail (self != NULL, NULL); _tmp0_ = self->priv->current; - _tmp1_ = _tmp0_->type; - if (_tmp1_ != VALADOC_GTKDOC_TOKEN_TYPE_GTKDOC_PARAGRAPH) { - ValadocGtkdocToken* _tmp2_; - _tmp2_ = self->priv->current; - valadoc_gtkdoc_parser_report_unexpected_token (self, _tmp2_, ""); + if (_tmp0_->type != VALADOC_GTKDOC_TOKEN_TYPE_GTKDOC_PARAGRAPH) { + ValadocGtkdocToken* _tmp1_; + _tmp1_ = self->priv->current; + valadoc_gtkdoc_parser_report_unexpected_token (self, _tmp1_, ""); result = NULL; return result; } - _tmp3_ = valadoc_gtkdoc_parser_next (self); - _tmp4_ = _tmp3_; - _valadoc_gtkdoc_token_unref0 (_tmp4_); - _tmp5_ = self->priv->factory; - _tmp6_ = valadoc_content_content_factory_create_paragraph (_tmp5_); - p = _tmp6_; - _tmp7_ = valadoc_gtkdoc_parser_parse_inline_content (self); - run = _tmp7_; - _tmp8_ = p; - _tmp9_ = valadoc_content_inline_content_get_content ((ValadocContentInlineContent*) _tmp8_); - _tmp10_ = _tmp9_; - _tmp11_ = run; - vala_collection_add ((ValaCollection*) _tmp10_, (ValadocContentInline*) _tmp11_); + _tmp2_ = valadoc_gtkdoc_parser_next (self); + _tmp3_ = _tmp2_; + _valadoc_gtkdoc_token_unref0 (_tmp3_); + _tmp4_ = self->priv->factory; + _tmp5_ = valadoc_content_content_factory_create_paragraph (_tmp4_); + p = _tmp5_; + _tmp6_ = valadoc_gtkdoc_parser_parse_inline_content (self); + run = _tmp6_; + _tmp7_ = p; + _tmp8_ = valadoc_content_inline_content_get_content ((ValadocContentInlineContent*) _tmp7_); + _tmp9_ = _tmp8_; + _tmp10_ = run; + vala_collection_add ((ValaCollection*) _tmp9_, (ValadocContentInline*) _tmp10_); result = p; _g_object_unref0 (run); return result; @@ -2612,8 +2550,8 @@ ValaCollection* content = NULL; ValaCollection* _tmp5_; gboolean _tmp6_ = FALSE; + ValadocGtkdocToken* _tmp11_; ValadocGtkdocToken* _tmp12_; - ValadocGtkdocToken* _tmp13_; ValaCollection* result = NULL; g_return_val_if_fail (self != NULL, NULL); g_return_val_if_fail (tag_name != NULL, NULL); @@ -2636,28 +2574,26 @@ content = _tmp5_; if (!valadoc_gtkdoc_parser_check_xml_close_tag (self, tag_name)) { ValadocGtkdocToken* _tmp7_; - ValadocGtkdocTokenType _tmp8_; _tmp7_ = self->priv->current; - _tmp8_ = _tmp7_->type; - _tmp6_ = _tmp8_ != VALADOC_GTKDOC_TOKEN_TYPE_EOF; + _tmp6_ = _tmp7_->type != VALADOC_GTKDOC_TOKEN_TYPE_EOF; } else { _tmp6_ = FALSE; } if (_tmp6_) { - ValadocGtkdocToken* _tmp9_; + ValadocGtkdocToken* _tmp8_; + gchar* _tmp9_; gchar* _tmp10_; - gchar* _tmp11_; - _tmp9_ = self->priv->current; - _tmp10_ = g_strdup_printf ("", tag_name); - _tmp11_ = _tmp10_; - valadoc_gtkdoc_parser_report_unexpected_token (self, _tmp9_, _tmp11_); - _g_free0 (_tmp11_); + _tmp8_ = self->priv->current; + _tmp9_ = g_strdup_printf ("", tag_name); + _tmp10_ = _tmp9_; + valadoc_gtkdoc_parser_report_unexpected_token (self, _tmp8_, _tmp10_); + _g_free0 (_tmp10_); result = content; return result; } - _tmp12_ = valadoc_gtkdoc_parser_next (self); - _tmp13_ = _tmp12_; - _valadoc_gtkdoc_token_unref0 (_tmp13_); + _tmp11_ = valadoc_gtkdoc_parser_next (self); + _tmp12_ = _tmp11_; + _valadoc_gtkdoc_token_unref0 (_tmp12_); result = content; return result; } @@ -2715,208 +2651,196 @@ valadoc_gtkdoc_parser_parse_gtkdoc_source (ValadocGtkdocParser* self) { ValadocGtkdocToken* _tmp0_; - ValadocGtkdocTokenType _tmp1_; GString* builder = NULL; - GString* _tmp3_; + GString* _tmp2_; ValadocGtkdocToken* source_token = NULL; + ValadocGtkdocToken* _tmp3_; ValadocGtkdocToken* _tmp4_; - ValadocGtkdocToken* _tmp5_; ValadocContentSourceCode* code = NULL; - ValadocContentContentFactory* _tmp27_; - ValadocContentSourceCode* _tmp28_; + ValadocContentContentFactory* _tmp22_; + ValadocContentSourceCode* _tmp23_; GMatchInfo* info = NULL; const gchar* source = NULL; - GString* _tmp29_; - const gchar* _tmp30_; - GRegex* _tmp31_; - const gchar* _tmp32_; - GMatchInfo* _tmp33_ = NULL; - gboolean _tmp34_; - ValadocContentSourceCode* _tmp56_; - const gchar* _tmp57_; + GString* _tmp24_; + const gchar* _tmp25_; + GRegex* _tmp26_; + const gchar* _tmp27_; + GMatchInfo* _tmp28_ = NULL; + gboolean _tmp29_; + ValadocContentSourceCode* _tmp51_; + const gchar* _tmp52_; ValadocContentParagraph* p = NULL; - ValadocContentContentFactory* _tmp58_; - ValadocContentParagraph* _tmp59_; - ValadocContentParagraph* _tmp60_; - ValaList* _tmp61_; - ValaList* _tmp62_; - ValadocContentSourceCode* _tmp63_; - ValadocGtkdocToken* _tmp64_; - ValadocGtkdocTokenType _tmp65_; - ValadocGtkdocToken* _tmp67_; - ValadocGtkdocToken* _tmp68_; + ValadocContentContentFactory* _tmp53_; + ValadocContentParagraph* _tmp54_; + ValadocContentParagraph* _tmp55_; + ValaList* _tmp56_; + ValaList* _tmp57_; + ValadocContentSourceCode* _tmp58_; + ValadocGtkdocToken* _tmp59_; + ValadocGtkdocToken* _tmp61_; + ValadocGtkdocToken* _tmp62_; ValadocContentParagraph* result = NULL; g_return_val_if_fail (self != NULL, NULL); _tmp0_ = self->priv->current; - _tmp1_ = _tmp0_->type; - if (_tmp1_ != VALADOC_GTKDOC_TOKEN_TYPE_GTKDOC_SOURCE_OPEN) { - ValadocGtkdocToken* _tmp2_; - _tmp2_ = self->priv->current; - valadoc_gtkdoc_parser_report_unexpected_token (self, _tmp2_, "|["); + if (_tmp0_->type != VALADOC_GTKDOC_TOKEN_TYPE_GTKDOC_SOURCE_OPEN) { + ValadocGtkdocToken* _tmp1_; + _tmp1_ = self->priv->current; + valadoc_gtkdoc_parser_report_unexpected_token (self, _tmp1_, "|["); result = NULL; return result; } - _tmp3_ = g_string_new (""); - builder = _tmp3_; - _tmp4_ = self->priv->current; - _tmp5_ = _valadoc_gtkdoc_token_ref0 (_tmp4_); - source_token = _tmp5_; + _tmp2_ = g_string_new (""); + builder = _tmp2_; + _tmp3_ = self->priv->current; + _tmp4_ = _valadoc_gtkdoc_token_ref0 (_tmp3_); + source_token = _tmp4_; { + ValadocGtkdocToken* _tmp5_; ValadocGtkdocToken* _tmp6_; - ValadocGtkdocToken* _tmp7_; - gboolean _tmp8_ = FALSE; - _tmp6_ = valadoc_gtkdoc_parser_next (self); - _tmp7_ = _tmp6_; - _valadoc_gtkdoc_token_unref0 (_tmp7_); - _tmp8_ = TRUE; + gboolean _tmp7_ = FALSE; + _tmp5_ = valadoc_gtkdoc_parser_next (self); + _tmp6_ = _tmp5_; + _valadoc_gtkdoc_token_unref0 (_tmp6_); + _tmp7_ = TRUE; while (TRUE) { - gboolean _tmp11_ = FALSE; - ValadocGtkdocToken* _tmp12_; - ValadocGtkdocTokenType _tmp13_; - ValadocGtkdocToken* _tmp16_; - ValadocGtkdocTokenType _tmp17_; - if (!_tmp8_) { + gboolean _tmp10_ = FALSE; + ValadocGtkdocToken* _tmp11_; + ValadocGtkdocToken* _tmp13_; + if (!_tmp7_) { + ValadocGtkdocToken* _tmp8_; ValadocGtkdocToken* _tmp9_; - ValadocGtkdocToken* _tmp10_; - _tmp9_ = valadoc_gtkdoc_parser_next (self); - _tmp10_ = _tmp9_; - _valadoc_gtkdoc_token_unref0 (_tmp10_); + _tmp8_ = valadoc_gtkdoc_parser_next (self); + _tmp9_ = _tmp8_; + _valadoc_gtkdoc_token_unref0 (_tmp9_); } - _tmp8_ = FALSE; - _tmp12_ = self->priv->current; - _tmp13_ = _tmp12_->type; - if (_tmp13_ != VALADOC_GTKDOC_TOKEN_TYPE_EOF) { - ValadocGtkdocToken* _tmp14_; - ValadocGtkdocTokenType _tmp15_; - _tmp14_ = self->priv->current; - _tmp15_ = _tmp14_->type; - _tmp11_ = _tmp15_ != VALADOC_GTKDOC_TOKEN_TYPE_GTKDOC_SOURCE_CLOSE; + _tmp7_ = FALSE; + _tmp11_ = self->priv->current; + if (_tmp11_->type != VALADOC_GTKDOC_TOKEN_TYPE_EOF) { + ValadocGtkdocToken* _tmp12_; + _tmp12_ = self->priv->current; + _tmp10_ = _tmp12_->type != VALADOC_GTKDOC_TOKEN_TYPE_GTKDOC_SOURCE_CLOSE; } else { - _tmp11_ = FALSE; + _tmp10_ = FALSE; } - if (!_tmp11_) { + if (!_tmp10_) { break; } - _tmp16_ = self->priv->current; - _tmp17_ = _tmp16_->type; - if (_tmp17_ == VALADOC_GTKDOC_TOKEN_TYPE_WORD) { - GString* _tmp18_; - ValadocGtkdocToken* _tmp19_; - const gchar* _tmp20_; - _tmp18_ = builder; - _tmp19_ = self->priv->current; - _tmp20_ = _tmp19_->content; - g_string_append (_tmp18_, _tmp20_); + _tmp13_ = self->priv->current; + if (_tmp13_->type == VALADOC_GTKDOC_TOKEN_TYPE_WORD) { + GString* _tmp14_; + ValadocGtkdocToken* _tmp15_; + const gchar* _tmp16_; + _tmp14_ = builder; + _tmp15_ = self->priv->current; + _tmp16_ = _tmp15_->content; + g_string_append (_tmp14_, _tmp16_); } else { - ValadocGtkdocToken* _tmp21_; - ValadocGtkdocTokenType _tmp22_; - _tmp21_ = self->priv->current; - _tmp22_ = _tmp21_->type; - if (_tmp22_ != VALADOC_GTKDOC_TOKEN_TYPE_XML_COMMENT) { - GString* _tmp23_; - ValadocGtkdocToken* _tmp24_; - const gchar* _tmp25_; - ValadocGtkdocToken* _tmp26_; - _tmp23_ = builder; - _tmp24_ = self->priv->current; - _tmp25_ = _tmp24_->start; - _tmp26_ = self->priv->current; - g_string_append_len (_tmp23_, _tmp25_, (gssize) _tmp26_->length); + ValadocGtkdocToken* _tmp17_; + _tmp17_ = self->priv->current; + if (_tmp17_->type != VALADOC_GTKDOC_TOKEN_TYPE_XML_COMMENT) { + GString* _tmp18_; + ValadocGtkdocToken* _tmp19_; + const gchar* _tmp20_; + ValadocGtkdocToken* _tmp21_; + _tmp18_ = builder; + _tmp19_ = self->priv->current; + _tmp20_ = _tmp19_->start; + _tmp21_ = self->priv->current; + g_string_append_len (_tmp18_, _tmp20_, (gssize) _tmp21_->length); } } } } - _tmp27_ = self->priv->factory; - _tmp28_ = valadoc_content_content_factory_create_source_code (_tmp27_); - code = _tmp28_; - _tmp29_ = builder; - _tmp30_ = _tmp29_->str; - source = _tmp30_; - _tmp31_ = self->priv->regex_source_lang; - _tmp32_ = source; - _tmp34_ = g_regex_match (_tmp31_, _tmp32_, 0, &_tmp33_); + _tmp22_ = self->priv->factory; + _tmp23_ = valadoc_content_content_factory_create_source_code (_tmp22_); + code = _tmp23_; + _tmp24_ = builder; + _tmp25_ = _tmp24_->str; + source = _tmp25_; + _tmp26_ = self->priv->regex_source_lang; + _tmp27_ = source; + _tmp29_ = g_regex_match (_tmp26_, _tmp27_, 0, &_tmp28_); _g_match_info_unref0 (info); - info = _tmp33_; - if (_tmp34_) { + info = _tmp28_; + if (_tmp29_) { gchar* lang_name = NULL; - GMatchInfo* _tmp35_; - gchar* _tmp36_; - gchar* _tmp37_; - gchar* _tmp38_; - gchar* _tmp39_; + GMatchInfo* _tmp30_; + gchar* _tmp31_; + gchar* _tmp32_; + gchar* _tmp33_; + gchar* _tmp34_; ValadocContentSourceCodeLanguage* lang = NULL; - const gchar* _tmp40_; - ValadocContentSourceCodeLanguage _tmp41_; - ValadocContentSourceCodeLanguage* _tmp42_; - ValadocContentSourceCode* _tmp43_; - ValadocContentSourceCodeLanguage* _tmp44_; - ValadocContentSourceCodeLanguage* _tmp45_; - const gchar* _tmp50_; - const gchar* _tmp51_; - const gchar* _tmp52_; - _tmp35_ = info; - _tmp36_ = g_match_info_fetch (_tmp35_, 1); - _tmp37_ = _tmp36_; - _tmp38_ = g_ascii_strdown (_tmp37_, (gssize) -1); - _tmp39_ = _tmp38_; - _g_free0 (_tmp37_); - lang_name = _tmp39_; - _tmp40_ = lang_name; - _tmp41_ = valadoc_content_source_code_language_from_string (_tmp40_, FALSE); - _tmp42_ = __valadoc_content_source_code_language_dup0 (&_tmp41_); - lang = _tmp42_; - _tmp43_ = code; - _tmp44_ = lang; - valadoc_content_source_code_set_language (_tmp43_, *_tmp44_); - _tmp45_ = lang; - if (_tmp45_ == NULL) { - ValadocGtkdocToken* _tmp46_; - const gchar* _tmp47_; - gchar* _tmp48_; - gchar* _tmp49_; - _tmp46_ = source_token; - _tmp47_ = lang_name; - _tmp48_ = g_strdup_printf ("Unknown language `%s' in source code block |[