/* valaccodemethodmodule.c generated by valac, the Vala compiler * generated from valaccodemethodmodule.vala, do not modify */ /* valaccodemethodmodule.vala * * Copyright (C) 2007-2010 Jürg Billeter * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA * * Author: * Jürg Billeter * Raffaele Sandrini */ #include #include #include #include #include #include #include #include #include #define VALA_TYPE_CCODE_BASE_MODULE (vala_ccode_base_module_get_type ()) #define VALA_CCODE_BASE_MODULE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CCODE_BASE_MODULE, ValaCCodeBaseModule)) #define VALA_CCODE_BASE_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CCODE_BASE_MODULE, ValaCCodeBaseModuleClass)) #define VALA_IS_CCODE_BASE_MODULE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CCODE_BASE_MODULE)) #define VALA_IS_CCODE_BASE_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CCODE_BASE_MODULE)) #define VALA_CCODE_BASE_MODULE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CCODE_BASE_MODULE, ValaCCodeBaseModuleClass)) typedef struct _ValaCCodeBaseModule ValaCCodeBaseModule; typedef struct _ValaCCodeBaseModuleClass ValaCCodeBaseModuleClass; typedef struct _ValaCCodeBaseModulePrivate ValaCCodeBaseModulePrivate; #define VALA_CCODE_BASE_MODULE_TYPE_EMIT_CONTEXT (vala_ccode_base_module_emit_context_get_type ()) #define VALA_CCODE_BASE_MODULE_EMIT_CONTEXT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_CCODE_BASE_MODULE_TYPE_EMIT_CONTEXT, ValaCCodeBaseModuleEmitContext)) #define VALA_CCODE_BASE_MODULE_EMIT_CONTEXT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_CCODE_BASE_MODULE_TYPE_EMIT_CONTEXT, ValaCCodeBaseModuleEmitContextClass)) #define VALA_CCODE_BASE_MODULE_IS_EMIT_CONTEXT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_CCODE_BASE_MODULE_TYPE_EMIT_CONTEXT)) #define VALA_CCODE_BASE_MODULE_IS_EMIT_CONTEXT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_CCODE_BASE_MODULE_TYPE_EMIT_CONTEXT)) #define VALA_CCODE_BASE_MODULE_EMIT_CONTEXT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_CCODE_BASE_MODULE_TYPE_EMIT_CONTEXT, ValaCCodeBaseModuleEmitContextClass)) typedef struct _ValaCCodeBaseModuleEmitContext ValaCCodeBaseModuleEmitContext; typedef struct _ValaCCodeBaseModuleEmitContextClass ValaCCodeBaseModuleEmitContextClass; #define VALA_TYPE_CCODE_STRUCT_MODULE (vala_ccode_struct_module_get_type ()) #define VALA_CCODE_STRUCT_MODULE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CCODE_STRUCT_MODULE, ValaCCodeStructModule)) #define VALA_CCODE_STRUCT_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CCODE_STRUCT_MODULE, ValaCCodeStructModuleClass)) #define VALA_IS_CCODE_STRUCT_MODULE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CCODE_STRUCT_MODULE)) #define VALA_IS_CCODE_STRUCT_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CCODE_STRUCT_MODULE)) #define VALA_CCODE_STRUCT_MODULE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CCODE_STRUCT_MODULE, ValaCCodeStructModuleClass)) typedef struct _ValaCCodeStructModule ValaCCodeStructModule; typedef struct _ValaCCodeStructModuleClass ValaCCodeStructModuleClass; typedef struct _ValaCCodeStructModulePrivate ValaCCodeStructModulePrivate; #define VALA_TYPE_CCODE_METHOD_MODULE (vala_ccode_method_module_get_type ()) #define VALA_CCODE_METHOD_MODULE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CCODE_METHOD_MODULE, ValaCCodeMethodModule)) #define VALA_CCODE_METHOD_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CCODE_METHOD_MODULE, ValaCCodeMethodModuleClass)) #define VALA_IS_CCODE_METHOD_MODULE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CCODE_METHOD_MODULE)) #define VALA_IS_CCODE_METHOD_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CCODE_METHOD_MODULE)) #define VALA_CCODE_METHOD_MODULE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CCODE_METHOD_MODULE, ValaCCodeMethodModuleClass)) typedef struct _ValaCCodeMethodModule ValaCCodeMethodModule; typedef struct _ValaCCodeMethodModuleClass ValaCCodeMethodModuleClass; typedef struct _ValaCCodeMethodModulePrivate ValaCCodeMethodModulePrivate; #define _vala_code_node_unref0(var) ((var == NULL) ? NULL : (var = (vala_code_node_unref (var), NULL))) #define _g_free0(var) (var = (g_free (var), NULL)) #define _vala_ccode_node_unref0(var) ((var == NULL) ? NULL : (var = (vala_ccode_node_unref (var), NULL))) #define _vala_iterable_unref0(var) ((var == NULL) ? NULL : (var = (vala_iterable_unref (var), NULL))) #define _vala_map_unref0(var) ((var == NULL) ? NULL : (var = (vala_map_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_TYPE_GLIB_VALUE (vala_glib_value_get_type ()) #define VALA_GLIB_VALUE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_GLIB_VALUE, ValaGLibValue)) #define VALA_GLIB_VALUE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_GLIB_VALUE, ValaGLibValueClass)) #define VALA_IS_GLIB_VALUE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_GLIB_VALUE)) #define VALA_IS_GLIB_VALUE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_GLIB_VALUE)) #define VALA_GLIB_VALUE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_GLIB_VALUE, ValaGLibValueClass)) typedef struct _ValaGLibValue ValaGLibValue; typedef struct _ValaGLibValueClass ValaGLibValueClass; #define _vala_target_value_unref0(var) ((var == NULL) ? NULL : (var = (vala_target_value_unref (var), NULL))) #define _vala_iterator_unref0(var) ((var == NULL) ? NULL : (var = (vala_iterator_unref (var), NULL))) struct _ValaCCodeBaseModule { ValaCodeGenerator parent_instance; ValaCCodeBaseModulePrivate * priv; ValaSymbol* root_symbol; ValaCCodeBaseModuleEmitContext* emit_context; ValaCCodeLineDirective* current_line; ValaCCodeFile* header_file; ValaCCodeFile* internal_header_file; ValaCCodeFile* cfile; ValaCCodeBaseModuleEmitContext* class_init_context; ValaCCodeBaseModuleEmitContext* base_init_context; ValaCCodeBaseModuleEmitContext* class_finalize_context; ValaCCodeBaseModuleEmitContext* base_finalize_context; ValaCCodeBaseModuleEmitContext* instance_init_context; ValaCCodeBaseModuleEmitContext* instance_finalize_context; ValaCCodeStruct* param_spec_struct; ValaCCodeStruct* closure_struct; ValaCCodeEnum* prop_enum; ValaSet* user_marshal_set; ValaSet* predefined_marshal_set; gint next_regex_id; gint next_coroutine_state; ValaDataType* void_type; ValaDataType* bool_type; ValaDataType* char_type; ValaDataType* uchar_type; ValaDataType* unichar_type; ValaDataType* short_type; ValaDataType* ushort_type; ValaDataType* int_type; ValaDataType* uint_type; ValaDataType* long_type; ValaDataType* ulong_type; ValaDataType* int8_type; ValaDataType* uint8_type; ValaDataType* int16_type; ValaDataType* uint16_type; ValaDataType* int32_type; ValaDataType* uint32_type; ValaDataType* int64_type; ValaDataType* uint64_type; ValaDataType* string_type; ValaDataType* regex_type; ValaDataType* float_type; ValaDataType* double_type; ValaTypeSymbol* gtype_type; ValaTypeSymbol* gobject_type; ValaErrorType* gerror_type; ValaClass* glist_type; ValaClass* gslist_type; ValaClass* gnode_type; ValaClass* gqueue_type; ValaClass* gvaluearray_type; ValaTypeSymbol* gstringbuilder_type; ValaTypeSymbol* garray_type; ValaTypeSymbol* gbytearray_type; ValaTypeSymbol* gptrarray_type; ValaTypeSymbol* gthreadpool_type; ValaDataType* gdestroynotify_type; ValaDataType* gquark_type; ValaStruct* gvalue_type; ValaClass* gvariant_type; ValaStruct* mutex_type; ValaTypeSymbol* type_module_type; ValaTypeSymbol* dbus_proxy_type; gboolean in_plugin; gchar* module_init_param_name; gboolean gvaluecollector_h_needed; gboolean requires_array_free; gboolean requires_array_move; gboolean requires_array_length; ValaSet* wrappers; }; struct _ValaCCodeBaseModuleClass { ValaCodeGeneratorClass parent_class; void (*append_vala_array_free) (ValaCCodeBaseModule* self); void (*append_vala_array_move) (ValaCCodeBaseModule* self); void (*append_vala_array_length) (ValaCCodeBaseModule* self); gboolean (*generate_enum_declaration) (ValaCCodeBaseModule* self, ValaEnum* en, ValaCCodeFile* decl_space); void (*generate_class_struct_declaration) (ValaCCodeBaseModule* self, ValaClass* cl, ValaCCodeFile* decl_space); void (*generate_struct_declaration) (ValaCCodeBaseModule* self, ValaStruct* st, ValaCCodeFile* decl_space); void (*generate_delegate_declaration) (ValaCCodeBaseModule* self, ValaDelegate* d, ValaCCodeFile* decl_space); void (*generate_cparameters) (ValaCCodeBaseModule* self, ValaMethod* m, ValaCCodeFile* decl_space, ValaMap* cparam_map, ValaCCodeFunction* func, ValaCCodeFunctionDeclarator* vdeclarator, ValaMap* carg_map, ValaCCodeFunctionCall* vcall, gint direction); ValaCCodeExpression* (*get_dup_func_expression) (ValaCCodeBaseModule* self, ValaDataType* type, ValaSourceReference* source_reference, gboolean is_chainup); gchar* (*append_struct_array_free) (ValaCCodeBaseModule* self, ValaStruct* st); ValaCCodeExpression* (*destroy_value) (ValaCCodeBaseModule* self, ValaTargetValue* value, gboolean is_macro_definition); void (*append_scope_free) (ValaCCodeBaseModule* self, ValaSymbol* sym, ValaCodeNode* stop_at); ValaTargetValue* (*get_local_cvalue) (ValaCCodeBaseModule* self, ValaLocalVariable* local); ValaTargetValue* (*get_parameter_cvalue) (ValaCCodeBaseModule* self, ValaParameter* param); ValaTargetValue* (*get_field_cvalue) (ValaCCodeBaseModule* self, ValaField* field, ValaTargetValue* instance); ValaTargetValue* (*load_variable) (ValaCCodeBaseModule* self, ValaVariable* variable, ValaTargetValue* value); ValaTargetValue* (*load_this_parameter) (ValaCCodeBaseModule* self, ValaTypeSymbol* sym); void (*store_value) (ValaCCodeBaseModule* self, ValaTargetValue* lvalue, ValaTargetValue* value); gchar* (*get_delegate_target_cname) (ValaCCodeBaseModule* self, const gchar* delegate_cname); ValaCCodeExpression* (*get_delegate_target_cexpression) (ValaCCodeBaseModule* self, ValaExpression* delegate_expr, ValaCCodeExpression** delegate_target_destroy_notify); ValaCCodeExpression* (*get_delegate_target_cvalue) (ValaCCodeBaseModule* self, ValaTargetValue* value); ValaCCodeExpression* (*get_delegate_target_destroy_notify_cvalue) (ValaCCodeBaseModule* self, ValaTargetValue* value); gchar* (*get_delegate_target_destroy_notify_cname) (ValaCCodeBaseModule* self, const gchar* delegate_cname); ValaTargetValue* (*copy_value) (ValaCCodeBaseModule* self, ValaTargetValue* value, ValaCodeNode* node); void (*generate_class_declaration) (ValaCCodeBaseModule* self, ValaClass* cl, ValaCCodeFile* decl_space); void (*generate_interface_declaration) (ValaCCodeBaseModule* self, ValaInterface* iface, ValaCCodeFile* decl_space); void (*generate_method_declaration) (ValaCCodeBaseModule* self, ValaMethod* m, ValaCCodeFile* decl_space); void (*generate_error_domain_declaration) (ValaCCodeBaseModule* self, ValaErrorDomain* edomain, ValaCCodeFile* decl_space); ValaCCodeExpression* (*deserialize_expression) (ValaCCodeBaseModule* self, ValaDataType* type, ValaCCodeExpression* variant_expr, ValaCCodeExpression* expr, ValaCCodeExpression* error_expr, gboolean* may_fail); ValaCCodeExpression* (*serialize_expression) (ValaCCodeBaseModule* self, ValaDataType* type, ValaCCodeExpression* expr); ValaCCodeExpression* (*get_implicit_cast_expression) (ValaCCodeBaseModule* self, ValaCCodeExpression* source_cexpr, ValaDataType* expression_type, ValaDataType* target_type, ValaCodeNode* node); void (*create_type_check_statement) (ValaCCodeBaseModule* self, ValaCodeNode* method_node, ValaDataType* ret_type, ValaTypeSymbol* t, gboolean non_null, const gchar* var_name); gboolean (*is_gobject_property) (ValaCCodeBaseModule* self, ValaProperty* prop); void (*generate_dynamic_method_wrapper) (ValaCCodeBaseModule* self, ValaDynamicMethod* method); gboolean (*method_has_wrapper) (ValaCCodeBaseModule* self, ValaMethod* method); ValaCCodeFunctionCall* (*get_param_spec) (ValaCCodeBaseModule* self, ValaProperty* prop); ValaCCodeFunctionCall* (*get_signal_creation) (ValaCCodeBaseModule* self, ValaSignal* sig, ValaTypeSymbol* type); void (*register_dbus_info) (ValaCCodeBaseModule* self, ValaCCodeBlock* block, ValaObjectTypeSymbol* bindable); gchar* (*get_dynamic_property_getter_cname) (ValaCCodeBaseModule* self, ValaDynamicProperty* node); gchar* (*get_dynamic_property_setter_cname) (ValaCCodeBaseModule* self, ValaDynamicProperty* node); gchar* (*get_dynamic_signal_cname) (ValaCCodeBaseModule* self, ValaDynamicSignal* node); gchar* (*get_dynamic_signal_connect_wrapper_name) (ValaCCodeBaseModule* self, ValaDynamicSignal* node); gchar* (*get_dynamic_signal_connect_after_wrapper_name) (ValaCCodeBaseModule* self, ValaDynamicSignal* node); gchar* (*get_dynamic_signal_disconnect_wrapper_name) (ValaCCodeBaseModule* self, ValaDynamicSignal* node); gchar* (*get_array_length_cname) (ValaCCodeBaseModule* self, const gchar* array_cname, gint dim); gchar* (*get_parameter_array_length_cname) (ValaCCodeBaseModule* self, ValaParameter* param, gint dim); ValaCCodeExpression* (*get_array_length_cexpression) (ValaCCodeBaseModule* self, ValaExpression* array_expr, gint dim); ValaCCodeExpression* (*get_array_length_cvalue) (ValaCCodeBaseModule* self, ValaTargetValue* value, gint dim); gchar* (*get_array_size_cname) (ValaCCodeBaseModule* self, const gchar* array_cname); void (*add_simple_check) (ValaCCodeBaseModule* self, ValaCodeNode* node, gboolean always_fails); gchar* (*generate_ready_function) (ValaCCodeBaseModule* self, ValaMethod* m); }; struct _ValaCCodeStructModule { ValaCCodeBaseModule parent_instance; ValaCCodeStructModulePrivate * priv; }; struct _ValaCCodeStructModuleClass { ValaCCodeBaseModuleClass parent_class; }; struct _ValaCCodeMethodModule { ValaCCodeStructModule parent_instance; ValaCCodeMethodModulePrivate * priv; }; struct _ValaCCodeMethodModuleClass { ValaCCodeStructModuleClass parent_class; void (*generate_method_result_declaration) (ValaCCodeMethodModule* self, ValaMethod* m, ValaCCodeFile* decl_space, ValaCCodeFunction* cfunc, ValaMap* cparam_map, ValaMap* carg_map); ValaCCodeParameter* (*generate_parameter) (ValaCCodeMethodModule* self, ValaParameter* param, ValaCCodeFile* decl_space, ValaMap* cparam_map, ValaMap* carg_map); }; static gpointer vala_ccode_method_module_parent_class = NULL; GType vala_ccode_base_module_get_type (void) G_GNUC_CONST; gpointer vala_ccode_base_module_emit_context_ref (gpointer instance); void vala_ccode_base_module_emit_context_unref (gpointer instance); GParamSpec* vala_ccode_base_module_param_spec_emit_context (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags); void vala_ccode_base_module_value_set_emit_context (GValue* value, gpointer v_object); void vala_ccode_base_module_value_take_emit_context (GValue* value, gpointer v_object); gpointer vala_ccode_base_module_value_get_emit_context (const GValue* value); GType vala_ccode_base_module_emit_context_get_type (void) G_GNUC_CONST; GType vala_ccode_struct_module_get_type (void) G_GNUC_CONST; GType vala_ccode_method_module_get_type (void) G_GNUC_CONST; enum { VALA_CCODE_METHOD_MODULE_DUMMY_PROPERTY }; static gboolean vala_ccode_method_module_real_method_has_wrapper (ValaCCodeBaseModule* base, ValaMethod* method); static gchar* vala_ccode_method_module_get_creturn_type (ValaCCodeMethodModule* self, ValaMethod* m, const gchar* default_value); gchar* vala_ccode_base_module_get_ccode_type (ValaCodeNode* node); static gboolean vala_ccode_method_module_is_gtypeinstance_creation_method (ValaCCodeMethodModule* self, ValaMethod* m); void vala_ccode_method_module_generate_method_result_declaration (ValaCCodeMethodModule* self, ValaMethod* m, ValaCCodeFile* decl_space, ValaCCodeFunction* cfunc, ValaMap* cparam_map, ValaMap* carg_map); static void vala_ccode_method_module_real_generate_method_result_declaration (ValaCCodeMethodModule* self, ValaMethod* m, ValaCCodeFile* decl_space, ValaCCodeFunction* cfunc, ValaMap* cparam_map, ValaMap* carg_map); gchar* vala_ccode_base_module_get_ccode_name (ValaCodeNode* node); void vala_ccode_base_module_generate_type_declaration (ValaCCodeBaseModule* self, ValaDataType* type, ValaCCodeFile* decl_space); gint vala_ccode_base_module_get_param_pos (ValaCCodeBaseModule* self, gdouble param_pos, gboolean ellipsis); ValaCCodeExpression* vala_ccode_base_module_get_result_cexpression (ValaCCodeBaseModule* self, const gchar* cname); gboolean vala_ccode_base_module_get_ccode_array_length (ValaCodeNode* node); gchar* vala_ccode_base_module_get_ccode_array_length_type (ValaCodeNode* node); gchar* vala_ccode_base_module_get_array_length_cname (ValaCCodeBaseModule* self, const gchar* array_cname, gint dim); gdouble vala_ccode_base_module_get_ccode_array_length_pos (ValaCodeNode* node); ValaCCodeExpression* vala_ccode_base_module_get_variable_cexpression (ValaCCodeBaseModule* self, const gchar* name); gchar* vala_ccode_base_module_get_delegate_target_cname (ValaCCodeBaseModule* self, const gchar* delegate_cname); gdouble vala_ccode_base_module_get_ccode_delegate_target_pos (ValaCodeNode* node); gchar* vala_ccode_base_module_get_delegate_target_destroy_notify_cname (ValaCCodeBaseModule* self, const gchar* delegate_cname); void vala_ccode_method_module_complete_async (ValaCCodeMethodModule* self); ValaCCodeFunction* vala_ccode_base_module_get_ccode (ValaCCodeBaseModule* self); static void vala_ccode_method_module_real_generate_method_declaration (ValaCCodeBaseModule* base, ValaMethod* m, ValaCCodeFile* decl_space); gboolean vala_ccode_base_module_add_symbol_declaration (ValaCCodeBaseModule* self, ValaCCodeFile* decl_space, ValaSymbol* sym, const gchar* name); void vala_ccode_base_module_generate_cparameters (ValaCCodeBaseModule* self, ValaMethod* m, ValaCCodeFile* decl_space, ValaMap* cparam_map, ValaCCodeFunction* func, ValaCCodeFunctionDeclarator* vdeclarator, ValaMap* carg_map, ValaCCodeFunctionCall* vcall, gint direction); gchar* vala_ccode_base_module_get_ccode_real_name (ValaSymbol* sym); static void vala_ccode_method_module_register_plugin_types (ValaCCodeMethodModule* self, ValaSymbol* sym, ValaSet* registered_types); static void vala_ccode_method_module_register_plugin_type (ValaCCodeMethodModule* self, ValaObjectTypeSymbol* type_symbol, ValaSet* registered_types); gchar* vala_ccode_base_module_get_ccode_lower_case_name (ValaCodeNode* node, const gchar* infix); static void vala_ccode_method_module_real_visit_method (ValaCodeVisitor* base, ValaMethod* m); void vala_ccode_base_module_push_context (ValaCCodeBaseModule* self, ValaCCodeBaseModuleEmitContext* emit_context); ValaCCodeBaseModuleEmitContext* vala_ccode_base_module_emit_context_new (ValaSymbol* symbol); ValaCCodeBaseModuleEmitContext* vala_ccode_base_module_emit_context_construct (GType object_type, ValaSymbol* symbol); void vala_ccode_base_module_push_line (ValaCCodeBaseModule* self, ValaSourceReference* source_reference); void vala_ccode_base_module_check_type (ValaCCodeBaseModule* self, ValaDataType* type); ValaTypeSymbol* vala_ccode_base_module_get_current_type_symbol (ValaCCodeBaseModule* self); void vala_ccode_base_module_generate_method_declaration (ValaCCodeBaseModule* self, ValaMethod* m, ValaCCodeFile* decl_space); gchar* vala_ccode_base_module_get_ccode_const_name (ValaCodeNode* node); void vala_ccode_base_module_push_function (ValaCCodeBaseModule* self, ValaCCodeFunction* func); ValaBlock* vala_ccode_base_module_get_current_closure_block (ValaCCodeBaseModule* self); gint vala_ccode_base_module_get_block_id (ValaCCodeBaseModule* self, ValaBlock* b); ValaBlock* vala_ccode_base_module_next_closure_block (ValaCCodeBaseModule* self, ValaSymbol* sym); ValaCCodeExpression* vala_ccode_base_module_get_cvalue_ (ValaCCodeBaseModule* self, ValaTargetValue* value); ValaTargetValue* vala_ccode_base_module_transform_value (ValaCCodeBaseModule* self, ValaTargetValue* value, ValaDataType* target_type, ValaCodeNode* node); ValaGLibValue* vala_glib_value_new (ValaDataType* value_type, ValaCCodeExpression* cvalue, gboolean lvalue); ValaGLibValue* vala_glib_value_construct (GType object_type, ValaDataType* value_type, ValaCCodeExpression* cvalue, gboolean lvalue); GType vala_glib_value_get_type (void) G_GNUC_CONST; static void vala_ccode_method_module_create_method_type_check_statement (ValaCCodeMethodModule* self, ValaMethod* m, ValaDataType* return_type, ValaTypeSymbol* t, gboolean non_null, const gchar* var_name); gchar* vala_ccode_base_module_get_variable_cname (ValaCCodeBaseModule* self, const gchar* name); ValaCCodeExpression* vala_ccode_base_module_default_value_for_type (ValaCCodeBaseModule* self, ValaDataType* type, gboolean initializer_expression); ValaClass* vala_ccode_base_module_get_current_class (ValaCCodeBaseModule* self); ValaCodeContext* vala_ccode_base_module_get_context (ValaCCodeBaseModule* self); static void vala_ccode_method_module_create_precondition_statement (ValaCCodeMethodModule* self, ValaCodeNode* method_node, ValaDataType* ret_type, ValaExpression* precondition); gboolean vala_ccode_base_module_get_current_method_inner_error (ValaCCodeBaseModule* self); void vala_ccode_base_module_return_default_value (ValaCCodeBaseModule* self, ValaDataType* return_type); void vala_ccode_base_module_pop_context (ValaCCodeBaseModule* self); void vala_ccode_method_module_generate_vfunc (ValaCCodeMethodModule* self, ValaMethod* m, ValaDataType* return_type, ValaMap* cparam_map, ValaMap* carg_map, const gchar* suffix, gint direction); void vala_ccode_base_module_pop_function (ValaCCodeBaseModule* self); void vala_ccode_base_module_pop_line (ValaCCodeBaseModule* self); ValaCCodeParameter* vala_ccode_method_module_generate_parameter (ValaCCodeMethodModule* self, ValaParameter* param, ValaCCodeFile* decl_space, ValaMap* cparam_map, ValaMap* carg_map); static ValaCCodeParameter* vala_ccode_method_module_real_generate_parameter (ValaCCodeMethodModule* self, ValaParameter* param, ValaCCodeFile* decl_space, ValaMap* cparam_map, ValaMap* carg_map); gdouble vala_ccode_base_module_get_ccode_pos (ValaParameter* param); static void vala_ccode_method_module_real_generate_cparameters (ValaCCodeBaseModule* base, ValaMethod* m, ValaCCodeFile* decl_space, ValaMap* cparam_map, ValaCCodeFunction* func, ValaCCodeFunctionDeclarator* vdeclarator, ValaMap* carg_map, ValaCCodeFunctionCall* vcall, gint direction); gdouble vala_ccode_base_module_get_ccode_instance_pos (ValaCodeNode* node); static ValaTypeSymbol* vala_ccode_method_module_find_parent_type (ValaCCodeMethodModule* self, ValaSymbol* sym); gchar* vala_ccode_base_module_get_ccode_upper_case_name (ValaSymbol* sym, const gchar* infix); gchar* vala_ccode_base_module_get_ccode_vfunc_name (ValaMethod* m); void vala_ccode_base_module_create_postcondition_statement (ValaCCodeBaseModule* self, ValaExpression* postcondition); void vala_ccode_base_module_create_type_check_statement (ValaCCodeBaseModule* self, ValaCodeNode* method_node, ValaDataType* ret_type, ValaTypeSymbol* t, gboolean non_null, const gchar* var_name); ValaCCodeExpression* vala_ccode_base_module_get_cvalue (ValaCCodeBaseModule* self, ValaExpression* expr); static void vala_ccode_method_module_real_visit_creation_method (ValaCodeVisitor* base, ValaCreationMethod* m); gchar* vala_ccode_base_module_get_ccode_type_id (ValaCodeNode* node); ValaCCodeMethodModule* vala_ccode_method_module_construct (GType object_type); ValaCCodeStructModule* vala_ccode_struct_module_construct (GType object_type); static gboolean vala_ccode_method_module_real_method_has_wrapper (ValaCCodeBaseModule* base, ValaMethod* method) { ValaCCodeMethodModule * self; gboolean result = FALSE; ValaMethod* _tmp0_; ValaAttribute* _tmp1_ = NULL; ValaAttribute* _tmp2_; gboolean _tmp3_; self = (ValaCCodeMethodModule*) base; g_return_val_if_fail (method != NULL, FALSE); _tmp0_ = method; _tmp1_ = vala_code_node_get_attribute ((ValaCodeNode*) _tmp0_, "NoWrapper"); _tmp2_ = _tmp1_; _tmp3_ = _tmp2_ == NULL; _vala_code_node_unref0 (_tmp2_); result = _tmp3_; return result; } static gchar* vala_ccode_method_module_get_creturn_type (ValaCCodeMethodModule* self, ValaMethod* m, const gchar* default_value) { gchar* result = NULL; ValaMethod* _tmp0_; gchar* _tmp1_ = NULL; gchar* type; const gchar* _tmp2_; g_return_val_if_fail (self != NULL, NULL); g_return_val_if_fail (m != NULL, NULL); g_return_val_if_fail (default_value != NULL, NULL); _tmp0_ = m; _tmp1_ = vala_ccode_base_module_get_ccode_type ((ValaCodeNode*) _tmp0_); type = _tmp1_; _tmp2_ = type; if (_tmp2_ == NULL) { const gchar* _tmp3_; gchar* _tmp4_; _tmp3_ = default_value; _tmp4_ = g_strdup (_tmp3_); result = _tmp4_; _g_free0 (type); return result; } result = type; return result; } static gpointer _vala_code_node_ref0 (gpointer self) { return self ? vala_code_node_ref (self) : NULL; } static gboolean vala_ccode_method_module_is_gtypeinstance_creation_method (ValaCCodeMethodModule* self, ValaMethod* m) { gboolean result = FALSE; gboolean _result_; ValaMethod* _tmp0_; ValaSymbol* _tmp1_; ValaSymbol* _tmp2_; ValaClass* _tmp3_; ValaClass* cl; gboolean _tmp4_ = FALSE; gboolean _tmp5_ = FALSE; ValaMethod* _tmp6_; gboolean _tmp8_; gboolean _tmp12_; g_return_val_if_fail (self != NULL, FALSE); g_return_val_if_fail (m != NULL, FALSE); _result_ = FALSE; _tmp0_ = m; _tmp1_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp0_); _tmp2_ = _tmp1_; _tmp3_ = _vala_code_node_ref0 (VALA_IS_CLASS (_tmp2_) ? ((ValaClass*) _tmp2_) : NULL); cl = _tmp3_; _tmp6_ = m; if (VALA_IS_CREATION_METHOD (_tmp6_)) { ValaClass* _tmp7_; _tmp7_ = cl; _tmp5_ = _tmp7_ != NULL; } else { _tmp5_ = FALSE; } _tmp8_ = _tmp5_; if (_tmp8_) { ValaClass* _tmp9_; gboolean _tmp10_; gboolean _tmp11_; _tmp9_ = cl; _tmp10_ = vala_class_get_is_compact (_tmp9_); _tmp11_ = _tmp10_; _tmp4_ = !_tmp11_; } else { _tmp4_ = FALSE; } _tmp12_ = _tmp4_; if (_tmp12_) { _result_ = TRUE; } result = _result_; _vala_code_node_unref0 (cl); return result; } static void vala_ccode_method_module_real_generate_method_result_declaration (ValaCCodeMethodModule* self, ValaMethod* m, ValaCCodeFile* decl_space, ValaCCodeFunction* cfunc, ValaMap* cparam_map, ValaMap* carg_map) { ValaMethod* _tmp0_; ValaDataType* _tmp1_; ValaDataType* _tmp2_; ValaDataType* _tmp3_; ValaDataType* creturn_type; ValaMethod* _tmp4_; ValaCCodeFunction* _tmp17_; ValaMethod* _tmp18_; ValaDataType* _tmp19_; gchar* _tmp20_ = NULL; gchar* _tmp21_; gchar* _tmp22_ = NULL; gchar* _tmp23_; ValaMethod* _tmp24_; ValaDataType* _tmp25_; ValaDataType* _tmp26_; ValaCCodeFile* _tmp27_; ValaMethod* _tmp28_; ValaDataType* _tmp29_; ValaDataType* _tmp30_; gboolean _tmp31_ = FALSE; gboolean _tmp156_ = FALSE; gboolean _tmp157_ = FALSE; ValaMethod* _tmp158_; ValaList* _tmp159_ = NULL; ValaList* _tmp160_; gint _tmp161_; gint _tmp162_; gboolean _tmp163_; gboolean _tmp176_; gboolean _tmp189_; g_return_if_fail (m != NULL); g_return_if_fail (decl_space != NULL); g_return_if_fail (cfunc != NULL); g_return_if_fail (cparam_map != NULL); _tmp0_ = m; _tmp1_ = vala_method_get_return_type (_tmp0_); _tmp2_ = _tmp1_; _tmp3_ = _vala_code_node_ref0 (_tmp2_); creturn_type = _tmp3_; _tmp4_ = m; if (VALA_IS_CREATION_METHOD (_tmp4_)) { ValaMethod* _tmp5_; ValaSymbol* _tmp6_; ValaSymbol* _tmp7_; ValaClass* _tmp8_; ValaClass* cl; ValaClass* _tmp9_; _tmp5_ = m; _tmp6_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp5_); _tmp7_ = _tmp6_; _tmp8_ = _vala_code_node_ref0 (VALA_IS_CLASS (_tmp7_) ? ((ValaClass*) _tmp7_) : NULL); cl = _tmp8_; _tmp9_ = cl; if (_tmp9_ != NULL) { ValaClass* _tmp10_; ValaObjectType* _tmp11_; _tmp10_ = cl; _tmp11_ = vala_object_type_new ((ValaObjectTypeSymbol*) _tmp10_); _vala_code_node_unref0 (creturn_type); creturn_type = (ValaDataType*) _tmp11_; } _vala_code_node_unref0 (cl); } else { ValaMethod* _tmp12_; ValaDataType* _tmp13_; ValaDataType* _tmp14_; gboolean _tmp15_ = FALSE; _tmp12_ = m; _tmp13_ = vala_method_get_return_type (_tmp12_); _tmp14_ = _tmp13_; _tmp15_ = vala_data_type_is_real_non_null_struct_type (_tmp14_); if (_tmp15_) { ValaVoidType* _tmp16_; _tmp16_ = vala_void_type_new (NULL); _vala_code_node_unref0 (creturn_type); creturn_type = (ValaDataType*) _tmp16_; } } _tmp17_ = cfunc; _tmp18_ = m; _tmp19_ = creturn_type; _tmp20_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp19_); _tmp21_ = _tmp20_; _tmp22_ = vala_ccode_method_module_get_creturn_type (self, _tmp18_, _tmp21_); _tmp23_ = _tmp22_; vala_ccode_function_set_return_type (_tmp17_, _tmp23_); _g_free0 (_tmp23_); _g_free0 (_tmp21_); _tmp24_ = m; _tmp25_ = vala_method_get_return_type (_tmp24_); _tmp26_ = _tmp25_; _tmp27_ = decl_space; vala_ccode_base_module_generate_type_declaration ((ValaCCodeBaseModule*) self, _tmp26_, _tmp27_); _tmp28_ = m; _tmp29_ = vala_method_get_return_type (_tmp28_); _tmp30_ = _tmp29_; _tmp31_ = vala_data_type_is_real_non_null_struct_type (_tmp30_); if (_tmp31_) { ValaMethod* _tmp32_; ValaDataType* _tmp33_; ValaDataType* _tmp34_; gchar* _tmp35_ = NULL; gchar* _tmp36_; gchar* _tmp37_; gchar* _tmp38_; ValaCCodeParameter* _tmp39_; ValaCCodeParameter* _tmp40_; ValaCCodeParameter* cparam; ValaMap* _tmp41_; gint _tmp42_ = 0; ValaCCodeParameter* _tmp43_; ValaMap* _tmp44_; _tmp32_ = m; _tmp33_ = vala_method_get_return_type (_tmp32_); _tmp34_ = _tmp33_; _tmp35_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp34_); _tmp36_ = _tmp35_; _tmp37_ = g_strconcat (_tmp36_, "*", NULL); _tmp38_ = _tmp37_; _tmp39_ = vala_ccode_parameter_new ("result", _tmp38_); _tmp40_ = _tmp39_; _g_free0 (_tmp38_); _g_free0 (_tmp36_); cparam = _tmp40_; _tmp41_ = cparam_map; _tmp42_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, (gdouble) (-3), FALSE); _tmp43_ = cparam; vala_map_set (_tmp41_, GINT_TO_POINTER (_tmp42_), _tmp43_); _tmp44_ = carg_map; if (_tmp44_ != NULL) { ValaMap* _tmp45_; gint _tmp46_ = 0; ValaCCodeExpression* _tmp47_ = NULL; ValaCCodeExpression* _tmp48_; _tmp45_ = carg_map; _tmp46_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, (gdouble) (-3), FALSE); _tmp47_ = vala_ccode_base_module_get_result_cexpression ((ValaCCodeBaseModule*) self, "result"); _tmp48_ = _tmp47_; vala_map_set (_tmp45_, GINT_TO_POINTER (_tmp46_), _tmp48_); _vala_ccode_node_unref0 (_tmp48_); } _vala_ccode_node_unref0 (cparam); } else { gboolean _tmp49_ = FALSE; ValaMethod* _tmp50_; gboolean _tmp51_ = FALSE; gboolean _tmp55_; _tmp50_ = m; _tmp51_ = vala_ccode_base_module_get_ccode_array_length ((ValaCodeNode*) _tmp50_); if (_tmp51_) { ValaMethod* _tmp52_; ValaDataType* _tmp53_; ValaDataType* _tmp54_; _tmp52_ = m; _tmp53_ = vala_method_get_return_type (_tmp52_); _tmp54_ = _tmp53_; _tmp49_ = VALA_IS_ARRAY_TYPE (_tmp54_); } else { _tmp49_ = FALSE; } _tmp55_ = _tmp49_; if (_tmp55_) { ValaMethod* _tmp56_; ValaDataType* _tmp57_; ValaDataType* _tmp58_; ValaArrayType* _tmp59_; ValaArrayType* array_type; gchar* _tmp60_ = NULL; ValaMethod* _tmp61_; gchar* _tmp62_ = NULL; gchar* _tmp63_; gboolean _tmp64_; const gchar* _tmp68_; gchar* _tmp69_; gchar* array_length_type; const gchar* _tmp70_; gchar* _tmp71_; _tmp56_ = m; _tmp57_ = vala_method_get_return_type (_tmp56_); _tmp58_ = _tmp57_; _tmp59_ = _vala_code_node_ref0 (VALA_ARRAY_TYPE (_tmp58_)); array_type = _tmp59_; _tmp61_ = m; _tmp62_ = vala_ccode_base_module_get_ccode_array_length_type ((ValaCodeNode*) _tmp61_); _tmp63_ = _tmp62_; _tmp64_ = _tmp63_ != NULL; _g_free0 (_tmp63_); if (_tmp64_) { ValaMethod* _tmp65_; gchar* _tmp66_ = NULL; _tmp65_ = m; _tmp66_ = vala_ccode_base_module_get_ccode_array_length_type ((ValaCodeNode*) _tmp65_); _g_free0 (_tmp60_); _tmp60_ = _tmp66_; } else { gchar* _tmp67_; _tmp67_ = g_strdup ("int"); _g_free0 (_tmp60_); _tmp60_ = _tmp67_; } _tmp68_ = _tmp60_; _tmp69_ = g_strdup (_tmp68_); array_length_type = _tmp69_; _tmp70_ = array_length_type; _tmp71_ = g_strconcat (_tmp70_, "*", NULL); _g_free0 (array_length_type); array_length_type = _tmp71_; { gint dim; dim = 1; { gboolean _tmp72_; _tmp72_ = TRUE; while (TRUE) { gboolean _tmp73_; gint _tmp75_; ValaArrayType* _tmp76_; gint _tmp77_; gint _tmp78_; gint _tmp79_; gchar* _tmp80_ = NULL; gchar* _tmp81_; const gchar* _tmp82_; ValaCCodeParameter* _tmp83_; ValaCCodeParameter* _tmp84_; ValaCCodeParameter* cparam; ValaMap* _tmp85_; ValaMethod* _tmp86_; gdouble _tmp87_ = 0.0; gint _tmp88_; gint _tmp89_ = 0; ValaCCodeParameter* _tmp90_; ValaMap* _tmp91_; _tmp73_ = _tmp72_; if (!_tmp73_) { gint _tmp74_; _tmp74_ = dim; dim = _tmp74_ + 1; } _tmp72_ = FALSE; _tmp75_ = dim; _tmp76_ = array_type; _tmp77_ = vala_array_type_get_rank (_tmp76_); _tmp78_ = _tmp77_; if (!(_tmp75_ <= _tmp78_)) { break; } _tmp79_ = dim; _tmp80_ = vala_ccode_base_module_get_array_length_cname ((ValaCCodeBaseModule*) self, "result", _tmp79_); _tmp81_ = _tmp80_; _tmp82_ = array_length_type; _tmp83_ = vala_ccode_parameter_new (_tmp81_, _tmp82_); _tmp84_ = _tmp83_; _g_free0 (_tmp81_); cparam = _tmp84_; _tmp85_ = cparam_map; _tmp86_ = m; _tmp87_ = vala_ccode_base_module_get_ccode_array_length_pos ((ValaCodeNode*) _tmp86_); _tmp88_ = dim; _tmp89_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, _tmp87_ + (0.01 * _tmp88_), FALSE); _tmp90_ = cparam; vala_map_set (_tmp85_, GINT_TO_POINTER (_tmp89_), _tmp90_); _tmp91_ = carg_map; if (_tmp91_ != NULL) { ValaMap* _tmp92_; ValaMethod* _tmp93_; gdouble _tmp94_ = 0.0; gint _tmp95_; gint _tmp96_ = 0; ValaCCodeParameter* _tmp97_; const gchar* _tmp98_; const gchar* _tmp99_; ValaCCodeExpression* _tmp100_ = NULL; ValaCCodeExpression* _tmp101_; _tmp92_ = carg_map; _tmp93_ = m; _tmp94_ = vala_ccode_base_module_get_ccode_array_length_pos ((ValaCodeNode*) _tmp93_); _tmp95_ = dim; _tmp96_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, _tmp94_ + (0.01 * _tmp95_), FALSE); _tmp97_ = cparam; _tmp98_ = vala_ccode_parameter_get_name (_tmp97_); _tmp99_ = _tmp98_; _tmp100_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, _tmp99_); _tmp101_ = _tmp100_; vala_map_set (_tmp92_, GINT_TO_POINTER (_tmp96_), _tmp101_); _vala_ccode_node_unref0 (_tmp101_); } _vala_ccode_node_unref0 (cparam); } } } _g_free0 (array_length_type); _g_free0 (_tmp60_); _vala_code_node_unref0 (array_type); } else { ValaMethod* _tmp102_; ValaDataType* _tmp103_; ValaDataType* _tmp104_; _tmp102_ = m; _tmp103_ = vala_method_get_return_type (_tmp102_); _tmp104_ = _tmp103_; if (VALA_IS_DELEGATE_TYPE (_tmp104_)) { ValaMethod* _tmp105_; ValaDataType* _tmp106_; ValaDataType* _tmp107_; ValaDelegateType* _tmp108_; ValaDelegateType* deleg_type; ValaDelegateType* _tmp109_; ValaDelegate* _tmp110_; ValaDelegate* _tmp111_; ValaDelegate* _tmp112_; ValaDelegate* d; ValaDelegate* _tmp113_; gboolean _tmp114_; gboolean _tmp115_; _tmp105_ = m; _tmp106_ = vala_method_get_return_type (_tmp105_); _tmp107_ = _tmp106_; _tmp108_ = _vala_code_node_ref0 (VALA_DELEGATE_TYPE (_tmp107_)); deleg_type = _tmp108_; _tmp109_ = deleg_type; _tmp110_ = vala_delegate_type_get_delegate_symbol (_tmp109_); _tmp111_ = _tmp110_; _tmp112_ = _vala_code_node_ref0 (_tmp111_); d = _tmp112_; _tmp113_ = d; _tmp114_ = vala_delegate_get_has_target (_tmp113_); _tmp115_ = _tmp114_; if (_tmp115_) { gchar* _tmp116_ = NULL; gchar* _tmp117_; ValaCCodeParameter* _tmp118_; ValaCCodeParameter* _tmp119_; ValaCCodeParameter* cparam; ValaMap* _tmp120_; ValaMethod* _tmp121_; gdouble _tmp122_ = 0.0; gint _tmp123_ = 0; ValaCCodeParameter* _tmp124_; ValaMap* _tmp125_; ValaDelegateType* _tmp135_; gboolean _tmp136_; gboolean _tmp137_; _tmp116_ = vala_ccode_base_module_get_delegate_target_cname ((ValaCCodeBaseModule*) self, "result"); _tmp117_ = _tmp116_; _tmp118_ = vala_ccode_parameter_new (_tmp117_, "void**"); _tmp119_ = _tmp118_; _g_free0 (_tmp117_); cparam = _tmp119_; _tmp120_ = cparam_map; _tmp121_ = m; _tmp122_ = vala_ccode_base_module_get_ccode_delegate_target_pos ((ValaCodeNode*) _tmp121_); _tmp123_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, _tmp122_, FALSE); _tmp124_ = cparam; vala_map_set (_tmp120_, GINT_TO_POINTER (_tmp123_), _tmp124_); _tmp125_ = carg_map; if (_tmp125_ != NULL) { ValaMap* _tmp126_; ValaMethod* _tmp127_; gdouble _tmp128_ = 0.0; gint _tmp129_ = 0; ValaCCodeParameter* _tmp130_; const gchar* _tmp131_; const gchar* _tmp132_; ValaCCodeExpression* _tmp133_ = NULL; ValaCCodeExpression* _tmp134_; _tmp126_ = carg_map; _tmp127_ = m; _tmp128_ = vala_ccode_base_module_get_ccode_delegate_target_pos ((ValaCodeNode*) _tmp127_); _tmp129_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, _tmp128_, FALSE); _tmp130_ = cparam; _tmp131_ = vala_ccode_parameter_get_name (_tmp130_); _tmp132_ = _tmp131_; _tmp133_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, _tmp132_); _tmp134_ = _tmp133_; vala_map_set (_tmp126_, GINT_TO_POINTER (_tmp129_), _tmp134_); _vala_ccode_node_unref0 (_tmp134_); } _tmp135_ = deleg_type; _tmp136_ = vala_data_type_get_value_owned ((ValaDataType*) _tmp135_); _tmp137_ = _tmp136_; if (_tmp137_) { gchar* _tmp138_ = NULL; gchar* _tmp139_; ValaCCodeParameter* _tmp140_; ValaMap* _tmp141_; ValaMethod* _tmp142_; gdouble _tmp143_ = 0.0; gint _tmp144_ = 0; ValaCCodeParameter* _tmp145_; ValaMap* _tmp146_; _tmp138_ = vala_ccode_base_module_get_delegate_target_destroy_notify_cname ((ValaCCodeBaseModule*) self, "result"); _tmp139_ = _tmp138_; _tmp140_ = vala_ccode_parameter_new (_tmp139_, "GDestroyNotify*"); _vala_ccode_node_unref0 (cparam); cparam = _tmp140_; _g_free0 (_tmp139_); _tmp141_ = cparam_map; _tmp142_ = m; _tmp143_ = vala_ccode_base_module_get_ccode_delegate_target_pos ((ValaCodeNode*) _tmp142_); _tmp144_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, _tmp143_ + 0.01, FALSE); _tmp145_ = cparam; vala_map_set (_tmp141_, GINT_TO_POINTER (_tmp144_), _tmp145_); _tmp146_ = carg_map; if (_tmp146_ != NULL) { ValaMap* _tmp147_; ValaMethod* _tmp148_; gdouble _tmp149_ = 0.0; gint _tmp150_ = 0; ValaCCodeParameter* _tmp151_; const gchar* _tmp152_; const gchar* _tmp153_; ValaCCodeExpression* _tmp154_ = NULL; ValaCCodeExpression* _tmp155_; _tmp147_ = carg_map; _tmp148_ = m; _tmp149_ = vala_ccode_base_module_get_ccode_delegate_target_pos ((ValaCodeNode*) _tmp148_); _tmp150_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, _tmp149_ + 0.01, FALSE); _tmp151_ = cparam; _tmp152_ = vala_ccode_parameter_get_name (_tmp151_); _tmp153_ = _tmp152_; _tmp154_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, _tmp153_); _tmp155_ = _tmp154_; vala_map_set (_tmp147_, GINT_TO_POINTER (_tmp150_), _tmp155_); _vala_ccode_node_unref0 (_tmp155_); } } _vala_ccode_node_unref0 (cparam); } _vala_code_node_unref0 (d); _vala_code_node_unref0 (deleg_type); } } } _tmp158_ = m; _tmp159_ = vala_code_node_get_error_types ((ValaCodeNode*) _tmp158_); _tmp160_ = _tmp159_; _tmp161_ = vala_collection_get_size ((ValaCollection*) _tmp160_); _tmp162_ = _tmp161_; _tmp163_ = _tmp162_ > 0; _vala_iterable_unref0 (_tmp160_); if (_tmp163_) { _tmp157_ = TRUE; } else { gboolean _tmp164_ = FALSE; ValaMethod* _tmp165_; ValaMethod* _tmp166_; ValaMethod* _tmp167_; gboolean _tmp175_; _tmp165_ = m; _tmp166_ = vala_method_get_base_method (_tmp165_); _tmp167_ = _tmp166_; if (_tmp167_ != NULL) { ValaMethod* _tmp168_; ValaMethod* _tmp169_; ValaMethod* _tmp170_; ValaList* _tmp171_ = NULL; ValaList* _tmp172_; gint _tmp173_; gint _tmp174_; _tmp168_ = m; _tmp169_ = vala_method_get_base_method (_tmp168_); _tmp170_ = _tmp169_; _tmp171_ = vala_code_node_get_error_types ((ValaCodeNode*) _tmp170_); _tmp172_ = _tmp171_; _tmp173_ = vala_collection_get_size ((ValaCollection*) _tmp172_); _tmp174_ = _tmp173_; _tmp164_ = _tmp174_ > 0; _vala_iterable_unref0 (_tmp172_); } else { _tmp164_ = FALSE; } _tmp175_ = _tmp164_; _tmp157_ = _tmp175_; } _tmp176_ = _tmp157_; if (_tmp176_) { _tmp156_ = TRUE; } else { gboolean _tmp177_ = FALSE; ValaMethod* _tmp178_; ValaMethod* _tmp179_; ValaMethod* _tmp180_; gboolean _tmp188_; _tmp178_ = m; _tmp179_ = vala_method_get_base_interface_method (_tmp178_); _tmp180_ = _tmp179_; if (_tmp180_ != NULL) { ValaMethod* _tmp181_; ValaMethod* _tmp182_; ValaMethod* _tmp183_; ValaList* _tmp184_ = NULL; ValaList* _tmp185_; gint _tmp186_; gint _tmp187_; _tmp181_ = m; _tmp182_ = vala_method_get_base_interface_method (_tmp181_); _tmp183_ = _tmp182_; _tmp184_ = vala_code_node_get_error_types ((ValaCodeNode*) _tmp183_); _tmp185_ = _tmp184_; _tmp186_ = vala_collection_get_size ((ValaCollection*) _tmp185_); _tmp187_ = _tmp186_; _tmp177_ = _tmp187_ > 0; _vala_iterable_unref0 (_tmp185_); } else { _tmp177_ = FALSE; } _tmp188_ = _tmp177_; _tmp156_ = _tmp188_; } _tmp189_ = _tmp156_; if (_tmp189_) { ValaCCodeParameter* _tmp203_; ValaCCodeParameter* cparam; ValaMap* _tmp204_; gint _tmp205_ = 0; ValaCCodeParameter* _tmp206_; ValaMap* _tmp207_; { ValaMethod* _tmp190_; ValaList* _tmp191_ = NULL; ValaList* _error_type_list; ValaList* _tmp192_; gint _tmp193_; gint _tmp194_; gint _error_type_size; gint _error_type_index; _tmp190_ = m; _tmp191_ = vala_code_node_get_error_types ((ValaCodeNode*) _tmp190_); _error_type_list = _tmp191_; _tmp192_ = _error_type_list; _tmp193_ = vala_collection_get_size ((ValaCollection*) _tmp192_); _tmp194_ = _tmp193_; _error_type_size = _tmp194_; _error_type_index = -1; while (TRUE) { gint _tmp195_; gint _tmp196_; gint _tmp197_; ValaList* _tmp198_; gint _tmp199_; gpointer _tmp200_ = NULL; ValaDataType* error_type; ValaDataType* _tmp201_; ValaCCodeFile* _tmp202_; _tmp195_ = _error_type_index; _error_type_index = _tmp195_ + 1; _tmp196_ = _error_type_index; _tmp197_ = _error_type_size; if (!(_tmp196_ < _tmp197_)) { break; } _tmp198_ = _error_type_list; _tmp199_ = _error_type_index; _tmp200_ = vala_list_get (_tmp198_, _tmp199_); error_type = (ValaDataType*) _tmp200_; _tmp201_ = error_type; _tmp202_ = decl_space; vala_ccode_base_module_generate_type_declaration ((ValaCCodeBaseModule*) self, _tmp201_, _tmp202_); _vala_code_node_unref0 (error_type); } _vala_iterable_unref0 (_error_type_list); } _tmp203_ = vala_ccode_parameter_new ("error", "GError**"); cparam = _tmp203_; _tmp204_ = cparam_map; _tmp205_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, (gdouble) (-1), FALSE); _tmp206_ = cparam; vala_map_set (_tmp204_, GINT_TO_POINTER (_tmp205_), _tmp206_); _tmp207_ = carg_map; if (_tmp207_ != NULL) { ValaMap* _tmp208_; gint _tmp209_ = 0; ValaCCodeParameter* _tmp210_; const gchar* _tmp211_; const gchar* _tmp212_; ValaCCodeIdentifier* _tmp213_; ValaCCodeIdentifier* _tmp214_; _tmp208_ = carg_map; _tmp209_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, (gdouble) (-1), FALSE); _tmp210_ = cparam; _tmp211_ = vala_ccode_parameter_get_name (_tmp210_); _tmp212_ = _tmp211_; _tmp213_ = vala_ccode_identifier_new (_tmp212_); _tmp214_ = _tmp213_; vala_map_set (_tmp208_, GINT_TO_POINTER (_tmp209_), (ValaCCodeExpression*) _tmp214_); _vala_ccode_node_unref0 (_tmp214_); } _vala_ccode_node_unref0 (cparam); } _vala_code_node_unref0 (creturn_type); } void vala_ccode_method_module_generate_method_result_declaration (ValaCCodeMethodModule* self, ValaMethod* m, ValaCCodeFile* decl_space, ValaCCodeFunction* cfunc, ValaMap* cparam_map, ValaMap* carg_map) { g_return_if_fail (self != NULL); VALA_CCODE_METHOD_MODULE_GET_CLASS (self)->generate_method_result_declaration (self, m, decl_space, cfunc, cparam_map, carg_map); } void vala_ccode_method_module_complete_async (ValaCCodeMethodModule* self) { ValaCCodeIdentifier* _tmp0_; ValaCCodeIdentifier* _tmp1_; ValaCCodeMemberAccess* _tmp2_; ValaCCodeMemberAccess* _tmp3_; ValaCCodeMemberAccess* state; ValaCCodeConstant* _tmp4_; ValaCCodeConstant* zero; ValaCCodeBinaryExpression* _tmp5_; ValaCCodeBinaryExpression* state_is_zero; ValaCCodeFunction* _tmp6_; ValaCCodeFunction* _tmp7_; ValaCCodeIdentifier* _tmp8_; ValaCCodeIdentifier* _tmp9_; ValaCCodeMemberAccess* _tmp10_; ValaCCodeMemberAccess* _tmp11_; ValaCCodeMemberAccess* async_result_expr; ValaCCodeIdentifier* _tmp12_; ValaCCodeIdentifier* _tmp13_; ValaCCodeFunctionCall* _tmp14_; ValaCCodeFunctionCall* _tmp15_; ValaCCodeFunctionCall* idle_call; ValaCCodeFunction* _tmp16_; ValaCCodeFunction* _tmp17_; ValaCCodeFunction* _tmp18_; ValaCCodeFunction* _tmp19_; ValaCCodeIdentifier* _tmp20_; ValaCCodeIdentifier* _tmp21_; ValaCCodeFunctionCall* _tmp22_; ValaCCodeFunctionCall* _tmp23_; ValaCCodeFunctionCall* direct_call; ValaCCodeFunction* _tmp24_; ValaCCodeFunction* _tmp25_; ValaCCodeFunction* _tmp26_; ValaCCodeFunction* _tmp27_; ValaCCodeIdentifier* _tmp28_; ValaCCodeIdentifier* _tmp29_; ValaCCodeFunctionCall* _tmp30_; ValaCCodeFunctionCall* _tmp31_; ValaCCodeFunctionCall* unref; ValaCCodeFunction* _tmp32_; ValaCCodeFunction* _tmp33_; ValaCCodeFunction* _tmp34_; ValaCCodeFunction* _tmp35_; ValaCCodeConstant* _tmp36_; ValaCCodeConstant* _tmp37_; g_return_if_fail (self != NULL); _tmp0_ = vala_ccode_identifier_new ("_data_"); _tmp1_ = _tmp0_; _tmp2_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp1_, "_state_"); _tmp3_ = _tmp2_; _vala_ccode_node_unref0 (_tmp1_); state = _tmp3_; _tmp4_ = vala_ccode_constant_new ("0"); zero = _tmp4_; _tmp5_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_EQUALITY, (ValaCCodeExpression*) state, (ValaCCodeExpression*) zero); state_is_zero = _tmp5_; _tmp6_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); _tmp7_ = _tmp6_; vala_ccode_function_open_if (_tmp7_, (ValaCCodeExpression*) state_is_zero); _tmp8_ = vala_ccode_identifier_new ("_data_"); _tmp9_ = _tmp8_; _tmp10_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp9_, "_async_result"); _tmp11_ = _tmp10_; _vala_ccode_node_unref0 (_tmp9_); async_result_expr = _tmp11_; _tmp12_ = vala_ccode_identifier_new ("g_simple_async_result_complete_in_idle"); _tmp13_ = _tmp12_; _tmp14_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp13_); _tmp15_ = _tmp14_; _vala_ccode_node_unref0 (_tmp13_); idle_call = _tmp15_; vala_ccode_function_call_add_argument (idle_call, (ValaCCodeExpression*) async_result_expr); _tmp16_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); _tmp17_ = _tmp16_; vala_ccode_function_add_expression (_tmp17_, (ValaCCodeExpression*) idle_call); _tmp18_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); _tmp19_ = _tmp18_; vala_ccode_function_add_else (_tmp19_); _tmp20_ = vala_ccode_identifier_new ("g_simple_async_result_complete"); _tmp21_ = _tmp20_; _tmp22_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp21_); _tmp23_ = _tmp22_; _vala_ccode_node_unref0 (_tmp21_); direct_call = _tmp23_; vala_ccode_function_call_add_argument (direct_call, (ValaCCodeExpression*) async_result_expr); _tmp24_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); _tmp25_ = _tmp24_; vala_ccode_function_add_expression (_tmp25_, (ValaCCodeExpression*) direct_call); _tmp26_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); _tmp27_ = _tmp26_; vala_ccode_function_close (_tmp27_); _tmp28_ = vala_ccode_identifier_new ("g_object_unref"); _tmp29_ = _tmp28_; _tmp30_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp29_); _tmp31_ = _tmp30_; _vala_ccode_node_unref0 (_tmp29_); unref = _tmp31_; vala_ccode_function_call_add_argument (unref, (ValaCCodeExpression*) async_result_expr); _tmp32_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); _tmp33_ = _tmp32_; vala_ccode_function_add_expression (_tmp33_, (ValaCCodeExpression*) unref); _tmp34_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); _tmp35_ = _tmp34_; _tmp36_ = vala_ccode_constant_new ("FALSE"); _tmp37_ = _tmp36_; vala_ccode_function_add_return (_tmp35_, (ValaCCodeExpression*) _tmp37_); _vala_ccode_node_unref0 (_tmp37_); _vala_ccode_node_unref0 (unref); _vala_ccode_node_unref0 (direct_call); _vala_ccode_node_unref0 (idle_call); _vala_ccode_node_unref0 (async_result_expr); _vala_ccode_node_unref0 (state_is_zero); _vala_ccode_node_unref0 (zero); _vala_ccode_node_unref0 (state); } static void vala_ccode_method_module_real_generate_method_declaration (ValaCCodeBaseModule* base, ValaMethod* m, ValaCCodeFile* decl_space) { ValaCCodeMethodModule * self; ValaMethod* _tmp0_; gboolean _tmp1_; gboolean _tmp2_; ValaCCodeFile* _tmp3_; ValaMethod* _tmp4_; ValaMethod* _tmp5_; gchar* _tmp6_ = NULL; gchar* _tmp7_; gboolean _tmp8_ = FALSE; gboolean _tmp9_; ValaMethod* _tmp10_; gchar* _tmp11_ = NULL; gchar* _tmp12_; ValaCCodeFunction* _tmp13_; ValaCCodeFunction* _tmp14_; ValaCCodeFunction* function; gboolean _tmp15_ = FALSE; ValaMethod* _tmp16_; gboolean _tmp17_ = FALSE; gboolean _tmp21_; ValaMethod* _tmp33_; gboolean _tmp34_; gboolean _tmp35_; GHashFunc _tmp40_; GEqualFunc _tmp41_; GEqualFunc _tmp42_; ValaHashMap* _tmp43_; ValaHashMap* cparam_map; GHashFunc _tmp44_; GEqualFunc _tmp45_; GEqualFunc _tmp46_; ValaHashMap* _tmp47_; ValaHashMap* carg_map; ValaMethod* _tmp48_; ValaSymbol* _tmp49_; ValaSymbol* _tmp50_; ValaClass* _tmp51_; ValaClass* cl; gboolean _tmp52_ = FALSE; gboolean _tmp53_ = FALSE; ValaMethod* _tmp54_; gboolean _tmp56_; gboolean _tmp60_; gboolean _tmp72_ = FALSE; ValaMethod* _tmp73_; gboolean _tmp75_; self = (ValaCCodeMethodModule*) base; g_return_if_fail (m != NULL); g_return_if_fail (decl_space != NULL); _tmp0_ = m; _tmp1_ = vala_method_get_is_async_callback (_tmp0_); _tmp2_ = _tmp1_; if (_tmp2_) { return; } _tmp3_ = decl_space; _tmp4_ = m; _tmp5_ = m; _tmp6_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp5_); _tmp7_ = _tmp6_; _tmp8_ = vala_ccode_base_module_add_symbol_declaration ((ValaCCodeBaseModule*) self, _tmp3_, (ValaSymbol*) _tmp4_, _tmp7_); _tmp9_ = _tmp8_; _g_free0 (_tmp7_); if (_tmp9_) { return; } _tmp10_ = m; _tmp11_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp10_); _tmp12_ = _tmp11_; _tmp13_ = vala_ccode_function_new (_tmp12_, "void"); _tmp14_ = _tmp13_; _g_free0 (_tmp12_); function = _tmp14_; _tmp16_ = m; _tmp17_ = vala_symbol_is_private_symbol ((ValaSymbol*) _tmp16_); if (_tmp17_) { ValaMethod* _tmp18_; gboolean _tmp19_; gboolean _tmp20_; _tmp18_ = m; _tmp19_ = vala_symbol_get_external ((ValaSymbol*) _tmp18_); _tmp20_ = _tmp19_; _tmp15_ = !_tmp20_; } else { _tmp15_ = FALSE; } _tmp21_ = _tmp15_; if (_tmp21_) { ValaCCodeFunction* _tmp22_; ValaCCodeFunction* _tmp23_; ValaCCodeModifiers _tmp24_; ValaCCodeModifiers _tmp25_; ValaMethod* _tmp26_; gboolean _tmp27_; gboolean _tmp28_; _tmp22_ = function; _tmp23_ = function; _tmp24_ = vala_ccode_function_get_modifiers (_tmp23_); _tmp25_ = _tmp24_; vala_ccode_function_set_modifiers (_tmp23_, _tmp25_ | VALA_CCODE_MODIFIERS_STATIC); _tmp26_ = m; _tmp27_ = vala_method_get_is_inline (_tmp26_); _tmp28_ = _tmp27_; if (_tmp28_) { ValaCCodeFunction* _tmp29_; ValaCCodeFunction* _tmp30_; ValaCCodeModifiers _tmp31_; ValaCCodeModifiers _tmp32_; _tmp29_ = function; _tmp30_ = function; _tmp31_ = vala_ccode_function_get_modifiers (_tmp30_); _tmp32_ = _tmp31_; vala_ccode_function_set_modifiers (_tmp30_, _tmp32_ | VALA_CCODE_MODIFIERS_INLINE); } } _tmp33_ = m; _tmp34_ = vala_symbol_get_deprecated ((ValaSymbol*) _tmp33_); _tmp35_ = _tmp34_; if (_tmp35_) { ValaCCodeFunction* _tmp36_; ValaCCodeFunction* _tmp37_; ValaCCodeModifiers _tmp38_; ValaCCodeModifiers _tmp39_; _tmp36_ = function; _tmp37_ = function; _tmp38_ = vala_ccode_function_get_modifiers (_tmp37_); _tmp39_ = _tmp38_; vala_ccode_function_set_modifiers (_tmp37_, _tmp39_ | VALA_CCODE_MODIFIERS_DEPRECATED); } _tmp40_ = g_direct_hash; _tmp41_ = g_direct_equal; _tmp42_ = g_direct_equal; _tmp43_ = vala_hash_map_new (G_TYPE_INT, NULL, NULL, VALA_TYPE_CCODE_PARAMETER, (GBoxedCopyFunc) vala_ccode_node_ref, vala_ccode_node_unref, _tmp40_, _tmp41_, _tmp42_); cparam_map = _tmp43_; _tmp44_ = g_direct_hash; _tmp45_ = g_direct_equal; _tmp46_ = g_direct_equal; _tmp47_ = vala_hash_map_new (G_TYPE_INT, NULL, NULL, VALA_TYPE_CCODE_EXPRESSION, (GBoxedCopyFunc) vala_ccode_node_ref, vala_ccode_node_unref, _tmp44_, _tmp45_, _tmp46_); carg_map = _tmp47_; _tmp48_ = m; _tmp49_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp48_); _tmp50_ = _tmp49_; _tmp51_ = _vala_code_node_ref0 (VALA_IS_CLASS (_tmp50_) ? ((ValaClass*) _tmp50_) : NULL); cl = _tmp51_; _tmp54_ = m; if (VALA_IS_CREATION_METHOD (_tmp54_)) { ValaClass* _tmp55_; _tmp55_ = cl; _tmp53_ = _tmp55_ != NULL; } else { _tmp53_ = FALSE; } _tmp56_ = _tmp53_; if (_tmp56_) { ValaClass* _tmp57_; gboolean _tmp58_; gboolean _tmp59_; _tmp57_ = cl; _tmp58_ = vala_class_get_is_abstract (_tmp57_); _tmp59_ = _tmp58_; _tmp52_ = _tmp59_; } else { _tmp52_ = FALSE; } _tmp60_ = _tmp52_; if (!_tmp60_) { ValaMethod* _tmp61_; ValaCCodeFile* _tmp62_; ValaHashMap* _tmp63_; ValaCCodeFunction* _tmp64_; ValaHashMap* _tmp65_; ValaCCodeIdentifier* _tmp66_; ValaCCodeIdentifier* _tmp67_; ValaCCodeFunctionCall* _tmp68_; ValaCCodeFunctionCall* _tmp69_; ValaCCodeFile* _tmp70_; ValaCCodeFunction* _tmp71_; _tmp61_ = m; _tmp62_ = decl_space; _tmp63_ = cparam_map; _tmp64_ = function; _tmp65_ = carg_map; _tmp66_ = vala_ccode_identifier_new ("fake"); _tmp67_ = _tmp66_; _tmp68_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp67_); _tmp69_ = _tmp68_; vala_ccode_base_module_generate_cparameters ((ValaCCodeBaseModule*) self, _tmp61_, _tmp62_, (ValaMap*) _tmp63_, _tmp64_, NULL, (ValaMap*) _tmp65_, _tmp69_, 3); _vala_ccode_node_unref0 (_tmp69_); _vala_ccode_node_unref0 (_tmp67_); _tmp70_ = decl_space; _tmp71_ = function; vala_ccode_file_add_function_declaration (_tmp70_, _tmp71_); } _tmp73_ = m; if (VALA_IS_CREATION_METHOD (_tmp73_)) { ValaClass* _tmp74_; _tmp74_ = cl; _tmp72_ = _tmp74_ != NULL; } else { _tmp72_ = FALSE; } _tmp75_ = _tmp72_; if (_tmp75_) { ValaMethod* _tmp76_; gchar* _tmp77_ = NULL; gchar* _tmp78_; ValaCCodeFunction* _tmp79_; ValaMethod* _tmp80_; gboolean _tmp81_ = FALSE; GHashFunc _tmp86_; GEqualFunc _tmp87_; GEqualFunc _tmp88_; ValaHashMap* _tmp89_; ValaMethod* _tmp90_; ValaCCodeFile* _tmp91_; ValaHashMap* _tmp92_; ValaCCodeFunction* _tmp93_; ValaCCodeFile* _tmp94_; ValaCCodeFunction* _tmp95_; _tmp76_ = m; _tmp77_ = vala_ccode_base_module_get_ccode_real_name ((ValaSymbol*) _tmp76_); _tmp78_ = _tmp77_; _tmp79_ = vala_ccode_function_new (_tmp78_, "void"); _vala_ccode_node_unref0 (function); function = _tmp79_; _g_free0 (_tmp78_); _tmp80_ = m; _tmp81_ = vala_symbol_is_private_symbol ((ValaSymbol*) _tmp80_); if (_tmp81_) { ValaCCodeFunction* _tmp82_; ValaCCodeFunction* _tmp83_; ValaCCodeModifiers _tmp84_; ValaCCodeModifiers _tmp85_; _tmp82_ = function; _tmp83_ = function; _tmp84_ = vala_ccode_function_get_modifiers (_tmp83_); _tmp85_ = _tmp84_; vala_ccode_function_set_modifiers (_tmp83_, _tmp85_ | VALA_CCODE_MODIFIERS_STATIC); } _tmp86_ = g_direct_hash; _tmp87_ = g_direct_equal; _tmp88_ = g_direct_equal; _tmp89_ = vala_hash_map_new (G_TYPE_INT, NULL, NULL, VALA_TYPE_CCODE_PARAMETER, (GBoxedCopyFunc) vala_ccode_node_ref, vala_ccode_node_unref, _tmp86_, _tmp87_, _tmp88_); _vala_map_unref0 (cparam_map); cparam_map = _tmp89_; _tmp90_ = m; _tmp91_ = decl_space; _tmp92_ = cparam_map; _tmp93_ = function; vala_ccode_base_module_generate_cparameters ((ValaCCodeBaseModule*) self, _tmp90_, _tmp91_, (ValaMap*) _tmp92_, _tmp93_, NULL, NULL, NULL, 3); _tmp94_ = decl_space; _tmp95_ = function; vala_ccode_file_add_function_declaration (_tmp94_, _tmp95_); } _vala_code_node_unref0 (cl); _vala_map_unref0 (carg_map); _vala_map_unref0 (cparam_map); _vala_ccode_node_unref0 (function); } static void vala_ccode_method_module_register_plugin_types (ValaCCodeMethodModule* self, ValaSymbol* sym, ValaSet* registered_types) { ValaSymbol* _tmp0_; ValaNamespace* _tmp1_; ValaNamespace* ns; ValaSymbol* _tmp2_; ValaClass* _tmp3_; ValaClass* cl; ValaSymbol* _tmp4_; ValaInterface* _tmp5_; ValaInterface* iface; ValaNamespace* _tmp6_; g_return_if_fail (self != NULL); g_return_if_fail (sym != NULL); g_return_if_fail (registered_types != NULL); _tmp0_ = sym; _tmp1_ = _vala_code_node_ref0 (VALA_IS_NAMESPACE (_tmp0_) ? ((ValaNamespace*) _tmp0_) : NULL); ns = _tmp1_; _tmp2_ = sym; _tmp3_ = _vala_code_node_ref0 (VALA_IS_CLASS (_tmp2_) ? ((ValaClass*) _tmp2_) : NULL); cl = _tmp3_; _tmp4_ = sym; _tmp5_ = _vala_code_node_ref0 (VALA_IS_INTERFACE (_tmp4_) ? ((ValaInterface*) _tmp4_) : NULL); iface = _tmp5_; _tmp6_ = ns; if (_tmp6_ != NULL) { { ValaNamespace* _tmp7_; ValaList* _tmp8_ = NULL; ValaList* _ns_ns_list; ValaList* _tmp9_; gint _tmp10_; gint _tmp11_; gint _ns_ns_size; gint _ns_ns_index; _tmp7_ = ns; _tmp8_ = vala_namespace_get_namespaces (_tmp7_); _ns_ns_list = _tmp8_; _tmp9_ = _ns_ns_list; _tmp10_ = vala_collection_get_size ((ValaCollection*) _tmp9_); _tmp11_ = _tmp10_; _ns_ns_size = _tmp11_; _ns_ns_index = -1; while (TRUE) { gint _tmp12_; gint _tmp13_; gint _tmp14_; ValaList* _tmp15_; gint _tmp16_; gpointer _tmp17_ = NULL; ValaNamespace* ns_ns; ValaNamespace* _tmp18_; ValaSet* _tmp19_; _tmp12_ = _ns_ns_index; _ns_ns_index = _tmp12_ + 1; _tmp13_ = _ns_ns_index; _tmp14_ = _ns_ns_size; if (!(_tmp13_ < _tmp14_)) { break; } _tmp15_ = _ns_ns_list; _tmp16_ = _ns_ns_index; _tmp17_ = vala_list_get (_tmp15_, _tmp16_); ns_ns = (ValaNamespace*) _tmp17_; _tmp18_ = ns_ns; _tmp19_ = registered_types; vala_ccode_method_module_register_plugin_types (self, (ValaSymbol*) _tmp18_, _tmp19_); _vala_code_node_unref0 (ns_ns); } _vala_iterable_unref0 (_ns_ns_list); } { ValaNamespace* _tmp20_; ValaList* _tmp21_ = NULL; ValaList* _ns_cl_list; ValaList* _tmp22_; gint _tmp23_; gint _tmp24_; gint _ns_cl_size; gint _ns_cl_index; _tmp20_ = ns; _tmp21_ = vala_namespace_get_classes (_tmp20_); _ns_cl_list = _tmp21_; _tmp22_ = _ns_cl_list; _tmp23_ = vala_collection_get_size ((ValaCollection*) _tmp22_); _tmp24_ = _tmp23_; _ns_cl_size = _tmp24_; _ns_cl_index = -1; while (TRUE) { gint _tmp25_; gint _tmp26_; gint _tmp27_; ValaList* _tmp28_; gint _tmp29_; gpointer _tmp30_ = NULL; ValaClass* ns_cl; ValaClass* _tmp31_; ValaSet* _tmp32_; _tmp25_ = _ns_cl_index; _ns_cl_index = _tmp25_ + 1; _tmp26_ = _ns_cl_index; _tmp27_ = _ns_cl_size; if (!(_tmp26_ < _tmp27_)) { break; } _tmp28_ = _ns_cl_list; _tmp29_ = _ns_cl_index; _tmp30_ = vala_list_get (_tmp28_, _tmp29_); ns_cl = (ValaClass*) _tmp30_; _tmp31_ = ns_cl; _tmp32_ = registered_types; vala_ccode_method_module_register_plugin_types (self, (ValaSymbol*) _tmp31_, _tmp32_); _vala_code_node_unref0 (ns_cl); } _vala_iterable_unref0 (_ns_cl_list); } { ValaNamespace* _tmp33_; ValaList* _tmp34_ = NULL; ValaList* _ns_iface_list; ValaList* _tmp35_; gint _tmp36_; gint _tmp37_; gint _ns_iface_size; gint _ns_iface_index; _tmp33_ = ns; _tmp34_ = vala_namespace_get_interfaces (_tmp33_); _ns_iface_list = _tmp34_; _tmp35_ = _ns_iface_list; _tmp36_ = vala_collection_get_size ((ValaCollection*) _tmp35_); _tmp37_ = _tmp36_; _ns_iface_size = _tmp37_; _ns_iface_index = -1; while (TRUE) { gint _tmp38_; gint _tmp39_; gint _tmp40_; ValaList* _tmp41_; gint _tmp42_; gpointer _tmp43_ = NULL; ValaInterface* ns_iface; ValaInterface* _tmp44_; ValaSet* _tmp45_; _tmp38_ = _ns_iface_index; _ns_iface_index = _tmp38_ + 1; _tmp39_ = _ns_iface_index; _tmp40_ = _ns_iface_size; if (!(_tmp39_ < _tmp40_)) { break; } _tmp41_ = _ns_iface_list; _tmp42_ = _ns_iface_index; _tmp43_ = vala_list_get (_tmp41_, _tmp42_); ns_iface = (ValaInterface*) _tmp43_; _tmp44_ = ns_iface; _tmp45_ = registered_types; vala_ccode_method_module_register_plugin_types (self, (ValaSymbol*) _tmp44_, _tmp45_); _vala_code_node_unref0 (ns_iface); } _vala_iterable_unref0 (_ns_iface_list); } } else { ValaClass* _tmp46_; _tmp46_ = cl; if (_tmp46_ != NULL) { ValaClass* _tmp47_; ValaSet* _tmp48_; _tmp47_ = cl; _tmp48_ = registered_types; vala_ccode_method_module_register_plugin_type (self, (ValaObjectTypeSymbol*) _tmp47_, _tmp48_); { ValaClass* _tmp49_; ValaList* _tmp50_ = NULL; ValaList* _cl_cl_list; ValaList* _tmp51_; gint _tmp52_; gint _tmp53_; gint _cl_cl_size; gint _cl_cl_index; _tmp49_ = cl; _tmp50_ = vala_class_get_classes (_tmp49_); _cl_cl_list = _tmp50_; _tmp51_ = _cl_cl_list; _tmp52_ = vala_collection_get_size ((ValaCollection*) _tmp51_); _tmp53_ = _tmp52_; _cl_cl_size = _tmp53_; _cl_cl_index = -1; while (TRUE) { gint _tmp54_; gint _tmp55_; gint _tmp56_; ValaList* _tmp57_; gint _tmp58_; gpointer _tmp59_ = NULL; ValaClass* cl_cl; ValaClass* _tmp60_; ValaSet* _tmp61_; _tmp54_ = _cl_cl_index; _cl_cl_index = _tmp54_ + 1; _tmp55_ = _cl_cl_index; _tmp56_ = _cl_cl_size; if (!(_tmp55_ < _tmp56_)) { break; } _tmp57_ = _cl_cl_list; _tmp58_ = _cl_cl_index; _tmp59_ = vala_list_get (_tmp57_, _tmp58_); cl_cl = (ValaClass*) _tmp59_; _tmp60_ = cl_cl; _tmp61_ = registered_types; vala_ccode_method_module_register_plugin_types (self, (ValaSymbol*) _tmp60_, _tmp61_); _vala_code_node_unref0 (cl_cl); } _vala_iterable_unref0 (_cl_cl_list); } } else { ValaInterface* _tmp62_; _tmp62_ = iface; if (_tmp62_ != NULL) { ValaInterface* _tmp63_; ValaSet* _tmp64_; _tmp63_ = iface; _tmp64_ = registered_types; vala_ccode_method_module_register_plugin_type (self, (ValaObjectTypeSymbol*) _tmp63_, _tmp64_); { ValaInterface* _tmp65_; ValaList* _tmp66_ = NULL; ValaList* _iface_cl_list; ValaList* _tmp67_; gint _tmp68_; gint _tmp69_; gint _iface_cl_size; gint _iface_cl_index; _tmp65_ = iface; _tmp66_ = vala_interface_get_classes (_tmp65_); _iface_cl_list = _tmp66_; _tmp67_ = _iface_cl_list; _tmp68_ = vala_collection_get_size ((ValaCollection*) _tmp67_); _tmp69_ = _tmp68_; _iface_cl_size = _tmp69_; _iface_cl_index = -1; while (TRUE) { gint _tmp70_; gint _tmp71_; gint _tmp72_; ValaList* _tmp73_; gint _tmp74_; gpointer _tmp75_ = NULL; ValaClass* iface_cl; ValaClass* _tmp76_; ValaSet* _tmp77_; _tmp70_ = _iface_cl_index; _iface_cl_index = _tmp70_ + 1; _tmp71_ = _iface_cl_index; _tmp72_ = _iface_cl_size; if (!(_tmp71_ < _tmp72_)) { break; } _tmp73_ = _iface_cl_list; _tmp74_ = _iface_cl_index; _tmp75_ = vala_list_get (_tmp73_, _tmp74_); iface_cl = (ValaClass*) _tmp75_; _tmp76_ = iface_cl; _tmp77_ = registered_types; vala_ccode_method_module_register_plugin_types (self, (ValaSymbol*) _tmp76_, _tmp77_); _vala_code_node_unref0 (iface_cl); } _vala_iterable_unref0 (_iface_cl_list); } } } } _vala_code_node_unref0 (iface); _vala_code_node_unref0 (cl); _vala_code_node_unref0 (ns); } static void vala_ccode_method_module_register_plugin_type (ValaCCodeMethodModule* self, ValaObjectTypeSymbol* type_symbol, ValaSet* registered_types) { ValaObjectTypeSymbol* _tmp0_; gboolean _tmp1_; gboolean _tmp2_; ValaSet* _tmp3_; ValaObjectTypeSymbol* _tmp4_; gboolean _tmp5_ = FALSE; ValaObjectTypeSymbol* _tmp6_; ValaClass* _tmp7_; ValaClass* cl; ValaClass* _tmp8_; ValaObjectTypeSymbol* _tmp27_; gchar* _tmp28_ = NULL; gchar* _tmp29_; gchar* _tmp30_ = NULL; gchar* _tmp31_; ValaCCodeIdentifier* _tmp32_; ValaCCodeIdentifier* _tmp33_; ValaCCodeFunctionCall* _tmp34_; ValaCCodeFunctionCall* _tmp35_; ValaCCodeFunctionCall* register_call; ValaCCodeFunctionCall* _tmp36_; const gchar* _tmp37_; ValaCCodeIdentifier* _tmp38_; ValaCCodeIdentifier* _tmp39_; ValaCCodeFunction* _tmp40_; ValaCCodeFunction* _tmp41_; ValaCCodeFunctionCall* _tmp42_; g_return_if_fail (self != NULL); g_return_if_fail (type_symbol != NULL); g_return_if_fail (registered_types != NULL); _tmp0_ = type_symbol; _tmp1_ = vala_symbol_get_external_package ((ValaSymbol*) _tmp0_); _tmp2_ = _tmp1_; if (_tmp2_) { return; } _tmp3_ = registered_types; _tmp4_ = type_symbol; _tmp5_ = vala_collection_add ((ValaCollection*) _tmp3_, (ValaSymbol*) _tmp4_); if (!_tmp5_) { return; } _tmp6_ = type_symbol; _tmp7_ = _vala_code_node_ref0 (VALA_IS_CLASS (_tmp6_) ? ((ValaClass*) _tmp6_) : NULL); cl = _tmp7_; _tmp8_ = cl; if (_tmp8_ != NULL) { ValaClass* _tmp9_; gboolean _tmp10_; gboolean _tmp11_; _tmp9_ = cl; _tmp10_ = vala_class_get_is_compact (_tmp9_); _tmp11_ = _tmp10_; if (_tmp11_) { _vala_code_node_unref0 (cl); return; } { ValaClass* _tmp12_; ValaList* _tmp13_ = NULL; ValaList* _base_type_list; ValaList* _tmp14_; gint _tmp15_; gint _tmp16_; gint _base_type_size; gint _base_type_index; _tmp12_ = cl; _tmp13_ = vala_class_get_base_types (_tmp12_); _base_type_list = _tmp13_; _tmp14_ = _base_type_list; _tmp15_ = vala_collection_get_size ((ValaCollection*) _tmp14_); _tmp16_ = _tmp15_; _base_type_size = _tmp16_; _base_type_index = -1; while (TRUE) { gint _tmp17_; gint _tmp18_; gint _tmp19_; ValaList* _tmp20_; gint _tmp21_; gpointer _tmp22_ = NULL; ValaDataType* base_type; ValaDataType* _tmp23_; ValaTypeSymbol* _tmp24_; ValaTypeSymbol* _tmp25_; ValaSet* _tmp26_; _tmp17_ = _base_type_index; _base_type_index = _tmp17_ + 1; _tmp18_ = _base_type_index; _tmp19_ = _base_type_size; if (!(_tmp18_ < _tmp19_)) { break; } _tmp20_ = _base_type_list; _tmp21_ = _base_type_index; _tmp22_ = vala_list_get (_tmp20_, _tmp21_); base_type = (ValaDataType*) _tmp22_; _tmp23_ = base_type; _tmp24_ = vala_data_type_get_data_type (_tmp23_); _tmp25_ = _tmp24_; _tmp26_ = registered_types; vala_ccode_method_module_register_plugin_type (self, VALA_OBJECT_TYPE_SYMBOL (_tmp25_), _tmp26_); _vala_code_node_unref0 (base_type); } _vala_iterable_unref0 (_base_type_list); } } _tmp27_ = type_symbol; _tmp28_ = vala_ccode_base_module_get_ccode_lower_case_name ((ValaCodeNode*) _tmp27_, NULL); _tmp29_ = _tmp28_; _tmp30_ = g_strdup_printf ("%s_register_type", _tmp29_); _tmp31_ = _tmp30_; _tmp32_ = vala_ccode_identifier_new (_tmp31_); _tmp33_ = _tmp32_; _tmp34_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp33_); _tmp35_ = _tmp34_; _vala_ccode_node_unref0 (_tmp33_); _g_free0 (_tmp31_); _g_free0 (_tmp29_); register_call = _tmp35_; _tmp36_ = register_call; _tmp37_ = ((ValaCCodeBaseModule*) self)->module_init_param_name; _tmp38_ = vala_ccode_identifier_new (_tmp37_); _tmp39_ = _tmp38_; vala_ccode_function_call_add_argument (_tmp36_, (ValaCCodeExpression*) _tmp39_); _vala_ccode_node_unref0 (_tmp39_); _tmp40_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); _tmp41_ = _tmp40_; _tmp42_ = register_call; vala_ccode_function_add_expression (_tmp41_, (ValaCCodeExpression*) _tmp42_); _vala_ccode_node_unref0 (register_call); _vala_code_node_unref0 (cl); } static void vala_ccode_method_module_real_visit_method (ValaCodeVisitor* base, ValaMethod* m) { ValaCCodeMethodModule * self; ValaMethod* _tmp0_; ValaCCodeBaseModuleEmitContext* _tmp1_; ValaCCodeBaseModuleEmitContext* _tmp2_; ValaMethod* _tmp3_; ValaSourceReference* _tmp4_; ValaSourceReference* _tmp5_; gboolean in_gobject_creation_method; gboolean in_fundamental_creation_method; ValaMethod* _tmp6_; ValaDataType* _tmp7_; ValaDataType* _tmp8_; ValaMethod* _tmp9_; ValaAttribute* _tmp10_ = NULL; ValaAttribute* _tmp11_; gboolean _tmp12_; ValaMethod* _tmp16_; ValaMethod* _tmp35_; gboolean _tmp36_; gboolean _tmp37_; ValaMethod* _tmp38_; ValaDataType* _tmp39_; ValaDataType* _tmp40_; ValaDataType* _tmp41_; ValaDataType* creturn_type; ValaMethod* _tmp42_; ValaDataType* _tmp43_; ValaDataType* _tmp44_; gboolean _tmp45_ = FALSE; gboolean _tmp59_ = FALSE; gboolean _tmp60_ = FALSE; gboolean _tmp61_ = FALSE; ValaMethod* _tmp62_; gboolean _tmp63_; gboolean _tmp64_; gboolean _tmp68_; gboolean _tmp77_; gboolean _tmp81_; ValaCCodeFunction* function = NULL; ValaMethod* _tmp92_; gchar* _tmp93_ = NULL; gchar* _tmp94_; ValaCCodeFunction* _tmp95_; ValaMethod* _tmp96_; gboolean _tmp97_; gboolean _tmp98_; GHashFunc _tmp103_; GEqualFunc _tmp104_; GEqualFunc _tmp105_; ValaHashMap* _tmp106_; ValaHashMap* cparam_map; ValaMethod* _tmp107_; ValaCCodeFile* _tmp108_; ValaHashMap* _tmp109_; ValaCCodeFunction* _tmp110_; gboolean _tmp111_ = FALSE; ValaMethod* _tmp112_; gboolean _tmp113_; gboolean _tmp114_; gboolean _tmp122_; ValaMethod* _tmp171_; ValaComment* _tmp172_; ValaComment* _tmp173_; ValaCCodeFunction* _tmp182_; gboolean _tmp183_ = FALSE; ValaMethod* _tmp184_; gboolean _tmp185_; gboolean _tmp186_; gboolean _tmp194_; ValaMethod* _tmp919_; ValaBlock* _tmp920_; ValaBlock* _tmp921_; gboolean _tmp925_ = FALSE; ValaMethod* _tmp926_; gboolean _tmp927_; gboolean _tmp928_; gboolean _tmp936_; gboolean _tmp1075_ = FALSE; ValaMethod* _tmp1076_; gboolean _tmp1077_; gboolean _tmp1078_; gboolean _tmp1081_; gboolean _tmp1117_ = FALSE; gboolean _tmp1118_ = FALSE; gboolean _tmp1119_ = FALSE; ValaMethod* _tmp1120_; gboolean _tmp1121_; gboolean _tmp1122_; gboolean _tmp1126_; gboolean _tmp1130_; gboolean _tmp1134_; ValaMethod* _tmp1147_; gboolean _tmp1148_; gboolean _tmp1149_; self = (ValaCCodeMethodModule*) base; g_return_if_fail (m != NULL); _tmp0_ = m; _tmp1_ = vala_ccode_base_module_emit_context_new ((ValaSymbol*) _tmp0_); _tmp2_ = _tmp1_; vala_ccode_base_module_push_context ((ValaCCodeBaseModule*) self, _tmp2_); _vala_ccode_base_module_emit_context_unref0 (_tmp2_); _tmp3_ = m; _tmp4_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp3_); _tmp5_ = _tmp4_; vala_ccode_base_module_push_line ((ValaCCodeBaseModule*) self, _tmp5_); in_gobject_creation_method = FALSE; in_fundamental_creation_method = FALSE; _tmp6_ = m; _tmp7_ = vala_method_get_return_type (_tmp6_); _tmp8_ = _tmp7_; vala_ccode_base_module_check_type ((ValaCCodeBaseModule*) self, _tmp8_); _tmp9_ = m; _tmp10_ = vala_code_node_get_attribute ((ValaCodeNode*) _tmp9_, "NoArrayLength"); _tmp11_ = _tmp10_; _tmp12_ = _tmp11_ != NULL; _vala_code_node_unref0 (_tmp11_); if (_tmp12_) { ValaMethod* _tmp13_; ValaSourceReference* _tmp14_; ValaSourceReference* _tmp15_; _tmp13_ = m; _tmp14_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp13_); _tmp15_ = _tmp14_; vala_report_deprecated (_tmp15_, "NoArrayLength attribute is deprecated, use [CCode (array_length = fals" \ "e)] instead."); } _tmp16_ = m; if (VALA_IS_CREATION_METHOD (_tmp16_)) { ValaTypeSymbol* _tmp17_; ValaTypeSymbol* _tmp18_; ValaClass* _tmp19_; ValaClass* cl; gboolean _tmp20_ = FALSE; ValaClass* _tmp21_; gboolean _tmp25_; _tmp17_ = vala_ccode_base_module_get_current_type_symbol ((ValaCCodeBaseModule*) self); _tmp18_ = _tmp17_; _tmp19_ = _vala_code_node_ref0 (VALA_IS_CLASS (_tmp18_) ? ((ValaClass*) _tmp18_) : NULL); cl = _tmp19_; _tmp21_ = cl; if (_tmp21_ != NULL) { ValaClass* _tmp22_; gboolean _tmp23_; gboolean _tmp24_; _tmp22_ = cl; _tmp23_ = vala_class_get_is_compact (_tmp22_); _tmp24_ = _tmp23_; _tmp20_ = !_tmp24_; } else { _tmp20_ = FALSE; } _tmp25_ = _tmp20_; if (_tmp25_) { ValaClass* _tmp26_; ValaClass* _tmp27_; ValaClass* _tmp28_; _tmp26_ = cl; _tmp27_ = vala_class_get_base_class (_tmp26_); _tmp28_ = _tmp27_; if (_tmp28_ == NULL) { in_fundamental_creation_method = TRUE; } else { gboolean _tmp29_ = FALSE; ValaTypeSymbol* _tmp30_; gboolean _tmp34_; _tmp30_ = ((ValaCCodeBaseModule*) self)->gobject_type; if (_tmp30_ != NULL) { ValaClass* _tmp31_; ValaTypeSymbol* _tmp32_; gboolean _tmp33_ = FALSE; _tmp31_ = cl; _tmp32_ = ((ValaCCodeBaseModule*) self)->gobject_type; _tmp33_ = vala_typesymbol_is_subtype_of ((ValaTypeSymbol*) _tmp31_, _tmp32_); _tmp29_ = _tmp33_; } else { _tmp29_ = FALSE; } _tmp34_ = _tmp29_; if (_tmp34_) { in_gobject_creation_method = TRUE; } } } _vala_code_node_unref0 (cl); } _tmp35_ = m; _tmp36_ = vala_method_get_coroutine (_tmp35_); _tmp37_ = _tmp36_; if (_tmp37_) { ((ValaCCodeBaseModule*) self)->next_coroutine_state = 1; } _tmp38_ = m; _tmp39_ = vala_method_get_return_type (_tmp38_); _tmp40_ = _tmp39_; _tmp41_ = _vala_code_node_ref0 (_tmp40_); creturn_type = _tmp41_; _tmp42_ = m; _tmp43_ = vala_method_get_return_type (_tmp42_); _tmp44_ = _tmp43_; _tmp45_ = vala_data_type_is_real_non_null_struct_type (_tmp44_); if (_tmp45_) { ValaVoidType* _tmp46_; _tmp46_ = vala_void_type_new (NULL); _vala_code_node_unref0 (creturn_type); creturn_type = (ValaDataType*) _tmp46_; } { ValaMethod* _tmp47_; ValaList* _tmp48_ = NULL; ValaList* _param_list; ValaList* _tmp49_; gint _tmp50_; gint _tmp51_; gint _param_size; gint _param_index; _tmp47_ = m; _tmp48_ = vala_method_get_parameters (_tmp47_); _param_list = _tmp48_; _tmp49_ = _param_list; _tmp50_ = vala_collection_get_size ((ValaCollection*) _tmp49_); _tmp51_ = _tmp50_; _param_size = _tmp51_; _param_index = -1; while (TRUE) { gint _tmp52_; gint _tmp53_; gint _tmp54_; ValaList* _tmp55_; gint _tmp56_; gpointer _tmp57_ = NULL; ValaParameter* param; ValaParameter* _tmp58_; _tmp52_ = _param_index; _param_index = _tmp52_ + 1; _tmp53_ = _param_index; _tmp54_ = _param_size; if (!(_tmp53_ < _tmp54_)) { break; } _tmp55_ = _param_list; _tmp56_ = _param_index; _tmp57_ = vala_list_get (_tmp55_, _tmp56_); param = (ValaParameter*) _tmp57_; _tmp58_ = param; vala_code_node_accept ((ValaCodeNode*) _tmp58_, (ValaCodeVisitor*) self); _vala_code_node_unref0 (param); } _vala_iterable_unref0 (_param_list); } _tmp62_ = m; _tmp63_ = vala_method_get_is_abstract (_tmp62_); _tmp64_ = _tmp63_; if (_tmp64_) { _tmp61_ = TRUE; } else { ValaMethod* _tmp65_; gboolean _tmp66_; gboolean _tmp67_; _tmp65_ = m; _tmp66_ = vala_method_get_is_virtual (_tmp65_); _tmp67_ = _tmp66_; _tmp61_ = _tmp67_; } _tmp68_ = _tmp61_; if (_tmp68_) { _tmp60_ = TRUE; } else { gboolean _tmp69_ = FALSE; ValaMethod* _tmp70_; ValaMethod* _tmp71_; ValaMethod* _tmp72_; gboolean _tmp76_; _tmp70_ = m; _tmp71_ = vala_method_get_base_method (_tmp70_); _tmp72_ = _tmp71_; if (_tmp72_ == NULL) { ValaMethod* _tmp73_; ValaMethod* _tmp74_; ValaMethod* _tmp75_; _tmp73_ = m; _tmp74_ = vala_method_get_base_interface_method (_tmp73_); _tmp75_ = _tmp74_; _tmp69_ = _tmp75_ == NULL; } else { _tmp69_ = FALSE; } _tmp76_ = _tmp69_; _tmp60_ = _tmp76_; } _tmp77_ = _tmp60_; if (_tmp77_) { ValaMethod* _tmp78_; ValaSignal* _tmp79_; ValaSignal* _tmp80_; _tmp78_ = m; _tmp79_ = vala_method_get_signal_reference (_tmp78_); _tmp80_ = _tmp79_; _tmp59_ = _tmp80_ == NULL; } else { _tmp59_ = FALSE; } _tmp81_ = _tmp59_; if (_tmp81_) { ValaMethod* _tmp82_; ValaCCodeFile* _tmp83_; ValaMethod* _tmp84_; gboolean _tmp85_ = FALSE; ValaMethod* _tmp88_; gboolean _tmp89_ = FALSE; _tmp82_ = m; _tmp83_ = ((ValaCCodeBaseModule*) self)->cfile; vala_ccode_base_module_generate_method_declaration ((ValaCCodeBaseModule*) self, _tmp82_, _tmp83_); _tmp84_ = m; _tmp85_ = vala_symbol_is_internal_symbol ((ValaSymbol*) _tmp84_); if (!_tmp85_) { ValaMethod* _tmp86_; ValaCCodeFile* _tmp87_; _tmp86_ = m; _tmp87_ = ((ValaCCodeBaseModule*) self)->header_file; vala_ccode_base_module_generate_method_declaration ((ValaCCodeBaseModule*) self, _tmp86_, _tmp87_); } _tmp88_ = m; _tmp89_ = vala_symbol_is_private_symbol ((ValaSymbol*) _tmp88_); if (!_tmp89_) { ValaMethod* _tmp90_; ValaCCodeFile* _tmp91_; _tmp90_ = m; _tmp91_ = ((ValaCCodeBaseModule*) self)->internal_header_file; vala_ccode_base_module_generate_method_declaration ((ValaCCodeBaseModule*) self, _tmp90_, _tmp91_); } } _tmp92_ = m; _tmp93_ = vala_ccode_base_module_get_ccode_real_name ((ValaSymbol*) _tmp92_); _tmp94_ = _tmp93_; _tmp95_ = vala_ccode_function_new (_tmp94_, "void"); _vala_ccode_node_unref0 (function); function = _tmp95_; _g_free0 (_tmp94_); _tmp96_ = m; _tmp97_ = vala_method_get_is_inline (_tmp96_); _tmp98_ = _tmp97_; if (_tmp98_) { ValaCCodeFunction* _tmp99_; ValaCCodeFunction* _tmp100_; ValaCCodeModifiers _tmp101_; ValaCCodeModifiers _tmp102_; _tmp99_ = function; _tmp100_ = function; _tmp101_ = vala_ccode_function_get_modifiers (_tmp100_); _tmp102_ = _tmp101_; vala_ccode_function_set_modifiers (_tmp100_, _tmp102_ | VALA_CCODE_MODIFIERS_INLINE); } _tmp103_ = g_direct_hash; _tmp104_ = g_direct_equal; _tmp105_ = g_direct_equal; _tmp106_ = vala_hash_map_new (G_TYPE_INT, NULL, NULL, VALA_TYPE_CCODE_PARAMETER, (GBoxedCopyFunc) vala_ccode_node_ref, vala_ccode_node_unref, _tmp103_, _tmp104_, _tmp105_); cparam_map = _tmp106_; _tmp107_ = m; _tmp108_ = ((ValaCCodeBaseModule*) self)->cfile; _tmp109_ = cparam_map; _tmp110_ = function; vala_ccode_base_module_generate_cparameters ((ValaCCodeBaseModule*) self, _tmp107_, _tmp108_, (ValaMap*) _tmp109_, _tmp110_, NULL, NULL, NULL, 3); _tmp112_ = m; _tmp113_ = vala_method_get_is_abstract (_tmp112_); _tmp114_ = _tmp113_; if (!_tmp114_) { _tmp111_ = TRUE; } else { gboolean _tmp115_ = FALSE; ValaMethod* _tmp116_; gboolean _tmp117_; gboolean _tmp118_; gboolean _tmp121_; _tmp116_ = m; _tmp117_ = vala_method_get_is_abstract (_tmp116_); _tmp118_ = _tmp117_; if (_tmp118_) { ValaTypeSymbol* _tmp119_; ValaTypeSymbol* _tmp120_; _tmp119_ = vala_ccode_base_module_get_current_type_symbol ((ValaCCodeBaseModule*) self); _tmp120_ = _tmp119_; _tmp115_ = VALA_IS_CLASS (_tmp120_); } else { _tmp115_ = FALSE; } _tmp121_ = _tmp115_; _tmp111_ = _tmp121_; } _tmp122_ = _tmp111_; if (_tmp122_) { ValaMethod* _tmp123_; gboolean _tmp124_; gboolean _tmp125_; _tmp123_ = m; _tmp124_ = vala_method_get_coroutine (_tmp123_); _tmp125_ = _tmp124_; if (!_tmp125_) { gboolean _tmp126_ = FALSE; ValaMethod* _tmp127_; ValaMethod* _tmp128_; ValaMethod* _tmp129_; gboolean _tmp133_; _tmp127_ = m; _tmp128_ = vala_method_get_base_method (_tmp127_); _tmp129_ = _tmp128_; if (_tmp129_ != NULL) { _tmp126_ = TRUE; } else { ValaMethod* _tmp130_; ValaMethod* _tmp131_; ValaMethod* _tmp132_; _tmp130_ = m; _tmp131_ = vala_method_get_base_interface_method (_tmp130_); _tmp132_ = _tmp131_; _tmp126_ = _tmp132_ != NULL; } _tmp133_ = _tmp126_; if (_tmp133_) { ValaCCodeFunction* _tmp134_; ValaCCodeFunction* _tmp135_; ValaCCodeModifiers _tmp136_; ValaCCodeModifiers _tmp137_; ValaCCodeFile* _tmp138_; ValaCCodeFunction* _tmp139_; _tmp134_ = function; _tmp135_ = function; _tmp136_ = vala_ccode_function_get_modifiers (_tmp135_); _tmp137_ = _tmp136_; vala_ccode_function_set_modifiers (_tmp135_, _tmp137_ | VALA_CCODE_MODIFIERS_STATIC); _tmp138_ = ((ValaCCodeBaseModule*) self)->cfile; _tmp139_ = function; vala_ccode_file_add_function_declaration (_tmp138_, _tmp139_); } else { ValaMethod* _tmp140_; gboolean _tmp141_ = FALSE; _tmp140_ = m; _tmp141_ = vala_symbol_is_private_symbol ((ValaSymbol*) _tmp140_); if (_tmp141_) { ValaCCodeFunction* _tmp142_; ValaCCodeFunction* _tmp143_; ValaCCodeModifiers _tmp144_; ValaCCodeModifiers _tmp145_; _tmp142_ = function; _tmp143_ = function; _tmp144_ = vala_ccode_function_get_modifiers (_tmp143_); _tmp145_ = _tmp144_; vala_ccode_function_set_modifiers (_tmp143_, _tmp145_ | VALA_CCODE_MODIFIERS_STATIC); } } } else { ValaMethod* _tmp146_; ValaBlock* _tmp147_; ValaBlock* _tmp148_; _tmp146_ = m; _tmp147_ = vala_subroutine_get_body ((ValaSubroutine*) _tmp146_); _tmp148_ = _tmp147_; if (_tmp148_ != NULL) { ValaMethod* _tmp149_; gchar* _tmp150_ = NULL; gchar* _tmp151_; gchar* _tmp152_; gchar* _tmp153_; ValaCCodeFunction* _tmp154_; ValaCCodeFunction* _tmp155_; ValaMethod* _tmp156_; gchar* _tmp157_ = NULL; gchar* _tmp158_; gchar* _tmp159_ = NULL; gchar* _tmp160_; gchar* _tmp161_; gchar* _tmp162_; ValaCCodeParameter* _tmp163_; ValaCCodeParameter* _tmp164_; ValaCCodeFunction* _tmp165_; ValaCCodeFunction* _tmp166_; ValaCCodeModifiers _tmp167_; ValaCCodeModifiers _tmp168_; ValaCCodeFile* _tmp169_; ValaCCodeFunction* _tmp170_; _tmp149_ = m; _tmp150_ = vala_ccode_base_module_get_ccode_real_name ((ValaSymbol*) _tmp149_); _tmp151_ = _tmp150_; _tmp152_ = g_strconcat (_tmp151_, "_co", NULL); _tmp153_ = _tmp152_; _tmp154_ = vala_ccode_function_new (_tmp153_, "gboolean"); _vala_ccode_node_unref0 (function); function = _tmp154_; _g_free0 (_tmp153_); _g_free0 (_tmp151_); _tmp155_ = function; _tmp156_ = m; _tmp157_ = vala_ccode_base_module_get_ccode_const_name ((ValaCodeNode*) _tmp156_); _tmp158_ = _tmp157_; _tmp159_ = vala_symbol_lower_case_to_camel_case (_tmp158_); _tmp160_ = _tmp159_; _tmp161_ = g_strconcat (_tmp160_, "Data*", NULL); _tmp162_ = _tmp161_; _tmp163_ = vala_ccode_parameter_new ("_data_", _tmp162_); _tmp164_ = _tmp163_; vala_ccode_function_add_parameter (_tmp155_, _tmp164_); _vala_ccode_node_unref0 (_tmp164_); _g_free0 (_tmp162_); _g_free0 (_tmp160_); _g_free0 (_tmp158_); _tmp165_ = function; _tmp166_ = function; _tmp167_ = vala_ccode_function_get_modifiers (_tmp166_); _tmp168_ = _tmp167_; vala_ccode_function_set_modifiers (_tmp166_, _tmp168_ | VALA_CCODE_MODIFIERS_STATIC); _tmp169_ = ((ValaCCodeBaseModule*) self)->cfile; _tmp170_ = function; vala_ccode_file_add_function_declaration (_tmp169_, _tmp170_); } } } _tmp171_ = m; _tmp172_ = vala_symbol_get_comment ((ValaSymbol*) _tmp171_); _tmp173_ = _tmp172_; if (_tmp173_ != NULL) { ValaCCodeFile* _tmp174_; ValaMethod* _tmp175_; ValaComment* _tmp176_; ValaComment* _tmp177_; const gchar* _tmp178_; const gchar* _tmp179_; ValaCCodeComment* _tmp180_; ValaCCodeComment* _tmp181_; _tmp174_ = ((ValaCCodeBaseModule*) self)->cfile; _tmp175_ = m; _tmp176_ = vala_symbol_get_comment ((ValaSymbol*) _tmp175_); _tmp177_ = _tmp176_; _tmp178_ = vala_comment_get_content (_tmp177_); _tmp179_ = _tmp178_; _tmp180_ = vala_ccode_comment_new (_tmp179_); _tmp181_ = _tmp180_; vala_ccode_file_add_type_member_definition (_tmp174_, (ValaCCodeNode*) _tmp181_); _vala_ccode_node_unref0 (_tmp181_); } _tmp182_ = function; vala_ccode_base_module_push_function ((ValaCCodeBaseModule*) self, _tmp182_); _tmp184_ = m; _tmp185_ = vala_method_get_is_abstract (_tmp184_); _tmp186_ = _tmp185_; if (!_tmp186_) { _tmp183_ = TRUE; } else { gboolean _tmp187_ = FALSE; ValaMethod* _tmp188_; gboolean _tmp189_; gboolean _tmp190_; gboolean _tmp193_; _tmp188_ = m; _tmp189_ = vala_method_get_is_abstract (_tmp188_); _tmp190_ = _tmp189_; if (_tmp190_) { ValaTypeSymbol* _tmp191_; ValaTypeSymbol* _tmp192_; _tmp191_ = vala_ccode_base_module_get_current_type_symbol ((ValaCCodeBaseModule*) self); _tmp192_ = _tmp191_; _tmp187_ = VALA_IS_CLASS (_tmp192_); } else { _tmp187_ = FALSE; } _tmp193_ = _tmp187_; _tmp183_ = _tmp193_; } _tmp194_ = _tmp183_; if (_tmp194_) { ValaMethod* _tmp195_; ValaBlock* _tmp196_; ValaBlock* _tmp197_; _tmp195_ = m; _tmp196_ = vala_subroutine_get_body ((ValaSubroutine*) _tmp195_); _tmp197_ = _tmp196_; if (_tmp197_ != NULL) { ValaMethod* _tmp198_; gboolean _tmp199_; gboolean _tmp200_; ValaMethod* _tmp244_; gboolean _tmp245_; gboolean _tmp246_; gboolean _tmp657_ = FALSE; gboolean _tmp658_ = FALSE; ValaMethod* _tmp659_; ValaDataType* _tmp660_; ValaDataType* _tmp661_; gboolean _tmp666_; gboolean _tmp670_; ValaMethod* _tmp687_; gboolean _tmp889_ = FALSE; ValaCodeContext* _tmp890_; ValaCodeContext* _tmp891_; ValaMethod* _tmp892_; ValaMethod* _tmp893_; ValaMethod* _tmp894_; gboolean _tmp896_; _tmp198_ = m; _tmp199_ = vala_method_get_coroutine (_tmp198_); _tmp200_ = _tmp199_; if (_tmp200_) { ValaCCodeFunction* _tmp201_; ValaCCodeFunction* _tmp202_; ValaCCodeIdentifier* _tmp203_; ValaCCodeIdentifier* _tmp204_; ValaCCodeMemberAccess* _tmp205_; ValaCCodeMemberAccess* _tmp206_; ValaCCodeFunction* _tmp207_; ValaCCodeFunction* _tmp208_; ValaCCodeConstant* _tmp209_; ValaCCodeConstant* _tmp210_; ValaCCodeFunction* _tmp211_; ValaCCodeFunction* _tmp212_; ValaCCodeFunction* _tmp232_; ValaCCodeFunction* _tmp233_; ValaCCodeFunction* _tmp234_; ValaCCodeFunction* _tmp235_; ValaCCodeIdentifier* _tmp236_; ValaCCodeIdentifier* _tmp237_; ValaCCodeFunctionCall* _tmp238_; ValaCCodeFunctionCall* _tmp239_; ValaCCodeFunction* _tmp240_; ValaCCodeFunction* _tmp241_; ValaCCodeFunction* _tmp242_; ValaCCodeFunction* _tmp243_; _tmp201_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); _tmp202_ = _tmp201_; _tmp203_ = vala_ccode_identifier_new ("_data_"); _tmp204_ = _tmp203_; _tmp205_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp204_, "_state_"); _tmp206_ = _tmp205_; vala_ccode_function_open_switch (_tmp202_, (ValaCCodeExpression*) _tmp206_); _vala_ccode_node_unref0 (_tmp206_); _vala_ccode_node_unref0 (_tmp204_); _tmp207_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); _tmp208_ = _tmp207_; _tmp209_ = vala_ccode_constant_new ("0"); _tmp210_ = _tmp209_; vala_ccode_function_add_case (_tmp208_, (ValaCCodeExpression*) _tmp210_); _vala_ccode_node_unref0 (_tmp210_); _tmp211_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); _tmp212_ = _tmp211_; vala_ccode_function_add_goto (_tmp212_, "_state_0"); { gint state; state = 1; { gboolean _tmp213_; _tmp213_ = TRUE; while (TRUE) { gboolean _tmp214_; gint _tmp216_; ValaMethod* _tmp217_; gint _tmp218_; gint _tmp219_; ValaCCodeFunction* _tmp220_; ValaCCodeFunction* _tmp221_; gint _tmp222_; gchar* _tmp223_ = NULL; gchar* _tmp224_; ValaCCodeConstant* _tmp225_; ValaCCodeConstant* _tmp226_; ValaCCodeFunction* _tmp227_; ValaCCodeFunction* _tmp228_; gint _tmp229_; gchar* _tmp230_ = NULL; gchar* _tmp231_; _tmp214_ = _tmp213_; if (!_tmp214_) { gint _tmp215_; _tmp215_ = state; state = _tmp215_ + 1; } _tmp213_ = FALSE; _tmp216_ = state; _tmp217_ = m; _tmp218_ = vala_method_get_yield_count (_tmp217_); _tmp219_ = _tmp218_; if (!(_tmp216_ <= _tmp219_)) { break; } _tmp220_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); _tmp221_ = _tmp220_; _tmp222_ = state; _tmp223_ = g_strdup_printf ("%i", _tmp222_); _tmp224_ = _tmp223_; _tmp225_ = vala_ccode_constant_new (_tmp224_); _tmp226_ = _tmp225_; vala_ccode_function_add_case (_tmp221_, (ValaCCodeExpression*) _tmp226_); _vala_ccode_node_unref0 (_tmp226_); _g_free0 (_tmp224_); _tmp227_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); _tmp228_ = _tmp227_; _tmp229_ = state; _tmp230_ = g_strdup_printf ("_state_%d", _tmp229_); _tmp231_ = _tmp230_; vala_ccode_function_add_goto (_tmp228_, _tmp231_); _g_free0 (_tmp231_); } } } _tmp232_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); _tmp233_ = _tmp232_; vala_ccode_function_add_default (_tmp233_); _tmp234_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); _tmp235_ = _tmp234_; _tmp236_ = vala_ccode_identifier_new ("g_assert_not_reached"); _tmp237_ = _tmp236_; _tmp238_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp237_); _tmp239_ = _tmp238_; vala_ccode_function_add_expression (_tmp235_, (ValaCCodeExpression*) _tmp239_); _vala_ccode_node_unref0 (_tmp239_); _vala_ccode_node_unref0 (_tmp237_); _tmp240_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); _tmp241_ = _tmp240_; vala_ccode_function_close (_tmp241_); _tmp242_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); _tmp243_ = _tmp242_; vala_ccode_function_add_label (_tmp243_, "_state_0"); } _tmp244_ = m; _tmp245_ = vala_method_get_closure (_tmp244_); _tmp246_ = _tmp245_; if (_tmp246_) { ValaBlock* _tmp247_; ValaBlock* _tmp248_; ValaBlock* _tmp249_; ValaBlock* closure_block; ValaBlock* _tmp250_; gint _tmp251_ = 0; gint block_id; ValaMethod* _tmp291_; ValaMemberBinding _tmp292_; ValaMemberBinding _tmp293_; _tmp247_ = vala_ccode_base_module_get_current_closure_block ((ValaCCodeBaseModule*) self); _tmp248_ = _tmp247_; _tmp249_ = _vala_code_node_ref0 (_tmp248_); closure_block = _tmp249_; _tmp250_ = closure_block; _tmp251_ = vala_ccode_base_module_get_block_id ((ValaCCodeBaseModule*) self, _tmp250_); block_id = _tmp251_; while (TRUE) { ValaBlock* _tmp252_; ValaSymbol* _tmp253_; ValaSymbol* _tmp254_; ValaBlock* _tmp255_ = NULL; ValaBlock* _tmp256_; ValaBlock* parent_closure_block; ValaBlock* _tmp257_; ValaBlock* _tmp258_; gint _tmp259_ = 0; gint parent_block_id; gint _tmp260_; gchar* _tmp261_ = NULL; gchar* _tmp262_; ValaCCodeIdentifier* _tmp263_; ValaCCodeIdentifier* _tmp264_; gint _tmp265_; gchar* _tmp266_ = NULL; gchar* _tmp267_; ValaCCodeMemberAccess* _tmp268_; ValaCCodeMemberAccess* _tmp269_; ValaCCodeMemberAccess* parent_data; ValaCCodeFunction* _tmp270_; ValaCCodeFunction* _tmp271_; gint _tmp272_; gchar* _tmp273_ = NULL; gchar* _tmp274_; gint _tmp275_; gchar* _tmp276_ = NULL; gchar* _tmp277_; ValaCCodeVariableDeclarator* _tmp278_; ValaCCodeVariableDeclarator* _tmp279_; ValaCCodeFunction* _tmp280_; ValaCCodeFunction* _tmp281_; gint _tmp282_; gchar* _tmp283_ = NULL; gchar* _tmp284_; ValaCCodeIdentifier* _tmp285_; ValaCCodeIdentifier* _tmp286_; ValaCCodeMemberAccess* _tmp287_; ValaBlock* _tmp288_; ValaBlock* _tmp289_; gint _tmp290_; _tmp252_ = closure_block; _tmp253_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp252_); _tmp254_ = _tmp253_; _tmp255_ = vala_ccode_base_module_next_closure_block ((ValaCCodeBaseModule*) self, _tmp254_); _tmp256_ = _vala_code_node_ref0 (_tmp255_); parent_closure_block = _tmp256_; _tmp257_ = parent_closure_block; if (_tmp257_ == NULL) { _vala_code_node_unref0 (parent_closure_block); break; } _tmp258_ = parent_closure_block; _tmp259_ = vala_ccode_base_module_get_block_id ((ValaCCodeBaseModule*) self, _tmp258_); parent_block_id = _tmp259_; _tmp260_ = block_id; _tmp261_ = g_strdup_printf ("_data%d_", _tmp260_); _tmp262_ = _tmp261_; _tmp263_ = vala_ccode_identifier_new (_tmp262_); _tmp264_ = _tmp263_; _tmp265_ = parent_block_id; _tmp266_ = g_strdup_printf ("_data%d_", _tmp265_); _tmp267_ = _tmp266_; _tmp268_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp264_, _tmp267_); _tmp269_ = _tmp268_; _g_free0 (_tmp267_); _vala_ccode_node_unref0 (_tmp264_); _g_free0 (_tmp262_); parent_data = _tmp269_; _tmp270_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); _tmp271_ = _tmp270_; _tmp272_ = parent_block_id; _tmp273_ = g_strdup_printf ("Block%dData*", _tmp272_); _tmp274_ = _tmp273_; _tmp275_ = parent_block_id; _tmp276_ = g_strdup_printf ("_data%d_", _tmp275_); _tmp277_ = _tmp276_; _tmp278_ = vala_ccode_variable_declarator_new (_tmp277_, NULL, NULL); _tmp279_ = _tmp278_; vala_ccode_function_add_declaration (_tmp271_, _tmp274_, (ValaCCodeDeclarator*) _tmp279_, 0); _vala_ccode_node_unref0 (_tmp279_); _g_free0 (_tmp277_); _g_free0 (_tmp274_); _tmp280_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); _tmp281_ = _tmp280_; _tmp282_ = parent_block_id; _tmp283_ = g_strdup_printf ("_data%d_", _tmp282_); _tmp284_ = _tmp283_; _tmp285_ = vala_ccode_identifier_new (_tmp284_); _tmp286_ = _tmp285_; _tmp287_ = parent_data; vala_ccode_function_add_assignment (_tmp281_, (ValaCCodeExpression*) _tmp286_, (ValaCCodeExpression*) _tmp287_); _vala_ccode_node_unref0 (_tmp286_); _g_free0 (_tmp284_); _tmp288_ = parent_closure_block; _tmp289_ = _vala_code_node_ref0 (_tmp288_); _vala_code_node_unref0 (closure_block); closure_block = _tmp289_; _tmp290_ = parent_block_id; block_id = _tmp290_; _vala_ccode_node_unref0 (parent_data); _vala_code_node_unref0 (parent_closure_block); } _tmp291_ = m; _tmp292_ = vala_method_get_binding (_tmp291_); _tmp293_ = _tmp292_; if (_tmp293_ == VALA_MEMBER_BINDING_INSTANCE) { gint _tmp294_; gchar* _tmp295_ = NULL; gchar* _tmp296_; ValaCCodeIdentifier* _tmp297_; ValaCCodeIdentifier* _tmp298_; ValaCCodeMemberAccess* _tmp299_; ValaCCodeMemberAccess* _tmp300_; ValaCCodeMemberAccess* cself; ValaCCodeFunction* _tmp301_; ValaCCodeFunction* _tmp302_; ValaTypeSymbol* _tmp303_; ValaTypeSymbol* _tmp304_; gchar* _tmp305_ = NULL; gchar* _tmp306_; gchar* _tmp307_ = NULL; gchar* _tmp308_; ValaCCodeVariableDeclarator* _tmp309_; ValaCCodeVariableDeclarator* _tmp310_; ValaCCodeFunction* _tmp311_; ValaCCodeFunction* _tmp312_; ValaCCodeIdentifier* _tmp313_; ValaCCodeIdentifier* _tmp314_; ValaCCodeMemberAccess* _tmp315_; _tmp294_ = block_id; _tmp295_ = g_strdup_printf ("_data%d_", _tmp294_); _tmp296_ = _tmp295_; _tmp297_ = vala_ccode_identifier_new (_tmp296_); _tmp298_ = _tmp297_; _tmp299_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp298_, "self"); _tmp300_ = _tmp299_; _vala_ccode_node_unref0 (_tmp298_); _g_free0 (_tmp296_); cself = _tmp300_; _tmp301_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); _tmp302_ = _tmp301_; _tmp303_ = vala_ccode_base_module_get_current_type_symbol ((ValaCCodeBaseModule*) self); _tmp304_ = _tmp303_; _tmp305_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp304_); _tmp306_ = _tmp305_; _tmp307_ = g_strdup_printf ("%s *", _tmp306_); _tmp308_ = _tmp307_; _tmp309_ = vala_ccode_variable_declarator_new ("self", NULL, NULL); _tmp310_ = _tmp309_; vala_ccode_function_add_declaration (_tmp302_, _tmp308_, (ValaCCodeDeclarator*) _tmp310_, 0); _vala_ccode_node_unref0 (_tmp310_); _g_free0 (_tmp308_); _g_free0 (_tmp306_); _tmp311_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); _tmp312_ = _tmp311_; _tmp313_ = vala_ccode_identifier_new ("self"); _tmp314_ = _tmp313_; _tmp315_ = cself; vala_ccode_function_add_assignment (_tmp312_, (ValaCCodeExpression*) _tmp314_, (ValaCCodeExpression*) _tmp315_); _vala_ccode_node_unref0 (_tmp314_); _vala_ccode_node_unref0 (cself); } { ValaMethod* _tmp316_; ValaList* _tmp317_ = NULL; ValaList* _type_param_list; ValaList* _tmp318_; gint _tmp319_; gint _tmp320_; gint _type_param_size; gint _type_param_index; _tmp316_ = m; _tmp317_ = vala_method_get_type_parameters (_tmp316_); _type_param_list = _tmp317_; _tmp318_ = _type_param_list; _tmp319_ = vala_collection_get_size ((ValaCollection*) _tmp318_); _tmp320_ = _tmp319_; _type_param_size = _tmp320_; _type_param_index = -1; while (TRUE) { gint _tmp321_; gint _tmp322_; gint _tmp323_; ValaList* _tmp324_; gint _tmp325_; gpointer _tmp326_ = NULL; ValaTypeParameter* type_param; gchar* func_name = NULL; ValaTypeParameter* _tmp327_; const gchar* _tmp328_; const gchar* _tmp329_; gchar* _tmp330_ = NULL; gchar* _tmp331_; gchar* _tmp332_ = NULL; ValaCCodeFunction* _tmp333_; ValaCCodeFunction* _tmp334_; const gchar* _tmp335_; ValaCCodeVariableDeclarator* _tmp336_; ValaCCodeVariableDeclarator* _tmp337_; ValaCCodeFunction* _tmp338_; ValaCCodeFunction* _tmp339_; const gchar* _tmp340_; ValaCCodeIdentifier* _tmp341_; ValaCCodeIdentifier* _tmp342_; gint _tmp343_; gchar* _tmp344_ = NULL; gchar* _tmp345_; ValaCCodeExpression* _tmp346_ = NULL; ValaCCodeExpression* _tmp347_; const gchar* _tmp348_; ValaCCodeMemberAccess* _tmp349_; ValaCCodeMemberAccess* _tmp350_; ValaTypeParameter* _tmp351_; const gchar* _tmp352_; const gchar* _tmp353_; gchar* _tmp354_ = NULL; gchar* _tmp355_; gchar* _tmp356_ = NULL; ValaCCodeFunction* _tmp357_; ValaCCodeFunction* _tmp358_; const gchar* _tmp359_; ValaCCodeVariableDeclarator* _tmp360_; ValaCCodeVariableDeclarator* _tmp361_; ValaCCodeFunction* _tmp362_; ValaCCodeFunction* _tmp363_; const gchar* _tmp364_; ValaCCodeIdentifier* _tmp365_; ValaCCodeIdentifier* _tmp366_; gint _tmp367_; gchar* _tmp368_ = NULL; gchar* _tmp369_; ValaCCodeExpression* _tmp370_ = NULL; ValaCCodeExpression* _tmp371_; const gchar* _tmp372_; ValaCCodeMemberAccess* _tmp373_; ValaCCodeMemberAccess* _tmp374_; ValaTypeParameter* _tmp375_; const gchar* _tmp376_; const gchar* _tmp377_; gchar* _tmp378_ = NULL; gchar* _tmp379_; gchar* _tmp380_ = NULL; ValaCCodeFunction* _tmp381_; ValaCCodeFunction* _tmp382_; const gchar* _tmp383_; ValaCCodeVariableDeclarator* _tmp384_; ValaCCodeVariableDeclarator* _tmp385_; ValaCCodeFunction* _tmp386_; ValaCCodeFunction* _tmp387_; const gchar* _tmp388_; ValaCCodeIdentifier* _tmp389_; ValaCCodeIdentifier* _tmp390_; gint _tmp391_; gchar* _tmp392_ = NULL; gchar* _tmp393_; ValaCCodeExpression* _tmp394_ = NULL; ValaCCodeExpression* _tmp395_; const gchar* _tmp396_; ValaCCodeMemberAccess* _tmp397_; ValaCCodeMemberAccess* _tmp398_; _tmp321_ = _type_param_index; _type_param_index = _tmp321_ + 1; _tmp322_ = _type_param_index; _tmp323_ = _type_param_size; if (!(_tmp322_ < _tmp323_)) { break; } _tmp324_ = _type_param_list; _tmp325_ = _type_param_index; _tmp326_ = vala_list_get (_tmp324_, _tmp325_); type_param = (ValaTypeParameter*) _tmp326_; _tmp327_ = type_param; _tmp328_ = vala_symbol_get_name ((ValaSymbol*) _tmp327_); _tmp329_ = _tmp328_; _tmp330_ = g_utf8_strdown (_tmp329_, (gssize) (-1)); _tmp331_ = _tmp330_; _tmp332_ = g_strdup_printf ("%s_type", _tmp331_); _g_free0 (func_name); func_name = _tmp332_; _g_free0 (_tmp331_); _tmp333_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); _tmp334_ = _tmp333_; _tmp335_ = func_name; _tmp336_ = vala_ccode_variable_declarator_new (_tmp335_, NULL, NULL); _tmp337_ = _tmp336_; vala_ccode_function_add_declaration (_tmp334_, "GType", (ValaCCodeDeclarator*) _tmp337_, 0); _vala_ccode_node_unref0 (_tmp337_); _tmp338_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); _tmp339_ = _tmp338_; _tmp340_ = func_name; _tmp341_ = vala_ccode_identifier_new (_tmp340_); _tmp342_ = _tmp341_; _tmp343_ = block_id; _tmp344_ = g_strdup_printf ("_data%d_", _tmp343_); _tmp345_ = _tmp344_; _tmp346_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, _tmp345_); _tmp347_ = _tmp346_; _tmp348_ = func_name; _tmp349_ = vala_ccode_member_access_new_pointer (_tmp347_, _tmp348_); _tmp350_ = _tmp349_; vala_ccode_function_add_assignment (_tmp339_, (ValaCCodeExpression*) _tmp342_, (ValaCCodeExpression*) _tmp350_); _vala_ccode_node_unref0 (_tmp350_); _vala_ccode_node_unref0 (_tmp347_); _g_free0 (_tmp345_); _vala_ccode_node_unref0 (_tmp342_); _tmp351_ = type_param; _tmp352_ = vala_symbol_get_name ((ValaSymbol*) _tmp351_); _tmp353_ = _tmp352_; _tmp354_ = g_utf8_strdown (_tmp353_, (gssize) (-1)); _tmp355_ = _tmp354_; _tmp356_ = g_strdup_printf ("%s_dup_func", _tmp355_); _g_free0 (func_name); func_name = _tmp356_; _g_free0 (_tmp355_); _tmp357_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); _tmp358_ = _tmp357_; _tmp359_ = func_name; _tmp360_ = vala_ccode_variable_declarator_new (_tmp359_, NULL, NULL); _tmp361_ = _tmp360_; vala_ccode_function_add_declaration (_tmp358_, "GBoxedCopyFunc", (ValaCCodeDeclarator*) _tmp361_, 0); _vala_ccode_node_unref0 (_tmp361_); _tmp362_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); _tmp363_ = _tmp362_; _tmp364_ = func_name; _tmp365_ = vala_ccode_identifier_new (_tmp364_); _tmp366_ = _tmp365_; _tmp367_ = block_id; _tmp368_ = g_strdup_printf ("_data%d_", _tmp367_); _tmp369_ = _tmp368_; _tmp370_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, _tmp369_); _tmp371_ = _tmp370_; _tmp372_ = func_name; _tmp373_ = vala_ccode_member_access_new_pointer (_tmp371_, _tmp372_); _tmp374_ = _tmp373_; vala_ccode_function_add_assignment (_tmp363_, (ValaCCodeExpression*) _tmp366_, (ValaCCodeExpression*) _tmp374_); _vala_ccode_node_unref0 (_tmp374_); _vala_ccode_node_unref0 (_tmp371_); _g_free0 (_tmp369_); _vala_ccode_node_unref0 (_tmp366_); _tmp375_ = type_param; _tmp376_ = vala_symbol_get_name ((ValaSymbol*) _tmp375_); _tmp377_ = _tmp376_; _tmp378_ = g_utf8_strdown (_tmp377_, (gssize) (-1)); _tmp379_ = _tmp378_; _tmp380_ = g_strdup_printf ("%s_destroy_func", _tmp379_); _g_free0 (func_name); func_name = _tmp380_; _g_free0 (_tmp379_); _tmp381_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); _tmp382_ = _tmp381_; _tmp383_ = func_name; _tmp384_ = vala_ccode_variable_declarator_new (_tmp383_, NULL, NULL); _tmp385_ = _tmp384_; vala_ccode_function_add_declaration (_tmp382_, "GDestroyNotify", (ValaCCodeDeclarator*) _tmp385_, 0); _vala_ccode_node_unref0 (_tmp385_); _tmp386_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); _tmp387_ = _tmp386_; _tmp388_ = func_name; _tmp389_ = vala_ccode_identifier_new (_tmp388_); _tmp390_ = _tmp389_; _tmp391_ = block_id; _tmp392_ = g_strdup_printf ("_data%d_", _tmp391_); _tmp393_ = _tmp392_; _tmp394_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, _tmp393_); _tmp395_ = _tmp394_; _tmp396_ = func_name; _tmp397_ = vala_ccode_member_access_new_pointer (_tmp395_, _tmp396_); _tmp398_ = _tmp397_; vala_ccode_function_add_assignment (_tmp387_, (ValaCCodeExpression*) _tmp390_, (ValaCCodeExpression*) _tmp398_); _vala_ccode_node_unref0 (_tmp398_); _vala_ccode_node_unref0 (_tmp395_); _g_free0 (_tmp393_); _vala_ccode_node_unref0 (_tmp390_); _g_free0 (func_name); _vala_code_node_unref0 (type_param); } _vala_iterable_unref0 (_type_param_list); } _vala_code_node_unref0 (closure_block); } else { gboolean _tmp399_ = FALSE; ValaMethod* _tmp400_; ValaSymbol* _tmp401_; ValaSymbol* _tmp402_; gboolean _tmp406_; _tmp400_ = m; _tmp401_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp400_); _tmp402_ = _tmp401_; if (VALA_IS_CLASS (_tmp402_)) { ValaMethod* _tmp403_; gboolean _tmp404_; gboolean _tmp405_; _tmp403_ = m; _tmp404_ = vala_method_get_coroutine (_tmp403_); _tmp405_ = _tmp404_; _tmp399_ = !_tmp405_; } else { _tmp399_ = FALSE; } _tmp406_ = _tmp399_; if (_tmp406_) { ValaMethod* _tmp407_; ValaSymbol* _tmp408_; ValaSymbol* _tmp409_; ValaClass* _tmp410_; ValaClass* cl; gboolean _tmp411_ = FALSE; ValaMethod* _tmp412_; gboolean _tmp413_; gboolean _tmp414_; gboolean _tmp428_; _tmp407_ = m; _tmp408_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp407_); _tmp409_ = _tmp408_; _tmp410_ = _vala_code_node_ref0 (VALA_CLASS (_tmp409_)); cl = _tmp410_; _tmp412_ = m; _tmp413_ = vala_method_get_overrides (_tmp412_); _tmp414_ = _tmp413_; if (_tmp414_) { _tmp411_ = TRUE; } else { gboolean _tmp415_ = FALSE; gboolean _tmp416_ = FALSE; ValaMethod* _tmp417_; ValaMethod* _tmp418_; ValaMethod* _tmp419_; gboolean _tmp423_; gboolean _tmp427_; _tmp417_ = m; _tmp418_ = vala_method_get_base_interface_method (_tmp417_); _tmp419_ = _tmp418_; if (_tmp419_ != NULL) { ValaMethod* _tmp420_; gboolean _tmp421_; gboolean _tmp422_; _tmp420_ = m; _tmp421_ = vala_method_get_is_abstract (_tmp420_); _tmp422_ = _tmp421_; _tmp416_ = !_tmp422_; } else { _tmp416_ = FALSE; } _tmp423_ = _tmp416_; if (_tmp423_) { ValaMethod* _tmp424_; gboolean _tmp425_; gboolean _tmp426_; _tmp424_ = m; _tmp425_ = vala_method_get_is_virtual (_tmp424_); _tmp426_ = _tmp425_; _tmp415_ = !_tmp426_; } else { _tmp415_ = FALSE; } _tmp427_ = _tmp415_; _tmp411_ = _tmp427_; } _tmp428_ = _tmp411_; if (_tmp428_) { ValaMethod* base_method = NULL; ValaReferenceType* base_expression_type = NULL; ValaMethod* _tmp429_; gboolean _tmp430_; gboolean _tmp431_; ValaClass* _tmp448_; ValaObjectType* _tmp449_; ValaObjectType* self_target_type; ValaReferenceType* _tmp450_; ValaCCodeIdentifier* _tmp451_; ValaCCodeIdentifier* _tmp452_; ValaGLibValue* _tmp453_; ValaGLibValue* _tmp454_; ValaObjectType* _tmp455_; ValaMethod* _tmp456_; ValaTargetValue* _tmp457_ = NULL; ValaTargetValue* _tmp458_; ValaCCodeExpression* _tmp459_ = NULL; ValaCCodeExpression* _tmp460_; ValaCCodeExpression* cself; ValaCCodeFunction* _tmp461_; ValaCCodeFunction* _tmp462_; ValaClass* _tmp463_; gchar* _tmp464_ = NULL; gchar* _tmp465_; gchar* _tmp466_ = NULL; gchar* _tmp467_; ValaCCodeVariableDeclarator* _tmp468_; ValaCCodeVariableDeclarator* _tmp469_; ValaCCodeFunction* _tmp470_; ValaCCodeFunction* _tmp471_; ValaCCodeIdentifier* _tmp472_; ValaCCodeIdentifier* _tmp473_; ValaCCodeExpression* _tmp474_; _tmp429_ = m; _tmp430_ = vala_method_get_overrides (_tmp429_); _tmp431_ = _tmp430_; if (_tmp431_) { ValaMethod* _tmp432_; ValaMethod* _tmp433_; ValaMethod* _tmp434_; ValaMethod* _tmp435_; ValaMethod* _tmp436_; ValaSymbol* _tmp437_; ValaSymbol* _tmp438_; ValaObjectType* _tmp439_; _tmp432_ = m; _tmp433_ = vala_method_get_base_method (_tmp432_); _tmp434_ = _tmp433_; _tmp435_ = _vala_code_node_ref0 (_tmp434_); _vala_code_node_unref0 (base_method); base_method = _tmp435_; _tmp436_ = base_method; _tmp437_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp436_); _tmp438_ = _tmp437_; _tmp439_ = vala_object_type_new ((ValaObjectTypeSymbol*) VALA_CLASS (_tmp438_)); _vala_code_node_unref0 (base_expression_type); base_expression_type = (ValaReferenceType*) _tmp439_; } else { ValaMethod* _tmp440_; ValaMethod* _tmp441_; ValaMethod* _tmp442_; ValaMethod* _tmp443_; ValaMethod* _tmp444_; ValaSymbol* _tmp445_; ValaSymbol* _tmp446_; ValaObjectType* _tmp447_; _tmp440_ = m; _tmp441_ = vala_method_get_base_interface_method (_tmp440_); _tmp442_ = _tmp441_; _tmp443_ = _vala_code_node_ref0 (_tmp442_); _vala_code_node_unref0 (base_method); base_method = _tmp443_; _tmp444_ = base_method; _tmp445_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp444_); _tmp446_ = _tmp445_; _tmp447_ = vala_object_type_new ((ValaObjectTypeSymbol*) VALA_INTERFACE (_tmp446_)); _vala_code_node_unref0 (base_expression_type); base_expression_type = (ValaReferenceType*) _tmp447_; } _tmp448_ = cl; _tmp449_ = vala_object_type_new ((ValaObjectTypeSymbol*) _tmp448_); self_target_type = _tmp449_; _tmp450_ = base_expression_type; _tmp451_ = vala_ccode_identifier_new ("base"); _tmp452_ = _tmp451_; _tmp453_ = vala_glib_value_new ((ValaDataType*) _tmp450_, (ValaCCodeExpression*) _tmp452_, TRUE); _tmp454_ = _tmp453_; _tmp455_ = self_target_type; _tmp456_ = m; _tmp457_ = vala_ccode_base_module_transform_value ((ValaCCodeBaseModule*) self, (ValaTargetValue*) _tmp454_, (ValaDataType*) _tmp455_, (ValaCodeNode*) _tmp456_); _tmp458_ = _tmp457_; _tmp459_ = vala_ccode_base_module_get_cvalue_ ((ValaCCodeBaseModule*) self, _tmp458_); _tmp460_ = _tmp459_; _vala_target_value_unref0 (_tmp458_); _vala_target_value_unref0 (_tmp454_); _vala_ccode_node_unref0 (_tmp452_); cself = _tmp460_; _tmp461_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); _tmp462_ = _tmp461_; _tmp463_ = cl; _tmp464_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp463_); _tmp465_ = _tmp464_; _tmp466_ = g_strdup_printf ("%s *", _tmp465_); _tmp467_ = _tmp466_; _tmp468_ = vala_ccode_variable_declarator_new ("self", NULL, NULL); _tmp469_ = _tmp468_; vala_ccode_function_add_declaration (_tmp462_, _tmp467_, (ValaCCodeDeclarator*) _tmp469_, 0); _vala_ccode_node_unref0 (_tmp469_); _g_free0 (_tmp467_); _g_free0 (_tmp465_); _tmp470_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); _tmp471_ = _tmp470_; _tmp472_ = vala_ccode_identifier_new ("self"); _tmp473_ = _tmp472_; _tmp474_ = cself; vala_ccode_function_add_assignment (_tmp471_, (ValaCCodeExpression*) _tmp473_, _tmp474_); _vala_ccode_node_unref0 (_tmp473_); _vala_ccode_node_unref0 (cself); _vala_code_node_unref0 (self_target_type); _vala_code_node_unref0 (base_expression_type); _vala_code_node_unref0 (base_method); } else { gboolean _tmp475_ = FALSE; gboolean _tmp476_ = FALSE; gboolean _tmp477_ = FALSE; ValaMethod* _tmp478_; ValaMemberBinding _tmp479_; ValaMemberBinding _tmp480_; gboolean _tmp482_; gboolean _tmp486_; gboolean _tmp490_; _tmp478_ = m; _tmp479_ = vala_method_get_binding (_tmp478_); _tmp480_ = _tmp479_; if (_tmp480_ == VALA_MEMBER_BINDING_INSTANCE) { ValaMethod* _tmp481_; _tmp481_ = m; _tmp477_ = !VALA_IS_CREATION_METHOD (_tmp481_); } else { _tmp477_ = FALSE; } _tmp482_ = _tmp477_; if (_tmp482_) { ValaMethod* _tmp483_; ValaMethod* _tmp484_; ValaMethod* _tmp485_; _tmp483_ = m; _tmp484_ = vala_method_get_base_method (_tmp483_); _tmp485_ = _tmp484_; _tmp476_ = _tmp485_ == NULL; } else { _tmp476_ = FALSE; } _tmp486_ = _tmp476_; if (_tmp486_) { ValaMethod* _tmp487_; ValaMethod* _tmp488_; ValaMethod* _tmp489_; _tmp487_ = m; _tmp488_ = vala_method_get_base_interface_method (_tmp487_); _tmp489_ = _tmp488_; _tmp475_ = _tmp489_ == NULL; } else { _tmp475_ = FALSE; } _tmp490_ = _tmp475_; if (_tmp490_) { ValaMethod* _tmp491_; ValaDataType* _tmp492_; ValaClass* _tmp493_; _tmp491_ = m; _tmp492_ = creturn_type; _tmp493_ = cl; vala_ccode_method_module_create_method_type_check_statement (self, _tmp491_, _tmp492_, (ValaTypeSymbol*) _tmp493_, TRUE, "self"); } } _vala_code_node_unref0 (cl); } } { ValaMethod* _tmp494_; ValaList* _tmp495_ = NULL; ValaList* _param_list; ValaList* _tmp496_; gint _tmp497_; gint _tmp498_; gint _param_size; gint _param_index; _tmp494_ = m; _tmp495_ = vala_method_get_parameters (_tmp494_); _param_list = _tmp495_; _tmp496_ = _param_list; _tmp497_ = vala_collection_get_size ((ValaCollection*) _tmp496_); _tmp498_ = _tmp497_; _param_size = _tmp498_; _param_index = -1; while (TRUE) { gint _tmp499_; gint _tmp500_; gint _tmp501_; ValaList* _tmp502_; gint _tmp503_; gpointer _tmp504_ = NULL; ValaParameter* param; ValaParameter* _tmp505_; gboolean _tmp506_; gboolean _tmp507_; ValaParameter* _tmp508_; ValaParameterDirection _tmp509_; ValaParameterDirection _tmp510_; _tmp499_ = _param_index; _param_index = _tmp499_ + 1; _tmp500_ = _param_index; _tmp501_ = _param_size; if (!(_tmp500_ < _tmp501_)) { break; } _tmp502_ = _param_list; _tmp503_ = _param_index; _tmp504_ = vala_list_get (_tmp502_, _tmp503_); param = (ValaParameter*) _tmp504_; _tmp505_ = param; _tmp506_ = vala_parameter_get_ellipsis (_tmp505_); _tmp507_ = _tmp506_; if (_tmp507_) { _vala_code_node_unref0 (param); break; } _tmp508_ = param; _tmp509_ = vala_parameter_get_direction (_tmp508_); _tmp510_ = _tmp509_; if (_tmp510_ != VALA_PARAMETER_DIRECTION_OUT) { ValaParameter* _tmp511_; ValaDataType* _tmp512_; ValaDataType* _tmp513_; ValaTypeSymbol* _tmp514_; ValaTypeSymbol* _tmp515_; ValaTypeSymbol* _tmp516_; ValaTypeSymbol* t; gboolean _tmp517_ = FALSE; ValaTypeSymbol* _tmp518_; gboolean _tmp527_; _tmp511_ = param; _tmp512_ = vala_variable_get_variable_type ((ValaVariable*) _tmp511_); _tmp513_ = _tmp512_; _tmp514_ = vala_data_type_get_data_type (_tmp513_); _tmp515_ = _tmp514_; _tmp516_ = _vala_code_node_ref0 (_tmp515_); t = _tmp516_; _tmp518_ = t; if (_tmp518_ != NULL) { gboolean _tmp519_ = FALSE; ValaTypeSymbol* _tmp520_; gboolean _tmp521_ = FALSE; gboolean _tmp526_; _tmp520_ = t; _tmp521_ = vala_typesymbol_is_reference_type (_tmp520_); if (_tmp521_) { _tmp519_ = TRUE; } else { ValaParameter* _tmp522_; ValaDataType* _tmp523_; ValaDataType* _tmp524_; gboolean _tmp525_ = FALSE; _tmp522_ = param; _tmp523_ = vala_variable_get_variable_type ((ValaVariable*) _tmp522_); _tmp524_ = _tmp523_; _tmp525_ = vala_data_type_is_real_struct_type (_tmp524_); _tmp519_ = _tmp525_; } _tmp526_ = _tmp519_; _tmp517_ = _tmp526_; } else { _tmp517_ = FALSE; } _tmp527_ = _tmp517_; if (_tmp527_) { ValaParameter* _tmp528_; const gchar* _tmp529_; const gchar* _tmp530_; gchar* _tmp531_ = NULL; gchar* cname; gboolean _tmp532_ = FALSE; ValaParameter* _tmp533_; ValaParameterDirection _tmp534_; ValaParameterDirection _tmp535_; gboolean _tmp540_; ValaMethod* _tmp543_; ValaDataType* _tmp544_; ValaTypeSymbol* _tmp545_; ValaParameter* _tmp546_; ValaDataType* _tmp547_; ValaDataType* _tmp548_; gboolean _tmp549_; gboolean _tmp550_; const gchar* _tmp551_; _tmp528_ = param; _tmp529_ = vala_symbol_get_name ((ValaSymbol*) _tmp528_); _tmp530_ = _tmp529_; _tmp531_ = vala_ccode_base_module_get_variable_cname ((ValaCCodeBaseModule*) self, _tmp530_); cname = _tmp531_; _tmp533_ = param; _tmp534_ = vala_parameter_get_direction (_tmp533_); _tmp535_ = _tmp534_; if (_tmp535_ == VALA_PARAMETER_DIRECTION_REF) { ValaParameter* _tmp536_; ValaDataType* _tmp537_; ValaDataType* _tmp538_; gboolean _tmp539_ = FALSE; _tmp536_ = param; _tmp537_ = vala_variable_get_variable_type ((ValaVariable*) _tmp536_); _tmp538_ = _tmp537_; _tmp539_ = vala_data_type_is_real_struct_type (_tmp538_); _tmp532_ = !_tmp539_; } else { _tmp532_ = FALSE; } _tmp540_ = _tmp532_; if (_tmp540_) { const gchar* _tmp541_; gchar* _tmp542_; _tmp541_ = cname; _tmp542_ = g_strconcat ("*", _tmp541_, NULL); _g_free0 (cname); cname = _tmp542_; } _tmp543_ = m; _tmp544_ = creturn_type; _tmp545_ = t; _tmp546_ = param; _tmp547_ = vala_variable_get_variable_type ((ValaVariable*) _tmp546_); _tmp548_ = _tmp547_; _tmp549_ = vala_data_type_get_nullable (_tmp548_); _tmp550_ = _tmp549_; _tmp551_ = cname; vala_ccode_method_module_create_method_type_check_statement (self, _tmp543_, _tmp544_, _tmp545_, !_tmp550_, _tmp551_); _g_free0 (cname); } _vala_code_node_unref0 (t); } else { ValaMethod* _tmp552_; gboolean _tmp553_; gboolean _tmp554_; _tmp552_ = m; _tmp553_ = vala_method_get_coroutine (_tmp552_); _tmp554_ = _tmp553_; if (!_tmp554_) { ValaParameter* _tmp555_; const gchar* _tmp556_; const gchar* _tmp557_; gchar* _tmp558_; gchar* _tmp559_; gchar* _tmp560_ = NULL; gchar* _tmp561_; ValaParameter* _tmp562_; ValaDataType* _tmp563_; ValaDataType* _tmp564_; ValaCCodeExpression* _tmp565_ = NULL; ValaCCodeExpression* _tmp566_; ValaCCodeVariableDeclarator* _tmp567_; ValaCCodeVariableDeclarator* _tmp568_; ValaCCodeVariableDeclarator* vardecl; ValaCCodeFunction* _tmp569_; ValaCCodeFunction* _tmp570_; ValaParameter* _tmp571_; ValaDataType* _tmp572_; ValaDataType* _tmp573_; gchar* _tmp574_ = NULL; gchar* _tmp575_; ValaCCodeVariableDeclarator* _tmp576_; ValaParameter* _tmp577_; ValaDataType* _tmp578_; ValaDataType* _tmp579_; _tmp555_ = param; _tmp556_ = vala_symbol_get_name ((ValaSymbol*) _tmp555_); _tmp557_ = _tmp556_; _tmp558_ = g_strconcat ("_vala_", _tmp557_, NULL); _tmp559_ = _tmp558_; _tmp560_ = vala_ccode_base_module_get_variable_cname ((ValaCCodeBaseModule*) self, _tmp559_); _tmp561_ = _tmp560_; _tmp562_ = param; _tmp563_ = vala_variable_get_variable_type ((ValaVariable*) _tmp562_); _tmp564_ = _tmp563_; _tmp565_ = vala_ccode_base_module_default_value_for_type ((ValaCCodeBaseModule*) self, _tmp564_, TRUE); _tmp566_ = _tmp565_; _tmp567_ = vala_ccode_variable_declarator_new_zero (_tmp561_, _tmp566_, NULL); _tmp568_ = _tmp567_; _vala_ccode_node_unref0 (_tmp566_); _g_free0 (_tmp561_); _g_free0 (_tmp559_); vardecl = _tmp568_; _tmp569_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); _tmp570_ = _tmp569_; _tmp571_ = param; _tmp572_ = vala_variable_get_variable_type ((ValaVariable*) _tmp571_); _tmp573_ = _tmp572_; _tmp574_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp573_); _tmp575_ = _tmp574_; _tmp576_ = vardecl; vala_ccode_function_add_declaration (_tmp570_, _tmp575_, (ValaCCodeDeclarator*) _tmp576_, 0); _g_free0 (_tmp575_); _tmp577_ = param; _tmp578_ = vala_variable_get_variable_type ((ValaVariable*) _tmp577_); _tmp579_ = _tmp578_; if (VALA_IS_ARRAY_TYPE (_tmp579_)) { ValaParameter* _tmp580_; ValaDataType* _tmp581_; ValaDataType* _tmp582_; ValaArrayType* _tmp583_; ValaArrayType* array_type; ValaArrayType* _tmp584_; gboolean _tmp585_; gboolean _tmp586_; _tmp580_ = param; _tmp581_ = vala_variable_get_variable_type ((ValaVariable*) _tmp580_); _tmp582_ = _tmp581_; _tmp583_ = _vala_code_node_ref0 (VALA_ARRAY_TYPE (_tmp582_)); array_type = _tmp583_; _tmp584_ = array_type; _tmp585_ = vala_array_type_get_fixed_length (_tmp584_); _tmp586_ = _tmp585_; if (!_tmp586_) { { gint dim; dim = 1; { gboolean _tmp587_; _tmp587_ = TRUE; while (TRUE) { gboolean _tmp588_; gint _tmp590_; ValaArrayType* _tmp591_; gint _tmp592_; gint _tmp593_; ValaParameter* _tmp594_; const gchar* _tmp595_; const gchar* _tmp596_; gchar* _tmp597_; gchar* _tmp598_; gchar* _tmp599_ = NULL; gchar* _tmp600_; gint _tmp601_; gchar* _tmp602_ = NULL; gchar* _tmp603_; ValaCCodeConstant* _tmp604_; ValaCCodeConstant* _tmp605_; ValaCCodeVariableDeclarator* _tmp606_; ValaCCodeFunction* _tmp607_; ValaCCodeFunction* _tmp608_; ValaCCodeVariableDeclarator* _tmp609_; _tmp588_ = _tmp587_; if (!_tmp588_) { gint _tmp589_; _tmp589_ = dim; dim = _tmp589_ + 1; } _tmp587_ = FALSE; _tmp590_ = dim; _tmp591_ = array_type; _tmp592_ = vala_array_type_get_rank (_tmp591_); _tmp593_ = _tmp592_; if (!(_tmp590_ <= _tmp593_)) { break; } _tmp594_ = param; _tmp595_ = vala_symbol_get_name ((ValaSymbol*) _tmp594_); _tmp596_ = _tmp595_; _tmp597_ = g_strconcat ("_vala_", _tmp596_, NULL); _tmp598_ = _tmp597_; _tmp599_ = vala_ccode_base_module_get_variable_cname ((ValaCCodeBaseModule*) self, _tmp598_); _tmp600_ = _tmp599_; _tmp601_ = dim; _tmp602_ = vala_ccode_base_module_get_array_length_cname ((ValaCCodeBaseModule*) self, _tmp600_, _tmp601_); _tmp603_ = _tmp602_; _tmp604_ = vala_ccode_constant_new ("0"); _tmp605_ = _tmp604_; _tmp606_ = vala_ccode_variable_declarator_new_zero (_tmp603_, (ValaCCodeExpression*) _tmp605_, NULL); _vala_ccode_node_unref0 (vardecl); vardecl = _tmp606_; _vala_ccode_node_unref0 (_tmp605_); _g_free0 (_tmp603_); _g_free0 (_tmp600_); _g_free0 (_tmp598_); _tmp607_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); _tmp608_ = _tmp607_; _tmp609_ = vardecl; vala_ccode_function_add_declaration (_tmp608_, "int", (ValaCCodeDeclarator*) _tmp609_, 0); } } } } _vala_code_node_unref0 (array_type); } else { ValaParameter* _tmp610_; ValaDataType* _tmp611_; ValaDataType* _tmp612_; _tmp610_ = param; _tmp611_ = vala_variable_get_variable_type ((ValaVariable*) _tmp610_); _tmp612_ = _tmp611_; if (VALA_IS_DELEGATE_TYPE (_tmp612_)) { ValaParameter* _tmp613_; ValaDataType* _tmp614_; ValaDataType* _tmp615_; ValaDelegateType* _tmp616_; ValaDelegateType* deleg_type; ValaDelegateType* _tmp617_; ValaDelegate* _tmp618_; ValaDelegate* _tmp619_; ValaDelegate* _tmp620_; ValaDelegate* d; ValaDelegate* _tmp621_; gboolean _tmp622_; gboolean _tmp623_; _tmp613_ = param; _tmp614_ = vala_variable_get_variable_type ((ValaVariable*) _tmp613_); _tmp615_ = _tmp614_; _tmp616_ = _vala_code_node_ref0 (VALA_DELEGATE_TYPE (_tmp615_)); deleg_type = _tmp616_; _tmp617_ = deleg_type; _tmp618_ = vala_delegate_type_get_delegate_symbol (_tmp617_); _tmp619_ = _tmp618_; _tmp620_ = _vala_code_node_ref0 (_tmp619_); d = _tmp620_; _tmp621_ = d; _tmp622_ = vala_delegate_get_has_target (_tmp621_); _tmp623_ = _tmp622_; if (_tmp623_) { ValaParameter* _tmp624_; const gchar* _tmp625_; const gchar* _tmp626_; gchar* _tmp627_; gchar* _tmp628_; gchar* _tmp629_ = NULL; gchar* _tmp630_; gchar* _tmp631_ = NULL; gchar* _tmp632_; ValaCCodeConstant* _tmp633_; ValaCCodeConstant* _tmp634_; ValaCCodeVariableDeclarator* _tmp635_; ValaCCodeFunction* _tmp636_; ValaCCodeFunction* _tmp637_; ValaCCodeVariableDeclarator* _tmp638_; ValaDelegateType* _tmp639_; gboolean _tmp640_; gboolean _tmp641_; _tmp624_ = param; _tmp625_ = vala_symbol_get_name ((ValaSymbol*) _tmp624_); _tmp626_ = _tmp625_; _tmp627_ = g_strconcat ("_vala_", _tmp626_, NULL); _tmp628_ = _tmp627_; _tmp629_ = vala_ccode_base_module_get_variable_cname ((ValaCCodeBaseModule*) self, _tmp628_); _tmp630_ = _tmp629_; _tmp631_ = vala_ccode_base_module_get_delegate_target_cname ((ValaCCodeBaseModule*) self, _tmp630_); _tmp632_ = _tmp631_; _tmp633_ = vala_ccode_constant_new ("NULL"); _tmp634_ = _tmp633_; _tmp635_ = vala_ccode_variable_declarator_new_zero (_tmp632_, (ValaCCodeExpression*) _tmp634_, NULL); _vala_ccode_node_unref0 (vardecl); vardecl = _tmp635_; _vala_ccode_node_unref0 (_tmp634_); _g_free0 (_tmp632_); _g_free0 (_tmp630_); _g_free0 (_tmp628_); _tmp636_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); _tmp637_ = _tmp636_; _tmp638_ = vardecl; vala_ccode_function_add_declaration (_tmp637_, "void *", (ValaCCodeDeclarator*) _tmp638_, 0); _tmp639_ = deleg_type; _tmp640_ = vala_data_type_get_value_owned ((ValaDataType*) _tmp639_); _tmp641_ = _tmp640_; if (_tmp641_) { ValaParameter* _tmp642_; const gchar* _tmp643_; const gchar* _tmp644_; gchar* _tmp645_; gchar* _tmp646_; gchar* _tmp647_ = NULL; gchar* _tmp648_; gchar* _tmp649_ = NULL; gchar* _tmp650_; ValaCCodeConstant* _tmp651_; ValaCCodeConstant* _tmp652_; ValaCCodeVariableDeclarator* _tmp653_; ValaCCodeFunction* _tmp654_; ValaCCodeFunction* _tmp655_; ValaCCodeVariableDeclarator* _tmp656_; _tmp642_ = param; _tmp643_ = vala_symbol_get_name ((ValaSymbol*) _tmp642_); _tmp644_ = _tmp643_; _tmp645_ = g_strconcat ("_vala_", _tmp644_, NULL); _tmp646_ = _tmp645_; _tmp647_ = vala_ccode_base_module_get_variable_cname ((ValaCCodeBaseModule*) self, _tmp646_); _tmp648_ = _tmp647_; _tmp649_ = vala_ccode_base_module_get_delegate_target_destroy_notify_cname ((ValaCCodeBaseModule*) self, _tmp648_); _tmp650_ = _tmp649_; _tmp651_ = vala_ccode_constant_new ("NULL"); _tmp652_ = _tmp651_; _tmp653_ = vala_ccode_variable_declarator_new_zero (_tmp650_, (ValaCCodeExpression*) _tmp652_, NULL); _vala_ccode_node_unref0 (vardecl); vardecl = _tmp653_; _vala_ccode_node_unref0 (_tmp652_); _g_free0 (_tmp650_); _g_free0 (_tmp648_); _g_free0 (_tmp646_); _tmp654_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); _tmp655_ = _tmp654_; _tmp656_ = vardecl; vala_ccode_function_add_declaration (_tmp655_, "GDestroyNotify", (ValaCCodeDeclarator*) _tmp656_, 0); } } _vala_code_node_unref0 (d); _vala_code_node_unref0 (deleg_type); } } _vala_ccode_node_unref0 (vardecl); } } _vala_code_node_unref0 (param); } _vala_iterable_unref0 (_param_list); } _tmp659_ = m; _tmp660_ = vala_method_get_return_type (_tmp659_); _tmp661_ = _tmp660_; if (!VALA_IS_VOID_TYPE (_tmp661_)) { ValaMethod* _tmp662_; ValaDataType* _tmp663_; ValaDataType* _tmp664_; gboolean _tmp665_ = FALSE; _tmp662_ = m; _tmp663_ = vala_method_get_return_type (_tmp662_); _tmp664_ = _tmp663_; _tmp665_ = vala_data_type_is_real_non_null_struct_type (_tmp664_); _tmp658_ = !_tmp665_; } else { _tmp658_ = FALSE; } _tmp666_ = _tmp658_; if (_tmp666_) { ValaMethod* _tmp667_; gboolean _tmp668_; gboolean _tmp669_; _tmp667_ = m; _tmp668_ = vala_method_get_coroutine (_tmp667_); _tmp669_ = _tmp668_; _tmp657_ = !_tmp669_; } else { _tmp657_ = FALSE; } _tmp670_ = _tmp657_; if (_tmp670_) { ValaMethod* _tmp671_; ValaDataType* _tmp672_; ValaDataType* _tmp673_; ValaCCodeExpression* _tmp674_ = NULL; ValaCCodeExpression* _tmp675_; ValaCCodeVariableDeclarator* _tmp676_; ValaCCodeVariableDeclarator* _tmp677_; ValaCCodeVariableDeclarator* vardecl; ValaCCodeVariableDeclarator* _tmp678_; ValaCCodeFunction* _tmp679_; ValaCCodeFunction* _tmp680_; ValaMethod* _tmp681_; ValaDataType* _tmp682_; ValaDataType* _tmp683_; gchar* _tmp684_ = NULL; gchar* _tmp685_; ValaCCodeVariableDeclarator* _tmp686_; _tmp671_ = m; _tmp672_ = vala_method_get_return_type (_tmp671_); _tmp673_ = _tmp672_; _tmp674_ = vala_ccode_base_module_default_value_for_type ((ValaCCodeBaseModule*) self, _tmp673_, TRUE); _tmp675_ = _tmp674_; _tmp676_ = vala_ccode_variable_declarator_new ("result", _tmp675_, NULL); _tmp677_ = _tmp676_; _vala_ccode_node_unref0 (_tmp675_); vardecl = _tmp677_; _tmp678_ = vardecl; vala_ccode_variable_declarator_set_init0 (_tmp678_, TRUE); _tmp679_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); _tmp680_ = _tmp679_; _tmp681_ = m; _tmp682_ = vala_method_get_return_type (_tmp681_); _tmp683_ = _tmp682_; _tmp684_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp683_); _tmp685_ = _tmp684_; _tmp686_ = vardecl; vala_ccode_function_add_declaration (_tmp680_, _tmp685_, (ValaCCodeDeclarator*) _tmp686_, 0); _g_free0 (_tmp685_); _vala_ccode_node_unref0 (vardecl); } _tmp687_ = m; if (VALA_IS_CREATION_METHOD (_tmp687_)) { gboolean _tmp688_; _tmp688_ = in_gobject_creation_method; if (_tmp688_) { ValaCCodeFunction* _tmp689_; ValaCCodeFunction* _tmp690_; ValaTypeSymbol* _tmp691_; ValaTypeSymbol* _tmp692_; gchar* _tmp693_ = NULL; gchar* _tmp694_; gchar* _tmp695_ = NULL; gchar* _tmp696_; ValaCCodeConstant* _tmp697_; ValaCCodeConstant* _tmp698_; ValaCCodeVariableDeclarator* _tmp699_; ValaCCodeVariableDeclarator* _tmp700_; _tmp689_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); _tmp690_ = _tmp689_; _tmp691_ = vala_ccode_base_module_get_current_type_symbol ((ValaCCodeBaseModule*) self); _tmp692_ = _tmp691_; _tmp693_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp692_); _tmp694_ = _tmp693_; _tmp695_ = g_strdup_printf ("%s *", _tmp694_); _tmp696_ = _tmp695_; _tmp697_ = vala_ccode_constant_new ("NULL"); _tmp698_ = _tmp697_; _tmp699_ = vala_ccode_variable_declarator_new_zero ("self", (ValaCCodeExpression*) _tmp698_, NULL); _tmp700_ = _tmp699_; vala_ccode_function_add_declaration (_tmp690_, _tmp696_, (ValaCCodeDeclarator*) _tmp700_, 0); _vala_ccode_node_unref0 (_tmp700_); _vala_ccode_node_unref0 (_tmp698_); _g_free0 (_tmp696_); _g_free0 (_tmp694_); } else { ValaMethod* _tmp701_; gboolean _tmp702_ = FALSE; _tmp701_ = m; _tmp702_ = vala_ccode_method_module_is_gtypeinstance_creation_method (self, _tmp701_); if (_tmp702_) { ValaMethod* _tmp703_; ValaSymbol* _tmp704_; ValaSymbol* _tmp705_; ValaClass* _tmp706_; ValaClass* cl; ValaCCodeFunction* _tmp707_; ValaCCodeFunction* _tmp708_; ValaClass* _tmp709_; gchar* _tmp710_ = NULL; gchar* _tmp711_; gchar* _tmp712_; gchar* _tmp713_; ValaCCodeConstant* _tmp714_; ValaCCodeConstant* _tmp715_; ValaCCodeVariableDeclarator* _tmp716_; ValaCCodeVariableDeclarator* _tmp717_; ValaClass* _tmp718_; gboolean _tmp719_ = FALSE; _tmp703_ = m; _tmp704_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp703_); _tmp705_ = _tmp704_; _tmp706_ = _vala_code_node_ref0 (VALA_CLASS (_tmp705_)); cl = _tmp706_; _tmp707_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); _tmp708_ = _tmp707_; _tmp709_ = cl; _tmp710_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp709_); _tmp711_ = _tmp710_; _tmp712_ = g_strconcat (_tmp711_, "*", NULL); _tmp713_ = _tmp712_; _tmp714_ = vala_ccode_constant_new ("NULL"); _tmp715_ = _tmp714_; _tmp716_ = vala_ccode_variable_declarator_new_zero ("self", (ValaCCodeExpression*) _tmp715_, NULL); _tmp717_ = _tmp716_; vala_ccode_function_add_declaration (_tmp708_, _tmp713_, (ValaCCodeDeclarator*) _tmp717_, 0); _vala_ccode_node_unref0 (_tmp717_); _vala_ccode_node_unref0 (_tmp715_); _g_free0 (_tmp713_); _g_free0 (_tmp711_); _tmp718_ = cl; _tmp719_ = vala_class_is_fundamental (_tmp718_); if (_tmp719_) { ValaCCodeIdentifier* _tmp720_; ValaCCodeIdentifier* _tmp721_; ValaCCodeFunctionCall* _tmp722_; ValaCCodeFunctionCall* _tmp723_; ValaCCodeFunctionCall* ccall; ValaCCodeFunctionCall* _tmp724_; ValaCCodeIdentifier* _tmp725_; ValaCCodeIdentifier* _tmp726_; ValaCCodeFunction* _tmp727_; ValaCCodeFunction* _tmp728_; ValaCCodeIdentifier* _tmp729_; ValaCCodeIdentifier* _tmp730_; ValaCCodeFunctionCall* _tmp731_; ValaClass* _tmp732_; gchar* _tmp733_ = NULL; gchar* _tmp734_; gchar* _tmp735_; gchar* _tmp736_; ValaCCodeCastExpression* _tmp737_; ValaCCodeCastExpression* _tmp738_; _tmp720_ = vala_ccode_identifier_new ("g_type_create_instance"); _tmp721_ = _tmp720_; _tmp722_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp721_); _tmp723_ = _tmp722_; _vala_ccode_node_unref0 (_tmp721_); ccall = _tmp723_; _tmp724_ = ccall; _tmp725_ = vala_ccode_identifier_new ("object_type"); _tmp726_ = _tmp725_; vala_ccode_function_call_add_argument (_tmp724_, (ValaCCodeExpression*) _tmp726_); _vala_ccode_node_unref0 (_tmp726_); _tmp727_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); _tmp728_ = _tmp727_; _tmp729_ = vala_ccode_identifier_new ("self"); _tmp730_ = _tmp729_; _tmp731_ = ccall; _tmp732_ = cl; _tmp733_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp732_); _tmp734_ = _tmp733_; _tmp735_ = g_strconcat (_tmp734_, "*", NULL); _tmp736_ = _tmp735_; _tmp737_ = vala_ccode_cast_expression_new ((ValaCCodeExpression*) _tmp731_, _tmp736_); _tmp738_ = _tmp737_; vala_ccode_function_add_assignment (_tmp728_, (ValaCCodeExpression*) _tmp730_, (ValaCCodeExpression*) _tmp738_); _vala_ccode_node_unref0 (_tmp738_); _g_free0 (_tmp736_); _g_free0 (_tmp734_); _vala_ccode_node_unref0 (_tmp730_); { ValaClass* _tmp739_; ValaClass* _tmp740_; ValaList* _tmp741_ = NULL; ValaList* _type_param_list; ValaList* _tmp742_; gint _tmp743_; gint _tmp744_; gint _type_param_size; gint _type_param_index; _tmp739_ = vala_ccode_base_module_get_current_class ((ValaCCodeBaseModule*) self); _tmp740_ = _tmp739_; _tmp741_ = vala_object_type_symbol_get_type_parameters ((ValaObjectTypeSymbol*) _tmp740_); _type_param_list = _tmp741_; _tmp742_ = _type_param_list; _tmp743_ = vala_collection_get_size ((ValaCollection*) _tmp742_); _tmp744_ = _tmp743_; _type_param_size = _tmp744_; _type_param_index = -1; while (TRUE) { gint _tmp745_; gint _tmp746_; gint _tmp747_; ValaList* _tmp748_; gint _tmp749_; gpointer _tmp750_ = NULL; ValaTypeParameter* type_param; ValaCCodeIdentifier* param_name = NULL; ValaCCodeAssignment* assign = NULL; ValaCCodeIdentifier* _tmp751_; ValaCCodeIdentifier* _tmp752_; ValaCCodeMemberAccess* _tmp753_; ValaCCodeMemberAccess* _tmp754_; ValaCCodeMemberAccess* priv_access; ValaTypeParameter* _tmp755_; const gchar* _tmp756_; const gchar* _tmp757_; gchar* _tmp758_ = NULL; gchar* _tmp759_; gchar* _tmp760_ = NULL; gchar* _tmp761_; ValaCCodeIdentifier* _tmp762_; ValaCCodeMemberAccess* _tmp763_; ValaCCodeIdentifier* _tmp764_; const gchar* _tmp765_; const gchar* _tmp766_; ValaCCodeMemberAccess* _tmp767_; ValaCCodeMemberAccess* _tmp768_; ValaCCodeIdentifier* _tmp769_; ValaCCodeAssignment* _tmp770_; ValaCCodeFunction* _tmp771_; ValaCCodeFunction* _tmp772_; ValaCCodeAssignment* _tmp773_; ValaTypeParameter* _tmp774_; const gchar* _tmp775_; const gchar* _tmp776_; gchar* _tmp777_ = NULL; gchar* _tmp778_; gchar* _tmp779_ = NULL; gchar* _tmp780_; ValaCCodeIdentifier* _tmp781_; ValaCCodeMemberAccess* _tmp782_; ValaCCodeIdentifier* _tmp783_; const gchar* _tmp784_; const gchar* _tmp785_; ValaCCodeMemberAccess* _tmp786_; ValaCCodeMemberAccess* _tmp787_; ValaCCodeIdentifier* _tmp788_; ValaCCodeAssignment* _tmp789_; ValaCCodeFunction* _tmp790_; ValaCCodeFunction* _tmp791_; ValaCCodeAssignment* _tmp792_; ValaTypeParameter* _tmp793_; const gchar* _tmp794_; const gchar* _tmp795_; gchar* _tmp796_ = NULL; gchar* _tmp797_; gchar* _tmp798_ = NULL; gchar* _tmp799_; ValaCCodeIdentifier* _tmp800_; ValaCCodeMemberAccess* _tmp801_; ValaCCodeIdentifier* _tmp802_; const gchar* _tmp803_; const gchar* _tmp804_; ValaCCodeMemberAccess* _tmp805_; ValaCCodeMemberAccess* _tmp806_; ValaCCodeIdentifier* _tmp807_; ValaCCodeAssignment* _tmp808_; ValaCCodeFunction* _tmp809_; ValaCCodeFunction* _tmp810_; ValaCCodeAssignment* _tmp811_; _tmp745_ = _type_param_index; _type_param_index = _tmp745_ + 1; _tmp746_ = _type_param_index; _tmp747_ = _type_param_size; if (!(_tmp746_ < _tmp747_)) { break; } _tmp748_ = _type_param_list; _tmp749_ = _type_param_index; _tmp750_ = vala_list_get (_tmp748_, _tmp749_); type_param = (ValaTypeParameter*) _tmp750_; _tmp751_ = vala_ccode_identifier_new ("self"); _tmp752_ = _tmp751_; _tmp753_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp752_, "priv"); _tmp754_ = _tmp753_; _vala_ccode_node_unref0 (_tmp752_); priv_access = _tmp754_; _tmp755_ = type_param; _tmp756_ = vala_symbol_get_name ((ValaSymbol*) _tmp755_); _tmp757_ = _tmp756_; _tmp758_ = g_utf8_strdown (_tmp757_, (gssize) (-1)); _tmp759_ = _tmp758_; _tmp760_ = g_strdup_printf ("%s_type", _tmp759_); _tmp761_ = _tmp760_; _tmp762_ = vala_ccode_identifier_new (_tmp761_); _vala_ccode_node_unref0 (param_name); param_name = _tmp762_; _g_free0 (_tmp761_); _g_free0 (_tmp759_); _tmp763_ = priv_access; _tmp764_ = param_name; _tmp765_ = vala_ccode_identifier_get_name (_tmp764_); _tmp766_ = _tmp765_; _tmp767_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp763_, _tmp766_); _tmp768_ = _tmp767_; _tmp769_ = param_name; _tmp770_ = vala_ccode_assignment_new ((ValaCCodeExpression*) _tmp768_, (ValaCCodeExpression*) _tmp769_, VALA_CCODE_ASSIGNMENT_OPERATOR_SIMPLE); _vala_ccode_node_unref0 (assign); assign = _tmp770_; _vala_ccode_node_unref0 (_tmp768_); _tmp771_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); _tmp772_ = _tmp771_; _tmp773_ = assign; vala_ccode_function_add_expression (_tmp772_, (ValaCCodeExpression*) _tmp773_); _tmp774_ = type_param; _tmp775_ = vala_symbol_get_name ((ValaSymbol*) _tmp774_); _tmp776_ = _tmp775_; _tmp777_ = g_utf8_strdown (_tmp776_, (gssize) (-1)); _tmp778_ = _tmp777_; _tmp779_ = g_strdup_printf ("%s_dup_func", _tmp778_); _tmp780_ = _tmp779_; _tmp781_ = vala_ccode_identifier_new (_tmp780_); _vala_ccode_node_unref0 (param_name); param_name = _tmp781_; _g_free0 (_tmp780_); _g_free0 (_tmp778_); _tmp782_ = priv_access; _tmp783_ = param_name; _tmp784_ = vala_ccode_identifier_get_name (_tmp783_); _tmp785_ = _tmp784_; _tmp786_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp782_, _tmp785_); _tmp787_ = _tmp786_; _tmp788_ = param_name; _tmp789_ = vala_ccode_assignment_new ((ValaCCodeExpression*) _tmp787_, (ValaCCodeExpression*) _tmp788_, VALA_CCODE_ASSIGNMENT_OPERATOR_SIMPLE); _vala_ccode_node_unref0 (assign); assign = _tmp789_; _vala_ccode_node_unref0 (_tmp787_); _tmp790_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); _tmp791_ = _tmp790_; _tmp792_ = assign; vala_ccode_function_add_expression (_tmp791_, (ValaCCodeExpression*) _tmp792_); _tmp793_ = type_param; _tmp794_ = vala_symbol_get_name ((ValaSymbol*) _tmp793_); _tmp795_ = _tmp794_; _tmp796_ = g_utf8_strdown (_tmp795_, (gssize) (-1)); _tmp797_ = _tmp796_; _tmp798_ = g_strdup_printf ("%s_destroy_func", _tmp797_); _tmp799_ = _tmp798_; _tmp800_ = vala_ccode_identifier_new (_tmp799_); _vala_ccode_node_unref0 (param_name); param_name = _tmp800_; _g_free0 (_tmp799_); _g_free0 (_tmp797_); _tmp801_ = priv_access; _tmp802_ = param_name; _tmp803_ = vala_ccode_identifier_get_name (_tmp802_); _tmp804_ = _tmp803_; _tmp805_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp801_, _tmp804_); _tmp806_ = _tmp805_; _tmp807_ = param_name; _tmp808_ = vala_ccode_assignment_new ((ValaCCodeExpression*) _tmp806_, (ValaCCodeExpression*) _tmp807_, VALA_CCODE_ASSIGNMENT_OPERATOR_SIMPLE); _vala_ccode_node_unref0 (assign); assign = _tmp808_; _vala_ccode_node_unref0 (_tmp806_); _tmp809_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); _tmp810_ = _tmp809_; _tmp811_ = assign; vala_ccode_function_add_expression (_tmp810_, (ValaCCodeExpression*) _tmp811_); _vala_ccode_node_unref0 (priv_access); _vala_ccode_node_unref0 (assign); _vala_ccode_node_unref0 (param_name); _vala_code_node_unref0 (type_param); } _vala_iterable_unref0 (_type_param_list); } _vala_ccode_node_unref0 (ccall); } _vala_code_node_unref0 (cl); } else { ValaTypeSymbol* _tmp812_; ValaTypeSymbol* _tmp813_; _tmp812_ = vala_ccode_base_module_get_current_type_symbol ((ValaCCodeBaseModule*) self); _tmp813_ = _tmp812_; if (VALA_IS_CLASS (_tmp813_)) { ValaMethod* _tmp814_; ValaSymbol* _tmp815_; ValaSymbol* _tmp816_; ValaClass* _tmp817_; ValaClass* cl; ValaCCodeFunction* _tmp818_; ValaCCodeFunction* _tmp819_; ValaClass* _tmp820_; gchar* _tmp821_ = NULL; gchar* _tmp822_; gchar* _tmp823_; gchar* _tmp824_; ValaCCodeVariableDeclarator* _tmp825_; ValaCCodeVariableDeclarator* _tmp826_; ValaMethod* _tmp827_; gboolean _tmp828_; gboolean _tmp829_; ValaClass* _tmp845_; ValaClass* _tmp846_; ValaClass* _tmp847_; _tmp814_ = m; _tmp815_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp814_); _tmp816_ = _tmp815_; _tmp817_ = _vala_code_node_ref0 (VALA_CLASS (_tmp816_)); cl = _tmp817_; _tmp818_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); _tmp819_ = _tmp818_; _tmp820_ = cl; _tmp821_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp820_); _tmp822_ = _tmp821_; _tmp823_ = g_strconcat (_tmp822_, "*", NULL); _tmp824_ = _tmp823_; _tmp825_ = vala_ccode_variable_declarator_new ("self", NULL, NULL); _tmp826_ = _tmp825_; vala_ccode_function_add_declaration (_tmp819_, _tmp824_, (ValaCCodeDeclarator*) _tmp826_, 0); _vala_ccode_node_unref0 (_tmp826_); _g_free0 (_tmp824_); _g_free0 (_tmp822_); _tmp827_ = m; _tmp828_ = vala_creation_method_get_chain_up (VALA_CREATION_METHOD (_tmp827_)); _tmp829_ = _tmp828_; if (!_tmp829_) { ValaCCodeIdentifier* _tmp830_; ValaCCodeIdentifier* _tmp831_; ValaCCodeFunctionCall* _tmp832_; ValaCCodeFunctionCall* _tmp833_; ValaCCodeFunctionCall* ccall; ValaCCodeFunctionCall* _tmp834_; ValaClass* _tmp835_; gchar* _tmp836_ = NULL; gchar* _tmp837_; ValaCCodeIdentifier* _tmp838_; ValaCCodeIdentifier* _tmp839_; ValaCCodeFunction* _tmp840_; ValaCCodeFunction* _tmp841_; ValaCCodeIdentifier* _tmp842_; ValaCCodeIdentifier* _tmp843_; ValaCCodeFunctionCall* _tmp844_; _tmp830_ = vala_ccode_identifier_new ("g_slice_new0"); _tmp831_ = _tmp830_; _tmp832_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp831_); _tmp833_ = _tmp832_; _vala_ccode_node_unref0 (_tmp831_); ccall = _tmp833_; _tmp834_ = ccall; _tmp835_ = cl; _tmp836_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp835_); _tmp837_ = _tmp836_; _tmp838_ = vala_ccode_identifier_new (_tmp837_); _tmp839_ = _tmp838_; vala_ccode_function_call_add_argument (_tmp834_, (ValaCCodeExpression*) _tmp839_); _vala_ccode_node_unref0 (_tmp839_); _g_free0 (_tmp837_); _tmp840_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); _tmp841_ = _tmp840_; _tmp842_ = vala_ccode_identifier_new ("self"); _tmp843_ = _tmp842_; _tmp844_ = ccall; vala_ccode_function_add_assignment (_tmp841_, (ValaCCodeExpression*) _tmp843_, (ValaCCodeExpression*) _tmp844_); _vala_ccode_node_unref0 (_tmp843_); _vala_ccode_node_unref0 (ccall); } _tmp845_ = cl; _tmp846_ = vala_class_get_base_class (_tmp845_); _tmp847_ = _tmp846_; if (_tmp847_ == NULL) { ValaClass* _tmp848_; gchar* _tmp849_ = NULL; gchar* _tmp850_; gchar* _tmp851_ = NULL; gchar* _tmp852_; ValaCCodeIdentifier* _tmp853_; ValaCCodeIdentifier* _tmp854_; ValaCCodeFunctionCall* _tmp855_; ValaCCodeFunctionCall* _tmp856_; ValaCCodeFunctionCall* cinitcall; ValaCCodeFunctionCall* _tmp857_; ValaCCodeIdentifier* _tmp858_; ValaCCodeIdentifier* _tmp859_; ValaCCodeFunction* _tmp860_; ValaCCodeFunction* _tmp861_; ValaCCodeFunctionCall* _tmp862_; _tmp848_ = cl; _tmp849_ = vala_ccode_base_module_get_ccode_lower_case_name ((ValaCodeNode*) _tmp848_, NULL); _tmp850_ = _tmp849_; _tmp851_ = g_strdup_printf ("%s_instance_init", _tmp850_); _tmp852_ = _tmp851_; _tmp853_ = vala_ccode_identifier_new (_tmp852_); _tmp854_ = _tmp853_; _tmp855_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp854_); _tmp856_ = _tmp855_; _vala_ccode_node_unref0 (_tmp854_); _g_free0 (_tmp852_); _g_free0 (_tmp850_); cinitcall = _tmp856_; _tmp857_ = cinitcall; _tmp858_ = vala_ccode_identifier_new ("self"); _tmp859_ = _tmp858_; vala_ccode_function_call_add_argument (_tmp857_, (ValaCCodeExpression*) _tmp859_); _vala_ccode_node_unref0 (_tmp859_); _tmp860_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); _tmp861_ = _tmp860_; _tmp862_ = cinitcall; vala_ccode_function_add_expression (_tmp861_, (ValaCCodeExpression*) _tmp862_); _vala_ccode_node_unref0 (cinitcall); } _vala_code_node_unref0 (cl); } else { ValaMethod* _tmp863_; ValaSymbol* _tmp864_; ValaSymbol* _tmp865_; ValaStruct* _tmp866_; ValaStruct* st; ValaCCodeFile* _tmp867_; ValaCCodeIdentifier* _tmp868_; ValaCCodeIdentifier* _tmp869_; ValaCCodeFunctionCall* _tmp870_; ValaCCodeFunctionCall* _tmp871_; ValaCCodeFunctionCall* czero; ValaCCodeFunctionCall* _tmp872_; ValaCCodeIdentifier* _tmp873_; ValaCCodeIdentifier* _tmp874_; ValaCCodeFunctionCall* _tmp875_; ValaCCodeConstant* _tmp876_; ValaCCodeConstant* _tmp877_; ValaCCodeFunctionCall* _tmp878_; ValaStruct* _tmp879_; gchar* _tmp880_ = NULL; gchar* _tmp881_; gchar* _tmp882_ = NULL; gchar* _tmp883_; ValaCCodeIdentifier* _tmp884_; ValaCCodeIdentifier* _tmp885_; ValaCCodeFunction* _tmp886_; ValaCCodeFunction* _tmp887_; ValaCCodeFunctionCall* _tmp888_; _tmp863_ = m; _tmp864_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp863_); _tmp865_ = _tmp864_; _tmp866_ = _vala_code_node_ref0 (VALA_STRUCT (_tmp865_)); st = _tmp866_; _tmp867_ = ((ValaCCodeBaseModule*) self)->cfile; vala_ccode_file_add_include (_tmp867_, "string.h", FALSE); _tmp868_ = vala_ccode_identifier_new ("memset"); _tmp869_ = _tmp868_; _tmp870_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp869_); _tmp871_ = _tmp870_; _vala_ccode_node_unref0 (_tmp869_); czero = _tmp871_; _tmp872_ = czero; _tmp873_ = vala_ccode_identifier_new ("self"); _tmp874_ = _tmp873_; vala_ccode_function_call_add_argument (_tmp872_, (ValaCCodeExpression*) _tmp874_); _vala_ccode_node_unref0 (_tmp874_); _tmp875_ = czero; _tmp876_ = vala_ccode_constant_new ("0"); _tmp877_ = _tmp876_; vala_ccode_function_call_add_argument (_tmp875_, (ValaCCodeExpression*) _tmp877_); _vala_ccode_node_unref0 (_tmp877_); _tmp878_ = czero; _tmp879_ = st; _tmp880_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp879_); _tmp881_ = _tmp880_; _tmp882_ = g_strdup_printf ("sizeof (%s)", _tmp881_); _tmp883_ = _tmp882_; _tmp884_ = vala_ccode_identifier_new (_tmp883_); _tmp885_ = _tmp884_; vala_ccode_function_call_add_argument (_tmp878_, (ValaCCodeExpression*) _tmp885_); _vala_ccode_node_unref0 (_tmp885_); _g_free0 (_tmp883_); _g_free0 (_tmp881_); _tmp886_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); _tmp887_ = _tmp886_; _tmp888_ = czero; vala_ccode_function_add_expression (_tmp887_, (ValaCCodeExpression*) _tmp888_); _vala_ccode_node_unref0 (czero); _vala_code_node_unref0 (st); } } } } _tmp890_ = vala_ccode_base_module_get_context ((ValaCCodeBaseModule*) self); _tmp891_ = _tmp890_; _tmp892_ = vala_code_context_get_module_init_method (_tmp891_); _tmp893_ = _tmp892_; _tmp894_ = m; if (_tmp893_ == _tmp894_) { gboolean _tmp895_; _tmp895_ = ((ValaCCodeBaseModule*) self)->in_plugin; _tmp889_ = _tmp895_; } else { _tmp889_ = FALSE; } _tmp896_ = _tmp889_; if (_tmp896_) { ValaCodeContext* _tmp897_; ValaCodeContext* _tmp898_; ValaNamespace* _tmp899_; ValaNamespace* _tmp900_; GHashFunc _tmp901_; GEqualFunc _tmp902_; ValaHashSet* _tmp903_; ValaHashSet* _tmp904_; _tmp897_ = vala_ccode_base_module_get_context ((ValaCCodeBaseModule*) self); _tmp898_ = _tmp897_; _tmp899_ = vala_code_context_get_root (_tmp898_); _tmp900_ = _tmp899_; _tmp901_ = g_direct_hash; _tmp902_ = g_direct_equal; _tmp903_ = vala_hash_set_new (VALA_TYPE_SYMBOL, (GBoxedCopyFunc) vala_code_node_ref, vala_code_node_unref, _tmp901_, _tmp902_); _tmp904_ = _tmp903_; vala_ccode_method_module_register_plugin_types (self, (ValaSymbol*) _tmp900_, (ValaSet*) _tmp904_); _vala_iterable_unref0 (_tmp904_); } { ValaMethod* _tmp905_; ValaList* _tmp906_ = NULL; ValaList* _precondition_list; ValaList* _tmp907_; gint _tmp908_; gint _tmp909_; gint _precondition_size; gint _precondition_index; _tmp905_ = m; _tmp906_ = vala_method_get_preconditions (_tmp905_); _precondition_list = _tmp906_; _tmp907_ = _precondition_list; _tmp908_ = vala_collection_get_size ((ValaCollection*) _tmp907_); _tmp909_ = _tmp908_; _precondition_size = _tmp909_; _precondition_index = -1; while (TRUE) { gint _tmp910_; gint _tmp911_; gint _tmp912_; ValaList* _tmp913_; gint _tmp914_; gpointer _tmp915_ = NULL; ValaExpression* precondition; ValaMethod* _tmp916_; ValaDataType* _tmp917_; ValaExpression* _tmp918_; _tmp910_ = _precondition_index; _precondition_index = _tmp910_ + 1; _tmp911_ = _precondition_index; _tmp912_ = _precondition_size; if (!(_tmp911_ < _tmp912_)) { break; } _tmp913_ = _precondition_list; _tmp914_ = _precondition_index; _tmp915_ = vala_list_get (_tmp913_, _tmp914_); precondition = (ValaExpression*) _tmp915_; _tmp916_ = m; _tmp917_ = creturn_type; _tmp918_ = precondition; vala_ccode_method_module_create_precondition_statement (self, (ValaCodeNode*) _tmp916_, _tmp917_, _tmp918_); _vala_code_node_unref0 (precondition); } _vala_iterable_unref0 (_precondition_list); } } } _tmp919_ = m; _tmp920_ = vala_subroutine_get_body ((ValaSubroutine*) _tmp919_); _tmp921_ = _tmp920_; if (_tmp921_ != NULL) { ValaMethod* _tmp922_; ValaBlock* _tmp923_; ValaBlock* _tmp924_; _tmp922_ = m; _tmp923_ = vala_subroutine_get_body ((ValaSubroutine*) _tmp922_); _tmp924_ = _tmp923_; vala_code_node_emit ((ValaCodeNode*) _tmp924_, (ValaCodeGenerator*) self); } _tmp926_ = m; _tmp927_ = vala_method_get_is_abstract (_tmp926_); _tmp928_ = _tmp927_; if (!_tmp928_) { _tmp925_ = TRUE; } else { gboolean _tmp929_ = FALSE; ValaMethod* _tmp930_; gboolean _tmp931_; gboolean _tmp932_; gboolean _tmp935_; _tmp930_ = m; _tmp931_ = vala_method_get_is_abstract (_tmp930_); _tmp932_ = _tmp931_; if (_tmp932_) { ValaTypeSymbol* _tmp933_; ValaTypeSymbol* _tmp934_; _tmp933_ = vala_ccode_base_module_get_current_type_symbol ((ValaCCodeBaseModule*) self); _tmp934_ = _tmp933_; _tmp929_ = VALA_IS_CLASS (_tmp934_); } else { _tmp929_ = FALSE; } _tmp935_ = _tmp929_; _tmp925_ = _tmp935_; } _tmp936_ = _tmp925_; if (_tmp936_) { ValaMethod* _tmp937_; ValaBlock* _tmp938_; ValaBlock* _tmp939_; _tmp937_ = m; _tmp938_ = vala_subroutine_get_body ((ValaSubroutine*) _tmp937_); _tmp939_ = _tmp938_; if (_tmp939_ != NULL) { gboolean _tmp940_; gboolean _tmp941_; ValaMethod* _tmp952_; gboolean _tmp953_; gboolean _tmp954_; gboolean _tmp955_ = FALSE; gboolean _tmp956_ = FALSE; ValaMethod* _tmp957_; ValaDataType* _tmp958_; ValaDataType* _tmp959_; gboolean _tmp964_; gboolean _tmp968_; ValaMethod* _tmp985_; ValaCCodeFile* _tmp1072_; ValaCCodeFunction* _tmp1073_; ValaCCodeFunction* _tmp1074_; _tmp940_ = vala_ccode_base_module_get_current_method_inner_error ((ValaCCodeBaseModule*) self); _tmp941_ = _tmp940_; if (_tmp941_) { ValaMethod* _tmp942_; gboolean _tmp943_; gboolean _tmp944_; _tmp942_ = m; _tmp943_ = vala_method_get_coroutine (_tmp942_); _tmp944_ = _tmp943_; if (_tmp944_) { ValaCCodeStruct* _tmp945_; _tmp945_ = ((ValaCCodeBaseModule*) self)->closure_struct; vala_ccode_struct_add_field (_tmp945_, "GError *", "_inner_error_", NULL); } else { ValaCCodeFunction* _tmp946_; ValaCCodeFunction* _tmp947_; ValaCCodeConstant* _tmp948_; ValaCCodeConstant* _tmp949_; ValaCCodeVariableDeclarator* _tmp950_; ValaCCodeVariableDeclarator* _tmp951_; _tmp946_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); _tmp947_ = _tmp946_; _tmp948_ = vala_ccode_constant_new ("NULL"); _tmp949_ = _tmp948_; _tmp950_ = vala_ccode_variable_declarator_new_zero ("_inner_error_", (ValaCCodeExpression*) _tmp949_, NULL); _tmp951_ = _tmp950_; vala_ccode_function_add_declaration (_tmp947_, "GError *", (ValaCCodeDeclarator*) _tmp951_, 0); _vala_ccode_node_unref0 (_tmp951_); _vala_ccode_node_unref0 (_tmp949_); } } _tmp952_ = m; _tmp953_ = vala_method_get_coroutine (_tmp952_); _tmp954_ = _tmp953_; if (_tmp954_) { vala_ccode_method_module_complete_async (self); } _tmp957_ = m; _tmp958_ = vala_method_get_return_type (_tmp957_); _tmp959_ = _tmp958_; if (!VALA_IS_VOID_TYPE (_tmp959_)) { ValaMethod* _tmp960_; ValaDataType* _tmp961_; ValaDataType* _tmp962_; gboolean _tmp963_ = FALSE; _tmp960_ = m; _tmp961_ = vala_method_get_return_type (_tmp960_); _tmp962_ = _tmp961_; _tmp963_ = vala_data_type_is_real_non_null_struct_type (_tmp962_); _tmp956_ = !_tmp963_; } else { _tmp956_ = FALSE; } _tmp964_ = _tmp956_; if (_tmp964_) { ValaMethod* _tmp965_; gboolean _tmp966_; gboolean _tmp967_; _tmp965_ = m; _tmp966_ = vala_method_get_coroutine (_tmp965_); _tmp967_ = _tmp966_; _tmp955_ = !_tmp967_; } else { _tmp955_ = FALSE; } _tmp968_ = _tmp955_; if (_tmp968_) { gboolean _tmp969_ = FALSE; ValaMethod* _tmp970_; ValaBasicBlock* _tmp971_; ValaBasicBlock* _tmp972_; gboolean _tmp980_; _tmp970_ = m; _tmp971_ = vala_subroutine_get_return_block ((ValaSubroutine*) _tmp970_); _tmp972_ = _tmp971_; if (_tmp972_ != NULL) { ValaMethod* _tmp973_; ValaBasicBlock* _tmp974_; ValaBasicBlock* _tmp975_; ValaList* _tmp976_ = NULL; ValaList* _tmp977_; gint _tmp978_; gint _tmp979_; _tmp973_ = m; _tmp974_ = vala_subroutine_get_return_block ((ValaSubroutine*) _tmp973_); _tmp975_ = _tmp974_; _tmp976_ = vala_basic_block_get_predecessors (_tmp975_); _tmp977_ = _tmp976_; _tmp978_ = vala_collection_get_size ((ValaCollection*) _tmp977_); _tmp979_ = _tmp978_; _tmp969_ = _tmp979_ == 0; _vala_iterable_unref0 (_tmp977_); } else { _tmp969_ = FALSE; } _tmp980_ = _tmp969_; if (_tmp980_) { ValaCCodeFunction* _tmp981_; ValaCCodeFunction* _tmp982_; ValaCCodeIdentifier* _tmp983_; ValaCCodeIdentifier* _tmp984_; _tmp981_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); _tmp982_ = _tmp981_; _tmp983_ = vala_ccode_identifier_new ("result"); _tmp984_ = _tmp983_; vala_ccode_function_add_return (_tmp982_, (ValaCCodeExpression*) _tmp984_); _vala_ccode_node_unref0 (_tmp984_); } } _tmp985_ = m; if (VALA_IS_CREATION_METHOD (_tmp985_)) { ValaTypeSymbol* _tmp986_; ValaTypeSymbol* _tmp987_; gboolean _tmp992_ = FALSE; gboolean _tmp993_ = FALSE; gboolean _tmp994_ = FALSE; gboolean _tmp995_ = FALSE; ValaTypeSymbol* _tmp996_; ValaTypeSymbol* _tmp997_; gboolean _tmp999_; gboolean _tmp1004_; gboolean _tmp1011_; gboolean _tmp1015_; ValaTypeSymbol* _tmp1057_; ValaTypeSymbol* _tmp1058_; _tmp986_ = vala_ccode_base_module_get_current_type_symbol ((ValaCCodeBaseModule*) self); _tmp987_ = _tmp986_; if (VALA_IS_CLASS (_tmp987_)) { ValaClass* _tmp988_; ValaClass* _tmp989_; ValaObjectType* _tmp990_; _tmp988_ = vala_ccode_base_module_get_current_class ((ValaCCodeBaseModule*) self); _tmp989_ = _tmp988_; _tmp990_ = vala_object_type_new ((ValaObjectTypeSymbol*) _tmp989_); _vala_code_node_unref0 (creturn_type); creturn_type = (ValaDataType*) _tmp990_; } else { ValaVoidType* _tmp991_; _tmp991_ = vala_void_type_new (NULL); _vala_code_node_unref0 (creturn_type); creturn_type = (ValaDataType*) _tmp991_; } _tmp996_ = vala_ccode_base_module_get_current_type_symbol ((ValaCCodeBaseModule*) self); _tmp997_ = _tmp996_; if (VALA_IS_CLASS (_tmp997_)) { ValaTypeSymbol* _tmp998_; _tmp998_ = ((ValaCCodeBaseModule*) self)->gobject_type; _tmp995_ = _tmp998_ != NULL; } else { _tmp995_ = FALSE; } _tmp999_ = _tmp995_; if (_tmp999_) { ValaClass* _tmp1000_; ValaClass* _tmp1001_; ValaTypeSymbol* _tmp1002_; gboolean _tmp1003_ = FALSE; _tmp1000_ = vala_ccode_base_module_get_current_class ((ValaCCodeBaseModule*) self); _tmp1001_ = _tmp1000_; _tmp1002_ = ((ValaCCodeBaseModule*) self)->gobject_type; _tmp1003_ = vala_typesymbol_is_subtype_of ((ValaTypeSymbol*) _tmp1001_, _tmp1002_); _tmp994_ = _tmp1003_; } else { _tmp994_ = FALSE; } _tmp1004_ = _tmp994_; if (_tmp1004_) { ValaClass* _tmp1005_; ValaClass* _tmp1006_; ValaList* _tmp1007_ = NULL; ValaList* _tmp1008_; gint _tmp1009_; gint _tmp1010_; _tmp1005_ = vala_ccode_base_module_get_current_class ((ValaCCodeBaseModule*) self); _tmp1006_ = _tmp1005_; _tmp1007_ = vala_object_type_symbol_get_type_parameters ((ValaObjectTypeSymbol*) _tmp1006_); _tmp1008_ = _tmp1007_; _tmp1009_ = vala_collection_get_size ((ValaCollection*) _tmp1008_); _tmp1010_ = _tmp1009_; _tmp993_ = _tmp1010_ > 0; _vala_iterable_unref0 (_tmp1008_); } else { _tmp993_ = FALSE; } _tmp1011_ = _tmp993_; if (_tmp1011_) { ValaMethod* _tmp1012_; gboolean _tmp1013_; gboolean _tmp1014_; _tmp1012_ = m; _tmp1013_ = vala_creation_method_get_chain_up (VALA_CREATION_METHOD (_tmp1012_)); _tmp1014_ = _tmp1013_; _tmp992_ = !_tmp1014_; } else { _tmp992_ = FALSE; } _tmp1015_ = _tmp992_; if (_tmp1015_) { ValaCCodeIdentifier* _tmp1016_; ValaCCodeIdentifier* _tmp1017_; ValaCCodeIdentifier* _tmp1018_; ValaCCodeIdentifier* _tmp1019_; ValaCCodeBinaryExpression* _tmp1020_; ValaCCodeBinaryExpression* _tmp1021_; ValaCCodeBinaryExpression* ccond; ValaCCodeFunction* _tmp1022_; ValaCCodeFunction* _tmp1023_; ValaCCodeBinaryExpression* _tmp1024_; ValaCCodeFunction* _tmp1025_; ValaCCodeFunction* _tmp1026_; ValaCCodeIdentifier* _tmp1027_; ValaCCodeIdentifier* _tmp1028_; ValaCCodeUnaryExpression* _tmp1029_; ValaCCodeUnaryExpression* _tmp1030_; ValaCCodeIdentifier* _tmp1031_; ValaCCodeIdentifier* _tmp1032_; ValaCCodeFunctionCall* _tmp1033_; ValaCCodeFunctionCall* _tmp1034_; ValaCCodeFunctionCall* cunsetcall; ValaCCodeFunctionCall* _tmp1035_; ValaCCodeIdentifier* _tmp1036_; ValaCCodeIdentifier* _tmp1037_; ValaCCodeMemberAccess* _tmp1038_; ValaCCodeMemberAccess* _tmp1039_; ValaCCodeUnaryExpression* _tmp1040_; ValaCCodeUnaryExpression* _tmp1041_; ValaCCodeFunction* _tmp1042_; ValaCCodeFunction* _tmp1043_; ValaCCodeFunctionCall* _tmp1044_; ValaCCodeFunction* _tmp1045_; ValaCCodeFunction* _tmp1046_; ValaCCodeIdentifier* _tmp1047_; ValaCCodeIdentifier* _tmp1048_; ValaCCodeFunctionCall* _tmp1049_; ValaCCodeFunctionCall* _tmp1050_; ValaCCodeFunctionCall* cfreeparams; ValaCCodeFunctionCall* _tmp1051_; ValaCCodeIdentifier* _tmp1052_; ValaCCodeIdentifier* _tmp1053_; ValaCCodeFunction* _tmp1054_; ValaCCodeFunction* _tmp1055_; ValaCCodeFunctionCall* _tmp1056_; _tmp1016_ = vala_ccode_identifier_new ("__params_it"); _tmp1017_ = _tmp1016_; _tmp1018_ = vala_ccode_identifier_new ("__params"); _tmp1019_ = _tmp1018_; _tmp1020_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_GREATER_THAN, (ValaCCodeExpression*) _tmp1017_, (ValaCCodeExpression*) _tmp1019_); _tmp1021_ = _tmp1020_; _vala_ccode_node_unref0 (_tmp1019_); _vala_ccode_node_unref0 (_tmp1017_); ccond = _tmp1021_; _tmp1022_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); _tmp1023_ = _tmp1022_; _tmp1024_ = ccond; vala_ccode_function_open_while (_tmp1023_, (ValaCCodeExpression*) _tmp1024_); _tmp1025_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); _tmp1026_ = _tmp1025_; _tmp1027_ = vala_ccode_identifier_new ("__params_it"); _tmp1028_ = _tmp1027_; _tmp1029_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_PREFIX_DECREMENT, (ValaCCodeExpression*) _tmp1028_); _tmp1030_ = _tmp1029_; vala_ccode_function_add_expression (_tmp1026_, (ValaCCodeExpression*) _tmp1030_); _vala_ccode_node_unref0 (_tmp1030_); _vala_ccode_node_unref0 (_tmp1028_); _tmp1031_ = vala_ccode_identifier_new ("g_value_unset"); _tmp1032_ = _tmp1031_; _tmp1033_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp1032_); _tmp1034_ = _tmp1033_; _vala_ccode_node_unref0 (_tmp1032_); cunsetcall = _tmp1034_; _tmp1035_ = cunsetcall; _tmp1036_ = vala_ccode_identifier_new ("__params_it"); _tmp1037_ = _tmp1036_; _tmp1038_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp1037_, "value"); _tmp1039_ = _tmp1038_; _tmp1040_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, (ValaCCodeExpression*) _tmp1039_); _tmp1041_ = _tmp1040_; vala_ccode_function_call_add_argument (_tmp1035_, (ValaCCodeExpression*) _tmp1041_); _vala_ccode_node_unref0 (_tmp1041_); _vala_ccode_node_unref0 (_tmp1039_); _vala_ccode_node_unref0 (_tmp1037_); _tmp1042_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); _tmp1043_ = _tmp1042_; _tmp1044_ = cunsetcall; vala_ccode_function_add_expression (_tmp1043_, (ValaCCodeExpression*) _tmp1044_); _tmp1045_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); _tmp1046_ = _tmp1045_; vala_ccode_function_close (_tmp1046_); _tmp1047_ = vala_ccode_identifier_new ("g_free"); _tmp1048_ = _tmp1047_; _tmp1049_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp1048_); _tmp1050_ = _tmp1049_; _vala_ccode_node_unref0 (_tmp1048_); cfreeparams = _tmp1050_; _tmp1051_ = cfreeparams; _tmp1052_ = vala_ccode_identifier_new ("__params"); _tmp1053_ = _tmp1052_; vala_ccode_function_call_add_argument (_tmp1051_, (ValaCCodeExpression*) _tmp1053_); _vala_ccode_node_unref0 (_tmp1053_); _tmp1054_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); _tmp1055_ = _tmp1054_; _tmp1056_ = cfreeparams; vala_ccode_function_add_expression (_tmp1055_, (ValaCCodeExpression*) _tmp1056_); _vala_ccode_node_unref0 (cfreeparams); _vala_ccode_node_unref0 (cunsetcall); _vala_ccode_node_unref0 (ccond); } _tmp1057_ = vala_ccode_base_module_get_current_type_symbol ((ValaCCodeBaseModule*) self); _tmp1058_ = _tmp1057_; if (VALA_IS_CLASS (_tmp1058_)) { ValaCCodeIdentifier* _tmp1059_; ValaCCodeExpression* cresult; ValaMethod* _tmp1060_; gchar* _tmp1061_ = NULL; gchar* _tmp1062_; gboolean _tmp1063_; ValaCCodeFunction* _tmp1069_; ValaCCodeFunction* _tmp1070_; ValaCCodeExpression* _tmp1071_; _tmp1059_ = vala_ccode_identifier_new ("self"); cresult = (ValaCCodeExpression*) _tmp1059_; _tmp1060_ = m; _tmp1061_ = vala_ccode_base_module_get_ccode_type ((ValaCodeNode*) _tmp1060_); _tmp1062_ = _tmp1061_; _tmp1063_ = _tmp1062_ != NULL; _g_free0 (_tmp1062_); if (_tmp1063_) { ValaCCodeExpression* _tmp1064_; ValaMethod* _tmp1065_; gchar* _tmp1066_ = NULL; gchar* _tmp1067_; ValaCCodeCastExpression* _tmp1068_; _tmp1064_ = cresult; _tmp1065_ = m; _tmp1066_ = vala_ccode_base_module_get_ccode_type ((ValaCodeNode*) _tmp1065_); _tmp1067_ = _tmp1066_; _tmp1068_ = vala_ccode_cast_expression_new (_tmp1064_, _tmp1067_); _vala_ccode_node_unref0 (cresult); cresult = (ValaCCodeExpression*) _tmp1068_; _g_free0 (_tmp1067_); } _tmp1069_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); _tmp1070_ = _tmp1069_; _tmp1071_ = cresult; vala_ccode_function_add_return (_tmp1070_, _tmp1071_); _vala_ccode_node_unref0 (cresult); } } _tmp1072_ = ((ValaCCodeBaseModule*) self)->cfile; _tmp1073_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); _tmp1074_ = _tmp1073_; vala_ccode_file_add_function (_tmp1072_, _tmp1074_); } } _tmp1076_ = m; _tmp1077_ = vala_method_get_is_abstract (_tmp1076_); _tmp1078_ = _tmp1077_; if (_tmp1078_) { ValaTypeSymbol* _tmp1079_; ValaTypeSymbol* _tmp1080_; _tmp1079_ = vala_ccode_base_module_get_current_type_symbol ((ValaCCodeBaseModule*) self); _tmp1080_ = _tmp1079_; _tmp1075_ = VALA_IS_CLASS (_tmp1080_); } else { _tmp1075_ = FALSE; } _tmp1081_ = _tmp1075_; if (_tmp1081_) { ValaCCodeIdentifier* _tmp1082_; ValaCCodeIdentifier* _tmp1083_; ValaCCodeFunctionCall* _tmp1084_; ValaCCodeFunctionCall* _tmp1085_; ValaCCodeFunctionCall* type_from_instance_call; ValaCCodeFunctionCall* _tmp1086_; ValaCCodeIdentifier* _tmp1087_; ValaCCodeIdentifier* _tmp1088_; ValaCCodeIdentifier* _tmp1089_; ValaCCodeIdentifier* _tmp1090_; ValaCCodeFunctionCall* _tmp1091_; ValaCCodeFunctionCall* _tmp1092_; ValaCCodeFunctionCall* type_name_call; ValaCCodeFunctionCall* _tmp1093_; ValaCCodeFunctionCall* _tmp1094_; ValaMethod* _tmp1095_; gchar* _tmp1096_ = NULL; gchar* _tmp1097_; gchar* _tmp1098_ = NULL; gchar* _tmp1099_; gchar* error_string; ValaCCodeIdentifier* _tmp1100_; ValaCCodeIdentifier* _tmp1101_; ValaCCodeFunctionCall* _tmp1102_; ValaCCodeFunctionCall* _tmp1103_; ValaCCodeFunctionCall* cerrorcall; ValaCCodeFunctionCall* _tmp1104_; const gchar* _tmp1105_; ValaCCodeConstant* _tmp1106_; ValaCCodeConstant* _tmp1107_; ValaCCodeFunctionCall* _tmp1108_; ValaCCodeFunctionCall* _tmp1109_; ValaCCodeFunction* _tmp1110_; ValaCCodeFunction* _tmp1111_; ValaCCodeFunctionCall* _tmp1112_; ValaDataType* _tmp1113_; ValaCCodeFile* _tmp1114_; ValaCCodeFunction* _tmp1115_; ValaCCodeFunction* _tmp1116_; _tmp1082_ = vala_ccode_identifier_new ("G_TYPE_FROM_INSTANCE"); _tmp1083_ = _tmp1082_; _tmp1084_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp1083_); _tmp1085_ = _tmp1084_; _vala_ccode_node_unref0 (_tmp1083_); type_from_instance_call = _tmp1085_; _tmp1086_ = type_from_instance_call; _tmp1087_ = vala_ccode_identifier_new ("self"); _tmp1088_ = _tmp1087_; vala_ccode_function_call_add_argument (_tmp1086_, (ValaCCodeExpression*) _tmp1088_); _vala_ccode_node_unref0 (_tmp1088_); _tmp1089_ = vala_ccode_identifier_new ("g_type_name"); _tmp1090_ = _tmp1089_; _tmp1091_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp1090_); _tmp1092_ = _tmp1091_; _vala_ccode_node_unref0 (_tmp1090_); type_name_call = _tmp1092_; _tmp1093_ = type_name_call; _tmp1094_ = type_from_instance_call; vala_ccode_function_call_add_argument (_tmp1093_, (ValaCCodeExpression*) _tmp1094_); _tmp1095_ = m; _tmp1096_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp1095_); _tmp1097_ = _tmp1096_; _tmp1098_ = g_strdup_printf ("\"Type `%%s' does not implement abstract method `%s'\"", _tmp1097_); _tmp1099_ = _tmp1098_; _g_free0 (_tmp1097_); error_string = _tmp1099_; _tmp1100_ = vala_ccode_identifier_new ("g_critical"); _tmp1101_ = _tmp1100_; _tmp1102_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp1101_); _tmp1103_ = _tmp1102_; _vala_ccode_node_unref0 (_tmp1101_); cerrorcall = _tmp1103_; _tmp1104_ = cerrorcall; _tmp1105_ = error_string; _tmp1106_ = vala_ccode_constant_new (_tmp1105_); _tmp1107_ = _tmp1106_; vala_ccode_function_call_add_argument (_tmp1104_, (ValaCCodeExpression*) _tmp1107_); _vala_ccode_node_unref0 (_tmp1107_); _tmp1108_ = cerrorcall; _tmp1109_ = type_name_call; vala_ccode_function_call_add_argument (_tmp1108_, (ValaCCodeExpression*) _tmp1109_); _tmp1110_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); _tmp1111_ = _tmp1110_; _tmp1112_ = cerrorcall; vala_ccode_function_add_expression (_tmp1111_, (ValaCCodeExpression*) _tmp1112_); _tmp1113_ = creturn_type; vala_ccode_base_module_return_default_value ((ValaCCodeBaseModule*) self, _tmp1113_); _tmp1114_ = ((ValaCCodeBaseModule*) self)->cfile; _tmp1115_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); _tmp1116_ = _tmp1115_; vala_ccode_file_add_function (_tmp1114_, _tmp1116_); _vala_ccode_node_unref0 (cerrorcall); _g_free0 (error_string); _vala_ccode_node_unref0 (type_name_call); _vala_ccode_node_unref0 (type_from_instance_call); } vala_ccode_base_module_pop_context ((ValaCCodeBaseModule*) self); _tmp1120_ = m; _tmp1121_ = vala_method_get_is_abstract (_tmp1120_); _tmp1122_ = _tmp1121_; if (_tmp1122_) { _tmp1119_ = TRUE; } else { ValaMethod* _tmp1123_; gboolean _tmp1124_; gboolean _tmp1125_; _tmp1123_ = m; _tmp1124_ = vala_method_get_is_virtual (_tmp1123_); _tmp1125_ = _tmp1124_; _tmp1119_ = _tmp1125_; } _tmp1126_ = _tmp1119_; if (_tmp1126_) { ValaMethod* _tmp1127_; gboolean _tmp1128_; gboolean _tmp1129_; _tmp1127_ = m; _tmp1128_ = vala_method_get_coroutine (_tmp1127_); _tmp1129_ = _tmp1128_; _tmp1118_ = !_tmp1129_; } else { _tmp1118_ = FALSE; } _tmp1130_ = _tmp1118_; if (_tmp1130_) { ValaMethod* _tmp1131_; ValaSignal* _tmp1132_; ValaSignal* _tmp1133_; _tmp1131_ = m; _tmp1132_ = vala_method_get_signal_reference (_tmp1131_); _tmp1133_ = _tmp1132_; _tmp1117_ = _tmp1133_ == NULL; } else { _tmp1117_ = FALSE; } _tmp1134_ = _tmp1117_; if (_tmp1134_) { GHashFunc _tmp1135_; GEqualFunc _tmp1136_; GEqualFunc _tmp1137_; ValaHashMap* _tmp1138_; GHashFunc _tmp1139_; GEqualFunc _tmp1140_; GEqualFunc _tmp1141_; ValaHashMap* _tmp1142_; ValaHashMap* carg_map; ValaMethod* _tmp1143_; ValaDataType* _tmp1144_; ValaHashMap* _tmp1145_; ValaHashMap* _tmp1146_; _tmp1135_ = g_direct_hash; _tmp1136_ = g_direct_equal; _tmp1137_ = g_direct_equal; _tmp1138_ = vala_hash_map_new (G_TYPE_INT, NULL, NULL, VALA_TYPE_CCODE_PARAMETER, (GBoxedCopyFunc) vala_ccode_node_ref, vala_ccode_node_unref, _tmp1135_, _tmp1136_, _tmp1137_); _vala_map_unref0 (cparam_map); cparam_map = _tmp1138_; _tmp1139_ = g_direct_hash; _tmp1140_ = g_direct_equal; _tmp1141_ = g_direct_equal; _tmp1142_ = vala_hash_map_new (G_TYPE_INT, NULL, NULL, VALA_TYPE_CCODE_EXPRESSION, (GBoxedCopyFunc) vala_ccode_node_ref, vala_ccode_node_unref, _tmp1139_, _tmp1140_, _tmp1141_); carg_map = _tmp1142_; _tmp1143_ = m; _tmp1144_ = creturn_type; _tmp1145_ = cparam_map; _tmp1146_ = carg_map; vala_ccode_method_module_generate_vfunc (self, _tmp1143_, _tmp1144_, (ValaMap*) _tmp1145_, (ValaMap*) _tmp1146_, "", 3); _vala_map_unref0 (carg_map); } _tmp1147_ = m; _tmp1148_ = vala_method_get_entry_point (_tmp1147_); _tmp1149_ = _tmp1148_; if (_tmp1149_) { ValaCCodeFunction* _tmp1150_; ValaCCodeFunction* cmain; ValaCCodeFunction* _tmp1151_; ValaCCodeFunction* _tmp1152_; ValaCCodeLineDirective* _tmp1153_; ValaCCodeLineDirective* _tmp1154_; ValaCCodeFunction* _tmp1155_; ValaCCodeParameter* _tmp1156_; ValaCCodeParameter* _tmp1157_; ValaCCodeFunction* _tmp1158_; ValaCCodeParameter* _tmp1159_; ValaCCodeParameter* _tmp1160_; ValaCCodeFunction* _tmp1161_; ValaCodeContext* _tmp1162_; ValaCodeContext* _tmp1163_; ValaProfile _tmp1164_; ValaProfile _tmp1165_; ValaCCodeFunction* _tmp1208_; const gchar* _tmp1209_; const gchar* _tmp1210_; ValaCCodeIdentifier* _tmp1211_; ValaCCodeIdentifier* _tmp1212_; ValaCCodeFunctionCall* _tmp1213_; ValaCCodeFunctionCall* _tmp1214_; ValaCCodeFunctionCall* main_call; ValaMethod* _tmp1215_; ValaList* _tmp1216_ = NULL; ValaList* _tmp1217_; gint _tmp1218_; gint _tmp1219_; gboolean _tmp1220_; ValaMethod* _tmp1227_; ValaDataType* _tmp1228_; ValaDataType* _tmp1229_; ValaCCodeFile* _tmp1240_; ValaCCodeFunction* _tmp1241_; _tmp1150_ = vala_ccode_function_new ("main", "int"); cmain = _tmp1150_; _tmp1151_ = cmain; _tmp1152_ = function; _tmp1153_ = vala_ccode_node_get_line ((ValaCCodeNode*) _tmp1152_); _tmp1154_ = _tmp1153_; vala_ccode_node_set_line ((ValaCCodeNode*) _tmp1151_, _tmp1154_); _tmp1155_ = cmain; _tmp1156_ = vala_ccode_parameter_new ("argc", "int"); _tmp1157_ = _tmp1156_; vala_ccode_function_add_parameter (_tmp1155_, _tmp1157_); _vala_ccode_node_unref0 (_tmp1157_); _tmp1158_ = cmain; _tmp1159_ = vala_ccode_parameter_new ("argv", "char **"); _tmp1160_ = _tmp1159_; vala_ccode_function_add_parameter (_tmp1158_, _tmp1160_); _vala_ccode_node_unref0 (_tmp1160_); _tmp1161_ = cmain; vala_ccode_base_module_push_function ((ValaCCodeBaseModule*) self, _tmp1161_); _tmp1162_ = vala_ccode_base_module_get_context ((ValaCCodeBaseModule*) self); _tmp1163_ = _tmp1162_; _tmp1164_ = vala_code_context_get_profile (_tmp1163_); _tmp1165_ = _tmp1164_; if (_tmp1165_ == VALA_PROFILE_GOBJECT) { ValaCodeContext* _tmp1166_; ValaCodeContext* _tmp1167_; gboolean _tmp1168_; gboolean _tmp1169_; ValaCodeContext* _tmp1184_; ValaCodeContext* _tmp1185_; gboolean _tmp1186_; gboolean _tmp1187_; ValaCCodeFunction* _tmp1202_; ValaCCodeFunction* _tmp1203_; ValaCCodeIdentifier* _tmp1204_; ValaCCodeIdentifier* _tmp1205_; ValaCCodeFunctionCall* _tmp1206_; ValaCCodeFunctionCall* _tmp1207_; _tmp1166_ = vala_ccode_base_module_get_context ((ValaCCodeBaseModule*) self); _tmp1167_ = _tmp1166_; _tmp1168_ = vala_code_context_get_mem_profiler (_tmp1167_); _tmp1169_ = _tmp1168_; if (_tmp1169_) { ValaCCodeIdentifier* _tmp1170_; ValaCCodeIdentifier* _tmp1171_; ValaCCodeFunctionCall* _tmp1172_; ValaCCodeFunctionCall* _tmp1173_; ValaCCodeFunctionCall* mem_profiler_init_call; ValaCCodeFunctionCall* _tmp1174_; ValaCCodeFunction* _tmp1175_; ValaCCodeLineDirective* _tmp1176_; ValaCCodeLineDirective* _tmp1177_; ValaCCodeFunctionCall* _tmp1178_; ValaCCodeConstant* _tmp1179_; ValaCCodeConstant* _tmp1180_; ValaCCodeFunction* _tmp1181_; ValaCCodeFunction* _tmp1182_; ValaCCodeFunctionCall* _tmp1183_; _tmp1170_ = vala_ccode_identifier_new ("g_mem_set_vtable"); _tmp1171_ = _tmp1170_; _tmp1172_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp1171_); _tmp1173_ = _tmp1172_; _vala_ccode_node_unref0 (_tmp1171_); mem_profiler_init_call = _tmp1173_; _tmp1174_ = mem_profiler_init_call; _tmp1175_ = cmain; _tmp1176_ = vala_ccode_node_get_line ((ValaCCodeNode*) _tmp1175_); _tmp1177_ = _tmp1176_; vala_ccode_node_set_line ((ValaCCodeNode*) _tmp1174_, _tmp1177_); _tmp1178_ = mem_profiler_init_call; _tmp1179_ = vala_ccode_constant_new ("glib_mem_profiler_table"); _tmp1180_ = _tmp1179_; vala_ccode_function_call_add_argument (_tmp1178_, (ValaCCodeExpression*) _tmp1180_); _vala_ccode_node_unref0 (_tmp1180_); _tmp1181_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); _tmp1182_ = _tmp1181_; _tmp1183_ = mem_profiler_init_call; vala_ccode_function_add_expression (_tmp1182_, (ValaCCodeExpression*) _tmp1183_); _vala_ccode_node_unref0 (mem_profiler_init_call); } _tmp1184_ = vala_ccode_base_module_get_context ((ValaCCodeBaseModule*) self); _tmp1185_ = _tmp1184_; _tmp1186_ = vala_code_context_get_thread (_tmp1185_); _tmp1187_ = _tmp1186_; if (_tmp1187_) { ValaCCodeIdentifier* _tmp1188_; ValaCCodeIdentifier* _tmp1189_; ValaCCodeFunctionCall* _tmp1190_; ValaCCodeFunctionCall* _tmp1191_; ValaCCodeFunctionCall* thread_init_call; ValaCCodeFunctionCall* _tmp1192_; ValaCCodeFunction* _tmp1193_; ValaCCodeLineDirective* _tmp1194_; ValaCCodeLineDirective* _tmp1195_; ValaCCodeFunctionCall* _tmp1196_; ValaCCodeConstant* _tmp1197_; ValaCCodeConstant* _tmp1198_; ValaCCodeFunction* _tmp1199_; ValaCCodeFunction* _tmp1200_; ValaCCodeFunctionCall* _tmp1201_; _tmp1188_ = vala_ccode_identifier_new ("g_thread_init"); _tmp1189_ = _tmp1188_; _tmp1190_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp1189_); _tmp1191_ = _tmp1190_; _vala_ccode_node_unref0 (_tmp1189_); thread_init_call = _tmp1191_; _tmp1192_ = thread_init_call; _tmp1193_ = cmain; _tmp1194_ = vala_ccode_node_get_line ((ValaCCodeNode*) _tmp1193_); _tmp1195_ = _tmp1194_; vala_ccode_node_set_line ((ValaCCodeNode*) _tmp1192_, _tmp1195_); _tmp1196_ = thread_init_call; _tmp1197_ = vala_ccode_constant_new ("NULL"); _tmp1198_ = _tmp1197_; vala_ccode_function_call_add_argument (_tmp1196_, (ValaCCodeExpression*) _tmp1198_); _vala_ccode_node_unref0 (_tmp1198_); _tmp1199_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); _tmp1200_ = _tmp1199_; _tmp1201_ = thread_init_call; vala_ccode_function_add_expression (_tmp1200_, (ValaCCodeExpression*) _tmp1201_); _vala_ccode_node_unref0 (thread_init_call); } _tmp1202_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); _tmp1203_ = _tmp1202_; _tmp1204_ = vala_ccode_identifier_new ("g_type_init"); _tmp1205_ = _tmp1204_; _tmp1206_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp1205_); _tmp1207_ = _tmp1206_; vala_ccode_function_add_expression (_tmp1203_, (ValaCCodeExpression*) _tmp1207_); _vala_ccode_node_unref0 (_tmp1207_); _vala_ccode_node_unref0 (_tmp1205_); } _tmp1208_ = function; _tmp1209_ = vala_ccode_function_get_name (_tmp1208_); _tmp1210_ = _tmp1209_; _tmp1211_ = vala_ccode_identifier_new (_tmp1210_); _tmp1212_ = _tmp1211_; _tmp1213_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp1212_); _tmp1214_ = _tmp1213_; _vala_ccode_node_unref0 (_tmp1212_); main_call = _tmp1214_; _tmp1215_ = m; _tmp1216_ = vala_method_get_parameters (_tmp1215_); _tmp1217_ = _tmp1216_; _tmp1218_ = vala_collection_get_size ((ValaCollection*) _tmp1217_); _tmp1219_ = _tmp1218_; _tmp1220_ = _tmp1219_ == 1; _vala_iterable_unref0 (_tmp1217_); if (_tmp1220_) { ValaCCodeFunctionCall* _tmp1221_; ValaCCodeIdentifier* _tmp1222_; ValaCCodeIdentifier* _tmp1223_; ValaCCodeFunctionCall* _tmp1224_; ValaCCodeIdentifier* _tmp1225_; ValaCCodeIdentifier* _tmp1226_; _tmp1221_ = main_call; _tmp1222_ = vala_ccode_identifier_new ("argv"); _tmp1223_ = _tmp1222_; vala_ccode_function_call_add_argument (_tmp1221_, (ValaCCodeExpression*) _tmp1223_); _vala_ccode_node_unref0 (_tmp1223_); _tmp1224_ = main_call; _tmp1225_ = vala_ccode_identifier_new ("argc"); _tmp1226_ = _tmp1225_; vala_ccode_function_call_add_argument (_tmp1224_, (ValaCCodeExpression*) _tmp1226_); _vala_ccode_node_unref0 (_tmp1226_); } _tmp1227_ = m; _tmp1228_ = vala_method_get_return_type (_tmp1227_); _tmp1229_ = _tmp1228_; if (VALA_IS_VOID_TYPE (_tmp1229_)) { ValaCCodeFunction* _tmp1230_; ValaCCodeFunction* _tmp1231_; ValaCCodeFunctionCall* _tmp1232_; ValaCCodeFunction* _tmp1233_; ValaCCodeFunction* _tmp1234_; ValaCCodeConstant* _tmp1235_; ValaCCodeConstant* _tmp1236_; _tmp1230_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); _tmp1231_ = _tmp1230_; _tmp1232_ = main_call; vala_ccode_function_add_expression (_tmp1231_, (ValaCCodeExpression*) _tmp1232_); _tmp1233_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); _tmp1234_ = _tmp1233_; _tmp1235_ = vala_ccode_constant_new ("0"); _tmp1236_ = _tmp1235_; vala_ccode_function_add_return (_tmp1234_, (ValaCCodeExpression*) _tmp1236_); _vala_ccode_node_unref0 (_tmp1236_); } else { ValaCCodeFunction* _tmp1237_; ValaCCodeFunction* _tmp1238_; ValaCCodeFunctionCall* _tmp1239_; _tmp1237_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); _tmp1238_ = _tmp1237_; _tmp1239_ = main_call; vala_ccode_function_add_return (_tmp1238_, (ValaCCodeExpression*) _tmp1239_); } vala_ccode_base_module_pop_function ((ValaCCodeBaseModule*) self); _tmp1240_ = ((ValaCCodeBaseModule*) self)->cfile; _tmp1241_ = cmain; vala_ccode_file_add_function (_tmp1240_, _tmp1241_); _vala_ccode_node_unref0 (main_call); _vala_ccode_node_unref0 (cmain); } vala_ccode_base_module_pop_line ((ValaCCodeBaseModule*) self); _vala_map_unref0 (cparam_map); _vala_ccode_node_unref0 (function); _vala_code_node_unref0 (creturn_type); } static ValaCCodeParameter* vala_ccode_method_module_real_generate_parameter (ValaCCodeMethodModule* self, ValaParameter* param, ValaCCodeFile* decl_space, ValaMap* cparam_map, ValaMap* carg_map) { ValaCCodeParameter* result = NULL; ValaCCodeParameter* cparam = NULL; ValaParameter* _tmp0_; gboolean _tmp1_; gboolean _tmp2_; ValaMap* _tmp61_; ValaParameter* _tmp62_; gdouble _tmp63_ = 0.0; ValaParameter* _tmp64_; gboolean _tmp65_; gboolean _tmp66_; gint _tmp67_ = 0; ValaCCodeParameter* _tmp68_; gboolean _tmp69_ = FALSE; ValaMap* _tmp70_; gboolean _tmp74_; g_return_val_if_fail (param != NULL, NULL); g_return_val_if_fail (decl_space != NULL, NULL); g_return_val_if_fail (cparam_map != NULL, NULL); _tmp0_ = param; _tmp1_ = vala_parameter_get_ellipsis (_tmp0_); _tmp2_ = _tmp1_; if (!_tmp2_) { ValaParameter* _tmp3_; ValaDataType* _tmp4_; ValaDataType* _tmp5_; gchar* _tmp6_ = NULL; gchar* ctypename; ValaParameter* _tmp7_; ValaDataType* _tmp8_; ValaDataType* _tmp9_; ValaCCodeFile* _tmp10_; ValaParameter* _tmp11_; ValaDataType* _tmp12_; ValaDataType* _tmp13_; ValaTypeSymbol* _tmp14_; ValaTypeSymbol* _tmp15_; ValaParameter* _tmp48_; ValaParameterDirection _tmp49_; ValaParameterDirection _tmp50_; ValaParameter* _tmp53_; const gchar* _tmp54_; const gchar* _tmp55_; gchar* _tmp56_ = NULL; gchar* _tmp57_; const gchar* _tmp58_; ValaCCodeParameter* _tmp59_; _tmp3_ = param; _tmp4_ = vala_variable_get_variable_type ((ValaVariable*) _tmp3_); _tmp5_ = _tmp4_; _tmp6_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp5_); ctypename = _tmp6_; _tmp7_ = param; _tmp8_ = vala_variable_get_variable_type ((ValaVariable*) _tmp7_); _tmp9_ = _tmp8_; _tmp10_ = decl_space; vala_ccode_base_module_generate_type_declaration ((ValaCCodeBaseModule*) self, _tmp9_, _tmp10_); _tmp11_ = param; _tmp12_ = vala_variable_get_variable_type ((ValaVariable*) _tmp11_); _tmp13_ = _tmp12_; _tmp14_ = vala_data_type_get_data_type (_tmp13_); _tmp15_ = _tmp14_; if (VALA_IS_STRUCT (_tmp15_)) { ValaParameter* _tmp16_; ValaDataType* _tmp17_; ValaDataType* _tmp18_; ValaTypeSymbol* _tmp19_; ValaTypeSymbol* _tmp20_; ValaStruct* _tmp21_; ValaStruct* st; gboolean _tmp22_ = FALSE; ValaStruct* _tmp23_; gboolean _tmp24_ = FALSE; gboolean _tmp28_; _tmp16_ = param; _tmp17_ = vala_variable_get_variable_type ((ValaVariable*) _tmp16_); _tmp18_ = _tmp17_; _tmp19_ = vala_data_type_get_data_type (_tmp18_); _tmp20_ = _tmp19_; _tmp21_ = _vala_code_node_ref0 (VALA_STRUCT (_tmp20_)); st = _tmp21_; _tmp23_ = st; _tmp24_ = vala_struct_is_simple_type (_tmp23_); if (!_tmp24_) { ValaParameter* _tmp25_; ValaParameterDirection _tmp26_; ValaParameterDirection _tmp27_; _tmp25_ = param; _tmp26_ = vala_parameter_get_direction (_tmp25_); _tmp27_ = _tmp26_; _tmp22_ = _tmp27_ == VALA_PARAMETER_DIRECTION_IN; } else { _tmp22_ = FALSE; } _tmp28_ = _tmp22_; if (_tmp28_) { gboolean _tmp29_ = FALSE; ValaStruct* _tmp30_; gboolean _tmp31_; gboolean _tmp32_; gboolean _tmp38_; ValaParameter* _tmp41_; ValaDataType* _tmp42_; ValaDataType* _tmp43_; gboolean _tmp44_; gboolean _tmp45_; _tmp30_ = st; _tmp31_ = vala_struct_get_is_immutable (_tmp30_); _tmp32_ = _tmp31_; if (_tmp32_) { ValaParameter* _tmp33_; ValaDataType* _tmp34_; ValaDataType* _tmp35_; gboolean _tmp36_; gboolean _tmp37_; _tmp33_ = param; _tmp34_ = vala_variable_get_variable_type ((ValaVariable*) _tmp33_); _tmp35_ = _tmp34_; _tmp36_ = vala_data_type_get_value_owned (_tmp35_); _tmp37_ = _tmp36_; _tmp29_ = !_tmp37_; } else { _tmp29_ = FALSE; } _tmp38_ = _tmp29_; if (_tmp38_) { const gchar* _tmp39_; gchar* _tmp40_; _tmp39_ = ctypename; _tmp40_ = g_strconcat ("const ", _tmp39_, NULL); _g_free0 (ctypename); ctypename = _tmp40_; } _tmp41_ = param; _tmp42_ = vala_variable_get_variable_type ((ValaVariable*) _tmp41_); _tmp43_ = _tmp42_; _tmp44_ = vala_data_type_get_nullable (_tmp43_); _tmp45_ = _tmp44_; if (!_tmp45_) { const gchar* _tmp46_; gchar* _tmp47_; _tmp46_ = ctypename; _tmp47_ = g_strconcat (_tmp46_, "*", NULL); _g_free0 (ctypename); ctypename = _tmp47_; } } _vala_code_node_unref0 (st); } _tmp48_ = param; _tmp49_ = vala_parameter_get_direction (_tmp48_); _tmp50_ = _tmp49_; if (_tmp50_ != VALA_PARAMETER_DIRECTION_IN) { const gchar* _tmp51_; gchar* _tmp52_; _tmp51_ = ctypename; _tmp52_ = g_strconcat (_tmp51_, "*", NULL); _g_free0 (ctypename); ctypename = _tmp52_; } _tmp53_ = param; _tmp54_ = vala_symbol_get_name ((ValaSymbol*) _tmp53_); _tmp55_ = _tmp54_; _tmp56_ = vala_ccode_base_module_get_variable_cname ((ValaCCodeBaseModule*) self, _tmp55_); _tmp57_ = _tmp56_; _tmp58_ = ctypename; _tmp59_ = vala_ccode_parameter_new (_tmp57_, _tmp58_); _vala_ccode_node_unref0 (cparam); cparam = _tmp59_; _g_free0 (_tmp57_); _g_free0 (ctypename); } else { ValaCCodeParameter* _tmp60_; _tmp60_ = vala_ccode_parameter_new_with_ellipsis (); _vala_ccode_node_unref0 (cparam); cparam = _tmp60_; } _tmp61_ = cparam_map; _tmp62_ = param; _tmp63_ = vala_ccode_base_module_get_ccode_pos (_tmp62_); _tmp64_ = param; _tmp65_ = vala_parameter_get_ellipsis (_tmp64_); _tmp66_ = _tmp65_; _tmp67_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, _tmp63_, _tmp66_); _tmp68_ = cparam; vala_map_set (_tmp61_, GINT_TO_POINTER (_tmp67_), _tmp68_); _tmp70_ = carg_map; if (_tmp70_ != NULL) { ValaParameter* _tmp71_; gboolean _tmp72_; gboolean _tmp73_; _tmp71_ = param; _tmp72_ = vala_parameter_get_ellipsis (_tmp71_); _tmp73_ = _tmp72_; _tmp69_ = !_tmp73_; } else { _tmp69_ = FALSE; } _tmp74_ = _tmp69_; if (_tmp74_) { ValaMap* _tmp75_; ValaParameter* _tmp76_; gdouble _tmp77_ = 0.0; ValaParameter* _tmp78_; gboolean _tmp79_; gboolean _tmp80_; gint _tmp81_ = 0; ValaParameter* _tmp82_; const gchar* _tmp83_; const gchar* _tmp84_; ValaCCodeExpression* _tmp85_ = NULL; ValaCCodeExpression* _tmp86_; _tmp75_ = carg_map; _tmp76_ = param; _tmp77_ = vala_ccode_base_module_get_ccode_pos (_tmp76_); _tmp78_ = param; _tmp79_ = vala_parameter_get_ellipsis (_tmp78_); _tmp80_ = _tmp79_; _tmp81_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, _tmp77_, _tmp80_); _tmp82_ = param; _tmp83_ = vala_symbol_get_name ((ValaSymbol*) _tmp82_); _tmp84_ = _tmp83_; _tmp85_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, _tmp84_); _tmp86_ = _tmp85_; vala_map_set (_tmp75_, GINT_TO_POINTER (_tmp81_), _tmp86_); _vala_ccode_node_unref0 (_tmp86_); } result = cparam; return result; } ValaCCodeParameter* vala_ccode_method_module_generate_parameter (ValaCCodeMethodModule* self, ValaParameter* param, ValaCCodeFile* decl_space, ValaMap* cparam_map, ValaMap* carg_map) { g_return_val_if_fail (self != NULL, NULL); return VALA_CCODE_METHOD_MODULE_GET_CLASS (self)->generate_parameter (self, param, decl_space, cparam_map, carg_map); } static void vala_ccode_method_module_real_generate_cparameters (ValaCCodeBaseModule* base, ValaMethod* m, ValaCCodeFile* decl_space, ValaMap* cparam_map, ValaCCodeFunction* func, ValaCCodeFunctionDeclarator* vdeclarator, ValaMap* carg_map, ValaCCodeFunctionCall* vcall, gint direction) { ValaCCodeMethodModule * self; ValaMethod* _tmp0_; gboolean _tmp1_; gboolean _tmp2_; ValaMethod* _tmp145_; gboolean _tmp146_ = FALSE; gint _tmp349_; gint last_pos; gint min_pos = 0; self = (ValaCCodeMethodModule*) base; g_return_if_fail (m != NULL); g_return_if_fail (decl_space != NULL); g_return_if_fail (cparam_map != NULL); g_return_if_fail (func != NULL); _tmp0_ = m; _tmp1_ = vala_method_get_closure (_tmp0_); _tmp2_ = _tmp1_; if (_tmp2_) { ValaBlock* _tmp3_; ValaBlock* _tmp4_; ValaBlock* _tmp5_; ValaBlock* closure_block; ValaBlock* _tmp6_; gint _tmp7_ = 0; gint block_id; gint _tmp8_; gchar* _tmp9_ = NULL; gchar* _tmp10_; gint _tmp11_; gchar* _tmp12_ = NULL; gchar* _tmp13_; ValaCCodeParameter* _tmp14_; ValaCCodeParameter* _tmp15_; ValaCCodeParameter* instance_param; ValaMap* _tmp16_; ValaMethod* _tmp17_; gdouble _tmp18_ = 0.0; gint _tmp19_ = 0; ValaCCodeParameter* _tmp20_; _tmp3_ = vala_ccode_base_module_get_current_closure_block ((ValaCCodeBaseModule*) self); _tmp4_ = _tmp3_; _tmp5_ = _vala_code_node_ref0 (_tmp4_); closure_block = _tmp5_; _tmp6_ = closure_block; _tmp7_ = vala_ccode_base_module_get_block_id ((ValaCCodeBaseModule*) self, _tmp6_); block_id = _tmp7_; _tmp8_ = block_id; _tmp9_ = g_strdup_printf ("_data%d_", _tmp8_); _tmp10_ = _tmp9_; _tmp11_ = block_id; _tmp12_ = g_strdup_printf ("Block%dData*", _tmp11_); _tmp13_ = _tmp12_; _tmp14_ = vala_ccode_parameter_new (_tmp10_, _tmp13_); _tmp15_ = _tmp14_; _g_free0 (_tmp13_); _g_free0 (_tmp10_); instance_param = _tmp15_; _tmp16_ = cparam_map; _tmp17_ = m; _tmp18_ = vala_ccode_base_module_get_ccode_instance_pos ((ValaCodeNode*) _tmp17_); _tmp19_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, _tmp18_, FALSE); _tmp20_ = instance_param; vala_map_set (_tmp16_, GINT_TO_POINTER (_tmp19_), _tmp20_); _vala_ccode_node_unref0 (instance_param); _vala_code_node_unref0 (closure_block); } else { gboolean _tmp21_ = FALSE; ValaMethod* _tmp22_; ValaSymbol* _tmp23_; ValaSymbol* _tmp24_; gboolean _tmp26_; _tmp22_ = m; _tmp23_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp22_); _tmp24_ = _tmp23_; if (VALA_IS_CLASS (_tmp24_)) { ValaMethod* _tmp25_; _tmp25_ = m; _tmp21_ = VALA_IS_CREATION_METHOD (_tmp25_); } else { _tmp21_ = FALSE; } _tmp26_ = _tmp21_; if (_tmp26_) { ValaMethod* _tmp27_; ValaSymbol* _tmp28_; ValaSymbol* _tmp29_; ValaClass* _tmp30_; ValaClass* cl; gboolean _tmp31_ = FALSE; ValaClass* _tmp32_; gboolean _tmp33_; gboolean _tmp34_; gboolean _tmp36_; _tmp27_ = m; _tmp28_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp27_); _tmp29_ = _tmp28_; _tmp30_ = _vala_code_node_ref0 (VALA_CLASS (_tmp29_)); cl = _tmp30_; _tmp32_ = cl; _tmp33_ = vala_class_get_is_compact (_tmp32_); _tmp34_ = _tmp33_; if (!_tmp34_) { ValaCCodeFunctionCall* _tmp35_; _tmp35_ = vcall; _tmp31_ = _tmp35_ == NULL; } else { _tmp31_ = FALSE; } _tmp36_ = _tmp31_; if (_tmp36_) { ValaMap* _tmp37_; ValaMethod* _tmp38_; gdouble _tmp39_ = 0.0; gint _tmp40_ = 0; ValaCCodeParameter* _tmp41_; ValaCCodeParameter* _tmp42_; _tmp37_ = cparam_map; _tmp38_ = m; _tmp39_ = vala_ccode_base_module_get_ccode_instance_pos ((ValaCodeNode*) _tmp38_); _tmp40_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, _tmp39_, FALSE); _tmp41_ = vala_ccode_parameter_new ("object_type", "GType"); _tmp42_ = _tmp41_; vala_map_set (_tmp37_, GINT_TO_POINTER (_tmp40_), _tmp42_); _vala_ccode_node_unref0 (_tmp42_); } _vala_code_node_unref0 (cl); } else { gboolean _tmp43_ = FALSE; ValaMethod* _tmp44_; ValaMemberBinding _tmp45_; ValaMemberBinding _tmp46_; gboolean _tmp53_; _tmp44_ = m; _tmp45_ = vala_method_get_binding (_tmp44_); _tmp46_ = _tmp45_; if (_tmp46_ == VALA_MEMBER_BINDING_INSTANCE) { _tmp43_ = TRUE; } else { gboolean _tmp47_ = FALSE; ValaMethod* _tmp48_; ValaSymbol* _tmp49_; ValaSymbol* _tmp50_; gboolean _tmp52_; _tmp48_ = m; _tmp49_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp48_); _tmp50_ = _tmp49_; if (VALA_IS_STRUCT (_tmp50_)) { ValaMethod* _tmp51_; _tmp51_ = m; _tmp47_ = VALA_IS_CREATION_METHOD (_tmp51_); } else { _tmp47_ = FALSE; } _tmp52_ = _tmp47_; _tmp43_ = _tmp52_; } _tmp53_ = _tmp43_; if (_tmp53_) { ValaMethod* _tmp54_; ValaTypeSymbol* _tmp55_ = NULL; ValaTypeSymbol* parent_type; ValaDataType* this_type = NULL; ValaTypeSymbol* _tmp56_; ValaDataType* _tmp68_; ValaCCodeFile* _tmp69_; ValaCCodeParameter* instance_param; gboolean _tmp70_ = FALSE; gboolean _tmp71_ = FALSE; ValaMethod* _tmp72_; ValaMethod* _tmp73_; ValaMethod* _tmp74_; gboolean _tmp78_; gboolean _tmp82_; ValaMap* _tmp123_; ValaMethod* _tmp124_; gdouble _tmp125_ = 0.0; gint _tmp126_ = 0; ValaCCodeParameter* _tmp127_; _tmp54_ = m; _tmp55_ = vala_ccode_method_module_find_parent_type (self, (ValaSymbol*) _tmp54_); parent_type = _tmp55_; _tmp56_ = parent_type; if (VALA_IS_CLASS (_tmp56_)) { ValaTypeSymbol* _tmp57_; ValaObjectType* _tmp58_; _tmp57_ = parent_type; _tmp58_ = vala_object_type_new ((ValaObjectTypeSymbol*) VALA_CLASS (_tmp57_)); _vala_code_node_unref0 (this_type); this_type = (ValaDataType*) _tmp58_; } else { ValaTypeSymbol* _tmp59_; _tmp59_ = parent_type; if (VALA_IS_INTERFACE (_tmp59_)) { ValaTypeSymbol* _tmp60_; ValaObjectType* _tmp61_; _tmp60_ = parent_type; _tmp61_ = vala_object_type_new ((ValaObjectTypeSymbol*) VALA_INTERFACE (_tmp60_)); _vala_code_node_unref0 (this_type); this_type = (ValaDataType*) _tmp61_; } else { ValaTypeSymbol* _tmp62_; _tmp62_ = parent_type; if (VALA_IS_STRUCT (_tmp62_)) { ValaTypeSymbol* _tmp63_; ValaStructValueType* _tmp64_; _tmp63_ = parent_type; _tmp64_ = vala_struct_value_type_new (VALA_STRUCT (_tmp63_)); _vala_code_node_unref0 (this_type); this_type = (ValaDataType*) _tmp64_; } else { ValaTypeSymbol* _tmp65_; _tmp65_ = parent_type; if (VALA_IS_ENUM (_tmp65_)) { ValaTypeSymbol* _tmp66_; ValaEnumValueType* _tmp67_; _tmp66_ = parent_type; _tmp67_ = vala_enum_value_type_new (VALA_ENUM (_tmp66_)); _vala_code_node_unref0 (this_type); this_type = (ValaDataType*) _tmp67_; } else { g_assert_not_reached (); } } } } _tmp68_ = this_type; _tmp69_ = decl_space; vala_ccode_base_module_generate_type_declaration ((ValaCCodeBaseModule*) self, _tmp68_, _tmp69_); instance_param = NULL; _tmp72_ = m; _tmp73_ = vala_method_get_base_interface_method (_tmp72_); _tmp74_ = _tmp73_; if (_tmp74_ != NULL) { ValaMethod* _tmp75_; gboolean _tmp76_; gboolean _tmp77_; _tmp75_ = m; _tmp76_ = vala_method_get_is_abstract (_tmp75_); _tmp77_ = _tmp76_; _tmp71_ = !_tmp77_; } else { _tmp71_ = FALSE; } _tmp78_ = _tmp71_; if (_tmp78_) { ValaMethod* _tmp79_; gboolean _tmp80_; gboolean _tmp81_; _tmp79_ = m; _tmp80_ = vala_method_get_is_virtual (_tmp79_); _tmp81_ = _tmp80_; _tmp70_ = !_tmp81_; } else { _tmp70_ = FALSE; } _tmp82_ = _tmp70_; if (_tmp82_) { ValaMethod* _tmp83_; ValaMethod* _tmp84_; ValaMethod* _tmp85_; ValaSymbol* _tmp86_; ValaSymbol* _tmp87_; ValaObjectType* _tmp88_; ValaObjectType* base_type; ValaObjectType* _tmp89_; gchar* _tmp90_ = NULL; gchar* _tmp91_; ValaCCodeParameter* _tmp92_; _tmp83_ = m; _tmp84_ = vala_method_get_base_interface_method (_tmp83_); _tmp85_ = _tmp84_; _tmp86_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp85_); _tmp87_ = _tmp86_; _tmp88_ = vala_object_type_new ((ValaObjectTypeSymbol*) VALA_INTERFACE (_tmp87_)); base_type = _tmp88_; _tmp89_ = base_type; _tmp90_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp89_); _tmp91_ = _tmp90_; _tmp92_ = vala_ccode_parameter_new ("base", _tmp91_); _vala_ccode_node_unref0 (instance_param); instance_param = _tmp92_; _g_free0 (_tmp91_); _vala_code_node_unref0 (base_type); } else { ValaMethod* _tmp93_; gboolean _tmp94_; gboolean _tmp95_; _tmp93_ = m; _tmp94_ = vala_method_get_overrides (_tmp93_); _tmp95_ = _tmp94_; if (_tmp95_) { ValaMethod* _tmp96_; ValaMethod* _tmp97_; ValaMethod* _tmp98_; ValaSymbol* _tmp99_; ValaSymbol* _tmp100_; ValaObjectType* _tmp101_; ValaObjectType* base_type; ValaObjectType* _tmp102_; gchar* _tmp103_ = NULL; gchar* _tmp104_; ValaCCodeParameter* _tmp105_; _tmp96_ = m; _tmp97_ = vala_method_get_base_method (_tmp96_); _tmp98_ = _tmp97_; _tmp99_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp98_); _tmp100_ = _tmp99_; _tmp101_ = vala_object_type_new ((ValaObjectTypeSymbol*) VALA_CLASS (_tmp100_)); base_type = _tmp101_; _tmp102_ = base_type; _tmp103_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp102_); _tmp104_ = _tmp103_; _tmp105_ = vala_ccode_parameter_new ("base", _tmp104_); _vala_ccode_node_unref0 (instance_param); instance_param = _tmp105_; _g_free0 (_tmp104_); _vala_code_node_unref0 (base_type); } else { gboolean _tmp106_ = FALSE; ValaMethod* _tmp107_; ValaSymbol* _tmp108_; ValaSymbol* _tmp109_; gboolean _tmp114_; _tmp107_ = m; _tmp108_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp107_); _tmp109_ = _tmp108_; if (VALA_IS_STRUCT (_tmp109_)) { ValaMethod* _tmp110_; ValaSymbol* _tmp111_; ValaSymbol* _tmp112_; gboolean _tmp113_ = FALSE; _tmp110_ = m; _tmp111_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp110_); _tmp112_ = _tmp111_; _tmp113_ = vala_struct_is_simple_type (VALA_STRUCT (_tmp112_)); _tmp106_ = !_tmp113_; } else { _tmp106_ = FALSE; } _tmp114_ = _tmp106_; if (_tmp114_) { ValaDataType* _tmp115_; gchar* _tmp116_ = NULL; gchar* _tmp117_; ValaCCodeParameter* _tmp118_; _tmp115_ = this_type; _tmp116_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp115_); _tmp117_ = _tmp116_; _tmp118_ = vala_ccode_parameter_new ("*self", _tmp117_); _vala_ccode_node_unref0 (instance_param); instance_param = _tmp118_; _g_free0 (_tmp117_); } else { ValaDataType* _tmp119_; gchar* _tmp120_ = NULL; gchar* _tmp121_; ValaCCodeParameter* _tmp122_; _tmp119_ = this_type; _tmp120_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp119_); _tmp121_ = _tmp120_; _tmp122_ = vala_ccode_parameter_new ("self", _tmp121_); _vala_ccode_node_unref0 (instance_param); instance_param = _tmp122_; _g_free0 (_tmp121_); } } } _tmp123_ = cparam_map; _tmp124_ = m; _tmp125_ = vala_ccode_base_module_get_ccode_instance_pos ((ValaCodeNode*) _tmp124_); _tmp126_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, _tmp125_, FALSE); _tmp127_ = instance_param; vala_map_set (_tmp123_, GINT_TO_POINTER (_tmp126_), _tmp127_); _vala_ccode_node_unref0 (instance_param); _vala_code_node_unref0 (this_type); _vala_code_node_unref0 (parent_type); } else { ValaMethod* _tmp128_; ValaMemberBinding _tmp129_; ValaMemberBinding _tmp130_; _tmp128_ = m; _tmp129_ = vala_method_get_binding (_tmp128_); _tmp130_ = _tmp129_; if (_tmp130_ == VALA_MEMBER_BINDING_CLASS) { ValaMethod* _tmp131_; ValaTypeSymbol* _tmp132_ = NULL; ValaTypeSymbol* parent_type; ValaDataType* this_type = NULL; ValaTypeSymbol* _tmp133_; ValaClassType* _tmp134_; ValaDataType* _tmp135_; gchar* _tmp136_ = NULL; gchar* _tmp137_; ValaCCodeParameter* _tmp138_; ValaCCodeParameter* _tmp139_; ValaCCodeParameter* class_param; ValaMap* _tmp140_; ValaMethod* _tmp141_; gdouble _tmp142_ = 0.0; gint _tmp143_ = 0; ValaCCodeParameter* _tmp144_; _tmp131_ = m; _tmp132_ = vala_ccode_method_module_find_parent_type (self, (ValaSymbol*) _tmp131_); parent_type = _tmp132_; _tmp133_ = parent_type; _tmp134_ = vala_class_type_new (VALA_CLASS (_tmp133_)); _vala_code_node_unref0 (this_type); this_type = (ValaDataType*) _tmp134_; _tmp135_ = this_type; _tmp136_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp135_); _tmp137_ = _tmp136_; _tmp138_ = vala_ccode_parameter_new ("klass", _tmp137_); _tmp139_ = _tmp138_; _g_free0 (_tmp137_); class_param = _tmp139_; _tmp140_ = cparam_map; _tmp141_ = m; _tmp142_ = vala_ccode_base_module_get_ccode_instance_pos ((ValaCodeNode*) _tmp141_); _tmp143_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, _tmp142_, FALSE); _tmp144_ = class_param; vala_map_set (_tmp140_, GINT_TO_POINTER (_tmp143_), _tmp144_); _vala_ccode_node_unref0 (class_param); _vala_code_node_unref0 (this_type); _vala_code_node_unref0 (parent_type); } } } } _tmp145_ = m; _tmp146_ = vala_ccode_method_module_is_gtypeinstance_creation_method (self, _tmp145_); if (_tmp146_) { gint type_param_index; ValaMethod* _tmp147_; ValaSymbol* _tmp148_; ValaSymbol* _tmp149_; ValaClass* _tmp150_; ValaClass* cl; type_param_index = 0; _tmp147_ = m; _tmp148_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp147_); _tmp149_ = _tmp148_; _tmp150_ = _vala_code_node_ref0 (VALA_CLASS (_tmp149_)); cl = _tmp150_; { ValaClass* _tmp151_; ValaList* _tmp152_ = NULL; ValaList* _type_param_list; ValaList* _tmp153_; gint _tmp154_; gint _tmp155_; gint _type_param_size; gint _type_param_index; _tmp151_ = cl; _tmp152_ = vala_object_type_symbol_get_type_parameters ((ValaObjectTypeSymbol*) _tmp151_); _type_param_list = _tmp152_; _tmp153_ = _type_param_list; _tmp154_ = vala_collection_get_size ((ValaCollection*) _tmp153_); _tmp155_ = _tmp154_; _type_param_size = _tmp155_; _type_param_index = -1; while (TRUE) { gint _tmp156_; gint _tmp157_; gint _tmp158_; ValaList* _tmp159_; gint _tmp160_; gpointer _tmp161_ = NULL; ValaTypeParameter* type_param; ValaMap* _tmp162_; gint _tmp163_; gint _tmp164_ = 0; ValaTypeParameter* _tmp165_; const gchar* _tmp166_; const gchar* _tmp167_; gchar* _tmp168_ = NULL; gchar* _tmp169_; gchar* _tmp170_ = NULL; gchar* _tmp171_; ValaCCodeParameter* _tmp172_; ValaCCodeParameter* _tmp173_; ValaMap* _tmp174_; gint _tmp175_; gint _tmp176_ = 0; ValaTypeParameter* _tmp177_; const gchar* _tmp178_; const gchar* _tmp179_; gchar* _tmp180_ = NULL; gchar* _tmp181_; gchar* _tmp182_ = NULL; gchar* _tmp183_; ValaCCodeParameter* _tmp184_; ValaCCodeParameter* _tmp185_; ValaMap* _tmp186_; gint _tmp187_; gint _tmp188_ = 0; ValaTypeParameter* _tmp189_; const gchar* _tmp190_; const gchar* _tmp191_; gchar* _tmp192_ = NULL; gchar* _tmp193_; gchar* _tmp194_ = NULL; gchar* _tmp195_; ValaCCodeParameter* _tmp196_; ValaCCodeParameter* _tmp197_; ValaMap* _tmp198_; gint _tmp235_; _tmp156_ = _type_param_index; _type_param_index = _tmp156_ + 1; _tmp157_ = _type_param_index; _tmp158_ = _type_param_size; if (!(_tmp157_ < _tmp158_)) { break; } _tmp159_ = _type_param_list; _tmp160_ = _type_param_index; _tmp161_ = vala_list_get (_tmp159_, _tmp160_); type_param = (ValaTypeParameter*) _tmp161_; _tmp162_ = cparam_map; _tmp163_ = type_param_index; _tmp164_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, (0.1 * _tmp163_) + 0.01, FALSE); _tmp165_ = type_param; _tmp166_ = vala_symbol_get_name ((ValaSymbol*) _tmp165_); _tmp167_ = _tmp166_; _tmp168_ = g_utf8_strdown (_tmp167_, (gssize) (-1)); _tmp169_ = _tmp168_; _tmp170_ = g_strdup_printf ("%s_type", _tmp169_); _tmp171_ = _tmp170_; _tmp172_ = vala_ccode_parameter_new (_tmp171_, "GType"); _tmp173_ = _tmp172_; vala_map_set (_tmp162_, GINT_TO_POINTER (_tmp164_), _tmp173_); _vala_ccode_node_unref0 (_tmp173_); _g_free0 (_tmp171_); _g_free0 (_tmp169_); _tmp174_ = cparam_map; _tmp175_ = type_param_index; _tmp176_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, (0.1 * _tmp175_) + 0.02, FALSE); _tmp177_ = type_param; _tmp178_ = vala_symbol_get_name ((ValaSymbol*) _tmp177_); _tmp179_ = _tmp178_; _tmp180_ = g_utf8_strdown (_tmp179_, (gssize) (-1)); _tmp181_ = _tmp180_; _tmp182_ = g_strdup_printf ("%s_dup_func", _tmp181_); _tmp183_ = _tmp182_; _tmp184_ = vala_ccode_parameter_new (_tmp183_, "GBoxedCopyFunc"); _tmp185_ = _tmp184_; vala_map_set (_tmp174_, GINT_TO_POINTER (_tmp176_), _tmp185_); _vala_ccode_node_unref0 (_tmp185_); _g_free0 (_tmp183_); _g_free0 (_tmp181_); _tmp186_ = cparam_map; _tmp187_ = type_param_index; _tmp188_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, (0.1 * _tmp187_) + 0.03, FALSE); _tmp189_ = type_param; _tmp190_ = vala_symbol_get_name ((ValaSymbol*) _tmp189_); _tmp191_ = _tmp190_; _tmp192_ = g_utf8_strdown (_tmp191_, (gssize) (-1)); _tmp193_ = _tmp192_; _tmp194_ = g_strdup_printf ("%s_destroy_func", _tmp193_); _tmp195_ = _tmp194_; _tmp196_ = vala_ccode_parameter_new (_tmp195_, "GDestroyNotify"); _tmp197_ = _tmp196_; vala_map_set (_tmp186_, GINT_TO_POINTER (_tmp188_), _tmp197_); _vala_ccode_node_unref0 (_tmp197_); _g_free0 (_tmp195_); _g_free0 (_tmp193_); _tmp198_ = carg_map; if (_tmp198_ != NULL) { ValaMap* _tmp199_; gint _tmp200_; gint _tmp201_ = 0; ValaTypeParameter* _tmp202_; const gchar* _tmp203_; const gchar* _tmp204_; gchar* _tmp205_ = NULL; gchar* _tmp206_; gchar* _tmp207_ = NULL; gchar* _tmp208_; ValaCCodeIdentifier* _tmp209_; ValaCCodeIdentifier* _tmp210_; ValaMap* _tmp211_; gint _tmp212_; gint _tmp213_ = 0; ValaTypeParameter* _tmp214_; const gchar* _tmp215_; const gchar* _tmp216_; gchar* _tmp217_ = NULL; gchar* _tmp218_; gchar* _tmp219_ = NULL; gchar* _tmp220_; ValaCCodeIdentifier* _tmp221_; ValaCCodeIdentifier* _tmp222_; ValaMap* _tmp223_; gint _tmp224_; gint _tmp225_ = 0; ValaTypeParameter* _tmp226_; const gchar* _tmp227_; const gchar* _tmp228_; gchar* _tmp229_ = NULL; gchar* _tmp230_; gchar* _tmp231_ = NULL; gchar* _tmp232_; ValaCCodeIdentifier* _tmp233_; ValaCCodeIdentifier* _tmp234_; _tmp199_ = carg_map; _tmp200_ = type_param_index; _tmp201_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, (0.1 * _tmp200_) + 0.01, FALSE); _tmp202_ = type_param; _tmp203_ = vala_symbol_get_name ((ValaSymbol*) _tmp202_); _tmp204_ = _tmp203_; _tmp205_ = g_utf8_strdown (_tmp204_, (gssize) (-1)); _tmp206_ = _tmp205_; _tmp207_ = g_strdup_printf ("%s_type", _tmp206_); _tmp208_ = _tmp207_; _tmp209_ = vala_ccode_identifier_new (_tmp208_); _tmp210_ = _tmp209_; vala_map_set (_tmp199_, GINT_TO_POINTER (_tmp201_), (ValaCCodeExpression*) _tmp210_); _vala_ccode_node_unref0 (_tmp210_); _g_free0 (_tmp208_); _g_free0 (_tmp206_); _tmp211_ = carg_map; _tmp212_ = type_param_index; _tmp213_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, (0.1 * _tmp212_) + 0.02, FALSE); _tmp214_ = type_param; _tmp215_ = vala_symbol_get_name ((ValaSymbol*) _tmp214_); _tmp216_ = _tmp215_; _tmp217_ = g_utf8_strdown (_tmp216_, (gssize) (-1)); _tmp218_ = _tmp217_; _tmp219_ = g_strdup_printf ("%s_dup_func", _tmp218_); _tmp220_ = _tmp219_; _tmp221_ = vala_ccode_identifier_new (_tmp220_); _tmp222_ = _tmp221_; vala_map_set (_tmp211_, GINT_TO_POINTER (_tmp213_), (ValaCCodeExpression*) _tmp222_); _vala_ccode_node_unref0 (_tmp222_); _g_free0 (_tmp220_); _g_free0 (_tmp218_); _tmp223_ = carg_map; _tmp224_ = type_param_index; _tmp225_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, (0.1 * _tmp224_) + 0.03, FALSE); _tmp226_ = type_param; _tmp227_ = vala_symbol_get_name ((ValaSymbol*) _tmp226_); _tmp228_ = _tmp227_; _tmp229_ = g_utf8_strdown (_tmp228_, (gssize) (-1)); _tmp230_ = _tmp229_; _tmp231_ = g_strdup_printf ("%s_destroy_func", _tmp230_); _tmp232_ = _tmp231_; _tmp233_ = vala_ccode_identifier_new (_tmp232_); _tmp234_ = _tmp233_; vala_map_set (_tmp223_, GINT_TO_POINTER (_tmp225_), (ValaCCodeExpression*) _tmp234_); _vala_ccode_node_unref0 (_tmp234_); _g_free0 (_tmp232_); _g_free0 (_tmp230_); } _tmp235_ = type_param_index; type_param_index = _tmp235_ + 1; _vala_code_node_unref0 (type_param); } _vala_iterable_unref0 (_type_param_list); } _vala_code_node_unref0 (cl); } else { gboolean _tmp236_ = FALSE; ValaMethod* _tmp237_; gboolean _tmp238_; gboolean _tmp239_; gboolean _tmp241_; _tmp237_ = m; _tmp238_ = vala_method_get_closure (_tmp237_); _tmp239_ = _tmp238_; if (!_tmp239_) { gint _tmp240_; _tmp240_ = direction; _tmp236_ = (_tmp240_ & 1) == 1; } else { _tmp236_ = FALSE; } _tmp241_ = _tmp236_; if (_tmp241_) { gint type_param_index; type_param_index = 0; { ValaMethod* _tmp242_; ValaList* _tmp243_ = NULL; ValaList* _type_param_list; ValaList* _tmp244_; gint _tmp245_; gint _tmp246_; gint _type_param_size; gint _type_param_index; _tmp242_ = m; _tmp243_ = vala_method_get_type_parameters (_tmp242_); _type_param_list = _tmp243_; _tmp244_ = _type_param_list; _tmp245_ = vala_collection_get_size ((ValaCollection*) _tmp244_); _tmp246_ = _tmp245_; _type_param_size = _tmp246_; _type_param_index = -1; while (TRUE) { gint _tmp247_; gint _tmp248_; gint _tmp249_; ValaList* _tmp250_; gint _tmp251_; gpointer _tmp252_ = NULL; ValaTypeParameter* type_param; ValaMap* _tmp253_; gint _tmp254_; gint _tmp255_ = 0; ValaTypeParameter* _tmp256_; const gchar* _tmp257_; const gchar* _tmp258_; gchar* _tmp259_ = NULL; gchar* _tmp260_; gchar* _tmp261_ = NULL; gchar* _tmp262_; ValaCCodeParameter* _tmp263_; ValaCCodeParameter* _tmp264_; ValaMap* _tmp265_; gint _tmp266_; gint _tmp267_ = 0; ValaTypeParameter* _tmp268_; const gchar* _tmp269_; const gchar* _tmp270_; gchar* _tmp271_ = NULL; gchar* _tmp272_; gchar* _tmp273_ = NULL; gchar* _tmp274_; ValaCCodeParameter* _tmp275_; ValaCCodeParameter* _tmp276_; ValaMap* _tmp277_; gint _tmp278_; gint _tmp279_ = 0; ValaTypeParameter* _tmp280_; const gchar* _tmp281_; const gchar* _tmp282_; gchar* _tmp283_ = NULL; gchar* _tmp284_; gchar* _tmp285_ = NULL; gchar* _tmp286_; ValaCCodeParameter* _tmp287_; ValaCCodeParameter* _tmp288_; ValaMap* _tmp289_; gint _tmp326_; _tmp247_ = _type_param_index; _type_param_index = _tmp247_ + 1; _tmp248_ = _type_param_index; _tmp249_ = _type_param_size; if (!(_tmp248_ < _tmp249_)) { break; } _tmp250_ = _type_param_list; _tmp251_ = _type_param_index; _tmp252_ = vala_list_get (_tmp250_, _tmp251_); type_param = (ValaTypeParameter*) _tmp252_; _tmp253_ = cparam_map; _tmp254_ = type_param_index; _tmp255_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, (0.1 * _tmp254_) + 0.01, FALSE); _tmp256_ = type_param; _tmp257_ = vala_symbol_get_name ((ValaSymbol*) _tmp256_); _tmp258_ = _tmp257_; _tmp259_ = g_utf8_strdown (_tmp258_, (gssize) (-1)); _tmp260_ = _tmp259_; _tmp261_ = g_strdup_printf ("%s_type", _tmp260_); _tmp262_ = _tmp261_; _tmp263_ = vala_ccode_parameter_new (_tmp262_, "GType"); _tmp264_ = _tmp263_; vala_map_set (_tmp253_, GINT_TO_POINTER (_tmp255_), _tmp264_); _vala_ccode_node_unref0 (_tmp264_); _g_free0 (_tmp262_); _g_free0 (_tmp260_); _tmp265_ = cparam_map; _tmp266_ = type_param_index; _tmp267_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, (0.1 * _tmp266_) + 0.02, FALSE); _tmp268_ = type_param; _tmp269_ = vala_symbol_get_name ((ValaSymbol*) _tmp268_); _tmp270_ = _tmp269_; _tmp271_ = g_utf8_strdown (_tmp270_, (gssize) (-1)); _tmp272_ = _tmp271_; _tmp273_ = g_strdup_printf ("%s_dup_func", _tmp272_); _tmp274_ = _tmp273_; _tmp275_ = vala_ccode_parameter_new (_tmp274_, "GBoxedCopyFunc"); _tmp276_ = _tmp275_; vala_map_set (_tmp265_, GINT_TO_POINTER (_tmp267_), _tmp276_); _vala_ccode_node_unref0 (_tmp276_); _g_free0 (_tmp274_); _g_free0 (_tmp272_); _tmp277_ = cparam_map; _tmp278_ = type_param_index; _tmp279_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, (0.1 * _tmp278_) + 0.03, FALSE); _tmp280_ = type_param; _tmp281_ = vala_symbol_get_name ((ValaSymbol*) _tmp280_); _tmp282_ = _tmp281_; _tmp283_ = g_utf8_strdown (_tmp282_, (gssize) (-1)); _tmp284_ = _tmp283_; _tmp285_ = g_strdup_printf ("%s_destroy_func", _tmp284_); _tmp286_ = _tmp285_; _tmp287_ = vala_ccode_parameter_new (_tmp286_, "GDestroyNotify"); _tmp288_ = _tmp287_; vala_map_set (_tmp277_, GINT_TO_POINTER (_tmp279_), _tmp288_); _vala_ccode_node_unref0 (_tmp288_); _g_free0 (_tmp286_); _g_free0 (_tmp284_); _tmp289_ = carg_map; if (_tmp289_ != NULL) { ValaMap* _tmp290_; gint _tmp291_; gint _tmp292_ = 0; ValaTypeParameter* _tmp293_; const gchar* _tmp294_; const gchar* _tmp295_; gchar* _tmp296_ = NULL; gchar* _tmp297_; gchar* _tmp298_ = NULL; gchar* _tmp299_; ValaCCodeIdentifier* _tmp300_; ValaCCodeIdentifier* _tmp301_; ValaMap* _tmp302_; gint _tmp303_; gint _tmp304_ = 0; ValaTypeParameter* _tmp305_; const gchar* _tmp306_; const gchar* _tmp307_; gchar* _tmp308_ = NULL; gchar* _tmp309_; gchar* _tmp310_ = NULL; gchar* _tmp311_; ValaCCodeIdentifier* _tmp312_; ValaCCodeIdentifier* _tmp313_; ValaMap* _tmp314_; gint _tmp315_; gint _tmp316_ = 0; ValaTypeParameter* _tmp317_; const gchar* _tmp318_; const gchar* _tmp319_; gchar* _tmp320_ = NULL; gchar* _tmp321_; gchar* _tmp322_ = NULL; gchar* _tmp323_; ValaCCodeIdentifier* _tmp324_; ValaCCodeIdentifier* _tmp325_; _tmp290_ = carg_map; _tmp291_ = type_param_index; _tmp292_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, (0.1 * _tmp291_) + 0.01, FALSE); _tmp293_ = type_param; _tmp294_ = vala_symbol_get_name ((ValaSymbol*) _tmp293_); _tmp295_ = _tmp294_; _tmp296_ = g_utf8_strdown (_tmp295_, (gssize) (-1)); _tmp297_ = _tmp296_; _tmp298_ = g_strdup_printf ("%s_type", _tmp297_); _tmp299_ = _tmp298_; _tmp300_ = vala_ccode_identifier_new (_tmp299_); _tmp301_ = _tmp300_; vala_map_set (_tmp290_, GINT_TO_POINTER (_tmp292_), (ValaCCodeExpression*) _tmp301_); _vala_ccode_node_unref0 (_tmp301_); _g_free0 (_tmp299_); _g_free0 (_tmp297_); _tmp302_ = carg_map; _tmp303_ = type_param_index; _tmp304_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, (0.1 * _tmp303_) + 0.02, FALSE); _tmp305_ = type_param; _tmp306_ = vala_symbol_get_name ((ValaSymbol*) _tmp305_); _tmp307_ = _tmp306_; _tmp308_ = g_utf8_strdown (_tmp307_, (gssize) (-1)); _tmp309_ = _tmp308_; _tmp310_ = g_strdup_printf ("%s_dup_func", _tmp309_); _tmp311_ = _tmp310_; _tmp312_ = vala_ccode_identifier_new (_tmp311_); _tmp313_ = _tmp312_; vala_map_set (_tmp302_, GINT_TO_POINTER (_tmp304_), (ValaCCodeExpression*) _tmp313_); _vala_ccode_node_unref0 (_tmp313_); _g_free0 (_tmp311_); _g_free0 (_tmp309_); _tmp314_ = carg_map; _tmp315_ = type_param_index; _tmp316_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, (0.1 * _tmp315_) + 0.03, FALSE); _tmp317_ = type_param; _tmp318_ = vala_symbol_get_name ((ValaSymbol*) _tmp317_); _tmp319_ = _tmp318_; _tmp320_ = g_utf8_strdown (_tmp319_, (gssize) (-1)); _tmp321_ = _tmp320_; _tmp322_ = g_strdup_printf ("%s_destroy_func", _tmp321_); _tmp323_ = _tmp322_; _tmp324_ = vala_ccode_identifier_new (_tmp323_); _tmp325_ = _tmp324_; vala_map_set (_tmp314_, GINT_TO_POINTER (_tmp316_), (ValaCCodeExpression*) _tmp325_); _vala_ccode_node_unref0 (_tmp325_); _g_free0 (_tmp323_); _g_free0 (_tmp321_); } _tmp326_ = type_param_index; type_param_index = _tmp326_ + 1; _vala_code_node_unref0 (type_param); } _vala_iterable_unref0 (_type_param_list); } } } { ValaMethod* _tmp327_; ValaList* _tmp328_ = NULL; ValaList* _param_list; ValaList* _tmp329_; gint _tmp330_; gint _tmp331_; gint _param_size; gint _param_index; _tmp327_ = m; _tmp328_ = vala_method_get_parameters (_tmp327_); _param_list = _tmp328_; _tmp329_ = _param_list; _tmp330_ = vala_collection_get_size ((ValaCollection*) _tmp329_); _tmp331_ = _tmp330_; _param_size = _tmp331_; _param_index = -1; while (TRUE) { gint _tmp332_; gint _tmp333_; gint _tmp334_; ValaList* _tmp335_; gint _tmp336_; gpointer _tmp337_ = NULL; ValaParameter* param; ValaParameter* _tmp338_; ValaParameterDirection _tmp339_; ValaParameterDirection _tmp340_; ValaParameter* _tmp343_; ValaCCodeFile* _tmp344_; ValaMap* _tmp345_; ValaMap* _tmp346_; ValaCCodeParameter* _tmp347_ = NULL; ValaCCodeParameter* _tmp348_; _tmp332_ = _param_index; _param_index = _tmp332_ + 1; _tmp333_ = _param_index; _tmp334_ = _param_size; if (!(_tmp333_ < _tmp334_)) { break; } _tmp335_ = _param_list; _tmp336_ = _param_index; _tmp337_ = vala_list_get (_tmp335_, _tmp336_); param = (ValaParameter*) _tmp337_; _tmp338_ = param; _tmp339_ = vala_parameter_get_direction (_tmp338_); _tmp340_ = _tmp339_; if (_tmp340_ != VALA_PARAMETER_DIRECTION_OUT) { gint _tmp341_; _tmp341_ = direction; if ((_tmp341_ & 1) == 0) { _vala_code_node_unref0 (param); continue; } } else { gint _tmp342_; _tmp342_ = direction; if ((_tmp342_ & 2) == 0) { _vala_code_node_unref0 (param); continue; } } _tmp343_ = param; _tmp344_ = decl_space; _tmp345_ = cparam_map; _tmp346_ = carg_map; _tmp347_ = vala_ccode_method_module_generate_parameter (self, _tmp343_, _tmp344_, _tmp345_, _tmp346_); _tmp348_ = _tmp347_; _vala_ccode_node_unref0 (_tmp348_); _vala_code_node_unref0 (param); } _vala_iterable_unref0 (_param_list); } _tmp349_ = direction; if ((_tmp349_ & 2) != 0) { ValaMethod* _tmp350_; ValaCCodeFile* _tmp351_; ValaCCodeFunction* _tmp352_; ValaMap* _tmp353_; ValaMap* _tmp354_; _tmp350_ = m; _tmp351_ = decl_space; _tmp352_ = func; _tmp353_ = cparam_map; _tmp354_ = carg_map; vala_ccode_method_module_generate_method_result_declaration (self, _tmp350_, _tmp351_, _tmp352_, _tmp353_, _tmp354_); } last_pos = -1; while (TRUE) { gint _tmp374_; ValaCCodeFunction* _tmp375_; ValaMap* _tmp376_; gint _tmp377_; gpointer _tmp378_ = NULL; ValaCCodeParameter* _tmp379_; ValaCCodeFunctionDeclarator* _tmp380_; ValaCCodeFunctionCall* _tmp386_; gint _tmp393_; min_pos = -1; { ValaMap* _tmp355_; ValaSet* _tmp356_ = NULL; ValaSet* _tmp357_; ValaIterator* _tmp358_ = NULL; ValaIterator* _tmp359_; ValaIterator* _pos_it; _tmp355_ = cparam_map; _tmp356_ = vala_map_get_keys (_tmp355_); _tmp357_ = _tmp356_; _tmp358_ = vala_iterable_iterator ((ValaIterable*) _tmp357_); _tmp359_ = _tmp358_; _vala_iterable_unref0 (_tmp357_); _pos_it = _tmp359_; while (TRUE) { ValaIterator* _tmp360_; gboolean _tmp361_ = FALSE; ValaIterator* _tmp362_; gpointer _tmp363_ = NULL; gint pos; gboolean _tmp364_ = FALSE; gint _tmp365_; gint _tmp366_; gboolean _tmp372_; _tmp360_ = _pos_it; _tmp361_ = vala_iterator_next (_tmp360_); if (!_tmp361_) { break; } _tmp362_ = _pos_it; _tmp363_ = vala_iterator_get (_tmp362_); pos = GPOINTER_TO_INT (_tmp363_); _tmp365_ = pos; _tmp366_ = last_pos; if (_tmp365_ > _tmp366_) { gboolean _tmp367_ = FALSE; gint _tmp368_; gboolean _tmp371_; _tmp368_ = min_pos; if (_tmp368_ == (-1)) { _tmp367_ = TRUE; } else { gint _tmp369_; gint _tmp370_; _tmp369_ = pos; _tmp370_ = min_pos; _tmp367_ = _tmp369_ < _tmp370_; } _tmp371_ = _tmp367_; _tmp364_ = _tmp371_; } else { _tmp364_ = FALSE; } _tmp372_ = _tmp364_; if (_tmp372_) { gint _tmp373_; _tmp373_ = pos; min_pos = _tmp373_; } } _vala_iterator_unref0 (_pos_it); } _tmp374_ = min_pos; if (_tmp374_ == (-1)) { break; } _tmp375_ = func; _tmp376_ = cparam_map; _tmp377_ = min_pos; _tmp378_ = vala_map_get (_tmp376_, GINT_TO_POINTER (_tmp377_)); _tmp379_ = (ValaCCodeParameter*) _tmp378_; vala_ccode_function_add_parameter (_tmp375_, _tmp379_); _vala_ccode_node_unref0 (_tmp379_); _tmp380_ = vdeclarator; if (_tmp380_ != NULL) { ValaCCodeFunctionDeclarator* _tmp381_; ValaMap* _tmp382_; gint _tmp383_; gpointer _tmp384_ = NULL; ValaCCodeParameter* _tmp385_; _tmp381_ = vdeclarator; _tmp382_ = cparam_map; _tmp383_ = min_pos; _tmp384_ = vala_map_get (_tmp382_, GINT_TO_POINTER (_tmp383_)); _tmp385_ = (ValaCCodeParameter*) _tmp384_; vala_ccode_function_declarator_add_parameter (_tmp381_, _tmp385_); _vala_ccode_node_unref0 (_tmp385_); } _tmp386_ = vcall; if (_tmp386_ != NULL) { ValaMap* _tmp387_; gint _tmp388_; gpointer _tmp389_ = NULL; ValaCCodeExpression* arg; ValaCCodeExpression* _tmp390_; _tmp387_ = carg_map; _tmp388_ = min_pos; _tmp389_ = vala_map_get (_tmp387_, GINT_TO_POINTER (_tmp388_)); arg = (ValaCCodeExpression*) _tmp389_; _tmp390_ = arg; if (_tmp390_ != NULL) { ValaCCodeFunctionCall* _tmp391_; ValaCCodeExpression* _tmp392_; _tmp391_ = vcall; _tmp392_ = arg; vala_ccode_function_call_add_argument (_tmp391_, _tmp392_); } _vala_ccode_node_unref0 (arg); } _tmp393_ = min_pos; last_pos = _tmp393_; } } static glong string_strnlen (gchar* str, glong maxlen) { glong result = 0L; gchar* _tmp0_; glong _tmp1_; gchar* _tmp2_ = NULL; gchar* end; gchar* _tmp3_; _tmp0_ = str; _tmp1_ = maxlen; _tmp2_ = memchr (_tmp0_, 0, (gsize) _tmp1_); end = _tmp2_; _tmp3_ = end; if (_tmp3_ == NULL) { glong _tmp4_; _tmp4_ = maxlen; result = _tmp4_; return result; } else { gchar* _tmp5_; gchar* _tmp6_; _tmp5_ = end; _tmp6_ = str; result = (glong) (_tmp5_ - _tmp6_); return result; } } static gchar* string_substring (const gchar* self, glong offset, glong len) { gchar* result = NULL; glong string_length = 0L; gboolean _tmp0_ = FALSE; glong _tmp1_; gboolean _tmp3_; glong _tmp9_; glong _tmp15_; glong _tmp18_; glong _tmp19_; glong _tmp20_; glong _tmp21_; glong _tmp22_; gchar* _tmp23_ = NULL; g_return_val_if_fail (self != NULL, NULL); _tmp1_ = offset; if (_tmp1_ >= ((glong) 0)) { glong _tmp2_; _tmp2_ = len; _tmp0_ = _tmp2_ >= ((glong) 0); } else { _tmp0_ = FALSE; } _tmp3_ = _tmp0_; if (_tmp3_) { glong _tmp4_; glong _tmp5_; glong _tmp6_ = 0L; _tmp4_ = offset; _tmp5_ = len; _tmp6_ = string_strnlen ((gchar*) self, _tmp4_ + _tmp5_); string_length = _tmp6_; } else { gint _tmp7_; gint _tmp8_; _tmp7_ = strlen (self); _tmp8_ = _tmp7_; string_length = (glong) _tmp8_; } _tmp9_ = offset; if (_tmp9_ < ((glong) 0)) { glong _tmp10_; glong _tmp11_; glong _tmp12_; _tmp10_ = string_length; _tmp11_ = offset; offset = _tmp10_ + _tmp11_; _tmp12_ = offset; g_return_val_if_fail (_tmp12_ >= ((glong) 0), NULL); } else { glong _tmp13_; glong _tmp14_; _tmp13_ = offset; _tmp14_ = string_length; g_return_val_if_fail (_tmp13_ <= _tmp14_, NULL); } _tmp15_ = len; if (_tmp15_ < ((glong) 0)) { glong _tmp16_; glong _tmp17_; _tmp16_ = string_length; _tmp17_ = offset; len = _tmp16_ - _tmp17_; } _tmp18_ = offset; _tmp19_ = len; _tmp20_ = string_length; g_return_val_if_fail ((_tmp18_ + _tmp19_) <= _tmp20_, NULL); _tmp21_ = offset; _tmp22_ = len; _tmp23_ = g_strndup (((gchar*) self) + _tmp21_, (gsize) _tmp22_); result = _tmp23_; return result; } void vala_ccode_method_module_generate_vfunc (ValaCCodeMethodModule* self, ValaMethod* m, ValaDataType* return_type, ValaMap* cparam_map, ValaMap* carg_map, const gchar* suffix, gint direction) { ValaCCodeBaseModuleEmitContext* _tmp0_; ValaCCodeBaseModuleEmitContext* _tmp1_; ValaMethod* _tmp2_; gchar* _tmp3_ = NULL; gchar* cname; gboolean _tmp4_ = FALSE; const gchar* _tmp5_; gboolean _tmp8_; const gchar* _tmp16_; const gchar* _tmp17_; gchar* _tmp18_; gchar* _tmp19_; ValaCCodeFunction* _tmp20_; ValaCCodeFunction* _tmp21_; ValaCCodeFunction* vfunc; ValaCCodeFunctionCall* vcast; ValaMethod* _tmp22_; ValaSymbol* _tmp23_; ValaSymbol* _tmp24_; ValaCCodeFunctionCall* _tmp49_; ValaCCodeIdentifier* _tmp50_; ValaCCodeIdentifier* _tmp51_; ValaMethod* _tmp52_; gchar* _tmp53_ = NULL; gboolean _tmp54_ = FALSE; const gchar* _tmp55_; gboolean _tmp58_; ValaCCodeFunctionCall* _tmp66_; const gchar* _tmp67_; const gchar* _tmp68_; gchar* _tmp69_; gchar* _tmp70_; ValaCCodeMemberAccess* _tmp71_; ValaCCodeMemberAccess* _tmp72_; ValaCCodeFunctionCall* _tmp73_; ValaCCodeFunctionCall* _tmp74_; ValaCCodeFunctionCall* vcall; ValaMap* _tmp75_; ValaMethod* _tmp76_; gdouble _tmp77_ = 0.0; gint _tmp78_ = 0; ValaCCodeIdentifier* _tmp79_; ValaCCodeIdentifier* _tmp80_; ValaMethod* _tmp81_; ValaCCodeFile* _tmp82_; ValaMap* _tmp83_; ValaCCodeFunction* _tmp84_; ValaMap* _tmp85_; ValaCCodeFunctionCall* _tmp86_; gint _tmp87_; ValaCCodeFunction* _tmp88_; gboolean _tmp89_ = FALSE; gboolean _tmp90_ = FALSE; gboolean _tmp91_ = FALSE; ValaCodeContext* _tmp92_; ValaCodeContext* _tmp93_; gboolean _tmp94_; gboolean _tmp95_; gboolean _tmp101_; gboolean _tmp108_; gboolean _tmp114_; ValaMethod* _tmp131_; ValaDataType* _tmp132_; ValaMethod* _tmp133_; ValaSymbol* _tmp134_; ValaSymbol* _tmp135_; gboolean _tmp150_ = FALSE; ValaDataType* _tmp151_; gboolean _tmp154_; ValaMethod* _tmp182_; ValaList* _tmp183_ = NULL; ValaList* _tmp184_; gint _tmp185_; gint _tmp186_; gboolean _tmp187_; ValaCCodeFile* _tmp205_; ValaCCodeFunction* _tmp206_; g_return_if_fail (self != NULL); g_return_if_fail (m != NULL); g_return_if_fail (return_type != NULL); g_return_if_fail (cparam_map != NULL); g_return_if_fail (carg_map != NULL); g_return_if_fail (suffix != NULL); _tmp0_ = vala_ccode_base_module_emit_context_new (NULL); _tmp1_ = _tmp0_; vala_ccode_base_module_push_context ((ValaCCodeBaseModule*) self, _tmp1_); _vala_ccode_base_module_emit_context_unref0 (_tmp1_); _tmp2_ = m; _tmp3_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp2_); cname = _tmp3_; _tmp5_ = suffix; if (g_strcmp0 (_tmp5_, "_finish") == 0) { const gchar* _tmp6_; gboolean _tmp7_ = FALSE; _tmp6_ = cname; _tmp7_ = g_str_has_suffix (_tmp6_, "_async"); _tmp4_ = _tmp7_; } else { _tmp4_ = FALSE; } _tmp8_ = _tmp4_; if (_tmp8_) { const gchar* _tmp9_; const gchar* _tmp10_; gint _tmp11_; gint _tmp12_; gint _tmp13_; gint _tmp14_; gchar* _tmp15_ = NULL; _tmp9_ = cname; _tmp10_ = cname; _tmp11_ = strlen (_tmp10_); _tmp12_ = _tmp11_; _tmp13_ = strlen ("_async"); _tmp14_ = _tmp13_; _tmp15_ = string_substring (_tmp9_, (glong) 0, (glong) (_tmp12_ - _tmp14_)); _g_free0 (cname); cname = _tmp15_; } _tmp16_ = cname; _tmp17_ = suffix; _tmp18_ = g_strconcat (_tmp16_, _tmp17_, NULL); _tmp19_ = _tmp18_; _tmp20_ = vala_ccode_function_new (_tmp19_, "void"); _tmp21_ = _tmp20_; _g_free0 (_tmp19_); vfunc = _tmp21_; vcast = NULL; _tmp22_ = m; _tmp23_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp22_); _tmp24_ = _tmp23_; if (VALA_IS_INTERFACE (_tmp24_)) { ValaMethod* _tmp25_; ValaSymbol* _tmp26_; ValaSymbol* _tmp27_; ValaInterface* _tmp28_; ValaInterface* iface; ValaInterface* _tmp29_; gchar* _tmp30_ = NULL; gchar* _tmp31_; gchar* _tmp32_ = NULL; gchar* _tmp33_; ValaCCodeIdentifier* _tmp34_; ValaCCodeIdentifier* _tmp35_; ValaCCodeFunctionCall* _tmp36_; _tmp25_ = m; _tmp26_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp25_); _tmp27_ = _tmp26_; _tmp28_ = _vala_code_node_ref0 (VALA_INTERFACE (_tmp27_)); iface = _tmp28_; _tmp29_ = iface; _tmp30_ = vala_ccode_base_module_get_ccode_upper_case_name ((ValaSymbol*) _tmp29_, NULL); _tmp31_ = _tmp30_; _tmp32_ = g_strdup_printf ("%s_GET_INTERFACE", _tmp31_); _tmp33_ = _tmp32_; _tmp34_ = vala_ccode_identifier_new (_tmp33_); _tmp35_ = _tmp34_; _tmp36_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp35_); _vala_ccode_node_unref0 (vcast); vcast = _tmp36_; _vala_ccode_node_unref0 (_tmp35_); _g_free0 (_tmp33_); _g_free0 (_tmp31_); _vala_code_node_unref0 (iface); } else { ValaMethod* _tmp37_; ValaSymbol* _tmp38_; ValaSymbol* _tmp39_; ValaClass* _tmp40_; ValaClass* cl; ValaClass* _tmp41_; gchar* _tmp42_ = NULL; gchar* _tmp43_; gchar* _tmp44_ = NULL; gchar* _tmp45_; ValaCCodeIdentifier* _tmp46_; ValaCCodeIdentifier* _tmp47_; ValaCCodeFunctionCall* _tmp48_; _tmp37_ = m; _tmp38_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp37_); _tmp39_ = _tmp38_; _tmp40_ = _vala_code_node_ref0 (VALA_CLASS (_tmp39_)); cl = _tmp40_; _tmp41_ = cl; _tmp42_ = vala_ccode_base_module_get_ccode_upper_case_name ((ValaSymbol*) _tmp41_, NULL); _tmp43_ = _tmp42_; _tmp44_ = g_strdup_printf ("%s_GET_CLASS", _tmp43_); _tmp45_ = _tmp44_; _tmp46_ = vala_ccode_identifier_new (_tmp45_); _tmp47_ = _tmp46_; _tmp48_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp47_); _vala_ccode_node_unref0 (vcast); vcast = _tmp48_; _vala_ccode_node_unref0 (_tmp47_); _g_free0 (_tmp45_); _g_free0 (_tmp43_); _vala_code_node_unref0 (cl); } _tmp49_ = vcast; _tmp50_ = vala_ccode_identifier_new ("self"); _tmp51_ = _tmp50_; vala_ccode_function_call_add_argument (_tmp49_, (ValaCCodeExpression*) _tmp51_); _vala_ccode_node_unref0 (_tmp51_); _tmp52_ = m; _tmp53_ = vala_ccode_base_module_get_ccode_vfunc_name (_tmp52_); _g_free0 (cname); cname = _tmp53_; _tmp55_ = suffix; if (g_strcmp0 (_tmp55_, "_finish") == 0) { const gchar* _tmp56_; gboolean _tmp57_ = FALSE; _tmp56_ = cname; _tmp57_ = g_str_has_suffix (_tmp56_, "_async"); _tmp54_ = _tmp57_; } else { _tmp54_ = FALSE; } _tmp58_ = _tmp54_; if (_tmp58_) { const gchar* _tmp59_; const gchar* _tmp60_; gint _tmp61_; gint _tmp62_; gint _tmp63_; gint _tmp64_; gchar* _tmp65_ = NULL; _tmp59_ = cname; _tmp60_ = cname; _tmp61_ = strlen (_tmp60_); _tmp62_ = _tmp61_; _tmp63_ = strlen ("_async"); _tmp64_ = _tmp63_; _tmp65_ = string_substring (_tmp59_, (glong) 0, (glong) (_tmp62_ - _tmp64_)); _g_free0 (cname); cname = _tmp65_; } _tmp66_ = vcast; _tmp67_ = cname; _tmp68_ = suffix; _tmp69_ = g_strconcat (_tmp67_, _tmp68_, NULL); _tmp70_ = _tmp69_; _tmp71_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp66_, _tmp70_); _tmp72_ = _tmp71_; _tmp73_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp72_); _tmp74_ = _tmp73_; _vala_ccode_node_unref0 (_tmp72_); _g_free0 (_tmp70_); vcall = _tmp74_; _tmp75_ = carg_map; _tmp76_ = m; _tmp77_ = vala_ccode_base_module_get_ccode_instance_pos ((ValaCodeNode*) _tmp76_); _tmp78_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, _tmp77_, FALSE); _tmp79_ = vala_ccode_identifier_new ("self"); _tmp80_ = _tmp79_; vala_map_set (_tmp75_, GINT_TO_POINTER (_tmp78_), (ValaCCodeExpression*) _tmp80_); _vala_ccode_node_unref0 (_tmp80_); _tmp81_ = m; _tmp82_ = ((ValaCCodeBaseModule*) self)->cfile; _tmp83_ = cparam_map; _tmp84_ = vfunc; _tmp85_ = carg_map; _tmp86_ = vcall; _tmp87_ = direction; vala_ccode_base_module_generate_cparameters ((ValaCCodeBaseModule*) self, _tmp81_, _tmp82_, _tmp83_, _tmp84_, NULL, _tmp85_, _tmp86_, _tmp87_); _tmp88_ = vfunc; vala_ccode_base_module_push_function ((ValaCCodeBaseModule*) self, _tmp88_); _tmp92_ = vala_ccode_base_module_get_context ((ValaCCodeBaseModule*) self); _tmp93_ = _tmp92_; _tmp94_ = vala_code_context_get_assert (_tmp93_); _tmp95_ = _tmp94_; if (_tmp95_) { ValaMethod* _tmp96_; ValaDataType* _tmp97_; ValaDataType* _tmp98_; ValaTypeSymbol* _tmp99_; ValaTypeSymbol* _tmp100_; _tmp96_ = m; _tmp97_ = vala_method_get_return_type (_tmp96_); _tmp98_ = _tmp97_; _tmp99_ = vala_data_type_get_data_type (_tmp98_); _tmp100_ = _tmp99_; _tmp91_ = VALA_IS_STRUCT (_tmp100_); } else { _tmp91_ = FALSE; } _tmp101_ = _tmp91_; if (_tmp101_) { ValaMethod* _tmp102_; ValaDataType* _tmp103_; ValaDataType* _tmp104_; ValaTypeSymbol* _tmp105_; ValaTypeSymbol* _tmp106_; gboolean _tmp107_ = FALSE; _tmp102_ = m; _tmp103_ = vala_method_get_return_type (_tmp102_); _tmp104_ = _tmp103_; _tmp105_ = vala_data_type_get_data_type (_tmp104_); _tmp106_ = _tmp105_; _tmp107_ = vala_struct_is_simple_type (VALA_STRUCT (_tmp106_)); _tmp90_ = _tmp107_; } else { _tmp90_ = FALSE; } _tmp108_ = _tmp90_; if (_tmp108_) { ValaMethod* _tmp109_; ValaDataType* _tmp110_; ValaDataType* _tmp111_; ValaCCodeExpression* _tmp112_ = NULL; ValaCCodeExpression* _tmp113_; _tmp109_ = m; _tmp110_ = vala_method_get_return_type (_tmp109_); _tmp111_ = _tmp110_; _tmp112_ = vala_ccode_base_module_default_value_for_type ((ValaCCodeBaseModule*) self, _tmp111_, FALSE); _tmp113_ = _tmp112_; _tmp89_ = _tmp113_ == NULL; _vala_ccode_node_unref0 (_tmp113_); } else { _tmp89_ = FALSE; } _tmp114_ = _tmp89_; if (_tmp114_) { ValaMethod* _tmp115_; ValaDataType* _tmp116_; ValaDataType* _tmp117_; ValaCCodeExpression* _tmp118_ = NULL; ValaCCodeExpression* _tmp119_; ValaCCodeVariableDeclarator* _tmp120_; ValaCCodeVariableDeclarator* _tmp121_; ValaCCodeVariableDeclarator* vardecl; ValaCCodeVariableDeclarator* _tmp122_; ValaCCodeFunction* _tmp123_; ValaCCodeFunction* _tmp124_; ValaMethod* _tmp125_; ValaDataType* _tmp126_; ValaDataType* _tmp127_; gchar* _tmp128_ = NULL; gchar* _tmp129_; ValaCCodeVariableDeclarator* _tmp130_; _tmp115_ = m; _tmp116_ = vala_method_get_return_type (_tmp115_); _tmp117_ = _tmp116_; _tmp118_ = vala_ccode_base_module_default_value_for_type ((ValaCCodeBaseModule*) self, _tmp117_, TRUE); _tmp119_ = _tmp118_; _tmp120_ = vala_ccode_variable_declarator_new ("result", _tmp119_, NULL); _tmp121_ = _tmp120_; _vala_ccode_node_unref0 (_tmp119_); vardecl = _tmp121_; _tmp122_ = vardecl; vala_ccode_variable_declarator_set_init0 (_tmp122_, TRUE); _tmp123_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); _tmp124_ = _tmp123_; _tmp125_ = m; _tmp126_ = vala_method_get_return_type (_tmp125_); _tmp127_ = _tmp126_; _tmp128_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp127_); _tmp129_ = _tmp128_; _tmp130_ = vardecl; vala_ccode_function_add_declaration (_tmp124_, _tmp129_, (ValaCCodeDeclarator*) _tmp130_, 0); _g_free0 (_tmp129_); _vala_ccode_node_unref0 (vardecl); } _tmp131_ = m; _tmp132_ = return_type; _tmp133_ = m; _tmp134_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp133_); _tmp135_ = _tmp134_; vala_ccode_method_module_create_method_type_check_statement (self, _tmp131_, _tmp132_, VALA_TYPESYMBOL (_tmp135_), TRUE, "self"); { ValaMethod* _tmp136_; ValaList* _tmp137_ = NULL; ValaList* _precondition_list; ValaList* _tmp138_; gint _tmp139_; gint _tmp140_; gint _precondition_size; gint _precondition_index; _tmp136_ = m; _tmp137_ = vala_method_get_preconditions (_tmp136_); _precondition_list = _tmp137_; _tmp138_ = _precondition_list; _tmp139_ = vala_collection_get_size ((ValaCollection*) _tmp138_); _tmp140_ = _tmp139_; _precondition_size = _tmp140_; _precondition_index = -1; while (TRUE) { gint _tmp141_; gint _tmp142_; gint _tmp143_; ValaList* _tmp144_; gint _tmp145_; gpointer _tmp146_ = NULL; ValaExpression* precondition; ValaMethod* _tmp147_; ValaDataType* _tmp148_; ValaExpression* _tmp149_; _tmp141_ = _precondition_index; _precondition_index = _tmp141_ + 1; _tmp142_ = _precondition_index; _tmp143_ = _precondition_size; if (!(_tmp142_ < _tmp143_)) { break; } _tmp144_ = _precondition_list; _tmp145_ = _precondition_index; _tmp146_ = vala_list_get (_tmp144_, _tmp145_); precondition = (ValaExpression*) _tmp146_; _tmp147_ = m; _tmp148_ = return_type; _tmp149_ = precondition; vala_ccode_method_module_create_precondition_statement (self, (ValaCodeNode*) _tmp147_, _tmp148_, _tmp149_); _vala_code_node_unref0 (precondition); } _vala_iterable_unref0 (_precondition_list); } _tmp151_ = return_type; if (VALA_IS_VOID_TYPE (_tmp151_)) { _tmp150_ = TRUE; } else { ValaDataType* _tmp152_; gboolean _tmp153_ = FALSE; _tmp152_ = return_type; _tmp153_ = vala_data_type_is_real_non_null_struct_type (_tmp152_); _tmp150_ = _tmp153_; } _tmp154_ = _tmp150_; if (_tmp154_) { ValaCCodeFunction* _tmp155_; ValaCCodeFunction* _tmp156_; ValaCCodeFunctionCall* _tmp157_; _tmp155_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); _tmp156_ = _tmp155_; _tmp157_ = vcall; vala_ccode_function_add_expression (_tmp156_, (ValaCCodeExpression*) _tmp157_); } else { ValaMethod* _tmp158_; ValaList* _tmp159_ = NULL; ValaList* _tmp160_; gint _tmp161_; gint _tmp162_; gboolean _tmp163_; _tmp158_ = m; _tmp159_ = vala_method_get_postconditions (_tmp158_); _tmp160_ = _tmp159_; _tmp161_ = vala_collection_get_size ((ValaCollection*) _tmp160_); _tmp162_ = _tmp161_; _tmp163_ = _tmp162_ == 0; _vala_iterable_unref0 (_tmp160_); if (_tmp163_) { ValaCCodeFunction* _tmp164_; ValaCCodeFunction* _tmp165_; ValaCCodeFunctionCall* _tmp166_; _tmp164_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); _tmp165_ = _tmp164_; _tmp166_ = vcall; vala_ccode_function_add_return (_tmp165_, (ValaCCodeExpression*) _tmp166_); } else { ValaCCodeFunction* _tmp167_; ValaCCodeFunction* _tmp168_; ValaMethod* _tmp169_; ValaDataType* _tmp170_; gchar* _tmp171_ = NULL; gchar* _tmp172_; gchar* _tmp173_ = NULL; gchar* _tmp174_; ValaCCodeVariableDeclarator* _tmp175_; ValaCCodeVariableDeclarator* _tmp176_; ValaCCodeFunction* _tmp177_; ValaCCodeFunction* _tmp178_; ValaCCodeIdentifier* _tmp179_; ValaCCodeIdentifier* _tmp180_; ValaCCodeFunctionCall* _tmp181_; _tmp167_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); _tmp168_ = _tmp167_; _tmp169_ = m; _tmp170_ = return_type; _tmp171_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp170_); _tmp172_ = _tmp171_; _tmp173_ = vala_ccode_method_module_get_creturn_type (self, _tmp169_, _tmp172_); _tmp174_ = _tmp173_; _tmp175_ = vala_ccode_variable_declarator_new ("result", NULL, NULL); _tmp176_ = _tmp175_; vala_ccode_function_add_declaration (_tmp168_, _tmp174_, (ValaCCodeDeclarator*) _tmp176_, 0); _vala_ccode_node_unref0 (_tmp176_); _g_free0 (_tmp174_); _g_free0 (_tmp172_); _tmp177_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); _tmp178_ = _tmp177_; _tmp179_ = vala_ccode_identifier_new ("result"); _tmp180_ = _tmp179_; _tmp181_ = vcall; vala_ccode_function_add_assignment (_tmp178_, (ValaCCodeExpression*) _tmp180_, (ValaCCodeExpression*) _tmp181_); _vala_ccode_node_unref0 (_tmp180_); } } _tmp182_ = m; _tmp183_ = vala_method_get_postconditions (_tmp182_); _tmp184_ = _tmp183_; _tmp185_ = vala_collection_get_size ((ValaCollection*) _tmp184_); _tmp186_ = _tmp185_; _tmp187_ = _tmp186_ > 0; _vala_iterable_unref0 (_tmp184_); if (_tmp187_) { ValaDataType* _tmp200_; { ValaMethod* _tmp188_; ValaList* _tmp189_ = NULL; ValaList* _postcondition_list; ValaList* _tmp190_; gint _tmp191_; gint _tmp192_; gint _postcondition_size; gint _postcondition_index; _tmp188_ = m; _tmp189_ = vala_method_get_postconditions (_tmp188_); _postcondition_list = _tmp189_; _tmp190_ = _postcondition_list; _tmp191_ = vala_collection_get_size ((ValaCollection*) _tmp190_); _tmp192_ = _tmp191_; _postcondition_size = _tmp192_; _postcondition_index = -1; while (TRUE) { gint _tmp193_; gint _tmp194_; gint _tmp195_; ValaList* _tmp196_; gint _tmp197_; gpointer _tmp198_ = NULL; ValaExpression* postcondition; ValaExpression* _tmp199_; _tmp193_ = _postcondition_index; _postcondition_index = _tmp193_ + 1; _tmp194_ = _postcondition_index; _tmp195_ = _postcondition_size; if (!(_tmp194_ < _tmp195_)) { break; } _tmp196_ = _postcondition_list; _tmp197_ = _postcondition_index; _tmp198_ = vala_list_get (_tmp196_, _tmp197_); postcondition = (ValaExpression*) _tmp198_; _tmp199_ = postcondition; vala_ccode_base_module_create_postcondition_statement ((ValaCCodeBaseModule*) self, _tmp199_); _vala_code_node_unref0 (postcondition); } _vala_iterable_unref0 (_postcondition_list); } _tmp200_ = return_type; if (!VALA_IS_VOID_TYPE (_tmp200_)) { ValaCCodeFunction* _tmp201_; ValaCCodeFunction* _tmp202_; ValaCCodeIdentifier* _tmp203_; ValaCCodeIdentifier* _tmp204_; _tmp201_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); _tmp202_ = _tmp201_; _tmp203_ = vala_ccode_identifier_new ("result"); _tmp204_ = _tmp203_; vala_ccode_function_add_return (_tmp202_, (ValaCCodeExpression*) _tmp204_); _vala_ccode_node_unref0 (_tmp204_); } } _tmp205_ = ((ValaCCodeBaseModule*) self)->cfile; _tmp206_ = vfunc; vala_ccode_file_add_function (_tmp205_, _tmp206_); vala_ccode_base_module_pop_context ((ValaCCodeBaseModule*) self); _vala_ccode_node_unref0 (vcall); _vala_ccode_node_unref0 (vcast); _vala_ccode_node_unref0 (vfunc); _g_free0 (cname); } static void vala_ccode_method_module_create_method_type_check_statement (ValaCCodeMethodModule* self, ValaMethod* m, ValaDataType* return_type, ValaTypeSymbol* t, gboolean non_null, const gchar* var_name) { ValaMethod* _tmp0_; gboolean _tmp1_; gboolean _tmp2_; g_return_if_fail (self != NULL); g_return_if_fail (m != NULL); g_return_if_fail (return_type != NULL); g_return_if_fail (t != NULL); g_return_if_fail (var_name != NULL); _tmp0_ = m; _tmp1_ = vala_method_get_coroutine (_tmp0_); _tmp2_ = _tmp1_; if (!_tmp2_) { ValaMethod* _tmp3_; ValaDataType* _tmp4_; ValaTypeSymbol* _tmp5_; gboolean _tmp6_; const gchar* _tmp7_; _tmp3_ = m; _tmp4_ = return_type; _tmp5_ = t; _tmp6_ = non_null; _tmp7_ = var_name; vala_ccode_base_module_create_type_check_statement ((ValaCCodeBaseModule*) self, (ValaCodeNode*) _tmp3_, _tmp4_, _tmp5_, _tmp6_, _tmp7_); } } static void vala_ccode_method_module_create_precondition_statement (ValaCCodeMethodModule* self, ValaCodeNode* method_node, ValaDataType* ret_type, ValaExpression* precondition) { ValaCCodeFunctionCall* _tmp0_; ValaCCodeFunctionCall* ccheck; ValaExpression* _tmp1_; ValaCCodeFunctionCall* _tmp2_; ValaExpression* _tmp3_; ValaCCodeExpression* _tmp4_ = NULL; ValaCCodeExpression* _tmp5_; ValaCodeNode* _tmp6_; ValaCCodeFunction* _tmp37_; ValaCCodeFunction* _tmp38_; ValaCCodeFunctionCall* _tmp39_; g_return_if_fail (self != NULL); g_return_if_fail (method_node != NULL); g_return_if_fail (ret_type != NULL); g_return_if_fail (precondition != NULL); _tmp0_ = vala_ccode_function_call_new (NULL); ccheck = _tmp0_; _tmp1_ = precondition; vala_code_node_emit ((ValaCodeNode*) _tmp1_, (ValaCodeGenerator*) self); _tmp2_ = ccheck; _tmp3_ = precondition; _tmp4_ = vala_ccode_base_module_get_cvalue ((ValaCCodeBaseModule*) self, _tmp3_); _tmp5_ = _tmp4_; vala_ccode_function_call_add_argument (_tmp2_, _tmp5_); _vala_ccode_node_unref0 (_tmp5_); _tmp6_ = method_node; if (VALA_IS_CREATION_METHOD (_tmp6_)) { ValaCCodeFunctionCall* _tmp7_; ValaCCodeIdentifier* _tmp8_; ValaCCodeIdentifier* _tmp9_; ValaCCodeFunctionCall* _tmp10_; ValaCCodeConstant* _tmp11_; ValaCCodeConstant* _tmp12_; _tmp7_ = ccheck; _tmp8_ = vala_ccode_identifier_new ("g_return_val_if_fail"); _tmp9_ = _tmp8_; vala_ccode_function_call_set_call (_tmp7_, (ValaCCodeExpression*) _tmp9_); _vala_ccode_node_unref0 (_tmp9_); _tmp10_ = ccheck; _tmp11_ = vala_ccode_constant_new ("NULL"); _tmp12_ = _tmp11_; vala_ccode_function_call_add_argument (_tmp10_, (ValaCCodeExpression*) _tmp12_); _vala_ccode_node_unref0 (_tmp12_); } else { gboolean _tmp13_ = FALSE; ValaCodeNode* _tmp14_; gboolean _tmp18_; _tmp14_ = method_node; if (VALA_IS_METHOD (_tmp14_)) { ValaCodeNode* _tmp15_; gboolean _tmp16_; gboolean _tmp17_; _tmp15_ = method_node; _tmp16_ = vala_method_get_coroutine (VALA_METHOD (_tmp15_)); _tmp17_ = _tmp16_; _tmp13_ = _tmp17_; } else { _tmp13_ = FALSE; } _tmp18_ = _tmp13_; if (_tmp18_) { ValaCCodeFunctionCall* _tmp19_; ValaCCodeIdentifier* _tmp20_; ValaCCodeIdentifier* _tmp21_; ValaCCodeFunctionCall* _tmp22_; ValaCCodeConstant* _tmp23_; ValaCCodeConstant* _tmp24_; _tmp19_ = ccheck; _tmp20_ = vala_ccode_identifier_new ("g_return_val_if_fail"); _tmp21_ = _tmp20_; vala_ccode_function_call_set_call (_tmp19_, (ValaCCodeExpression*) _tmp21_); _vala_ccode_node_unref0 (_tmp21_); _tmp22_ = ccheck; _tmp23_ = vala_ccode_constant_new ("FALSE"); _tmp24_ = _tmp23_; vala_ccode_function_call_add_argument (_tmp22_, (ValaCCodeExpression*) _tmp24_); _vala_ccode_node_unref0 (_tmp24_); } else { ValaDataType* _tmp25_; _tmp25_ = ret_type; if (VALA_IS_VOID_TYPE (_tmp25_)) { ValaCCodeFunctionCall* _tmp26_; ValaCCodeIdentifier* _tmp27_; ValaCCodeIdentifier* _tmp28_; _tmp26_ = ccheck; _tmp27_ = vala_ccode_identifier_new ("g_return_if_fail"); _tmp28_ = _tmp27_; vala_ccode_function_call_set_call (_tmp26_, (ValaCCodeExpression*) _tmp28_); _vala_ccode_node_unref0 (_tmp28_); } else { ValaCCodeFunctionCall* _tmp29_; ValaCCodeIdentifier* _tmp30_; ValaCCodeIdentifier* _tmp31_; ValaDataType* _tmp32_; ValaCCodeExpression* _tmp33_ = NULL; ValaCCodeExpression* cdefault; ValaCCodeExpression* _tmp34_; _tmp29_ = ccheck; _tmp30_ = vala_ccode_identifier_new ("g_return_val_if_fail"); _tmp31_ = _tmp30_; vala_ccode_function_call_set_call (_tmp29_, (ValaCCodeExpression*) _tmp31_); _vala_ccode_node_unref0 (_tmp31_); _tmp32_ = ret_type; _tmp33_ = vala_ccode_base_module_default_value_for_type ((ValaCCodeBaseModule*) self, _tmp32_, FALSE); cdefault = _tmp33_; _tmp34_ = cdefault; if (_tmp34_ != NULL) { ValaCCodeFunctionCall* _tmp35_; ValaCCodeExpression* _tmp36_; _tmp35_ = ccheck; _tmp36_ = cdefault; vala_ccode_function_call_add_argument (_tmp35_, _tmp36_); } else { _vala_ccode_node_unref0 (cdefault); _vala_ccode_node_unref0 (ccheck); return; } _vala_ccode_node_unref0 (cdefault); } } } _tmp37_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); _tmp38_ = _tmp37_; _tmp39_ = ccheck; vala_ccode_function_add_expression (_tmp38_, (ValaCCodeExpression*) _tmp39_); _vala_ccode_node_unref0 (ccheck); } static ValaTypeSymbol* vala_ccode_method_module_find_parent_type (ValaCCodeMethodModule* self, ValaSymbol* sym) { ValaTypeSymbol* result = NULL; g_return_val_if_fail (self != NULL, NULL); g_return_val_if_fail (sym != NULL, NULL); while (TRUE) { ValaSymbol* _tmp0_; ValaSymbol* _tmp1_; ValaSymbol* _tmp4_; ValaSymbol* _tmp5_; ValaSymbol* _tmp6_; _tmp0_ = sym; if (!(_tmp0_ != NULL)) { break; } _tmp1_ = sym; if (VALA_IS_TYPESYMBOL (_tmp1_)) { ValaSymbol* _tmp2_; ValaTypeSymbol* _tmp3_; _tmp2_ = sym; _tmp3_ = _vala_code_node_ref0 (VALA_TYPESYMBOL (_tmp2_)); result = _tmp3_; return result; } _tmp4_ = sym; _tmp5_ = vala_symbol_get_parent_symbol (_tmp4_); _tmp6_ = _tmp5_; sym = _tmp6_; } result = NULL; return result; } static void vala_ccode_method_module_real_visit_creation_method (ValaCodeVisitor* base, ValaCreationMethod* m) { ValaCCodeMethodModule * self; ValaCreationMethod* _tmp0_; ValaSourceReference* _tmp1_; ValaSourceReference* _tmp2_; ValaCreationMethod* _tmp3_; gboolean _tmp4_ = FALSE; gboolean visible; ValaCreationMethod* _tmp5_; ValaCreationMethod* _tmp6_; ValaSourceFileType _tmp7_; ValaSourceFileType _tmp8_; gboolean _tmp9_ = FALSE; gboolean _tmp10_ = FALSE; ValaTypeSymbol* _tmp11_; ValaTypeSymbol* _tmp12_; gboolean _tmp17_; gboolean _tmp22_; self = (ValaCCodeMethodModule*) base; g_return_if_fail (m != NULL); _tmp0_ = m; _tmp1_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp0_); _tmp2_ = _tmp1_; vala_ccode_base_module_push_line ((ValaCCodeBaseModule*) self, _tmp2_); _tmp3_ = m; _tmp4_ = vala_symbol_is_private_symbol ((ValaSymbol*) _tmp3_); visible = !_tmp4_; _tmp5_ = m; vala_code_visitor_visit_method ((ValaCodeVisitor*) self, (ValaMethod*) _tmp5_); _tmp6_ = m; _tmp7_ = vala_symbol_get_source_type ((ValaSymbol*) _tmp6_); _tmp8_ = _tmp7_; if (_tmp8_ == VALA_SOURCE_FILE_TYPE_FAST) { return; } _tmp11_ = vala_ccode_base_module_get_current_type_symbol ((ValaCCodeBaseModule*) self); _tmp12_ = _tmp11_; if (VALA_IS_CLASS (_tmp12_)) { ValaClass* _tmp13_; ValaClass* _tmp14_; gboolean _tmp15_; gboolean _tmp16_; _tmp13_ = vala_ccode_base_module_get_current_class ((ValaCCodeBaseModule*) self); _tmp14_ = _tmp13_; _tmp15_ = vala_class_get_is_compact (_tmp14_); _tmp16_ = _tmp15_; _tmp10_ = !_tmp16_; } else { _tmp10_ = FALSE; } _tmp17_ = _tmp10_; if (_tmp17_) { ValaClass* _tmp18_; ValaClass* _tmp19_; gboolean _tmp20_; gboolean _tmp21_; _tmp18_ = vala_ccode_base_module_get_current_class ((ValaCCodeBaseModule*) self); _tmp19_ = _tmp18_; _tmp20_ = vala_class_get_is_abstract (_tmp19_); _tmp21_ = _tmp20_; _tmp9_ = !_tmp21_; } else { _tmp9_ = FALSE; } _tmp22_ = _tmp9_; if (_tmp22_) { ValaCreationMethod* _tmp23_; gchar* _tmp24_ = NULL; gchar* _tmp25_; ValaCCodeFunction* _tmp26_; ValaCCodeFunction* _tmp27_; ValaCCodeFunction* vfunc; GHashFunc _tmp28_; GEqualFunc _tmp29_; GEqualFunc _tmp30_; ValaHashMap* _tmp31_; ValaHashMap* cparam_map; GHashFunc _tmp32_; GEqualFunc _tmp33_; GEqualFunc _tmp34_; ValaHashMap* _tmp35_; ValaHashMap* carg_map; ValaCCodeFunction* _tmp36_; ValaCreationMethod* _tmp37_; gchar* _tmp38_ = NULL; gchar* _tmp39_; ValaCCodeIdentifier* _tmp40_; ValaCCodeIdentifier* _tmp41_; ValaCCodeFunctionCall* _tmp42_; ValaCCodeFunctionCall* _tmp43_; ValaCCodeFunctionCall* vcall; ValaCCodeFunctionCall* _tmp44_; ValaClass* _tmp45_; ValaClass* _tmp46_; gchar* _tmp47_ = NULL; gchar* _tmp48_; ValaCCodeIdentifier* _tmp49_; ValaCCodeIdentifier* _tmp50_; ValaCreationMethod* _tmp51_; ValaCCodeFile* _tmp52_; ValaHashMap* _tmp53_; ValaCCodeFunction* _tmp54_; ValaHashMap* _tmp55_; ValaCCodeFunctionCall* _tmp56_; ValaCCodeFunction* _tmp57_; ValaCCodeFunction* _tmp58_; ValaCCodeFunctionCall* _tmp59_; gboolean _tmp60_; ValaCCodeFile* _tmp65_; ValaCCodeFunction* _tmp66_; _tmp23_ = m; _tmp24_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp23_); _tmp25_ = _tmp24_; _tmp26_ = vala_ccode_function_new (_tmp25_, "void"); _tmp27_ = _tmp26_; _g_free0 (_tmp25_); vfunc = _tmp27_; _tmp28_ = g_direct_hash; _tmp29_ = g_direct_equal; _tmp30_ = g_direct_equal; _tmp31_ = vala_hash_map_new (G_TYPE_INT, NULL, NULL, VALA_TYPE_CCODE_PARAMETER, (GBoxedCopyFunc) vala_ccode_node_ref, vala_ccode_node_unref, _tmp28_, _tmp29_, _tmp30_); cparam_map = _tmp31_; _tmp32_ = g_direct_hash; _tmp33_ = g_direct_equal; _tmp34_ = g_direct_equal; _tmp35_ = vala_hash_map_new (G_TYPE_INT, NULL, NULL, VALA_TYPE_CCODE_EXPRESSION, (GBoxedCopyFunc) vala_ccode_node_ref, vala_ccode_node_unref, _tmp32_, _tmp33_, _tmp34_); carg_map = _tmp35_; _tmp36_ = vfunc; vala_ccode_base_module_push_function ((ValaCCodeBaseModule*) self, _tmp36_); _tmp37_ = m; _tmp38_ = vala_ccode_base_module_get_ccode_real_name ((ValaSymbol*) _tmp37_); _tmp39_ = _tmp38_; _tmp40_ = vala_ccode_identifier_new (_tmp39_); _tmp41_ = _tmp40_; _tmp42_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp41_); _tmp43_ = _tmp42_; _vala_ccode_node_unref0 (_tmp41_); _g_free0 (_tmp39_); vcall = _tmp43_; _tmp44_ = vcall; _tmp45_ = vala_ccode_base_module_get_current_class ((ValaCCodeBaseModule*) self); _tmp46_ = _tmp45_; _tmp47_ = vala_ccode_base_module_get_ccode_type_id ((ValaCodeNode*) _tmp46_); _tmp48_ = _tmp47_; _tmp49_ = vala_ccode_identifier_new (_tmp48_); _tmp50_ = _tmp49_; vala_ccode_function_call_add_argument (_tmp44_, (ValaCCodeExpression*) _tmp50_); _vala_ccode_node_unref0 (_tmp50_); _g_free0 (_tmp48_); _tmp51_ = m; _tmp52_ = ((ValaCCodeBaseModule*) self)->cfile; _tmp53_ = cparam_map; _tmp54_ = vfunc; _tmp55_ = carg_map; _tmp56_ = vcall; vala_ccode_base_module_generate_cparameters ((ValaCCodeBaseModule*) self, (ValaMethod*) _tmp51_, _tmp52_, (ValaMap*) _tmp53_, _tmp54_, NULL, (ValaMap*) _tmp55_, _tmp56_, 3); _tmp57_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self); _tmp58_ = _tmp57_; _tmp59_ = vcall; vala_ccode_function_add_return (_tmp58_, (ValaCCodeExpression*) _tmp59_); _tmp60_ = visible; if (!_tmp60_) { ValaCCodeFunction* _tmp61_; ValaCCodeFunction* _tmp62_; ValaCCodeModifiers _tmp63_; ValaCCodeModifiers _tmp64_; _tmp61_ = vfunc; _tmp62_ = vfunc; _tmp63_ = vala_ccode_function_get_modifiers (_tmp62_); _tmp64_ = _tmp63_; vala_ccode_function_set_modifiers (_tmp62_, _tmp64_ | VALA_CCODE_MODIFIERS_STATIC); } vala_ccode_base_module_pop_function ((ValaCCodeBaseModule*) self); _tmp65_ = ((ValaCCodeBaseModule*) self)->cfile; _tmp66_ = vfunc; vala_ccode_file_add_function (_tmp65_, _tmp66_); _vala_ccode_node_unref0 (vcall); _vala_map_unref0 (carg_map); _vala_map_unref0 (cparam_map); _vala_ccode_node_unref0 (vfunc); } vala_ccode_base_module_pop_line ((ValaCCodeBaseModule*) self); } ValaCCodeMethodModule* vala_ccode_method_module_construct (GType object_type) { ValaCCodeMethodModule* self = NULL; self = (ValaCCodeMethodModule*) vala_ccode_struct_module_construct (object_type); return self; } static void vala_ccode_method_module_class_init (ValaCCodeMethodModuleClass * klass) { vala_ccode_method_module_parent_class = g_type_class_peek_parent (klass); VALA_CCODE_BASE_MODULE_CLASS (klass)->method_has_wrapper = vala_ccode_method_module_real_method_has_wrapper; VALA_CCODE_METHOD_MODULE_CLASS (klass)->generate_method_result_declaration = vala_ccode_method_module_real_generate_method_result_declaration; VALA_CCODE_BASE_MODULE_CLASS (klass)->generate_method_declaration = vala_ccode_method_module_real_generate_method_declaration; VALA_CODE_VISITOR_CLASS (klass)->visit_method = vala_ccode_method_module_real_visit_method; VALA_CCODE_METHOD_MODULE_CLASS (klass)->generate_parameter = vala_ccode_method_module_real_generate_parameter; VALA_CCODE_BASE_MODULE_CLASS (klass)->generate_cparameters = vala_ccode_method_module_real_generate_cparameters; VALA_CODE_VISITOR_CLASS (klass)->visit_creation_method = vala_ccode_method_module_real_visit_creation_method; } static void vala_ccode_method_module_instance_init (ValaCCodeMethodModule * self) { } /** * The link between a method and generated code. */ GType vala_ccode_method_module_get_type (void) { static volatile gsize vala_ccode_method_module_type_id__volatile = 0; if (g_once_init_enter (&vala_ccode_method_module_type_id__volatile)) { static const GTypeInfo g_define_type_info = { sizeof (ValaCCodeMethodModuleClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) vala_ccode_method_module_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ValaCCodeMethodModule), 0, (GInstanceInitFunc) vala_ccode_method_module_instance_init, NULL }; GType vala_ccode_method_module_type_id; vala_ccode_method_module_type_id = g_type_register_static (VALA_TYPE_CCODE_STRUCT_MODULE, "ValaCCodeMethodModule", &g_define_type_info, G_TYPE_FLAG_ABSTRACT); g_once_init_leave (&vala_ccode_method_module_type_id__volatile, vala_ccode_method_module_type_id); } return vala_ccode_method_module_type_id__volatile; }