Logo Search packages:      
Sourcecode: vala-0.12 version File versions  Download package

valaccodemethodcallmodule.c

/* valaccodemethodcallmodule.c generated by valac, the Vala compiler
 * generated from valaccodemethodcallmodule.vala, do not modify */

/* valaccodemethodcallmodule.vala
 *
 * Copyright (C) 2006-2010  Jürg Billeter
 * Copyright (C) 2006-2008  Raffaele Sandrini
 *
 * 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 <j@bitron.ch>
 *    Raffaele Sandrini <raffaele@sandrini.ch>
 */

#include <glib.h>
#include <glib-object.h>
#include <vala.h>
#include <valaccode.h>
#include <valagee.h>
#include <stdlib.h>
#include <string.h>
#include <float.h>
#include <math.h>


#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_TYPE_CCODE_CONTROL_FLOW_MODULE (vala_ccode_control_flow_module_get_type ())
#define VALA_CCODE_CONTROL_FLOW_MODULE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CCODE_CONTROL_FLOW_MODULE, ValaCCodeControlFlowModule))
#define VALA_CCODE_CONTROL_FLOW_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CCODE_CONTROL_FLOW_MODULE, ValaCCodeControlFlowModuleClass))
#define VALA_IS_CCODE_CONTROL_FLOW_MODULE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CCODE_CONTROL_FLOW_MODULE))
#define VALA_IS_CCODE_CONTROL_FLOW_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CCODE_CONTROL_FLOW_MODULE))
#define VALA_CCODE_CONTROL_FLOW_MODULE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CCODE_CONTROL_FLOW_MODULE, ValaCCodeControlFlowModuleClass))

typedef struct _ValaCCodeControlFlowModule ValaCCodeControlFlowModule;
typedef struct _ValaCCodeControlFlowModuleClass ValaCCodeControlFlowModuleClass;
typedef struct _ValaCCodeControlFlowModulePrivate ValaCCodeControlFlowModulePrivate;

#define VALA_TYPE_CCODE_MEMBER_ACCESS_MODULE (vala_ccode_member_access_module_get_type ())
#define VALA_CCODE_MEMBER_ACCESS_MODULE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CCODE_MEMBER_ACCESS_MODULE, ValaCCodeMemberAccessModule))
#define VALA_CCODE_MEMBER_ACCESS_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CCODE_MEMBER_ACCESS_MODULE, ValaCCodeMemberAccessModuleClass))
#define VALA_IS_CCODE_MEMBER_ACCESS_MODULE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CCODE_MEMBER_ACCESS_MODULE))
#define VALA_IS_CCODE_MEMBER_ACCESS_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CCODE_MEMBER_ACCESS_MODULE))
#define VALA_CCODE_MEMBER_ACCESS_MODULE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CCODE_MEMBER_ACCESS_MODULE, ValaCCodeMemberAccessModuleClass))

typedef struct _ValaCCodeMemberAccessModule ValaCCodeMemberAccessModule;
typedef struct _ValaCCodeMemberAccessModuleClass ValaCCodeMemberAccessModuleClass;
typedef struct _ValaCCodeMemberAccessModulePrivate ValaCCodeMemberAccessModulePrivate;

#define VALA_TYPE_CCODE_ASSIGNMENT_MODULE (vala_ccode_assignment_module_get_type ())
#define VALA_CCODE_ASSIGNMENT_MODULE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CCODE_ASSIGNMENT_MODULE, ValaCCodeAssignmentModule))
#define VALA_CCODE_ASSIGNMENT_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CCODE_ASSIGNMENT_MODULE, ValaCCodeAssignmentModuleClass))
#define VALA_IS_CCODE_ASSIGNMENT_MODULE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CCODE_ASSIGNMENT_MODULE))
#define VALA_IS_CCODE_ASSIGNMENT_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CCODE_ASSIGNMENT_MODULE))
#define VALA_CCODE_ASSIGNMENT_MODULE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CCODE_ASSIGNMENT_MODULE, ValaCCodeAssignmentModuleClass))

typedef struct _ValaCCodeAssignmentModule ValaCCodeAssignmentModule;
typedef struct _ValaCCodeAssignmentModuleClass ValaCCodeAssignmentModuleClass;
typedef struct _ValaCCodeAssignmentModulePrivate ValaCCodeAssignmentModulePrivate;

#define VALA_TYPE_CCODE_METHOD_CALL_MODULE (vala_ccode_method_call_module_get_type ())
#define VALA_CCODE_METHOD_CALL_MODULE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CCODE_METHOD_CALL_MODULE, ValaCCodeMethodCallModule))
#define VALA_CCODE_METHOD_CALL_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CCODE_METHOD_CALL_MODULE, ValaCCodeMethodCallModuleClass))
#define VALA_IS_CCODE_METHOD_CALL_MODULE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CCODE_METHOD_CALL_MODULE))
#define VALA_IS_CCODE_METHOD_CALL_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CCODE_METHOD_CALL_MODULE))
#define VALA_CCODE_METHOD_CALL_MODULE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CCODE_METHOD_CALL_MODULE, ValaCCodeMethodCallModuleClass))

typedef struct _ValaCCodeMethodCallModule ValaCCodeMethodCallModule;
typedef struct _ValaCCodeMethodCallModuleClass ValaCCodeMethodCallModuleClass;
typedef struct _ValaCCodeMethodCallModulePrivate ValaCCodeMethodCallModulePrivate;
#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_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_map_unref0(var) ((var == NULL) ? NULL : (var = (vala_map_unref (var), NULL)))

#define VALA_TYPE_CTYPE (vala_ctype_get_type ())
#define VALA_CTYPE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CTYPE, ValaCType))
#define VALA_CTYPE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CTYPE, ValaCTypeClass))
#define VALA_IS_CTYPE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CTYPE))
#define VALA_IS_CTYPE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CTYPE))
#define VALA_CTYPE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CTYPE, ValaCTypeClass))

typedef struct _ValaCType ValaCType;
typedef struct _ValaCTypeClass ValaCTypeClass;
#define _vala_iterator_unref0(var) ((var == NULL) ? NULL : (var = (vala_iterator_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)))

struct _ValaCCodeBaseModule {
      ValaCodeGenerator parent_instance;
      ValaCCodeBaseModulePrivate * priv;
      ValaSymbol* root_symbol;
      ValaCCodeBaseModuleEmitContext* emit_context;
      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;
      gboolean in_constructor;
      gboolean in_static_or_class_context;
      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* 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;
      ValaTypeSymbol* dbus_object_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_variable) (ValaCCodeBaseModule* self, ValaVariable* variable, ValaTargetValue* target_lvalue);
      ValaCCodeExpression* (*destroy_value) (ValaCCodeBaseModule* self, ValaTargetValue* value, gboolean is_macro_definition);
      void (*append_local_free) (ValaCCodeBaseModule* self, ValaSymbol* sym, gboolean stop_at_loop, 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_this_parameter) (ValaCCodeBaseModule* self, ValaTypeSymbol* sym);
      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);
      ValaCCodeExpression* (*get_ref_cexpression) (ValaCCodeBaseModule* self, ValaDataType* expression_type, ValaCCodeExpression* cexpr, ValaExpression* expr, 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, ValaExpression* expr);
      gboolean (*is_gobject_property) (ValaCCodeBaseModule* self, ValaProperty* prop);
      gchar* (*get_custom_creturn_type) (ValaCCodeBaseModule* self, ValaMethod* m);
      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);
      void (*generate_marshaller) (ValaCCodeBaseModule* self, ValaList* params, ValaDataType* return_type, gboolean dbus);
      gchar* (*get_marshaller_function) (ValaCCodeBaseModule* self, ValaList* params, ValaDataType* return_type, const gchar* prefix, gboolean dbus);
      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);
};

struct _ValaCCodeControlFlowModule {
      ValaCCodeMethodModule parent_instance;
      ValaCCodeControlFlowModulePrivate * priv;
};

struct _ValaCCodeControlFlowModuleClass {
      ValaCCodeMethodModuleClass parent_class;
};

struct _ValaCCodeMemberAccessModule {
      ValaCCodeControlFlowModule parent_instance;
      ValaCCodeMemberAccessModulePrivate * priv;
};

struct _ValaCCodeMemberAccessModuleClass {
      ValaCCodeControlFlowModuleClass parent_class;
};

struct _ValaCCodeAssignmentModule {
      ValaCCodeMemberAccessModule parent_instance;
      ValaCCodeAssignmentModulePrivate * priv;
};

struct _ValaCCodeAssignmentModuleClass {
      ValaCCodeMemberAccessModuleClass parent_class;
};

struct _ValaCCodeMethodCallModule {
      ValaCCodeAssignmentModule parent_instance;
      ValaCCodeMethodCallModulePrivate * priv;
};

struct _ValaCCodeMethodCallModuleClass {
      ValaCCodeAssignmentModuleClass parent_class;
};


static gpointer vala_ccode_method_call_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;
GType vala_ccode_control_flow_module_get_type (void) G_GNUC_CONST;
GType vala_ccode_member_access_module_get_type (void) G_GNUC_CONST;
GType vala_ccode_assignment_module_get_type (void) G_GNUC_CONST;
GType vala_ccode_method_call_module_get_type (void) G_GNUC_CONST;
enum  {
      VALA_CCODE_METHOD_CALL_MODULE_DUMMY_PROPERTY
};
static void vala_ccode_method_call_module_real_visit_method_call (ValaCodeVisitor* base, ValaMethodCall* expr);
ValaCCodeExpression* vala_ccode_base_module_get_cvalue (ValaCCodeBaseModule* self, ValaExpression* expr);
static gchar* vala_ccode_method_call_module_generate_enum_tostring_function (ValaCCodeMethodCallModule* self, ValaEnum* en);
void vala_ccode_base_module_generate_method_declaration (ValaCCodeBaseModule* self, ValaMethod* m, ValaCCodeFile* decl_space);
ValaClass* vala_ccode_base_module_get_current_class (ValaCCodeBaseModule* self);
gint vala_ccode_base_module_get_param_pos (ValaCCodeBaseModule* self, gdouble param_pos, gboolean ellipsis);
ValaCodeContext* vala_ccode_base_module_get_context (ValaCCodeBaseModule* self);
void vala_ccode_base_module_add_generic_type_arguments (ValaCCodeBaseModule* self, ValaMap* arg_map, ValaList* type_args, ValaCodeNode* expr, gboolean is_chainup);
ValaMethod* vala_ccode_base_module_get_current_method (ValaCCodeBaseModule* self);
ValaCCodeExpression* vala_ccode_base_module_get_variable_cexpression (ValaCCodeBaseModule* self, const gchar* name);
gint vala_ccode_base_module_get_block_id (ValaCCodeBaseModule* self, ValaBlock* b);
ValaLocalVariable* vala_ccode_base_module_get_temp_variable (ValaCCodeBaseModule* self, ValaDataType* type, gboolean value_owned, ValaCodeNode* node_reference, gboolean init);
void vala_ccode_base_module_emit_temp_var (ValaCCodeBaseModule* self, ValaLocalVariable* local, gboolean always_init);
ValaCCodeFunction* vala_ccode_base_module_get_ccode (ValaCCodeBaseModule* self);
void vala_ccode_base_module_generate_dynamic_method_wrapper (ValaCCodeBaseModule* self, ValaDynamicMethod* method);
ValaCCodeExpression* vala_ccode_base_module_get_dup_func_expression (ValaCCodeBaseModule* self, ValaDataType* type, ValaSourceReference* source_reference, gboolean is_chainup);
ValaCCodeExpression* vala_ccode_base_module_get_array_length_cexpression (ValaCCodeBaseModule* self, ValaExpression* array_expr, gint dim);
ValaCCodeExpression* vala_ccode_base_module_get_delegate_target_cexpression (ValaCCodeBaseModule* self, ValaExpression* delegate_expr, ValaCCodeExpression** delegate_target_destroy_notify);
gboolean vala_ccode_base_module_requires_copy (ValaCCodeBaseModule* self, ValaDataType* type);
ValaCCodeExpression* vala_ccode_base_module_get_destroy_func_expression (ValaCCodeBaseModule* self, ValaDataType* type, gboolean is_chainup);
ValaCCodeExpression* vala_ccode_base_module_handle_struct_argument (ValaCCodeBaseModule* self, ValaParameter* param, ValaExpression* arg, ValaCCodeExpression* cexpr);
void vala_ccode_base_module_set_cvalue (ValaCCodeBaseModule* self, ValaExpression* expr, ValaCCodeExpression* cvalue);
ValaCType* vala_ctype_new (const gchar* ctype_name);
ValaCType* vala_ctype_construct (GType object_type, const gchar* ctype_name);
GType vala_ctype_get_type (void) G_GNUC_CONST;
void vala_ccode_base_module_append_array_length (ValaCCodeBaseModule* self, ValaExpression* expr, ValaCCodeExpression* size);
ValaList* vala_ccode_base_module_get_array_lengths (ValaCCodeBaseModule* self, ValaExpression* expr);
void vala_ccode_base_module_set_delegate_target (ValaCCodeBaseModule* self, ValaExpression* expr, ValaCCodeExpression* delegate_target);
ValaCCodeExpression* vala_ccode_base_module_get_delegate_target (ValaCCodeBaseModule* self, ValaExpression* expr);
void vala_ccode_base_module_set_delegate_target_destroy_notify (ValaCCodeBaseModule* self, ValaExpression* expr, ValaCCodeExpression* destroy_notify);
ValaCCodeExpression* vala_ccode_base_module_get_delegate_target_destroy_notify (ValaCCodeBaseModule* self, ValaExpression* expr);
gchar* vala_ccode_base_module_generate_ready_function (ValaCCodeBaseModule* self, ValaMethod* m);
void vala_ccode_base_module_set_current_method_inner_error (ValaCCodeBaseModule* self, gboolean value);
ValaCCodeExpression* vala_ccode_base_module_get_array_size_cvalue (ValaCCodeBaseModule* self, ValaTargetValue* value);
gboolean vala_ccode_base_module_requires_destroy (ValaCCodeBaseModule* self, ValaDataType* type);
ValaCCodeExpression* vala_ccode_base_module_get_unref_expression (ValaCCodeBaseModule* self, ValaCCodeExpression* cvar, ValaDataType* type, ValaExpression* expr, gboolean is_macro_definition);
ValaCCodeExpression* vala_ccode_base_module_transform_expression (ValaCCodeBaseModule* self, ValaCCodeExpression* source_cexpr, ValaDataType* expression_type, ValaDataType* target_type, ValaExpression* expr);
gboolean vala_ccode_base_module_add_wrapper (ValaCCodeBaseModule* self, const gchar* wrapper_name);
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_function (ValaCCodeBaseModule* self, ValaCCodeFunction* func);
void vala_ccode_base_module_pop_context (ValaCCodeBaseModule* self);
ValaCCodeMethodCallModule* vala_ccode_method_call_module_new (void);
ValaCCodeMethodCallModule* vala_ccode_method_call_module_construct (GType object_type);
ValaCCodeAssignmentModule* vala_ccode_assignment_module_new (void);
ValaCCodeAssignmentModule* vala_ccode_assignment_module_construct (GType object_type);
static void _vala_array_destroy (gpointer array, gint array_length, GDestroyNotify destroy_func);
static void _vala_array_free (gpointer array, gint array_length, GDestroyNotify destroy_func);
static gint _vala_array_length (gpointer array);


static gpointer _vala_code_node_ref0 (gpointer self) {
      return self ? vala_code_node_ref (self) : NULL;
}


static gpointer _vala_map_ref0 (gpointer self) {
      return self ? vala_map_ref (self) : NULL;
}


static gpointer _vala_ccode_node_ref0 (gpointer self) {
      return self ? vala_ccode_node_ref (self) : NULL;
}


static void vala_ccode_method_call_module_real_visit_method_call (ValaCodeVisitor* base, ValaMethodCall* expr) {
      ValaCCodeMethodCallModule * self;
      ValaExpression* _tmp0_ = NULL;
      ValaCCodeExpression* _tmp1_ = NULL;
      ValaCCodeExpression* _tmp2_;
      ValaCCodeFunctionCall* _tmp3_ = NULL;
      ValaCCodeFunctionCall* _tmp4_;
      ValaCCodeFunctionCall* ccall;
      ValaCCodeFunctionCall* async_call;
      ValaMethod* m;
      ValaDelegate* deleg;
      ValaList* params = NULL;
      ValaExpression* _tmp5_ = NULL;
      ValaExpression* _tmp6_;
      ValaMemberAccess* _tmp7_;
      ValaMemberAccess* ma;
      ValaExpression* _tmp8_ = NULL;
      ValaDataType* _tmp9_ = NULL;
      ValaDataType* _tmp10_;
      ValaDataType* itype;
      ValaList* _tmp11_ = NULL;
      ValaHashMap* _tmp62_ = NULL;
      ValaHashMap* in_arg_map;
      ValaHashMap* _tmp63_;
      ValaHashMap* out_arg_map;
      gboolean _tmp64_ = FALSE;
      gboolean _tmp150_ = FALSE;
      ValaCCodeExpression* _tmp214_;
      ValaCCodeExpression* ccall_expr;
      ValaCCodeExpression* instance;
      gboolean _tmp224_ = FALSE;
      gboolean _tmp319_ = FALSE;
      gboolean ellipsis;
      gint i;
      gint arg_pos = 0;
      ValaIterator* _tmp470_ = NULL;
      ValaIterator* params_it;
      gboolean _tmp644_;
      gboolean _tmp649_ = FALSE;
      gboolean _tmp650_ = FALSE;
      gboolean _tmp711_ = FALSE;
      gboolean _tmp758_ = FALSE;
      gboolean _tmp770_;
      ValaDataType* _tmp804_ = NULL;
      ValaDataType* _tmp805_;
      gboolean _tmp806_;
      gboolean _tmp807_;
      gboolean return_result_via_out_param;
      gboolean _tmp808_ = FALSE;
      ValaCCodeExpression* out_param_ref;
      gint last_pos = 0;
      gint min_pos = 0;
      gboolean _tmp847_;
      gboolean _tmp867_ = FALSE;
      gboolean _tmp868_ = FALSE;
      gboolean _tmp936_ = FALSE;
      ValaCodeNode* _tmp937_ = NULL;
      ValaIterator* _tmp965_ = NULL;
      self = (ValaCCodeMethodCallModule*) base;
      g_return_if_fail (expr != NULL);
      _tmp0_ = vala_method_call_get_call (expr);
      _tmp1_ = vala_ccode_base_module_get_cvalue ((ValaCCodeBaseModule*) self, _tmp0_);
      _tmp2_ = _tmp1_;
      _tmp3_ = vala_ccode_function_call_new (_tmp2_);
      _tmp4_ = _tmp3_;
      _vala_ccode_node_unref0 (_tmp2_);
      ccall = _tmp4_;
      async_call = NULL;
      m = NULL;
      deleg = NULL;
      _tmp5_ = vala_method_call_get_call (expr);
      _tmp6_ = _tmp5_;
      _tmp7_ = _vala_code_node_ref0 (VALA_IS_MEMBER_ACCESS (_tmp6_) ? ((ValaMemberAccess*) _tmp6_) : NULL);
      ma = _tmp7_;
      _tmp8_ = vala_method_call_get_call (expr);
      _tmp9_ = vala_expression_get_value_type (_tmp8_);
      _tmp10_ = _vala_code_node_ref0 (_tmp9_);
      itype = _tmp10_;
      _tmp11_ = vala_data_type_get_parameters (itype);
      _vala_iterable_unref0 (params);
      params = _tmp11_;
      if (VALA_IS_METHOD_TYPE (itype)) {
            ValaMethod* _tmp12_ = NULL;
            ValaMethod* _tmp13_;
            gboolean _tmp14_ = FALSE;
            gboolean _tmp15_ = FALSE;
            ValaExpression* _tmp16_ = NULL;
            g_assert (ma != NULL);
            _tmp12_ = vala_method_type_get_method_symbol (VALA_METHOD_TYPE (itype));
            _tmp13_ = _vala_code_node_ref0 (_tmp12_);
            _vala_code_node_unref0 (m);
            m = _tmp13_;
            _tmp16_ = vala_member_access_get_inner (ma);
            if (_tmp16_ != NULL) {
                  ValaExpression* _tmp17_ = NULL;
                  ValaDataType* _tmp18_ = NULL;
                  _tmp17_ = vala_member_access_get_inner (ma);
                  _tmp18_ = vala_expression_get_value_type (_tmp17_);
                  _tmp15_ = VALA_IS_ENUM_VALUE_TYPE (_tmp18_);
            } else {
                  _tmp15_ = FALSE;
            }
            if (_tmp15_) {
                  ValaExpression* _tmp19_ = NULL;
                  ValaDataType* _tmp20_ = NULL;
                  ValaMethod* _tmp21_ = NULL;
                  ValaMethod* _tmp22_;
                  _tmp19_ = vala_member_access_get_inner (ma);
                  _tmp20_ = vala_expression_get_value_type (_tmp19_);
                  _tmp21_ = vala_enum_value_type_get_to_string_method (VALA_ENUM_VALUE_TYPE (_tmp20_));
                  _tmp22_ = _tmp21_;
                  _tmp14_ = _tmp22_ == m;
                  _vala_code_node_unref0 (_tmp22_);
            } else {
                  _tmp14_ = FALSE;
            }
            if (_tmp14_) {
                  ValaExpression* _tmp23_ = NULL;
                  ValaDataType* _tmp24_ = NULL;
                  ValaTypeSymbol* _tmp25_ = NULL;
                  ValaEnum* _tmp26_;
                  ValaEnum* en;
                  gchar* _tmp27_ = NULL;
                  gchar* _tmp28_;
                  ValaCCodeIdentifier* _tmp29_ = NULL;
                  ValaCCodeIdentifier* _tmp30_;
                  _tmp23_ = vala_member_access_get_inner (ma);
                  _tmp24_ = vala_expression_get_value_type (_tmp23_);
                  _tmp25_ = vala_data_type_get_data_type (_tmp24_);
                  _tmp26_ = _vala_code_node_ref0 (VALA_ENUM (_tmp25_));
                  en = _tmp26_;
                  _tmp27_ = vala_ccode_method_call_module_generate_enum_tostring_function (self, en);
                  _tmp28_ = _tmp27_;
                  _tmp29_ = vala_ccode_identifier_new (_tmp28_);
                  _tmp30_ = _tmp29_;
                  vala_ccode_function_call_set_call (ccall, (ValaCCodeExpression*) _tmp30_);
                  _vala_ccode_node_unref0 (_tmp30_);
                  _g_free0 (_tmp28_);
                  _vala_code_node_unref0 (en);
            }
      } else {
            if (VALA_IS_SIGNAL_TYPE (itype)) {
                  ValaSignalType* _tmp31_;
                  ValaSignalType* sig_type;
                  gboolean _tmp32_ = FALSE;
                  gboolean _tmp33_ = FALSE;
                  _tmp31_ = _vala_code_node_ref0 (VALA_SIGNAL_TYPE (itype));
                  sig_type = _tmp31_;
                  if (ma != NULL) {
                        ValaExpression* _tmp34_ = NULL;
                        _tmp34_ = vala_member_access_get_inner (ma);
                        _tmp33_ = VALA_IS_BASE_ACCESS (_tmp34_);
                  } else {
                        _tmp33_ = FALSE;
                  }
                  if (_tmp33_) {
                        ValaSignal* _tmp35_ = NULL;
                        gboolean _tmp36_;
                        _tmp35_ = vala_signal_type_get_signal_symbol (sig_type);
                        _tmp36_ = vala_signal_get_is_virtual (_tmp35_);
                        _tmp32_ = _tmp36_;
                  } else {
                        _tmp32_ = FALSE;
                  }
                  if (_tmp32_) {
                        ValaSignal* _tmp37_ = NULL;
                        ValaMethod* _tmp38_ = NULL;
                        ValaMethod* _tmp39_;
                        _tmp37_ = vala_signal_type_get_signal_symbol (sig_type);
                        _tmp38_ = vala_signal_get_default_handler (_tmp37_);
                        _tmp39_ = _vala_code_node_ref0 (_tmp38_);
                        _vala_code_node_unref0 (m);
                        m = _tmp39_;
                  } else {
                        ValaExpression* _tmp40_ = NULL;
                        ValaCCodeExpression* _tmp41_ = NULL;
                        _tmp40_ = vala_method_call_get_call (expr);
                        _tmp41_ = vala_ccode_base_module_get_cvalue ((ValaCCodeBaseModule*) self, _tmp40_);
                        _vala_ccode_node_unref0 (ccall);
                        ccall = VALA_CCODE_FUNCTION_CALL (_tmp41_);
                  }
                  _vala_code_node_unref0 (sig_type);
            } else {
                  if (VALA_IS_OBJECT_TYPE (itype)) {
                        ValaObjectTypeSymbol* _tmp42_ = NULL;
                        ValaClass* _tmp43_;
                        ValaClass* cl;
                        ValaMethod* _tmp44_ = NULL;
                        ValaMethod* _tmp45_;
                        gchar* _tmp46_ = NULL;
                        gchar* _tmp47_;
                        ValaCCodeIdentifier* _tmp48_ = NULL;
                        ValaCCodeIdentifier* _tmp49_;
                        ValaCCodeFunctionCall* _tmp50_ = NULL;
                        _tmp42_ = vala_object_type_get_type_symbol (VALA_OBJECT_TYPE (itype));
                        _tmp43_ = _vala_code_node_ref0 (VALA_CLASS (_tmp42_));
                        cl = _tmp43_;
                        _tmp44_ = vala_class_get_default_construction_method (cl);
                        _tmp45_ = _vala_code_node_ref0 (_tmp44_);
                        _vala_code_node_unref0 (m);
                        m = _tmp45_;
                        vala_ccode_base_module_generate_method_declaration ((ValaCCodeBaseModule*) self, m, ((ValaCCodeBaseModule*) self)->cfile);
                        _tmp46_ = vala_method_get_real_cname (m);
                        _tmp47_ = _tmp46_;
                        _tmp48_ = vala_ccode_identifier_new (_tmp47_);
                        _tmp49_ = _tmp48_;
                        _tmp50_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp49_);
                        _vala_ccode_node_unref0 (ccall);
                        ccall = _tmp50_;
                        _vala_ccode_node_unref0 (_tmp49_);
                        _g_free0 (_tmp47_);
                        _vala_code_node_unref0 (cl);
                  } else {
                        if (VALA_IS_STRUCT_VALUE_TYPE (itype)) {
                              ValaTypeSymbol* _tmp51_ = NULL;
                              ValaStruct* _tmp52_;
                              ValaStruct* st;
                              ValaMethod* _tmp53_ = NULL;
                              ValaMethod* _tmp54_;
                              gchar* _tmp55_ = NULL;
                              gchar* _tmp56_;
                              ValaCCodeIdentifier* _tmp57_ = NULL;
                              ValaCCodeIdentifier* _tmp58_;
                              ValaCCodeFunctionCall* _tmp59_ = NULL;
                              _tmp51_ = vala_value_type_get_type_symbol ((ValaValueType*) VALA_STRUCT_VALUE_TYPE (itype));
                              _tmp52_ = _vala_code_node_ref0 (VALA_STRUCT (_tmp51_));
                              st = _tmp52_;
                              _tmp53_ = vala_struct_get_default_construction_method (st);
                              _tmp54_ = _vala_code_node_ref0 (_tmp53_);
                              _vala_code_node_unref0 (m);
                              m = _tmp54_;
                              vala_ccode_base_module_generate_method_declaration ((ValaCCodeBaseModule*) self, m, ((ValaCCodeBaseModule*) self)->cfile);
                              _tmp55_ = vala_method_get_real_cname (m);
                              _tmp56_ = _tmp55_;
                              _tmp57_ = vala_ccode_identifier_new (_tmp56_);
                              _tmp58_ = _tmp57_;
                              _tmp59_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp58_);
                              _vala_ccode_node_unref0 (ccall);
                              ccall = _tmp59_;
                              _vala_ccode_node_unref0 (_tmp58_);
                              _g_free0 (_tmp56_);
                              _vala_code_node_unref0 (st);
                        } else {
                              if (VALA_IS_DELEGATE_TYPE (itype)) {
                                    ValaDelegate* _tmp60_ = NULL;
                                    ValaDelegate* _tmp61_;
                                    _tmp60_ = vala_delegate_type_get_delegate_symbol (VALA_DELEGATE_TYPE (itype));
                                    _tmp61_ = _vala_code_node_ref0 (_tmp60_);
                                    _vala_code_node_unref0 (deleg);
                                    deleg = _tmp61_;
                              }
                        }
                  }
            }
      }
      _tmp62_ = vala_hash_map_new (G_TYPE_INT, NULL, NULL, VALA_TYPE_CCODE_EXPRESSION, (GBoxedCopyFunc) vala_ccode_node_ref, vala_ccode_node_unref, g_direct_hash, g_direct_equal, g_direct_equal);
      in_arg_map = _tmp62_;
      _tmp63_ = _vala_map_ref0 (in_arg_map);
      out_arg_map = _tmp63_;
      if (m != NULL) {
            gboolean _tmp65_;
            _tmp65_ = vala_method_get_coroutine (m);
            _tmp64_ = _tmp65_;
      } else {
            _tmp64_ = FALSE;
      }
      if (_tmp64_) {
            gchar* _tmp66_ = NULL;
            gchar* _tmp67_;
            ValaCCodeIdentifier* _tmp68_ = NULL;
            ValaCCodeIdentifier* _tmp69_;
            ValaCCodeFunctionCall* _tmp70_ = NULL;
            gchar* _tmp71_ = NULL;
            gchar* _tmp72_;
            ValaCCodeIdentifier* _tmp73_ = NULL;
            ValaCCodeIdentifier* _tmp74_;
            ValaCCodeFunctionCall* _tmp75_ = NULL;
            ValaCCodeFunctionCall* _tmp76_;
            ValaCCodeFunctionCall* finish_call;
            ValaExpression* _tmp77_ = NULL;
            gboolean _tmp126_ = FALSE;
            const gchar* _tmp127_ = NULL;
            _tmp66_ = vala_method_get_cname (m);
            _tmp67_ = _tmp66_;
            _tmp68_ = vala_ccode_identifier_new (_tmp67_);
            _tmp69_ = _tmp68_;
            _tmp70_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp69_);
            _vala_ccode_node_unref0 (async_call);
            async_call = _tmp70_;
            _vala_ccode_node_unref0 (_tmp69_);
            _g_free0 (_tmp67_);
            _tmp71_ = vala_method_get_finish_cname (m);
            _tmp72_ = _tmp71_;
            _tmp73_ = vala_ccode_identifier_new (_tmp72_);
            _tmp74_ = _tmp73_;
            _tmp75_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp74_);
            _tmp76_ = _tmp75_;
            _vala_ccode_node_unref0 (_tmp74_);
            _g_free0 (_tmp72_);
            finish_call = _tmp76_;
            _tmp77_ = vala_member_access_get_inner (ma);
            if (VALA_IS_BASE_ACCESS (_tmp77_)) {
                  ValaMethod* _tmp78_ = NULL;
                  _tmp78_ = vala_method_get_base_method (m);
                  if (_tmp78_ != NULL) {
                        ValaMethod* _tmp79_ = NULL;
                        ValaSymbol* _tmp80_ = NULL;
                        ValaClass* _tmp81_;
                        ValaClass* base_class;
                        gchar* _tmp82_ = NULL;
                        gchar* _tmp83_;
                        gchar* _tmp84_ = NULL;
                        gchar* _tmp85_;
                        ValaCCodeIdentifier* _tmp86_ = NULL;
                        ValaCCodeIdentifier* _tmp87_;
                        ValaCCodeFunctionCall* _tmp88_ = NULL;
                        ValaCCodeFunctionCall* _tmp89_;
                        ValaCCodeFunctionCall* vcast;
                        ValaClass* _tmp90_ = NULL;
                        gchar* _tmp91_ = NULL;
                        gchar* _tmp92_;
                        gchar* _tmp93_ = NULL;
                        gchar* _tmp94_;
                        ValaCCodeIdentifier* _tmp95_ = NULL;
                        ValaCCodeIdentifier* _tmp96_;
                        const gchar* _tmp97_ = NULL;
                        ValaCCodeMemberAccess* _tmp98_ = NULL;
                        ValaCCodeMemberAccess* _tmp99_;
                        gchar* _tmp100_ = NULL;
                        gchar* _tmp101_;
                        ValaCCodeMemberAccess* _tmp102_ = NULL;
                        ValaCCodeMemberAccess* _tmp103_;
                        _tmp79_ = vala_method_get_base_method (m);
                        _tmp80_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp79_);
                        _tmp81_ = _vala_code_node_ref0 (VALA_CLASS (_tmp80_));
                        base_class = _tmp81_;
                        _tmp82_ = vala_typesymbol_get_upper_case_cname ((ValaTypeSymbol*) base_class, NULL);
                        _tmp83_ = _tmp82_;
                        _tmp84_ = g_strdup_printf ("%s_CLASS", _tmp83_);
                        _tmp85_ = _tmp84_;
                        _tmp86_ = vala_ccode_identifier_new (_tmp85_);
                        _tmp87_ = _tmp86_;
                        _tmp88_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp87_);
                        _tmp89_ = _tmp88_;
                        _vala_ccode_node_unref0 (_tmp87_);
                        _g_free0 (_tmp85_);
                        _g_free0 (_tmp83_);
                        vcast = _tmp89_;
                        _tmp90_ = vala_ccode_base_module_get_current_class ((ValaCCodeBaseModule*) self);
                        _tmp91_ = vala_symbol_get_lower_case_cname ((ValaSymbol*) _tmp90_, NULL);
                        _tmp92_ = _tmp91_;
                        _tmp93_ = g_strdup_printf ("%s_parent_class", _tmp92_);
                        _tmp94_ = _tmp93_;
                        _tmp95_ = vala_ccode_identifier_new (_tmp94_);
                        _tmp96_ = _tmp95_;
                        vala_ccode_function_call_add_argument (vcast, (ValaCCodeExpression*) _tmp96_);
                        _vala_ccode_node_unref0 (_tmp96_);
                        _g_free0 (_tmp94_);
                        _g_free0 (_tmp92_);
                        _tmp97_ = vala_method_get_vfunc_name (m);
                        _tmp98_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) vcast, _tmp97_);
                        _tmp99_ = _tmp98_;
                        vala_ccode_function_call_set_call (async_call, (ValaCCodeExpression*) _tmp99_);
                        _vala_ccode_node_unref0 (_tmp99_);
                        _tmp100_ = vala_method_get_finish_vfunc_name (m);
                        _tmp101_ = _tmp100_;
                        _tmp102_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) vcast, _tmp101_);
                        _tmp103_ = _tmp102_;
                        vala_ccode_function_call_set_call (finish_call, (ValaCCodeExpression*) _tmp103_);
                        _vala_ccode_node_unref0 (_tmp103_);
                        _g_free0 (_tmp101_);
                        _vala_ccode_node_unref0 (vcast);
                        _vala_code_node_unref0 (base_class);
                  } else {
                        ValaMethod* _tmp104_ = NULL;
                        _tmp104_ = vala_method_get_base_interface_method (m);
                        if (_tmp104_ != NULL) {
                              ValaMethod* _tmp105_ = NULL;
                              ValaSymbol* _tmp106_ = NULL;
                              ValaInterface* _tmp107_;
                              ValaInterface* base_iface;
                              ValaClass* _tmp108_ = NULL;
                              gchar* _tmp109_ = NULL;
                              gchar* _tmp110_;
                              gchar* _tmp111_ = NULL;
                              gchar* _tmp112_;
                              gchar* _tmp113_ = NULL;
                              gchar* _tmp114_;
                              gchar* parent_iface_var;
                              ValaCCodeIdentifier* _tmp115_ = NULL;
                              ValaCCodeIdentifier* _tmp116_;
                              const gchar* _tmp117_ = NULL;
                              ValaCCodeMemberAccess* _tmp118_ = NULL;
                              ValaCCodeMemberAccess* _tmp119_;
                              ValaCCodeIdentifier* _tmp120_ = NULL;
                              ValaCCodeIdentifier* _tmp121_;
                              gchar* _tmp122_ = NULL;
                              gchar* _tmp123_;
                              ValaCCodeMemberAccess* _tmp124_ = NULL;
                              ValaCCodeMemberAccess* _tmp125_;
                              _tmp105_ = vala_method_get_base_interface_method (m);
                              _tmp106_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp105_);
                              _tmp107_ = _vala_code_node_ref0 (VALA_INTERFACE (_tmp106_));
                              base_iface = _tmp107_;
                              _tmp108_ = vala_ccode_base_module_get_current_class ((ValaCCodeBaseModule*) self);
                              _tmp109_ = vala_symbol_get_lower_case_cname ((ValaSymbol*) _tmp108_, NULL);
                              _tmp110_ = _tmp109_;
                              _tmp111_ = vala_symbol_get_lower_case_cname ((ValaSymbol*) base_iface, NULL);
                              _tmp112_ = _tmp111_;
                              _tmp113_ = g_strdup_printf ("%s_%s_parent_iface", _tmp110_, _tmp112_);
                              _tmp114_ = _tmp113_;
                              _g_free0 (_tmp112_);
                              _g_free0 (_tmp110_);
                              parent_iface_var = _tmp114_;
                              _tmp115_ = vala_ccode_identifier_new (parent_iface_var);
                              _tmp116_ = _tmp115_;
                              _tmp117_ = vala_method_get_vfunc_name (m);
                              _tmp118_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp116_, _tmp117_);
                              _tmp119_ = _tmp118_;
                              vala_ccode_function_call_set_call (async_call, (ValaCCodeExpression*) _tmp119_);
                              _vala_ccode_node_unref0 (_tmp119_);
                              _vala_ccode_node_unref0 (_tmp116_);
                              _tmp120_ = vala_ccode_identifier_new (parent_iface_var);
                              _tmp121_ = _tmp120_;
                              _tmp122_ = vala_method_get_finish_vfunc_name (m);
                              _tmp123_ = _tmp122_;
                              _tmp124_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp121_, _tmp123_);
                              _tmp125_ = _tmp124_;
                              vala_ccode_function_call_set_call (finish_call, (ValaCCodeExpression*) _tmp125_);
                              _vala_ccode_node_unref0 (_tmp125_);
                              _g_free0 (_tmp123_);
                              _vala_ccode_node_unref0 (_tmp121_);
                              _g_free0 (parent_iface_var);
                              _vala_code_node_unref0 (base_iface);
                        }
                  }
            }
            _tmp127_ = vala_member_access_get_member_name (ma);
            if (g_strcmp0 (_tmp127_, "begin") == 0) {
                  ValaExpression* _tmp128_ = NULL;
                  ValaSymbol* _tmp129_ = NULL;
                  ValaSymbol* _tmp130_ = NULL;
                  _tmp128_ = vala_member_access_get_inner (ma);
                  _tmp129_ = vala_expression_get_symbol_reference (_tmp128_);
                  _tmp130_ = vala_expression_get_symbol_reference ((ValaExpression*) ma);
                  _tmp126_ = _tmp129_ == _tmp130_;
            } else {
                  _tmp126_ = FALSE;
            }
            if (_tmp126_) {
                  ValaCCodeFunctionCall* _tmp131_;
                  ValaList* _tmp132_ = NULL;
                  _tmp131_ = _vala_ccode_node_ref0 (async_call);
                  _vala_ccode_node_unref0 (ccall);
                  ccall = _tmp131_;
                  _tmp132_ = vala_method_get_async_begin_parameters (m);
                  _vala_iterable_unref0 (params);
                  params = _tmp132_;
            } else {
                  gboolean _tmp133_ = FALSE;
                  const gchar* _tmp134_ = NULL;
                  _tmp134_ = vala_member_access_get_member_name (ma);
                  if (g_strcmp0 (_tmp134_, "end") == 0) {
                        ValaExpression* _tmp135_ = NULL;
                        ValaSymbol* _tmp136_ = NULL;
                        ValaSymbol* _tmp137_ = NULL;
                        _tmp135_ = vala_member_access_get_inner (ma);
                        _tmp136_ = vala_expression_get_symbol_reference (_tmp135_);
                        _tmp137_ = vala_expression_get_symbol_reference ((ValaExpression*) ma);
                        _tmp133_ = _tmp136_ == _tmp137_;
                  } else {
                        _tmp133_ = FALSE;
                  }
                  if (_tmp133_) {
                        ValaCCodeFunctionCall* _tmp138_;
                        ValaList* _tmp139_ = NULL;
                        _tmp138_ = _vala_ccode_node_ref0 (finish_call);
                        _vala_ccode_node_unref0 (ccall);
                        ccall = _tmp138_;
                        _tmp139_ = vala_method_get_async_end_parameters (m);
                        _vala_iterable_unref0 (params);
                        params = _tmp139_;
                  } else {
                        gboolean _tmp140_;
                        _tmp140_ = vala_method_call_get_is_yield_expression (expr);
                        if (!_tmp140_) {
                              ValaCCodeFunctionCall* _tmp141_;
                              ValaList* _tmp142_ = NULL;
                              _tmp141_ = _vala_ccode_node_ref0 (async_call);
                              _vala_ccode_node_unref0 (ccall);
                              ccall = _tmp141_;
                              _tmp142_ = vala_method_get_async_begin_parameters (m);
                              _vala_iterable_unref0 (params);
                              params = _tmp142_;
                        } else {
                              ValaCCodeFunctionCall* _tmp143_;
                              ValaHashMap* _tmp144_ = NULL;
                              gint _tmp145_;
                              ValaCCodeIdentifier* _tmp146_ = NULL;
                              ValaCCodeIdentifier* _tmp147_;
                              ValaCCodeMemberAccess* _tmp148_ = NULL;
                              ValaCCodeMemberAccess* _tmp149_;
                              _tmp143_ = _vala_ccode_node_ref0 (finish_call);
                              _vala_ccode_node_unref0 (ccall);
                              ccall = _tmp143_;
                              _tmp144_ = vala_hash_map_new (G_TYPE_INT, NULL, NULL, VALA_TYPE_CCODE_EXPRESSION, (GBoxedCopyFunc) vala_ccode_node_ref, vala_ccode_node_unref, g_direct_hash, g_direct_equal, g_direct_equal);
                              _vala_map_unref0 (out_arg_map);
                              out_arg_map = _tmp144_;
                              _tmp145_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, 0.1, FALSE);
                              _tmp146_ = vala_ccode_identifier_new ("data");
                              _tmp147_ = _tmp146_;
                              _tmp148_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp147_, "_res_");
                              _tmp149_ = _tmp148_;
                              vala_map_set ((ValaMap*) out_arg_map, GINT_TO_POINTER (_tmp145_), (ValaCCodeExpression*) _tmp149_);
                              _vala_ccode_node_unref0 (_tmp149_);
                              _vala_ccode_node_unref0 (_tmp147_);
                        }
                  }
            }
            _vala_ccode_node_unref0 (finish_call);
      }
      if (VALA_IS_CREATION_METHOD (m)) {
            ValaSymbol* _tmp151_ = NULL;
            _tmp151_ = vala_symbol_get_parent_symbol ((ValaSymbol*) m);
            _tmp150_ = VALA_IS_CLASS (_tmp151_);
      } else {
            _tmp150_ = FALSE;
      }
      if (_tmp150_) {
            ValaCodeContext* _tmp152_ = NULL;
            ValaProfile _tmp153_;
            ValaClass* _tmp160_ = NULL;
            gboolean _tmp161_;
            _tmp152_ = vala_ccode_base_module_get_context ((ValaCCodeBaseModule*) self);
            _tmp153_ = vala_code_context_get_profile (_tmp152_);
            if (_tmp153_ == VALA_PROFILE_GOBJECT) {
                  ValaSymbol* _tmp154_ = NULL;
                  gboolean _tmp155_;
                  _tmp154_ = vala_symbol_get_parent_symbol ((ValaSymbol*) m);
                  _tmp155_ = vala_class_get_is_compact (VALA_CLASS (_tmp154_));
                  if (!_tmp155_) {
                        ValaCCodeIdentifier* _tmp156_ = NULL;
                        ValaCCodeIdentifier* _tmp157_;
                        _tmp156_ = vala_ccode_identifier_new ("object_type");
                        _tmp157_ = _tmp156_;
                        vala_ccode_function_call_add_argument (ccall, (ValaCCodeExpression*) _tmp157_);
                        _vala_ccode_node_unref0 (_tmp157_);
                  }
            } else {
                  ValaCCodeIdentifier* _tmp158_ = NULL;
                  ValaCCodeIdentifier* _tmp159_;
                  _tmp158_ = vala_ccode_identifier_new ("self");
                  _tmp159_ = _tmp158_;
                  vala_ccode_function_call_add_argument (ccall, (ValaCCodeExpression*) _tmp159_);
                  _vala_ccode_node_unref0 (_tmp159_);
            }
            _tmp160_ = vala_ccode_base_module_get_current_class ((ValaCCodeBaseModule*) self);
            _tmp161_ = vala_class_get_is_compact (_tmp160_);
            if (!_tmp161_) {
                  ValaClass* _tmp162_ = NULL;
                  ValaSymbol* _tmp163_ = NULL;
                  _tmp162_ = vala_ccode_base_module_get_current_class ((ValaCCodeBaseModule*) self);
                  _tmp163_ = vala_symbol_get_parent_symbol ((ValaSymbol*) m);
                  if (VALA_SYMBOL (_tmp162_) != _tmp163_) {
                        {
                              ValaClass* _tmp164_ = NULL;
                              ValaList* _tmp165_ = NULL;
                              ValaList* _base_type_list;
                              gint _tmp166_;
                              gint _base_type_size;
                              gint _base_type_index;
                              _tmp164_ = vala_ccode_base_module_get_current_class ((ValaCCodeBaseModule*) self);
                              _tmp165_ = vala_class_get_base_types (_tmp164_);
                              _base_type_list = _tmp165_;
                              _tmp166_ = vala_collection_get_size ((ValaCollection*) _base_type_list);
                              _base_type_size = _tmp166_;
                              _base_type_index = -1;
                              while (TRUE) {
                                    gpointer _tmp167_ = NULL;
                                    ValaDataType* base_type;
                                    ValaTypeSymbol* _tmp168_ = NULL;
                                    _base_type_index = _base_type_index + 1;
                                    if (!(_base_type_index < _base_type_size)) {
                                          break;
                                    }
                                    _tmp167_ = vala_list_get (_base_type_list, _base_type_index);
                                    base_type = (ValaDataType*) _tmp167_;
                                    _tmp168_ = vala_data_type_get_data_type (base_type);
                                    if (VALA_IS_CLASS (_tmp168_)) {
                                          ValaList* _tmp169_ = NULL;
                                          ValaList* _tmp170_;
                                          _tmp169_ = vala_data_type_get_type_arguments (base_type);
                                          _tmp170_ = _tmp169_;
                                          vala_ccode_base_module_add_generic_type_arguments ((ValaCCodeBaseModule*) self, (ValaMap*) in_arg_map, _tmp170_, (ValaCodeNode*) expr, TRUE);
                                          _vala_iterable_unref0 (_tmp170_);
                                          _vala_code_node_unref0 (base_type);
                                          break;
                                    }
                                    _vala_code_node_unref0 (base_type);
                              }
                              _vala_iterable_unref0 (_base_type_list);
                        }
                  } else {
                        gint type_param_index;
                        ValaSymbol* _tmp171_ = NULL;
                        ValaClass* _tmp172_;
                        ValaClass* cl;
                        type_param_index = 0;
                        _tmp171_ = vala_symbol_get_parent_symbol ((ValaSymbol*) m);
                        _tmp172_ = _vala_code_node_ref0 (VALA_CLASS (_tmp171_));
                        cl = _tmp172_;
                        {
                              ValaList* _tmp173_ = NULL;
                              ValaList* _type_param_list;
                              gint _tmp174_;
                              gint _type_param_size;
                              gint _type_param_index;
                              _tmp173_ = vala_object_type_symbol_get_type_parameters ((ValaObjectTypeSymbol*) cl);
                              _type_param_list = _tmp173_;
                              _tmp174_ = vala_collection_get_size ((ValaCollection*) _type_param_list);
                              _type_param_size = _tmp174_;
                              _type_param_index = -1;
                              while (TRUE) {
                                    gpointer _tmp175_ = NULL;
                                    ValaTypeParameter* type_param;
                                    gint _tmp176_;
                                    const gchar* _tmp177_ = NULL;
                                    gchar* _tmp178_ = NULL;
                                    gchar* _tmp179_;
                                    gchar* _tmp180_ = NULL;
                                    gchar* _tmp181_;
                                    ValaCCodeIdentifier* _tmp182_ = NULL;
                                    ValaCCodeIdentifier* _tmp183_;
                                    gint _tmp184_;
                                    const gchar* _tmp185_ = NULL;
                                    gchar* _tmp186_ = NULL;
                                    gchar* _tmp187_;
                                    gchar* _tmp188_ = NULL;
                                    gchar* _tmp189_;
                                    ValaCCodeIdentifier* _tmp190_ = NULL;
                                    ValaCCodeIdentifier* _tmp191_;
                                    gint _tmp192_;
                                    const gchar* _tmp193_ = NULL;
                                    gchar* _tmp194_ = NULL;
                                    gchar* _tmp195_;
                                    gchar* _tmp196_ = NULL;
                                    gchar* _tmp197_;
                                    ValaCCodeIdentifier* _tmp198_ = NULL;
                                    ValaCCodeIdentifier* _tmp199_;
                                    _type_param_index = _type_param_index + 1;
                                    if (!(_type_param_index < _type_param_size)) {
                                          break;
                                    }
                                    _tmp175_ = vala_list_get (_type_param_list, _type_param_index);
                                    type_param = (ValaTypeParameter*) _tmp175_;
                                    _tmp176_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, (0.1 * type_param_index) + 0.01, FALSE);
                                    _tmp177_ = vala_symbol_get_name ((ValaSymbol*) type_param);
                                    _tmp178_ = g_utf8_strdown (_tmp177_, (gssize) (-1));
                                    _tmp179_ = _tmp178_;
                                    _tmp180_ = g_strdup_printf ("%s_type", _tmp179_);
                                    _tmp181_ = _tmp180_;
                                    _tmp182_ = vala_ccode_identifier_new (_tmp181_);
                                    _tmp183_ = _tmp182_;
                                    vala_map_set ((ValaMap*) in_arg_map, GINT_TO_POINTER (_tmp176_), (ValaCCodeExpression*) _tmp183_);
                                    _vala_ccode_node_unref0 (_tmp183_);
                                    _g_free0 (_tmp181_);
                                    _g_free0 (_tmp179_);
                                    _tmp184_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, (0.1 * type_param_index) + 0.02, FALSE);
                                    _tmp185_ = vala_symbol_get_name ((ValaSymbol*) type_param);
                                    _tmp186_ = g_utf8_strdown (_tmp185_, (gssize) (-1));
                                    _tmp187_ = _tmp186_;
                                    _tmp188_ = g_strdup_printf ("%s_dup_func", _tmp187_);
                                    _tmp189_ = _tmp188_;
                                    _tmp190_ = vala_ccode_identifier_new (_tmp189_);
                                    _tmp191_ = _tmp190_;
                                    vala_map_set ((ValaMap*) in_arg_map, GINT_TO_POINTER (_tmp184_), (ValaCCodeExpression*) _tmp191_);
                                    _vala_ccode_node_unref0 (_tmp191_);
                                    _g_free0 (_tmp189_);
                                    _g_free0 (_tmp187_);
                                    _tmp192_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, (0.1 * type_param_index) + 0.03, FALSE);
                                    _tmp193_ = vala_symbol_get_name ((ValaSymbol*) type_param);
                                    _tmp194_ = g_utf8_strdown (_tmp193_, (gssize) (-1));
                                    _tmp195_ = _tmp194_;
                                    _tmp196_ = g_strdup_printf ("%s_destroy_func", _tmp195_);
                                    _tmp197_ = _tmp196_;
                                    _tmp198_ = vala_ccode_identifier_new (_tmp197_);
                                    _tmp199_ = _tmp198_;
                                    vala_map_set ((ValaMap*) in_arg_map, GINT_TO_POINTER (_tmp192_), (ValaCCodeExpression*) _tmp199_);
                                    _vala_ccode_node_unref0 (_tmp199_);
                                    _g_free0 (_tmp197_);
                                    _g_free0 (_tmp195_);
                                    type_param_index++;
                                    _vala_code_node_unref0 (type_param);
                              }
                              _vala_iterable_unref0 (_type_param_list);
                        }
                        _vala_code_node_unref0 (cl);
                  }
            }
      } else {
            gboolean _tmp200_ = FALSE;
            if (VALA_IS_CREATION_METHOD (m)) {
                  ValaSymbol* _tmp201_ = NULL;
                  _tmp201_ = vala_symbol_get_parent_symbol ((ValaSymbol*) m);
                  _tmp200_ = VALA_IS_STRUCT (_tmp201_);
            } else {
                  _tmp200_ = FALSE;
            }
            if (_tmp200_) {
                  ValaCCodeIdentifier* _tmp202_ = NULL;
                  ValaCCodeIdentifier* _tmp203_;
                  _tmp202_ = vala_ccode_identifier_new ("self");
                  _tmp203_ = _tmp202_;
                  vala_ccode_function_call_add_argument (ccall, (ValaCCodeExpression*) _tmp203_);
                  _vala_ccode_node_unref0 (_tmp203_);
            } else {
                  gboolean _tmp204_ = FALSE;
                  gboolean _tmp205_ = FALSE;
                  gboolean _tmp206_ = FALSE;
                  if (m != NULL) {
                        ValaList* _tmp207_ = NULL;
                        ValaList* _tmp208_;
                        gint _tmp209_;
                        _tmp207_ = vala_method_get_type_parameters (m);
                        _tmp208_ = _tmp207_;
                        _tmp209_ = vala_collection_get_size ((ValaCollection*) _tmp208_);
                        _tmp206_ = _tmp209_ > 0;
                        _vala_iterable_unref0 (_tmp208_);
                  } else {
                        _tmp206_ = FALSE;
                  }
                  if (_tmp206_) {
                        gboolean _tmp210_;
                        _tmp210_ = vala_method_get_has_generic_type_parameter (m);
                        _tmp205_ = !_tmp210_;
                  } else {
                        _tmp205_ = FALSE;
                  }
                  if (_tmp205_) {
                        gboolean _tmp211_;
                        _tmp211_ = vala_method_get_simple_generics (m);
                        _tmp204_ = !_tmp211_;
                  } else {
                        _tmp204_ = FALSE;
                  }
                  if (_tmp204_) {
                        ValaList* _tmp212_ = NULL;
                        ValaList* _tmp213_;
                        _tmp212_ = vala_member_access_get_type_arguments (ma);
                        _tmp213_ = _tmp212_;
                        vala_ccode_base_module_add_generic_type_arguments ((ValaCCodeBaseModule*) self, (ValaMap*) in_arg_map, _tmp213_, (ValaCodeNode*) expr, FALSE);
                        _vala_iterable_unref0 (_tmp213_);
                  }
            }
      }
      _tmp214_ = _vala_ccode_node_ref0 ((ValaCCodeExpression*) ccall);
      ccall_expr = _tmp214_;
      if (VALA_IS_ARRAY_RESIZE_METHOD (m)) {
            ValaExpression* _tmp215_ = NULL;
            ValaDataType* _tmp216_ = NULL;
            ValaArrayType* _tmp217_;
            ValaArrayType* array_type;
            gint _tmp218_;
            ValaDataType* _tmp219_ = NULL;
            gchar* _tmp220_ = NULL;
            gchar* _tmp221_;
            ValaCCodeIdentifier* _tmp222_ = NULL;
            ValaCCodeIdentifier* _tmp223_;
            _tmp215_ = vala_member_access_get_inner (ma);
            _tmp216_ = vala_expression_get_value_type (_tmp215_);
            _tmp217_ = _vala_code_node_ref0 (VALA_ARRAY_TYPE (_tmp216_));
            array_type = _tmp217_;
            _tmp218_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, (gdouble) 0, FALSE);
            _tmp219_ = vala_array_type_get_element_type (array_type);
            _tmp220_ = vala_data_type_get_cname (_tmp219_);
            _tmp221_ = _tmp220_;
            _tmp222_ = vala_ccode_identifier_new (_tmp221_);
            _tmp223_ = _tmp222_;
            vala_map_set ((ValaMap*) in_arg_map, GINT_TO_POINTER (_tmp218_), (ValaCCodeExpression*) _tmp223_);
            _vala_ccode_node_unref0 (_tmp223_);
            _g_free0 (_tmp221_);
            _vala_code_node_unref0 (array_type);
      } else {
            if (VALA_IS_ARRAY_MOVE_METHOD (m)) {
                  ((ValaCCodeBaseModule*) self)->requires_array_move = TRUE;
            }
      }
      instance = NULL;
      if (m != NULL) {
            gboolean _tmp225_;
            _tmp225_ = vala_method_get_is_async_callback (m);
            _tmp224_ = _tmp225_;
      } else {
            _tmp224_ = FALSE;
      }
      if (_tmp224_) {
            ValaMethod* _tmp226_ = NULL;
            gboolean _tmp227_;
            gdouble _tmp238_;
            gint _tmp239_;
            gdouble _tmp240_;
            gint _tmp241_;
            _tmp226_ = vala_ccode_base_module_get_current_method ((ValaCCodeBaseModule*) self);
            _tmp227_ = vala_method_get_closure (_tmp226_);
            if (_tmp227_) {
                  ValaSymbol* _tmp228_ = NULL;
                  ValaBlock* _tmp229_ = NULL;
                  ValaBlock* _tmp230_;
                  ValaBlock* block;
                  gint _tmp231_;
                  gchar* _tmp232_ = NULL;
                  gchar* _tmp233_;
                  ValaCCodeExpression* _tmp234_ = NULL;
                  ValaCCodeExpression* _tmp235_;
                  ValaCCodeMemberAccess* _tmp236_ = NULL;
                  _tmp228_ = vala_symbol_get_parent_symbol ((ValaSymbol*) m);
                  _tmp229_ = vala_subroutine_get_body ((ValaSubroutine*) VALA_METHOD (_tmp228_));
                  _tmp230_ = _vala_code_node_ref0 (_tmp229_);
                  block = _tmp230_;
                  _tmp231_ = vala_ccode_base_module_get_block_id ((ValaCCodeBaseModule*) self, block);
                  _tmp232_ = g_strdup_printf ("_data%d_", _tmp231_);
                  _tmp233_ = _tmp232_;
                  _tmp234_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, _tmp233_);
                  _tmp235_ = _tmp234_;
                  _tmp236_ = vala_ccode_member_access_new_pointer (_tmp235_, "_async_data_");
                  _vala_ccode_node_unref0 (instance);
                  instance = (ValaCCodeExpression*) _tmp236_;
                  _vala_ccode_node_unref0 (_tmp235_);
                  _g_free0 (_tmp233_);
                  _vala_code_node_unref0 (block);
            } else {
                  ValaCCodeIdentifier* _tmp237_ = NULL;
                  _tmp237_ = vala_ccode_identifier_new ("data");
                  _vala_ccode_node_unref0 (instance);
                  instance = (ValaCCodeExpression*) _tmp237_;
            }
            _tmp238_ = vala_method_get_cinstance_parameter_position (m);
            _tmp239_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, _tmp238_, FALSE);
            vala_map_set ((ValaMap*) in_arg_map, GINT_TO_POINTER (_tmp239_), instance);
            _tmp240_ = vala_method_get_cinstance_parameter_position (m);
            _tmp241_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, _tmp240_, FALSE);
            vala_map_set ((ValaMap*) out_arg_map, GINT_TO_POINTER (_tmp241_), instance);
      } else {
            gboolean _tmp242_ = FALSE;
            gboolean _tmp243_ = FALSE;
            if (m != NULL) {
                  ValaMemberBinding _tmp244_;
                  _tmp244_ = vala_method_get_binding (m);
                  _tmp243_ = _tmp244_ == VALA_MEMBER_BINDING_INSTANCE;
            } else {
                  _tmp243_ = FALSE;
            }
            if (_tmp243_) {
                  _tmp242_ = !VALA_IS_CREATION_METHOD (m);
            } else {
                  _tmp242_ = FALSE;
            }
            if (_tmp242_) {
                  ValaExpression* _tmp245_ = NULL;
                  ValaCCodeExpression* _tmp246_ = NULL;
                  gboolean _tmp247_ = FALSE;
                  gboolean _tmp248_ = FALSE;
                  const gchar* _tmp249_ = NULL;
                  ValaSymbol* _tmp258_ = NULL;
                  ValaSymbol* _tmp259_;
                  ValaStruct* _tmp260_;
                  ValaStruct* st;
                  gboolean _tmp261_ = FALSE;
                  gdouble _tmp282_;
                  gint _tmp283_;
                  gdouble _tmp284_;
                  gint _tmp285_;
                  _tmp245_ = vala_member_access_get_inner (ma);
                  _tmp246_ = vala_ccode_base_module_get_cvalue ((ValaCCodeBaseModule*) self, _tmp245_);
                  _vala_ccode_node_unref0 (instance);
                  instance = _tmp246_;
                  _tmp249_ = vala_member_access_get_member_name (ma);
                  if (g_strcmp0 (_tmp249_, "begin") == 0) {
                        _tmp248_ = TRUE;
                  } else {
                        const gchar* _tmp250_ = NULL;
                        _tmp250_ = vala_member_access_get_member_name (ma);
                        _tmp248_ = g_strcmp0 (_tmp250_, "end") == 0;
                  }
                  if (_tmp248_) {
                        ValaExpression* _tmp251_ = NULL;
                        ValaSymbol* _tmp252_ = NULL;
                        ValaSymbol* _tmp253_ = NULL;
                        _tmp251_ = vala_member_access_get_inner (ma);
                        _tmp252_ = vala_expression_get_symbol_reference (_tmp251_);
                        _tmp253_ = vala_expression_get_symbol_reference ((ValaExpression*) ma);
                        _tmp247_ = _tmp252_ == _tmp253_;
                  } else {
                        _tmp247_ = FALSE;
                  }
                  if (_tmp247_) {
                        ValaExpression* _tmp254_ = NULL;
                        ValaMemberAccess* _tmp255_;
                        ValaMemberAccess* inner_ma;
                        ValaExpression* _tmp256_ = NULL;
                        ValaCCodeExpression* _tmp257_ = NULL;
                        _tmp254_ = vala_member_access_get_inner (ma);
                        _tmp255_ = _vala_code_node_ref0 (VALA_MEMBER_ACCESS (_tmp254_));
                        inner_ma = _tmp255_;
                        _tmp256_ = vala_member_access_get_inner (inner_ma);
                        _tmp257_ = vala_ccode_base_module_get_cvalue ((ValaCCodeBaseModule*) self, _tmp256_);
                        _vala_ccode_node_unref0 (instance);
                        instance = _tmp257_;
                        _vala_code_node_unref0 (inner_ma);
                  }
                  _tmp258_ = vala_symbol_get_parent_symbol ((ValaSymbol*) m);
                  _tmp259_ = _tmp258_;
                  _tmp260_ = _vala_code_node_ref0 (VALA_IS_STRUCT (_tmp259_) ? ((ValaStruct*) _tmp259_) : NULL);
                  st = _tmp260_;
                  if (st != NULL) {
                        gboolean _tmp262_;
                        _tmp262_ = vala_struct_is_simple_type (st);
                        _tmp261_ = !_tmp262_;
                  } else {
                        _tmp261_ = FALSE;
                  }
                  if (_tmp261_) {
                        ValaCCodeExpression* _tmp263_;
                        ValaCCodeUnaryExpression* _tmp264_;
                        ValaCCodeUnaryExpression* unary;
                        gboolean _tmp265_ = FALSE;
                        _tmp263_ = instance;
                        _tmp264_ = _vala_ccode_node_ref0 (VALA_IS_CCODE_UNARY_EXPRESSION (_tmp263_) ? ((ValaCCodeUnaryExpression*) _tmp263_) : NULL);
                        unary = _tmp264_;
                        if (unary != NULL) {
                              ValaCCodeUnaryOperator _tmp266_;
                              _tmp266_ = vala_ccode_unary_expression_get_operator (unary);
                              _tmp265_ = _tmp266_ == VALA_CCODE_UNARY_OPERATOR_POINTER_INDIRECTION;
                        } else {
                              _tmp265_ = FALSE;
                        }
                        if (_tmp265_) {
                              ValaCCodeExpression* _tmp267_ = NULL;
                              ValaCCodeExpression* _tmp268_;
                              _tmp267_ = vala_ccode_unary_expression_get_inner (unary);
                              _tmp268_ = _vala_ccode_node_ref0 (_tmp267_);
                              _vala_ccode_node_unref0 (instance);
                              instance = _tmp268_;
                        } else {
                              gboolean _tmp269_ = FALSE;
                              if (VALA_IS_CCODE_IDENTIFIER (instance)) {
                                    _tmp269_ = TRUE;
                              } else {
                                    _tmp269_ = VALA_IS_CCODE_MEMBER_ACCESS (instance);
                              }
                              if (_tmp269_) {
                                    ValaCCodeUnaryExpression* _tmp270_ = NULL;
                                    _tmp270_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, instance);
                                    _vala_ccode_node_unref0 (instance);
                                    instance = (ValaCCodeExpression*) _tmp270_;
                              } else {
                                    ValaExpression* _tmp271_ = NULL;
                                    ValaDataType* _tmp272_ = NULL;
                                    ValaLocalVariable* _tmp273_ = NULL;
                                    ValaLocalVariable* temp_var;
                                    ValaCCodeFunction* _tmp274_ = NULL;
                                    const gchar* _tmp275_ = NULL;
                                    ValaCCodeExpression* _tmp276_ = NULL;
                                    ValaCCodeExpression* _tmp277_;
                                    const gchar* _tmp278_ = NULL;
                                    ValaCCodeExpression* _tmp279_ = NULL;
                                    ValaCCodeExpression* _tmp280_;
                                    ValaCCodeUnaryExpression* _tmp281_ = NULL;
                                    _tmp271_ = vala_member_access_get_inner (ma);
                                    _tmp272_ = vala_expression_get_target_type (_tmp271_);
                                    _tmp273_ = vala_ccode_base_module_get_temp_variable ((ValaCCodeBaseModule*) self, _tmp272_, TRUE, NULL, FALSE);
                                    temp_var = _tmp273_;
                                    vala_ccode_base_module_emit_temp_var ((ValaCCodeBaseModule*) self, temp_var, FALSE);
                                    _tmp274_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
                                    _tmp275_ = vala_symbol_get_name ((ValaSymbol*) temp_var);
                                    _tmp276_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, _tmp275_);
                                    _tmp277_ = _tmp276_;
                                    vala_ccode_function_add_assignment (_tmp274_, _tmp277_, instance);
                                    _vala_ccode_node_unref0 (_tmp277_);
                                    _tmp278_ = vala_symbol_get_name ((ValaSymbol*) temp_var);
                                    _tmp279_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, _tmp278_);
                                    _tmp280_ = _tmp279_;
                                    _tmp281_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, _tmp280_);
                                    _vala_ccode_node_unref0 (instance);
                                    instance = (ValaCCodeExpression*) _tmp281_;
                                    _vala_ccode_node_unref0 (_tmp280_);
                                    _vala_code_node_unref0 (temp_var);
                              }
                        }
                        _vala_ccode_node_unref0 (unary);
                  }
                  _tmp282_ = vala_method_get_cinstance_parameter_position (m);
                  _tmp283_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, _tmp282_, FALSE);
                  vala_map_set ((ValaMap*) in_arg_map, GINT_TO_POINTER (_tmp283_), instance);
                  _tmp284_ = vala_method_get_cinstance_parameter_position (m);
                  _tmp285_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, _tmp284_, FALSE);
                  vala_map_set ((ValaMap*) out_arg_map, GINT_TO_POINTER (_tmp285_), instance);
                  _vala_code_node_unref0 (st);
            } else {
                  gboolean _tmp286_ = FALSE;
                  if (m != NULL) {
                        ValaMemberBinding _tmp287_;
                        _tmp287_ = vala_method_get_binding (m);
                        _tmp286_ = _tmp287_ == VALA_MEMBER_BINDING_CLASS;
                  } else {
                        _tmp286_ = FALSE;
                  }
                  if (_tmp286_) {
                        ValaSymbol* _tmp288_ = NULL;
                        ValaClass* _tmp289_;
                        ValaClass* cl;
                        gchar* _tmp290_ = NULL;
                        gchar* _tmp291_;
                        gchar* _tmp292_;
                        gchar* _tmp293_;
                        ValaCCodeIdentifier* _tmp294_ = NULL;
                        ValaCCodeIdentifier* _tmp295_;
                        ValaCCodeFunctionCall* _tmp296_ = NULL;
                        ValaCCodeFunctionCall* _tmp297_;
                        ValaCCodeFunctionCall* cast;
                        ValaCCodeExpression* klass = NULL;
                        ValaExpression* _tmp298_ = NULL;
                        gdouble _tmp315_;
                        gint _tmp316_;
                        gdouble _tmp317_;
                        gint _tmp318_;
                        _tmp288_ = vala_symbol_get_parent_symbol ((ValaSymbol*) m);
                        _tmp289_ = _vala_code_node_ref0 (VALA_CLASS (_tmp288_));
                        cl = _tmp289_;
                        _tmp290_ = vala_typesymbol_get_upper_case_cname ((ValaTypeSymbol*) cl, NULL);
                        _tmp291_ = _tmp290_;
                        _tmp292_ = g_strconcat (_tmp291_, "_CLASS", NULL);
                        _tmp293_ = _tmp292_;
                        _tmp294_ = vala_ccode_identifier_new (_tmp293_);
                        _tmp295_ = _tmp294_;
                        _tmp296_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp295_);
                        _tmp297_ = _tmp296_;
                        _vala_ccode_node_unref0 (_tmp295_);
                        _g_free0 (_tmp293_);
                        _g_free0 (_tmp291_);
                        cast = _tmp297_;
                        _tmp298_ = vala_member_access_get_inner (ma);
                        if (_tmp298_ == NULL) {
                              if (((ValaCCodeBaseModule*) self)->in_static_or_class_context) {
                                    ValaCCodeIdentifier* _tmp299_ = NULL;
                                    _tmp299_ = vala_ccode_identifier_new ("klass");
                                    _vala_ccode_node_unref0 (klass);
                                    klass = (ValaCCodeExpression*) _tmp299_;
                              } else {
                                    ValaCCodeIdentifier* _tmp300_ = NULL;
                                    ValaCCodeIdentifier* _tmp301_;
                                    ValaCCodeFunctionCall* _tmp302_ = NULL;
                                    ValaCCodeFunctionCall* _tmp303_;
                                    ValaCCodeFunctionCall* k;
                                    ValaCCodeIdentifier* _tmp304_ = NULL;
                                    ValaCCodeIdentifier* _tmp305_;
                                    ValaCCodeExpression* _tmp306_;
                                    _tmp300_ = vala_ccode_identifier_new ("G_OBJECT_GET_CLASS");
                                    _tmp301_ = _tmp300_;
                                    _tmp302_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp301_);
                                    _tmp303_ = _tmp302_;
                                    _vala_ccode_node_unref0 (_tmp301_);
                                    k = _tmp303_;
                                    _tmp304_ = vala_ccode_identifier_new ("self");
                                    _tmp305_ = _tmp304_;
                                    vala_ccode_function_call_add_argument (k, (ValaCCodeExpression*) _tmp305_);
                                    _vala_ccode_node_unref0 (_tmp305_);
                                    _tmp306_ = _vala_ccode_node_ref0 ((ValaCCodeExpression*) k);
                                    _vala_ccode_node_unref0 (klass);
                                    klass = _tmp306_;
                                    _vala_ccode_node_unref0 (k);
                              }
                        } else {
                              ValaCCodeIdentifier* _tmp307_ = NULL;
                              ValaCCodeIdentifier* _tmp308_;
                              ValaCCodeFunctionCall* _tmp309_ = NULL;
                              ValaCCodeFunctionCall* _tmp310_;
                              ValaCCodeFunctionCall* k;
                              ValaExpression* _tmp311_ = NULL;
                              ValaCCodeExpression* _tmp312_ = NULL;
                              ValaCCodeExpression* _tmp313_;
                              ValaCCodeExpression* _tmp314_;
                              _tmp307_ = vala_ccode_identifier_new ("G_OBJECT_GET_CLASS");
                              _tmp308_ = _tmp307_;
                              _tmp309_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp308_);
                              _tmp310_ = _tmp309_;
                              _vala_ccode_node_unref0 (_tmp308_);
                              k = _tmp310_;
                              _tmp311_ = vala_member_access_get_inner (ma);
                              _tmp312_ = vala_ccode_base_module_get_cvalue ((ValaCCodeBaseModule*) self, _tmp311_);
                              _tmp313_ = _tmp312_;
                              vala_ccode_function_call_add_argument (k, _tmp313_);
                              _vala_ccode_node_unref0 (_tmp313_);
                              _tmp314_ = _vala_ccode_node_ref0 ((ValaCCodeExpression*) k);
                              _vala_ccode_node_unref0 (klass);
                              klass = _tmp314_;
                              _vala_ccode_node_unref0 (k);
                        }
                        vala_ccode_function_call_add_argument (cast, klass);
                        _tmp315_ = vala_method_get_cinstance_parameter_position (m);
                        _tmp316_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, _tmp315_, FALSE);
                        vala_map_set ((ValaMap*) in_arg_map, GINT_TO_POINTER (_tmp316_), (ValaCCodeExpression*) cast);
                        _tmp317_ = vala_method_get_cinstance_parameter_position (m);
                        _tmp318_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, _tmp317_, FALSE);
                        vala_map_set ((ValaMap*) out_arg_map, GINT_TO_POINTER (_tmp318_), (ValaCCodeExpression*) cast);
                        _vala_ccode_node_unref0 (klass);
                        _vala_ccode_node_unref0 (cast);
                        _vala_code_node_unref0 (cl);
                  }
            }
      }
      if (m != NULL) {
            gboolean _tmp320_;
            _tmp320_ = vala_method_get_has_generic_type_parameter (m);
            _tmp319_ = _tmp320_;
      } else {
            _tmp319_ = FALSE;
      }
      if (_tmp319_) {
            ValaList* _tmp321_ = NULL;
            ValaList* _tmp322_;
            gint _tmp323_;
            gboolean _tmp324_;
            _tmp321_ = vala_method_get_type_parameters (m);
            _tmp322_ = _tmp321_;
            _tmp323_ = vala_collection_get_size ((ValaCollection*) _tmp322_);
            _tmp324_ = _tmp323_ > 0;
            _vala_iterable_unref0 (_tmp322_);
            if (_tmp324_) {
                  gint type_param_index;
                  type_param_index = 0;
                  {
                        ValaList* _tmp325_ = NULL;
                        ValaList* _type_arg_list;
                        gint _tmp326_;
                        gint _type_arg_size;
                        gint _type_arg_index;
                        _tmp325_ = vala_member_access_get_type_arguments (ma);
                        _type_arg_list = _tmp325_;
                        _tmp326_ = vala_collection_get_size ((ValaCollection*) _type_arg_list);
                        _type_arg_size = _tmp326_;
                        _type_arg_index = -1;
                        while (TRUE) {
                              gpointer _tmp327_ = NULL;
                              ValaDataType* type_arg;
                              gdouble _tmp328_;
                              gint _tmp329_;
                              gchar* _tmp330_ = NULL;
                              gchar* _tmp331_;
                              ValaCCodeIdentifier* _tmp332_ = NULL;
                              ValaCCodeIdentifier* _tmp333_;
                              _type_arg_index = _type_arg_index + 1;
                              if (!(_type_arg_index < _type_arg_size)) {
                                    break;
                              }
                              _tmp327_ = vala_list_get (_type_arg_list, _type_arg_index);
                              type_arg = (ValaDataType*) _tmp327_;
                              _tmp328_ = vala_method_get_generic_type_parameter_position (m);
                              _tmp329_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, _tmp328_ + (0.01 * type_param_index), FALSE);
                              _tmp330_ = vala_data_type_get_cname (type_arg);
                              _tmp331_ = _tmp330_;
                              _tmp332_ = vala_ccode_identifier_new (_tmp331_);
                              _tmp333_ = _tmp332_;
                              vala_map_set ((ValaMap*) in_arg_map, GINT_TO_POINTER (_tmp329_), (ValaCCodeExpression*) _tmp333_);
                              _vala_ccode_node_unref0 (_tmp333_);
                              _g_free0 (_tmp331_);
                              type_param_index++;
                              _vala_code_node_unref0 (type_arg);
                        }
                        _vala_iterable_unref0 (_type_arg_list);
                  }
            } else {
                  gint type_param_index;
                  type_param_index = 0;
                  {
                        ValaExpression* _tmp334_ = NULL;
                        ValaDataType* _tmp335_ = NULL;
                        ValaList* _tmp336_ = NULL;
                        ValaList* _type_arg_list;
                        gint _tmp337_;
                        gint _type_arg_size;
                        gint _type_arg_index;
                        _tmp334_ = vala_member_access_get_inner (ma);
                        _tmp335_ = vala_expression_get_value_type (_tmp334_);
                        _tmp336_ = vala_data_type_get_type_arguments (_tmp335_);
                        _type_arg_list = _tmp336_;
                        _tmp337_ = vala_collection_get_size ((ValaCollection*) _type_arg_list);
                        _type_arg_size = _tmp337_;
                        _type_arg_index = -1;
                        while (TRUE) {
                              gpointer _tmp338_ = NULL;
                              ValaDataType* type_arg;
                              gdouble _tmp339_;
                              gint _tmp340_;
                              gchar* _tmp341_ = NULL;
                              gchar* _tmp342_;
                              ValaCCodeIdentifier* _tmp343_ = NULL;
                              ValaCCodeIdentifier* _tmp344_;
                              _type_arg_index = _type_arg_index + 1;
                              if (!(_type_arg_index < _type_arg_size)) {
                                    break;
                              }
                              _tmp338_ = vala_list_get (_type_arg_list, _type_arg_index);
                              type_arg = (ValaDataType*) _tmp338_;
                              _tmp339_ = vala_method_get_generic_type_parameter_position (m);
                              _tmp340_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, _tmp339_ + (0.01 * type_param_index), FALSE);
                              _tmp341_ = vala_data_type_get_cname (type_arg);
                              _tmp342_ = _tmp341_;
                              _tmp343_ = vala_ccode_identifier_new (_tmp342_);
                              _tmp344_ = _tmp343_;
                              vala_map_set ((ValaMap*) in_arg_map, GINT_TO_POINTER (_tmp340_), (ValaCCodeExpression*) _tmp344_);
                              _vala_ccode_node_unref0 (_tmp344_);
                              _g_free0 (_tmp342_);
                              type_param_index++;
                              _vala_code_node_unref0 (type_arg);
                        }
                        _vala_iterable_unref0 (_type_arg_list);
                  }
            }
      }
      if (VALA_IS_ARRAY_MOVE_METHOD (m)) {
            ValaExpression* _tmp345_ = NULL;
            ValaDataType* _tmp346_ = NULL;
            ValaArrayType* _tmp347_;
            ValaArrayType* array_type;
            ValaCCodeIdentifier* _tmp348_ = NULL;
            ValaCCodeIdentifier* _tmp349_;
            ValaCCodeFunctionCall* _tmp350_ = NULL;
            ValaCCodeFunctionCall* _tmp351_;
            ValaCCodeFunctionCall* csizeof;
            ValaDataType* _tmp352_ = NULL;
            gchar* _tmp353_ = NULL;
            gchar* _tmp354_;
            ValaCCodeIdentifier* _tmp355_ = NULL;
            ValaCCodeIdentifier* _tmp356_;
            gint _tmp357_;
            _tmp345_ = vala_member_access_get_inner (ma);
            _tmp346_ = vala_expression_get_value_type (_tmp345_);
            _tmp347_ = _vala_code_node_ref0 (VALA_ARRAY_TYPE (_tmp346_));
            array_type = _tmp347_;
            _tmp348_ = vala_ccode_identifier_new ("sizeof");
            _tmp349_ = _tmp348_;
            _tmp350_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp349_);
            _tmp351_ = _tmp350_;
            _vala_ccode_node_unref0 (_tmp349_);
            csizeof = _tmp351_;
            _tmp352_ = vala_array_type_get_element_type (array_type);
            _tmp353_ = vala_data_type_get_cname (_tmp352_);
            _tmp354_ = _tmp353_;
            _tmp355_ = vala_ccode_identifier_new (_tmp354_);
            _tmp356_ = _tmp355_;
            vala_ccode_function_call_add_argument (csizeof, (ValaCCodeExpression*) _tmp356_);
            _vala_ccode_node_unref0 (_tmp356_);
            _g_free0 (_tmp354_);
            _tmp357_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, 0.1, FALSE);
            vala_map_set ((ValaMap*) in_arg_map, GINT_TO_POINTER (_tmp357_), (ValaCCodeExpression*) csizeof);
            _vala_ccode_node_unref0 (csizeof);
            _vala_code_node_unref0 (array_type);
      } else {
            if (VALA_IS_DYNAMIC_METHOD (m)) {
                  gint param_nr;
                  vala_method_clear_parameters (m);
                  param_nr = 1;
                  {
                        ValaList* _tmp358_ = NULL;
                        ValaList* _arg_list;
                        gint _tmp359_;
                        gint _arg_size;
                        gint _arg_index;
                        _tmp358_ = vala_method_call_get_argument_list (expr);
                        _arg_list = _tmp358_;
                        _tmp359_ = vala_collection_get_size ((ValaCollection*) _arg_list);
                        _arg_size = _tmp359_;
                        _arg_index = -1;
                        while (TRUE) {
                              gpointer _tmp360_ = NULL;
                              ValaExpression* arg;
                              ValaExpression* _tmp361_;
                              ValaUnaryExpression* _tmp362_;
                              ValaUnaryExpression* unary;
                              gboolean _tmp363_ = FALSE;
                              _arg_index = _arg_index + 1;
                              if (!(_arg_index < _arg_size)) {
                                    break;
                              }
                              _tmp360_ = vala_list_get (_arg_list, _arg_index);
                              arg = (ValaExpression*) _tmp360_;
                              _tmp361_ = arg;
                              _tmp362_ = _vala_code_node_ref0 (VALA_IS_UNARY_EXPRESSION (_tmp361_) ? ((ValaUnaryExpression*) _tmp361_) : NULL);
                              unary = _tmp362_;
                              if (unary != NULL) {
                                    ValaUnaryOperator _tmp364_;
                                    _tmp364_ = vala_unary_expression_get_operator (unary);
                                    _tmp363_ = _tmp364_ == VALA_UNARY_OPERATOR_OUT;
                              } else {
                                    _tmp363_ = FALSE;
                              }
                              if (_tmp363_) {
                                    gchar* _tmp365_ = NULL;
                                    gchar* _tmp366_;
                                    ValaExpression* _tmp367_ = NULL;
                                    ValaDataType* _tmp368_ = NULL;
                                    ValaParameter* _tmp369_ = NULL;
                                    ValaParameter* _tmp370_;
                                    ValaParameter* param;
                                    _tmp365_ = g_strdup_printf ("param%d", param_nr);
                                    _tmp366_ = _tmp365_;
                                    _tmp367_ = vala_unary_expression_get_inner (unary);
                                    _tmp368_ = vala_expression_get_value_type (_tmp367_);
                                    _tmp369_ = vala_parameter_new (_tmp366_, _tmp368_, NULL);
                                    _tmp370_ = _tmp369_;
                                    _g_free0 (_tmp366_);
                                    param = _tmp370_;
                                    vala_parameter_set_direction (param, VALA_PARAMETER_DIRECTION_OUT);
                                    vala_method_add_parameter (m, param);
                                    _vala_code_node_unref0 (param);
                              } else {
                                    gboolean _tmp371_ = FALSE;
                                    if (unary != NULL) {
                                          ValaUnaryOperator _tmp372_;
                                          _tmp372_ = vala_unary_expression_get_operator (unary);
                                          _tmp371_ = _tmp372_ == VALA_UNARY_OPERATOR_REF;
                                    } else {
                                          _tmp371_ = FALSE;
                                    }
                                    if (_tmp371_) {
                                          gchar* _tmp373_ = NULL;
                                          gchar* _tmp374_;
                                          ValaExpression* _tmp375_ = NULL;
                                          ValaDataType* _tmp376_ = NULL;
                                          ValaParameter* _tmp377_ = NULL;
                                          ValaParameter* _tmp378_;
                                          ValaParameter* param;
                                          _tmp373_ = g_strdup_printf ("param%d", param_nr);
                                          _tmp374_ = _tmp373_;
                                          _tmp375_ = vala_unary_expression_get_inner (unary);
                                          _tmp376_ = vala_expression_get_value_type (_tmp375_);
                                          _tmp377_ = vala_parameter_new (_tmp374_, _tmp376_, NULL);
                                          _tmp378_ = _tmp377_;
                                          _g_free0 (_tmp374_);
                                          param = _tmp378_;
                                          vala_parameter_set_direction (param, VALA_PARAMETER_DIRECTION_REF);
                                          vala_method_add_parameter (m, param);
                                          _vala_code_node_unref0 (param);
                                    } else {
                                          gchar* _tmp379_ = NULL;
                                          gchar* _tmp380_;
                                          ValaDataType* _tmp381_ = NULL;
                                          ValaParameter* _tmp382_ = NULL;
                                          ValaParameter* _tmp383_;
                                          _tmp379_ = g_strdup_printf ("param%d", param_nr);
                                          _tmp380_ = _tmp379_;
                                          _tmp381_ = vala_expression_get_value_type (arg);
                                          _tmp382_ = vala_parameter_new (_tmp380_, _tmp381_, NULL);
                                          _tmp383_ = _tmp382_;
                                          vala_method_add_parameter (m, _tmp383_);
                                          _vala_code_node_unref0 (_tmp383_);
                                          _g_free0 (_tmp380_);
                                    }
                              }
                              param_nr++;
                              _vala_code_node_unref0 (unary);
                              _vala_code_node_unref0 (arg);
                        }
                        _vala_iterable_unref0 (_arg_list);
                  }
                  {
                        ValaList* _tmp384_ = NULL;
                        ValaList* _param_list;
                        gint _tmp385_;
                        gint _param_size;
                        gint _param_index;
                        _tmp384_ = vala_method_get_parameters (m);
                        _param_list = _tmp384_;
                        _tmp385_ = vala_collection_get_size ((ValaCollection*) _param_list);
                        _param_size = _tmp385_;
                        _param_index = -1;
                        while (TRUE) {
                              gpointer _tmp386_ = NULL;
                              ValaParameter* param;
                              _param_index = _param_index + 1;
                              if (!(_param_index < _param_size)) {
                                    break;
                              }
                              _tmp386_ = vala_list_get (_param_list, _param_index);
                              param = (ValaParameter*) _tmp386_;
                              vala_code_node_accept ((ValaCodeNode*) param, (ValaCodeVisitor*) self);
                              _vala_code_node_unref0 (param);
                        }
                        _vala_iterable_unref0 (_param_list);
                  }
                  vala_ccode_base_module_generate_dynamic_method_wrapper ((ValaCCodeBaseModule*) self, VALA_DYNAMIC_METHOD (m));
            } else {
                  gboolean _tmp387_ = FALSE;
                  gboolean _tmp388_ = FALSE;
                  if (VALA_IS_CREATION_METHOD (m)) {
                        ValaCodeContext* _tmp389_ = NULL;
                        ValaProfile _tmp390_;
                        _tmp389_ = vala_ccode_base_module_get_context ((ValaCCodeBaseModule*) self);
                        _tmp390_ = vala_code_context_get_profile (_tmp389_);
                        _tmp388_ = _tmp390_ == VALA_PROFILE_GOBJECT;
                  } else {
                        _tmp388_ = FALSE;
                  }
                  if (_tmp388_) {
                        ValaSymbol* _tmp391_ = NULL;
                        _tmp391_ = vala_symbol_get_parent_symbol ((ValaSymbol*) m);
                        _tmp387_ = VALA_IS_CLASS (_tmp391_);
                  } else {
                        _tmp387_ = FALSE;
                  }
                  if (_tmp387_) {
                        ValaCCodeFunction* _tmp392_ = NULL;
                        ValaCCodeIdentifier* _tmp393_ = NULL;
                        ValaCCodeIdentifier* _tmp394_;
                        ValaClass* _tmp395_ = NULL;
                        gchar* _tmp396_ = NULL;
                        gchar* _tmp397_;
                        gchar* _tmp398_;
                        gchar* _tmp399_;
                        ValaCCodeCastExpression* _tmp400_ = NULL;
                        ValaCCodeCastExpression* _tmp401_;
                        ValaMethod* _tmp402_ = NULL;
                        ValaBlock* _tmp403_ = NULL;
                        gboolean _tmp404_;
                        gboolean _tmp425_ = FALSE;
                        ValaClass* _tmp426_ = NULL;
                        gboolean _tmp427_;
                        _tmp392_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
                        _tmp393_ = vala_ccode_identifier_new ("self");
                        _tmp394_ = _tmp393_;
                        _tmp395_ = vala_ccode_base_module_get_current_class ((ValaCCodeBaseModule*) self);
                        _tmp396_ = vala_typesymbol_get_cname ((ValaTypeSymbol*) _tmp395_, FALSE);
                        _tmp397_ = _tmp396_;
                        _tmp398_ = g_strconcat (_tmp397_, "*", NULL);
                        _tmp399_ = _tmp398_;
                        _tmp400_ = vala_ccode_cast_expression_new ((ValaCCodeExpression*) ccall, _tmp399_);
                        _tmp401_ = _tmp400_;
                        vala_ccode_function_add_assignment (_tmp392_, (ValaCCodeExpression*) _tmp394_, (ValaCCodeExpression*) _tmp401_);
                        _vala_ccode_node_unref0 (_tmp401_);
                        _g_free0 (_tmp399_);
                        _g_free0 (_tmp397_);
                        _vala_ccode_node_unref0 (_tmp394_);
                        _tmp402_ = vala_ccode_base_module_get_current_method ((ValaCCodeBaseModule*) self);
                        _tmp403_ = vala_subroutine_get_body ((ValaSubroutine*) _tmp402_);
                        _tmp404_ = vala_block_get_captured (_tmp403_);
                        if (_tmp404_) {
                              ValaClass* _tmp405_ = NULL;
                              ValaObjectType* _tmp406_ = NULL;
                              ValaObjectType* _tmp407_;
                              ValaSourceReference* _tmp408_ = NULL;
                              ValaCCodeExpression* _tmp409_ = NULL;
                              ValaCCodeExpression* _tmp410_;
                              ValaCCodeFunctionCall* _tmp411_ = NULL;
                              ValaCCodeFunctionCall* _tmp412_;
                              ValaCCodeFunctionCall* ref_call;
                              ValaCCodeIdentifier* _tmp413_ = NULL;
                              ValaCCodeIdentifier* _tmp414_;
                              ValaCCodeFunction* _tmp415_ = NULL;
                              ValaMethod* _tmp416_ = NULL;
                              ValaBlock* _tmp417_ = NULL;
                              gint _tmp418_;
                              gchar* _tmp419_ = NULL;
                              gchar* _tmp420_;
                              ValaCCodeExpression* _tmp421_ = NULL;
                              ValaCCodeExpression* _tmp422_;
                              ValaCCodeMemberAccess* _tmp423_ = NULL;
                              ValaCCodeMemberAccess* _tmp424_;
                              _tmp405_ = vala_ccode_base_module_get_current_class ((ValaCCodeBaseModule*) self);
                              _tmp406_ = vala_object_type_new ((ValaObjectTypeSymbol*) _tmp405_);
                              _tmp407_ = _tmp406_;
                              _tmp408_ = vala_code_node_get_source_reference ((ValaCodeNode*) expr);
                              _tmp409_ = vala_ccode_base_module_get_dup_func_expression ((ValaCCodeBaseModule*) self, (ValaDataType*) _tmp407_, _tmp408_, FALSE);
                              _tmp410_ = _tmp409_;
                              _tmp411_ = vala_ccode_function_call_new (_tmp410_);
                              _tmp412_ = _tmp411_;
                              _vala_ccode_node_unref0 (_tmp410_);
                              _vala_code_node_unref0 (_tmp407_);
                              ref_call = _tmp412_;
                              _tmp413_ = vala_ccode_identifier_new ("self");
                              _tmp414_ = _tmp413_;
                              vala_ccode_function_call_add_argument (ref_call, (ValaCCodeExpression*) _tmp414_);
                              _vala_ccode_node_unref0 (_tmp414_);
                              _tmp415_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
                              _tmp416_ = vala_ccode_base_module_get_current_method ((ValaCCodeBaseModule*) self);
                              _tmp417_ = vala_subroutine_get_body ((ValaSubroutine*) _tmp416_);
                              _tmp418_ = vala_ccode_base_module_get_block_id ((ValaCCodeBaseModule*) self, _tmp417_);
                              _tmp419_ = g_strdup_printf ("_data%d_", _tmp418_);
                              _tmp420_ = _tmp419_;
                              _tmp421_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, _tmp420_);
                              _tmp422_ = _tmp421_;
                              _tmp423_ = vala_ccode_member_access_new_pointer (_tmp422_, "self");
                              _tmp424_ = _tmp423_;
                              vala_ccode_function_add_assignment (_tmp415_, (ValaCCodeExpression*) _tmp424_, (ValaCCodeExpression*) ref_call);
                              _vala_ccode_node_unref0 (_tmp424_);
                              _vala_ccode_node_unref0 (_tmp422_);
                              _g_free0 (_tmp420_);
                              _vala_ccode_node_unref0 (ref_call);
                        }
                        _tmp426_ = vala_ccode_base_module_get_current_class ((ValaCCodeBaseModule*) self);
                        _tmp427_ = vala_class_get_is_compact (_tmp426_);
                        if (!_tmp427_) {
                              ValaClass* _tmp428_ = NULL;
                              ValaList* _tmp429_ = NULL;
                              ValaList* _tmp430_;
                              gint _tmp431_;
                              _tmp428_ = vala_ccode_base_module_get_current_class ((ValaCCodeBaseModule*) self);
                              _tmp429_ = vala_object_type_symbol_get_type_parameters ((ValaObjectTypeSymbol*) _tmp428_);
                              _tmp430_ = _tmp429_;
                              _tmp431_ = vala_collection_get_size ((ValaCollection*) _tmp430_);
                              _tmp425_ = _tmp431_ > 0;
                              _vala_iterable_unref0 (_tmp430_);
                        } else {
                              _tmp425_ = FALSE;
                        }
                        if (_tmp425_) {
                              {
                                    ValaClass* _tmp432_ = NULL;
                                    ValaList* _tmp433_ = NULL;
                                    ValaList* _type_param_list;
                                    gint _tmp434_;
                                    gint _type_param_size;
                                    gint _type_param_index;
                                    _tmp432_ = vala_ccode_base_module_get_current_class ((ValaCCodeBaseModule*) self);
                                    _tmp433_ = vala_object_type_symbol_get_type_parameters ((ValaObjectTypeSymbol*) _tmp432_);
                                    _type_param_list = _tmp433_;
                                    _tmp434_ = vala_collection_get_size ((ValaCollection*) _type_param_list);
                                    _type_param_size = _tmp434_;
                                    _type_param_index = -1;
                                    while (TRUE) {
                                          gpointer _tmp435_ = NULL;
                                          ValaTypeParameter* type_param;
                                          ValaCCodeIdentifier* param_name = NULL;
                                          ValaCCodeIdentifier* _tmp436_ = NULL;
                                          ValaCCodeIdentifier* _tmp437_;
                                          ValaCCodeMemberAccess* _tmp438_ = NULL;
                                          ValaCCodeMemberAccess* _tmp439_;
                                          ValaCCodeMemberAccess* priv_access;
                                          const gchar* _tmp440_ = NULL;
                                          gchar* _tmp441_ = NULL;
                                          gchar* _tmp442_;
                                          gchar* _tmp443_ = NULL;
                                          gchar* _tmp444_;
                                          ValaCCodeIdentifier* _tmp445_ = NULL;
                                          ValaCCodeFunction* _tmp446_ = NULL;
                                          const gchar* _tmp447_ = NULL;
                                          ValaCCodeMemberAccess* _tmp448_ = NULL;
                                          ValaCCodeMemberAccess* _tmp449_;
                                          const gchar* _tmp450_ = NULL;
                                          gchar* _tmp451_ = NULL;
                                          gchar* _tmp452_;
                                          gchar* _tmp453_ = NULL;
                                          gchar* _tmp454_;
                                          ValaCCodeIdentifier* _tmp455_ = NULL;
                                          ValaCCodeFunction* _tmp456_ = NULL;
                                          const gchar* _tmp457_ = NULL;
                                          ValaCCodeMemberAccess* _tmp458_ = NULL;
                                          ValaCCodeMemberAccess* _tmp459_;
                                          const gchar* _tmp460_ = NULL;
                                          gchar* _tmp461_ = NULL;
                                          gchar* _tmp462_;
                                          gchar* _tmp463_ = NULL;
                                          gchar* _tmp464_;
                                          ValaCCodeIdentifier* _tmp465_ = NULL;
                                          ValaCCodeFunction* _tmp466_ = NULL;
                                          const gchar* _tmp467_ = NULL;
                                          ValaCCodeMemberAccess* _tmp468_ = NULL;
                                          ValaCCodeMemberAccess* _tmp469_;
                                          _type_param_index = _type_param_index + 1;
                                          if (!(_type_param_index < _type_param_size)) {
                                                break;
                                          }
                                          _tmp435_ = vala_list_get (_type_param_list, _type_param_index);
                                          type_param = (ValaTypeParameter*) _tmp435_;
                                          _tmp436_ = vala_ccode_identifier_new ("self");
                                          _tmp437_ = _tmp436_;
                                          _tmp438_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp437_, "priv");
                                          _tmp439_ = _tmp438_;
                                          _vala_ccode_node_unref0 (_tmp437_);
                                          priv_access = _tmp439_;
                                          _tmp440_ = vala_symbol_get_name ((ValaSymbol*) type_param);
                                          _tmp441_ = g_utf8_strdown (_tmp440_, (gssize) (-1));
                                          _tmp442_ = _tmp441_;
                                          _tmp443_ = g_strdup_printf ("%s_type", _tmp442_);
                                          _tmp444_ = _tmp443_;
                                          _tmp445_ = vala_ccode_identifier_new (_tmp444_);
                                          _vala_ccode_node_unref0 (param_name);
                                          param_name = _tmp445_;
                                          _g_free0 (_tmp444_);
                                          _g_free0 (_tmp442_);
                                          _tmp446_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
                                          _tmp447_ = vala_ccode_identifier_get_name (param_name);
                                          _tmp448_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) priv_access, _tmp447_);
                                          _tmp449_ = _tmp448_;
                                          vala_ccode_function_add_assignment (_tmp446_, (ValaCCodeExpression*) _tmp449_, (ValaCCodeExpression*) param_name);
                                          _vala_ccode_node_unref0 (_tmp449_);
                                          _tmp450_ = vala_symbol_get_name ((ValaSymbol*) type_param);
                                          _tmp451_ = g_utf8_strdown (_tmp450_, (gssize) (-1));
                                          _tmp452_ = _tmp451_;
                                          _tmp453_ = g_strdup_printf ("%s_dup_func", _tmp452_);
                                          _tmp454_ = _tmp453_;
                                          _tmp455_ = vala_ccode_identifier_new (_tmp454_);
                                          _vala_ccode_node_unref0 (param_name);
                                          param_name = _tmp455_;
                                          _g_free0 (_tmp454_);
                                          _g_free0 (_tmp452_);
                                          _tmp456_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
                                          _tmp457_ = vala_ccode_identifier_get_name (param_name);
                                          _tmp458_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) priv_access, _tmp457_);
                                          _tmp459_ = _tmp458_;
                                          vala_ccode_function_add_assignment (_tmp456_, (ValaCCodeExpression*) _tmp459_, (ValaCCodeExpression*) param_name);
                                          _vala_ccode_node_unref0 (_tmp459_);
                                          _tmp460_ = vala_symbol_get_name ((ValaSymbol*) type_param);
                                          _tmp461_ = g_utf8_strdown (_tmp460_, (gssize) (-1));
                                          _tmp462_ = _tmp461_;
                                          _tmp463_ = g_strdup_printf ("%s_destroy_func", _tmp462_);
                                          _tmp464_ = _tmp463_;
                                          _tmp465_ = vala_ccode_identifier_new (_tmp464_);
                                          _vala_ccode_node_unref0 (param_name);
                                          param_name = _tmp465_;
                                          _g_free0 (_tmp464_);
                                          _g_free0 (_tmp462_);
                                          _tmp466_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
                                          _tmp467_ = vala_ccode_identifier_get_name (param_name);
                                          _tmp468_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) priv_access, _tmp467_);
                                          _tmp469_ = _tmp468_;
                                          vala_ccode_function_add_assignment (_tmp466_, (ValaCCodeExpression*) _tmp469_, (ValaCCodeExpression*) param_name);
                                          _vala_ccode_node_unref0 (_tmp469_);
                                          _vala_ccode_node_unref0 (priv_access);
                                          _vala_ccode_node_unref0 (param_name);
                                          _vala_code_node_unref0 (type_param);
                                    }
                                    _vala_iterable_unref0 (_type_param_list);
                              }
                        }
                        _vala_ccode_node_unref0 (ccall_expr);
                        ccall_expr = NULL;
                  }
            }
      }
      ellipsis = FALSE;
      i = 1;
      _tmp470_ = vala_iterable_iterator ((ValaIterable*) params);
      params_it = _tmp470_;
      {
            ValaList* _tmp471_ = NULL;
            ValaList* _arg_list;
            gint _tmp472_;
            gint _arg_size;
            gint _arg_index;
            _tmp471_ = vala_method_call_get_argument_list (expr);
            _arg_list = _tmp471_;
            _tmp472_ = vala_collection_get_size ((ValaCollection*) _arg_list);
            _arg_size = _tmp472_;
            _arg_index = -1;
            while (TRUE) {
                  gpointer _tmp473_ = NULL;
                  ValaExpression* arg;
                  ValaCCodeExpression* _tmp474_ = NULL;
                  ValaCCodeExpression* cexpr;
                  ValaHashMap* _tmp475_;
                  ValaHashMap* carg_map;
                  gboolean _tmp476_;
                  gboolean _tmp631_ = FALSE;
                  _arg_index = _arg_index + 1;
                  if (!(_arg_index < _arg_size)) {
                        break;
                  }
                  _tmp473_ = vala_list_get (_arg_list, _arg_index);
                  arg = (ValaExpression*) _tmp473_;
                  _tmp474_ = vala_ccode_base_module_get_cvalue ((ValaCCodeBaseModule*) self, arg);
                  cexpr = _tmp474_;
                  _tmp475_ = _vala_map_ref0 (in_arg_map);
                  carg_map = _tmp475_;
                  _tmp476_ = vala_iterator_next (params_it);
                  if (_tmp476_) {
                        gpointer _tmp477_ = NULL;
                        ValaParameter* param;
                        gboolean _tmp478_ = FALSE;
                        gboolean _tmp479_;
                        gdouble _tmp627_;
                        gint _tmp628_;
                        _tmp477_ = vala_iterator_get (params_it);
                        param = (ValaParameter*) _tmp477_;
                        _tmp479_ = vala_parameter_get_params_array (param);
                        if (_tmp479_) {
                              _tmp478_ = TRUE;
                        } else {
                              gboolean _tmp480_;
                              _tmp480_ = vala_parameter_get_ellipsis (param);
                              _tmp478_ = _tmp480_;
                        }
                        ellipsis = _tmp478_;
                        if (!ellipsis) {
                              ValaParameterDirection _tmp481_;
                              ValaExpression* _tmp483_;
                              ValaUnaryExpression* _tmp484_;
                              ValaUnaryExpression* unary;
                              gboolean _tmp485_ = FALSE;
                              const gchar* _tmp623_ = NULL;
                              _tmp481_ = vala_parameter_get_direction (param);
                              if (_tmp481_ == VALA_PARAMETER_DIRECTION_OUT) {
                                    ValaHashMap* _tmp482_;
                                    _tmp482_ = _vala_map_ref0 (out_arg_map);
                                    _vala_map_unref0 (carg_map);
                                    carg_map = _tmp482_;
                              }
                              _tmp483_ = arg;
                              _tmp484_ = _vala_code_node_ref0 (VALA_IS_UNARY_EXPRESSION (_tmp483_) ? ((ValaUnaryExpression*) _tmp483_) : NULL);
                              unary = _tmp484_;
                              if (unary == NULL) {
                                    _tmp485_ = TRUE;
                              } else {
                                    ValaUnaryOperator _tmp486_;
                                    _tmp486_ = vala_unary_expression_get_operator (unary);
                                    _tmp485_ = _tmp486_ != VALA_UNARY_OPERATOR_OUT;
                              }
                              if (_tmp485_) {
                                    gboolean _tmp487_ = FALSE;
                                    gboolean _tmp488_;
                                    ValaCCodeExpression* _tmp558_ = NULL;
                                    _tmp488_ = vala_variable_get_no_array_length ((ValaVariable*) param);
                                    if (!_tmp488_) {
                                          ValaDataType* _tmp489_ = NULL;
                                          _tmp489_ = vala_variable_get_variable_type ((ValaVariable*) param);
                                          _tmp487_ = VALA_IS_ARRAY_TYPE (_tmp489_);
                                    } else {
                                          _tmp487_ = FALSE;
                                    }
                                    if (_tmp487_) {
                                          ValaDataType* _tmp490_ = NULL;
                                          ValaArrayType* _tmp491_;
                                          ValaArrayType* array_type;
                                          _tmp490_ = vala_variable_get_variable_type ((ValaVariable*) param);
                                          _tmp491_ = _vala_code_node_ref0 (VALA_ARRAY_TYPE (_tmp490_));
                                          array_type = _tmp491_;
                                          {
                                                gint dim;
                                                dim = 1;
                                                {
                                                      gboolean _tmp492_;
                                                      _tmp492_ = TRUE;
                                                      while (TRUE) {
                                                            gint _tmp493_;
                                                            ValaCCodeExpression* array_length_expr;
                                                            const gchar* _tmp494_ = NULL;
                                                            gdouble _tmp500_;
                                                            gint _tmp501_;
                                                            if (!_tmp492_) {
                                                                  dim++;
                                                            }
                                                            _tmp492_ = FALSE;
                                                            _tmp493_ = vala_array_type_get_rank (array_type);
                                                            if (!(dim <= _tmp493_)) {
                                                                  break;
                                                            }
                                                            array_length_expr = NULL;
                                                            _tmp494_ = vala_variable_get_array_length_type ((ValaVariable*) param);
                                                            if (_tmp494_ != NULL) {
                                                                  ValaCCodeExpression* _tmp495_ = NULL;
                                                                  ValaCCodeExpression* _tmp496_;
                                                                  const gchar* _tmp497_ = NULL;
                                                                  ValaCCodeCastExpression* _tmp498_ = NULL;
                                                                  _tmp495_ = vala_ccode_base_module_get_array_length_cexpression ((ValaCCodeBaseModule*) self, arg, dim);
                                                                  _tmp496_ = _tmp495_;
                                                                  _tmp497_ = vala_variable_get_array_length_type ((ValaVariable*) param);
                                                                  _tmp498_ = vala_ccode_cast_expression_new (_tmp496_, _tmp497_);
                                                                  _vala_ccode_node_unref0 (array_length_expr);
                                                                  array_length_expr = (ValaCCodeExpression*) _tmp498_;
                                                                  _vala_ccode_node_unref0 (_tmp496_);
                                                            } else {
                                                                  ValaCCodeExpression* _tmp499_ = NULL;
                                                                  _tmp499_ = vala_ccode_base_module_get_array_length_cexpression ((ValaCCodeBaseModule*) self, arg, dim);
                                                                  _vala_ccode_node_unref0 (array_length_expr);
                                                                  array_length_expr = _tmp499_;
                                                            }
                                                            _tmp500_ = vala_parameter_get_carray_length_parameter_position (param);
                                                            _tmp501_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, _tmp500_ + (0.01 * dim), FALSE);
                                                            vala_map_set ((ValaMap*) carg_map, GINT_TO_POINTER (_tmp501_), array_length_expr);
                                                            _vala_ccode_node_unref0 (array_length_expr);
                                                      }
                                                }
                                          }
                                          _vala_code_node_unref0 (array_type);
                                    } else {
                                          ValaDataType* _tmp502_ = NULL;
                                          _tmp502_ = vala_variable_get_variable_type ((ValaVariable*) param);
                                          if (VALA_IS_DELEGATE_TYPE (_tmp502_)) {
                                                ValaDataType* _tmp503_ = NULL;
                                                ValaDelegateType* _tmp504_;
                                                ValaDelegateType* deleg_type;
                                                ValaDelegate* _tmp505_ = NULL;
                                                ValaDelegate* _tmp506_;
                                                ValaDelegate* d;
                                                gboolean _tmp507_;
                                                _tmp503_ = vala_variable_get_variable_type ((ValaVariable*) param);
                                                _tmp504_ = _vala_code_node_ref0 (VALA_DELEGATE_TYPE (_tmp503_));
                                                deleg_type = _tmp504_;
                                                _tmp505_ = vala_delegate_type_get_delegate_symbol (deleg_type);
                                                _tmp506_ = _vala_code_node_ref0 (_tmp505_);
                                                d = _tmp506_;
                                                _tmp507_ = vala_delegate_get_has_target (d);
                                                if (_tmp507_) {
                                                      ValaCCodeExpression* delegate_target_destroy_notify = NULL;
                                                      ValaCCodeExpression* _tmp508_ = NULL;
                                                      ValaCCodeExpression* _tmp509_ = NULL;
                                                      ValaCCodeExpression* delegate_target;
                                                      const gchar* _tmp510_ = NULL;
                                                      _tmp509_ = vala_ccode_base_module_get_delegate_target_cexpression ((ValaCCodeBaseModule*) self, arg, &_tmp508_);
                                                      _vala_ccode_node_unref0 (delegate_target_destroy_notify);
                                                      delegate_target_destroy_notify = _tmp508_;
                                                      delegate_target = _tmp509_;
                                                      g_assert (delegate_target != NULL);
                                                      _tmp510_ = vala_parameter_get_ctype (param);
                                                      if (g_strcmp0 (_tmp510_, "GClosure*") == 0) {
                                                            ValaCCodeIdentifier* _tmp511_ = NULL;
                                                            ValaCCodeIdentifier* _tmp512_;
                                                            ValaCCodeFunctionCall* _tmp513_ = NULL;
                                                            ValaCCodeFunctionCall* _tmp514_;
                                                            ValaCCodeFunctionCall* closure_new;
                                                            ValaCCodeCastExpression* _tmp515_ = NULL;
                                                            ValaCCodeCastExpression* _tmp516_;
                                                            ValaCCodeIdentifier* _tmp517_ = NULL;
                                                            ValaCCodeIdentifier* _tmp518_;
                                                            ValaCCodeBinaryExpression* _tmp519_ = NULL;
                                                            ValaCCodeBinaryExpression* _tmp520_;
                                                            ValaCCodeIdentifier* _tmp521_ = NULL;
                                                            ValaCCodeIdentifier* _tmp522_;
                                                            ValaCCodeConditionalExpression* _tmp523_ = NULL;
                                                            _tmp511_ = vala_ccode_identifier_new ("g_cclosure_new");
                                                            _tmp512_ = _tmp511_;
                                                            _tmp513_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp512_);
                                                            _tmp514_ = _tmp513_;
                                                            _vala_ccode_node_unref0 (_tmp512_);
                                                            closure_new = _tmp514_;
                                                            _tmp515_ = vala_ccode_cast_expression_new (cexpr, "GCallback");
                                                            _tmp516_ = _tmp515_;
                                                            vala_ccode_function_call_add_argument (closure_new, (ValaCCodeExpression*) _tmp516_);
                                                            _vala_ccode_node_unref0 (_tmp516_);
                                                            vala_ccode_function_call_add_argument (closure_new, delegate_target);
                                                            vala_ccode_function_call_add_argument (closure_new, delegate_target_destroy_notify);
                                                            _tmp517_ = vala_ccode_identifier_new ("NULL");
                                                            _tmp518_ = _tmp517_;
                                                            _tmp519_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_EQUALITY, cexpr, (ValaCCodeExpression*) _tmp518_);
                                                            _tmp520_ = _tmp519_;
                                                            _tmp521_ = vala_ccode_identifier_new ("NULL");
                                                            _tmp522_ = _tmp521_;
                                                            _tmp523_ = vala_ccode_conditional_expression_new ((ValaCCodeExpression*) _tmp520_, (ValaCCodeExpression*) _tmp522_, (ValaCCodeExpression*) closure_new);
                                                            _vala_ccode_node_unref0 (cexpr);
                                                            cexpr = (ValaCCodeExpression*) _tmp523_;
                                                            _vala_ccode_node_unref0 (_tmp522_);
                                                            _vala_ccode_node_unref0 (_tmp520_);
                                                            _vala_ccode_node_unref0 (_tmp518_);
                                                            _vala_ccode_node_unref0 (closure_new);
                                                      } else {
                                                            gdouble _tmp524_;
                                                            gint _tmp525_;
                                                            gboolean _tmp526_;
                                                            _tmp524_ = vala_parameter_get_cdelegate_target_parameter_position (param);
                                                            _tmp525_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, _tmp524_, FALSE);
                                                            vala_map_set ((ValaMap*) carg_map, GINT_TO_POINTER (_tmp525_), delegate_target);
                                                            _tmp526_ = vala_data_type_get_value_owned ((ValaDataType*) deleg_type);
                                                            if (_tmp526_) {
                                                                  gdouble _tmp527_;
                                                                  gint _tmp528_;
                                                                  g_assert (delegate_target_destroy_notify != NULL);
                                                                  _tmp527_ = vala_parameter_get_cdelegate_target_parameter_position (param);
                                                                  _tmp528_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, _tmp527_ + 0.01, FALSE);
                                                                  vala_map_set ((ValaMap*) carg_map, GINT_TO_POINTER (_tmp528_), delegate_target_destroy_notify);
                                                            }
                                                      }
                                                      _vala_ccode_node_unref0 (delegate_target);
                                                      _vala_ccode_node_unref0 (delegate_target_destroy_notify);
                                                }
                                                _vala_code_node_unref0 (d);
                                                _vala_code_node_unref0 (deleg_type);
                                          } else {
                                                ValaDataType* _tmp529_ = NULL;
                                                _tmp529_ = vala_variable_get_variable_type ((ValaVariable*) param);
                                                if (VALA_IS_METHOD_TYPE (_tmp529_)) {
                                                      ValaCCodeExpression* delegate_target_destroy_notify = NULL;
                                                      gdouble _tmp530_;
                                                      gint _tmp531_;
                                                      ValaCCodeExpression* _tmp532_ = NULL;
                                                      ValaCCodeExpression* _tmp533_ = NULL;
                                                      ValaCCodeExpression* _tmp534_;
                                                      _tmp530_ = vala_parameter_get_cdelegate_target_parameter_position (param);
                                                      _tmp531_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, _tmp530_, FALSE);
                                                      _tmp533_ = vala_ccode_base_module_get_delegate_target_cexpression ((ValaCCodeBaseModule*) self, arg, &_tmp532_);
                                                      _vala_ccode_node_unref0 (delegate_target_destroy_notify);
                                                      delegate_target_destroy_notify = _tmp532_;
                                                      _tmp534_ = _tmp533_;
                                                      vala_map_set ((ValaMap*) carg_map, GINT_TO_POINTER (_tmp531_), _tmp534_);
                                                      _vala_ccode_node_unref0 (_tmp534_);
                                                      _vala_ccode_node_unref0 (delegate_target_destroy_notify);
                                                } else {
                                                      ValaDataType* _tmp535_ = NULL;
                                                      _tmp535_ = vala_variable_get_variable_type ((ValaVariable*) param);
                                                      if (VALA_IS_GENERIC_TYPE (_tmp535_)) {
                                                            gboolean _tmp536_ = FALSE;
                                                            if (m != NULL) {
                                                                  gboolean _tmp537_;
                                                                  _tmp537_ = vala_method_get_simple_generics (m);
                                                                  _tmp536_ = _tmp537_;
                                                            } else {
                                                                  _tmp536_ = FALSE;
                                                            }
                                                            if (_tmp536_) {
                                                                  ValaDataType* _tmp538_ = NULL;
                                                                  ValaGenericType* _tmp539_;
                                                                  ValaGenericType* generic_type;
                                                                  ValaTypeParameter* _tmp540_ = NULL;
                                                                  const gchar* _tmp541_ = NULL;
                                                                  gint _tmp542_;
                                                                  gint type_param_index;
                                                                  ValaList* _tmp543_ = NULL;
                                                                  ValaList* _tmp544_;
                                                                  gpointer _tmp545_ = NULL;
                                                                  ValaDataType* _tmp546_;
                                                                  ValaDataType* type_arg;
                                                                  ValaDataType* _tmp547_ = NULL;
                                                                  gboolean _tmp548_;
                                                                  _tmp538_ = vala_variable_get_variable_type ((ValaVariable*) param);
                                                                  _tmp539_ = _vala_code_node_ref0 (VALA_GENERIC_TYPE (_tmp538_));
                                                                  generic_type = _tmp539_;
                                                                  _tmp540_ = vala_data_type_get_type_parameter ((ValaDataType*) generic_type);
                                                                  _tmp541_ = vala_symbol_get_name ((ValaSymbol*) _tmp540_);
                                                                  _tmp542_ = vala_method_get_type_parameter_index (m, _tmp541_);
                                                                  type_param_index = _tmp542_;
                                                                  _tmp543_ = vala_member_access_get_type_arguments (ma);
                                                                  _tmp544_ = _tmp543_;
                                                                  _tmp545_ = vala_list_get (_tmp544_, type_param_index);
                                                                  _tmp546_ = (ValaDataType*) _tmp545_;
                                                                  _vala_iterable_unref0 (_tmp544_);
                                                                  type_arg = _tmp546_;
                                                                  _tmp547_ = vala_variable_get_variable_type ((ValaVariable*) param);
                                                                  _tmp548_ = vala_data_type_get_value_owned (_tmp547_);
                                                                  if (_tmp548_) {
                                                                        gboolean _tmp549_;
                                                                        _tmp549_ = vala_ccode_base_module_requires_copy ((ValaCCodeBaseModule*) self, type_arg);
                                                                        if (_tmp549_) {
                                                                              gdouble _tmp550_;
                                                                              gint _tmp551_;
                                                                              ValaCCodeExpression* _tmp552_ = NULL;
                                                                              ValaCCodeExpression* _tmp553_;
                                                                              _tmp550_ = vala_parameter_get_cdestroy_notify_parameter_position (param);
                                                                              _tmp551_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, _tmp550_, FALSE);
                                                                              _tmp552_ = vala_ccode_base_module_get_destroy_func_expression ((ValaCCodeBaseModule*) self, type_arg, FALSE);
                                                                              _tmp553_ = _tmp552_;
                                                                              vala_map_set ((ValaMap*) carg_map, GINT_TO_POINTER (_tmp551_), _tmp553_);
                                                                              _vala_ccode_node_unref0 (_tmp553_);
                                                                        } else {
                                                                              gdouble _tmp554_;
                                                                              gint _tmp555_;
                                                                              ValaCCodeConstant* _tmp556_ = NULL;
                                                                              ValaCCodeConstant* _tmp557_;
                                                                              _tmp554_ = vala_parameter_get_cdestroy_notify_parameter_position (param);
                                                                              _tmp555_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, _tmp554_, FALSE);
                                                                              _tmp556_ = vala_ccode_constant_new ("NULL");
                                                                              _tmp557_ = _tmp556_;
                                                                              vala_map_set ((ValaMap*) carg_map, GINT_TO_POINTER (_tmp555_), (ValaCCodeExpression*) _tmp557_);
                                                                              _vala_ccode_node_unref0 (_tmp557_);
                                                                        }
                                                                  }
                                                                  _vala_code_node_unref0 (type_arg);
                                                                  _vala_code_node_unref0 (generic_type);
                                                            }
                                                      }
                                                }
                                          }
                                    }
                                    _tmp558_ = vala_ccode_base_module_handle_struct_argument ((ValaCCodeBaseModule*) self, param, arg, cexpr);
                                    _vala_ccode_node_unref0 (cexpr);
                                    cexpr = _tmp558_;
                              } else {
                                    ValaDataType* _tmp559_ = NULL;
                                    ValaDataType* _tmp560_ = NULL;
                                    gboolean _tmp561_;
                                    ValaLocalVariable* _tmp562_ = NULL;
                                    ValaLocalVariable* temp_var;
                                    const gchar* _tmp563_ = NULL;
                                    ValaCCodeExpression* _tmp564_ = NULL;
                                    ValaCCodeExpression* _tmp565_;
                                    ValaCCodeExpression* _tmp566_ = NULL;
                                    ValaCCodeExpression* _tmp567_;
                                    ValaCCodeUnaryExpression* _tmp568_ = NULL;
                                    gboolean _tmp569_ = FALSE;
                                    gboolean _tmp570_;
                                    vala_expression_set_target_value (arg, NULL);
                                    _tmp559_ = vala_variable_get_variable_type ((ValaVariable*) param);
                                    _tmp560_ = vala_variable_get_variable_type ((ValaVariable*) param);
                                    _tmp561_ = vala_data_type_get_value_owned (_tmp560_);
                                    _tmp562_ = vala_ccode_base_module_get_temp_variable ((ValaCCodeBaseModule*) self, _tmp559_, _tmp561_, NULL, TRUE);
                                    temp_var = _tmp562_;
                                    vala_ccode_base_module_emit_temp_var ((ValaCCodeBaseModule*) self, temp_var, FALSE);
                                    _tmp563_ = vala_symbol_get_name ((ValaSymbol*) temp_var);
                                    _tmp564_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, _tmp563_);
                                    _tmp565_ = _tmp564_;
                                    vala_ccode_base_module_set_cvalue ((ValaCCodeBaseModule*) self, arg, _tmp565_);
                                    _vala_ccode_node_unref0 (_tmp565_);
                                    _tmp566_ = vala_ccode_base_module_get_cvalue ((ValaCCodeBaseModule*) self, arg);
                                    _tmp567_ = _tmp566_;
                                    _tmp568_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, _tmp567_);
                                    _vala_ccode_node_unref0 (cexpr);
                                    cexpr = (ValaCCodeExpression*) _tmp568_;
                                    _vala_ccode_node_unref0 (_tmp567_);
                                    _tmp570_ = vala_variable_get_no_array_length ((ValaVariable*) param);
                                    if (!_tmp570_) {
                                          ValaDataType* _tmp571_ = NULL;
                                          _tmp571_ = vala_variable_get_variable_type ((ValaVariable*) param);
                                          _tmp569_ = VALA_IS_ARRAY_TYPE (_tmp571_);
                                    } else {
                                          _tmp569_ = FALSE;
                                    }
                                    if (_tmp569_) {
                                          ValaDataType* _tmp572_ = NULL;
                                          ValaArrayType* _tmp573_;
                                          ValaArrayType* array_type;
                                          ValaDataType* _tmp574_;
                                          ValaDataType* array_length_type;
                                          const gchar* _tmp575_ = NULL;
                                          _tmp572_ = vala_variable_get_variable_type ((ValaVariable*) param);
                                          _tmp573_ = _vala_code_node_ref0 (VALA_ARRAY_TYPE (_tmp572_));
                                          array_type = _tmp573_;
                                          _tmp574_ = _vala_code_node_ref0 (((ValaCCodeBaseModule*) self)->int_type);
                                          array_length_type = _tmp574_;
                                          _tmp575_ = vala_variable_get_array_length_type ((ValaVariable*) param);
                                          if (_tmp575_ != NULL) {
                                                const gchar* _tmp576_ = NULL;
                                                ValaCType* _tmp577_ = NULL;
                                                _tmp576_ = vala_variable_get_array_length_type ((ValaVariable*) param);
                                                _tmp577_ = vala_ctype_new (_tmp576_);
                                                _vala_code_node_unref0 (array_length_type);
                                                array_length_type = (ValaDataType*) _tmp577_;
                                          }
                                          {
                                                gint dim;
                                                dim = 1;
                                                {
                                                      gboolean _tmp578_;
                                                      _tmp578_ = TRUE;
                                                      while (TRUE) {
                                                            gint _tmp579_;
                                                            ValaLocalVariable* _tmp580_ = NULL;
                                                            ValaLocalVariable* temp_array_length;
                                                            const gchar* _tmp581_ = NULL;
                                                            ValaCCodeExpression* _tmp582_ = NULL;
                                                            ValaCCodeExpression* _tmp583_;
                                                            gdouble _tmp584_;
                                                            gint _tmp585_;
                                                            ValaList* _tmp586_ = NULL;
                                                            ValaList* _tmp587_;
                                                            gpointer _tmp588_ = NULL;
                                                            ValaCCodeExpression* _tmp589_;
                                                            ValaCCodeUnaryExpression* _tmp590_ = NULL;
                                                            ValaCCodeUnaryExpression* _tmp591_;
                                                            if (!_tmp578_) {
                                                                  dim++;
                                                            }
                                                            _tmp578_ = FALSE;
                                                            _tmp579_ = vala_array_type_get_rank (array_type);
                                                            if (!(dim <= _tmp579_)) {
                                                                  break;
                                                            }
                                                            _tmp580_ = vala_ccode_base_module_get_temp_variable ((ValaCCodeBaseModule*) self, array_length_type, TRUE, NULL, TRUE);
                                                            temp_array_length = _tmp580_;
                                                            vala_ccode_base_module_emit_temp_var ((ValaCCodeBaseModule*) self, temp_array_length, FALSE);
                                                            _tmp581_ = vala_symbol_get_name ((ValaSymbol*) temp_array_length);
                                                            _tmp582_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, _tmp581_);
                                                            _tmp583_ = _tmp582_;
                                                            vala_ccode_base_module_append_array_length ((ValaCCodeBaseModule*) self, arg, _tmp583_);
                                                            _vala_ccode_node_unref0 (_tmp583_);
                                                            _tmp584_ = vala_parameter_get_carray_length_parameter_position (param);
                                                            _tmp585_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, _tmp584_ + (0.01 * dim), FALSE);
                                                            _tmp586_ = vala_ccode_base_module_get_array_lengths ((ValaCCodeBaseModule*) self, arg);
                                                            _tmp587_ = _tmp586_;
                                                            _tmp588_ = vala_list_get (_tmp587_, dim - 1);
                                                            _tmp589_ = (ValaCCodeExpression*) _tmp588_;
                                                            _tmp590_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, _tmp589_);
                                                            _tmp591_ = _tmp590_;
                                                            vala_map_set ((ValaMap*) carg_map, GINT_TO_POINTER (_tmp585_), (ValaCCodeExpression*) _tmp591_);
                                                            _vala_ccode_node_unref0 (_tmp591_);
                                                            _vala_ccode_node_unref0 (_tmp589_);
                                                            _vala_iterable_unref0 (_tmp587_);
                                                            _vala_code_node_unref0 (temp_array_length);
                                                      }
                                                }
                                          }
                                          _vala_code_node_unref0 (array_length_type);
                                          _vala_code_node_unref0 (array_type);
                                    } else {
                                          ValaDataType* _tmp592_ = NULL;
                                          _tmp592_ = vala_variable_get_variable_type ((ValaVariable*) param);
                                          if (VALA_IS_DELEGATE_TYPE (_tmp592_)) {
                                                ValaDataType* _tmp593_ = NULL;
                                                ValaDelegateType* _tmp594_;
                                                ValaDelegateType* deleg_type;
                                                ValaDelegate* _tmp595_ = NULL;
                                                ValaDelegate* _tmp596_;
                                                ValaDelegate* d;
                                                gboolean _tmp597_;
                                                _tmp593_ = vala_variable_get_variable_type ((ValaVariable*) param);
                                                _tmp594_ = _vala_code_node_ref0 (VALA_DELEGATE_TYPE (_tmp593_));
                                                deleg_type = _tmp594_;
                                                _tmp595_ = vala_delegate_type_get_delegate_symbol (deleg_type);
                                                _tmp596_ = _vala_code_node_ref0 (_tmp595_);
                                                d = _tmp596_;
                                                _tmp597_ = vala_delegate_get_has_target (d);
                                                if (_tmp597_) {
                                                      ValaVoidType* _tmp598_ = NULL;
                                                      ValaVoidType* _tmp599_;
                                                      ValaPointerType* _tmp600_ = NULL;
                                                      ValaPointerType* _tmp601_;
                                                      ValaLocalVariable* _tmp602_ = NULL;
                                                      const gchar* _tmp603_ = NULL;
                                                      ValaCCodeExpression* _tmp604_ = NULL;
                                                      ValaCCodeExpression* _tmp605_;
                                                      gdouble _tmp606_;
                                                      gint _tmp607_;
                                                      ValaCCodeExpression* _tmp608_ = NULL;
                                                      ValaCCodeExpression* _tmp609_;
                                                      ValaCCodeUnaryExpression* _tmp610_ = NULL;
                                                      ValaCCodeUnaryExpression* _tmp611_;
                                                      gboolean _tmp612_;
                                                      _tmp598_ = vala_void_type_new (NULL);
                                                      _tmp599_ = _tmp598_;
                                                      _tmp600_ = vala_pointer_type_new ((ValaDataType*) _tmp599_, NULL);
                                                      _tmp601_ = _tmp600_;
                                                      _tmp602_ = vala_ccode_base_module_get_temp_variable ((ValaCCodeBaseModule*) self, (ValaDataType*) _tmp601_, TRUE, NULL, TRUE);
                                                      _vala_code_node_unref0 (temp_var);
                                                      temp_var = _tmp602_;
                                                      _vala_code_node_unref0 (_tmp601_);
                                                      _vala_code_node_unref0 (_tmp599_);
                                                      vala_ccode_base_module_emit_temp_var ((ValaCCodeBaseModule*) self, temp_var, FALSE);
                                                      _tmp603_ = vala_symbol_get_name ((ValaSymbol*) temp_var);
                                                      _tmp604_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, _tmp603_);
                                                      _tmp605_ = _tmp604_;
                                                      vala_ccode_base_module_set_delegate_target ((ValaCCodeBaseModule*) self, arg, _tmp605_);
                                                      _vala_ccode_node_unref0 (_tmp605_);
                                                      _tmp606_ = vala_parameter_get_cdelegate_target_parameter_position (param);
                                                      _tmp607_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, _tmp606_, FALSE);
                                                      _tmp608_ = vala_ccode_base_module_get_delegate_target ((ValaCCodeBaseModule*) self, arg);
                                                      _tmp609_ = _tmp608_;
                                                      _tmp610_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, _tmp609_);
                                                      _tmp611_ = _tmp610_;
                                                      vala_map_set ((ValaMap*) carg_map, GINT_TO_POINTER (_tmp607_), (ValaCCodeExpression*) _tmp611_);
                                                      _vala_ccode_node_unref0 (_tmp611_);
                                                      _vala_ccode_node_unref0 (_tmp609_);
                                                      _tmp612_ = vala_data_type_get_value_owned ((ValaDataType*) deleg_type);
                                                      if (_tmp612_) {
                                                            ValaLocalVariable* _tmp613_ = NULL;
                                                            const gchar* _tmp614_ = NULL;
                                                            ValaCCodeExpression* _tmp615_ = NULL;
                                                            ValaCCodeExpression* _tmp616_;
                                                            gdouble _tmp617_;
                                                            gint _tmp618_;
                                                            ValaCCodeExpression* _tmp619_ = NULL;
                                                            ValaCCodeExpression* _tmp620_;
                                                            ValaCCodeUnaryExpression* _tmp621_ = NULL;
                                                            ValaCCodeUnaryExpression* _tmp622_;
                                                            _tmp613_ = vala_ccode_base_module_get_temp_variable ((ValaCCodeBaseModule*) self, ((ValaCCodeBaseModule*) self)->gdestroynotify_type, TRUE, NULL, TRUE);
                                                            _vala_code_node_unref0 (temp_var);
                                                            temp_var = _tmp613_;
                                                            vala_ccode_base_module_emit_temp_var ((ValaCCodeBaseModule*) self, temp_var, FALSE);
                                                            _tmp614_ = vala_symbol_get_name ((ValaSymbol*) temp_var);
                                                            _tmp615_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, _tmp614_);
                                                            _tmp616_ = _tmp615_;
                                                            vala_ccode_base_module_set_delegate_target_destroy_notify ((ValaCCodeBaseModule*) self, arg, _tmp616_);
                                                            _vala_ccode_node_unref0 (_tmp616_);
                                                            _tmp617_ = vala_parameter_get_cdelegate_target_parameter_position (param);
                                                            _tmp618_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, _tmp617_ + 0.01, FALSE);
                                                            _tmp619_ = vala_ccode_base_module_get_delegate_target_destroy_notify ((ValaCCodeBaseModule*) self, arg);
                                                            _tmp620_ = _tmp619_;
                                                            _tmp621_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, _tmp620_);
                                                            _tmp622_ = _tmp621_;
                                                            vala_map_set ((ValaMap*) carg_map, GINT_TO_POINTER (_tmp618_), (ValaCCodeExpression*) _tmp622_);
                                                            _vala_ccode_node_unref0 (_tmp622_);
                                                            _vala_ccode_node_unref0 (_tmp620_);
                                                      }
                                                }
                                                _vala_code_node_unref0 (d);
                                                _vala_code_node_unref0 (deleg_type);
                                          }
                                    }
                                    _vala_code_node_unref0 (temp_var);
                              }
                              _tmp623_ = vala_parameter_get_ctype (param);
                              if (_tmp623_ != NULL) {
                                    const gchar* _tmp624_ = NULL;
                                    ValaCCodeCastExpression* _tmp625_ = NULL;
                                    _tmp624_ = vala_parameter_get_ctype (param);
                                    _tmp625_ = vala_ccode_cast_expression_new (cexpr, _tmp624_);
                                    _vala_ccode_node_unref0 (cexpr);
                                    cexpr = (ValaCCodeExpression*) _tmp625_;
                              }
                              _vala_code_node_unref0 (unary);
                        } else {
                              ValaCCodeExpression* _tmp626_ = NULL;
                              _tmp626_ = vala_ccode_base_module_handle_struct_argument ((ValaCCodeBaseModule*) self, NULL, arg, cexpr);
                              _vala_ccode_node_unref0 (cexpr);
                              cexpr = _tmp626_;
                        }
                        _tmp627_ = vala_parameter_get_cparameter_position (param);
                        _tmp628_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, _tmp627_, ellipsis);
                        arg_pos = _tmp628_;
                        _vala_code_node_unref0 (param);
                  } else {
                        ValaCCodeExpression* _tmp629_ = NULL;
                        gint _tmp630_;
                        _tmp629_ = vala_ccode_base_module_handle_struct_argument ((ValaCCodeBaseModule*) self, NULL, arg, cexpr);
                        _vala_ccode_node_unref0 (cexpr);
                        cexpr = _tmp629_;
                        _tmp630_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, (gdouble) i, ellipsis);
                        arg_pos = _tmp630_;
                  }
                  vala_map_set ((ValaMap*) carg_map, GINT_TO_POINTER (arg_pos), cexpr);
                  if (VALA_IS_NAMED_ARGUMENT (arg)) {
                        _tmp631_ = ellipsis;
                  } else {
                        _tmp631_ = FALSE;
                  }
                  if (_tmp631_) {
                        ValaNamedArgument* _tmp632_;
                        ValaNamedArgument* named_arg;
                        const gchar* _tmp633_ = NULL;
                        gchar** _tmp634_;
                        gchar** _tmp635_ = NULL;
                        gchar** _tmp636_;
                        gint _tmp636__length1;
                        gchar* _tmp637_ = NULL;
                        gchar* _tmp638_;
                        gchar* name;
                        gint _tmp639_;
                        gchar* _tmp640_ = NULL;
                        gchar* _tmp641_;
                        ValaCCodeConstant* _tmp642_ = NULL;
                        ValaCCodeConstant* _tmp643_;
                        _tmp632_ = _vala_code_node_ref0 (VALA_NAMED_ARGUMENT (arg));
                        named_arg = _tmp632_;
                        _tmp633_ = vala_named_argument_get_name (named_arg);
                        _tmp635_ = _tmp634_ = g_strsplit (_tmp633_, "_", 0);
                        _tmp636_ = _tmp635_;
                        _tmp636__length1 = _vala_array_length (_tmp634_);
                        _tmp637_ = g_strjoinv ("-", _tmp636_);
                        _tmp638_ = _tmp637_;
                        _tmp636_ = (_vala_array_free (_tmp636_, _tmp636__length1, (GDestroyNotify) g_free), NULL);
                        name = _tmp638_;
                        _tmp639_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, i - 0.1, ellipsis);
                        _tmp640_ = g_strdup_printf ("\"%s\"", name);
                        _tmp641_ = _tmp640_;
                        _tmp642_ = vala_ccode_constant_new (_tmp641_);
                        _tmp643_ = _tmp642_;
                        vala_map_set ((ValaMap*) carg_map, GINT_TO_POINTER (_tmp639_), (ValaCCodeExpression*) _tmp643_);
                        _vala_ccode_node_unref0 (_tmp643_);
                        _g_free0 (_tmp641_);
                        _g_free0 (name);
                        _vala_code_node_unref0 (named_arg);
                  }
                  i++;
                  _vala_map_unref0 (carg_map);
                  _vala_ccode_node_unref0 (cexpr);
                  _vala_code_node_unref0 (arg);
            }
            _vala_iterable_unref0 (_arg_list);
      }
      _tmp644_ = vala_iterator_next (params_it);
      if (_tmp644_) {
            gpointer _tmp645_ = NULL;
            ValaParameter* param;
            gboolean _tmp646_ = FALSE;
            gboolean _tmp647_;
            _tmp645_ = vala_iterator_get (params_it);
            param = (ValaParameter*) _tmp645_;
            _tmp647_ = vala_parameter_get_params_array (param);
            if (_tmp647_) {
                  _tmp646_ = TRUE;
            } else {
                  gboolean _tmp648_;
                  _tmp648_ = vala_parameter_get_ellipsis (param);
                  _tmp646_ = _tmp648_;
            }
            g_assert (_tmp646_);
            ellipsis = TRUE;
            _vala_code_node_unref0 (param);
      }
      if (m != NULL) {
            ValaDataType* _tmp651_ = NULL;
            _tmp651_ = vala_method_get_return_type (m);
            _tmp650_ = VALA_IS_ARRAY_TYPE (_tmp651_);
      } else {
            _tmp650_ = FALSE;
      }
      if (_tmp650_) {
            _tmp649_ = async_call != ccall;
      } else {
            _tmp649_ = FALSE;
      }
      if (_tmp649_) {
            ValaDataType* _tmp652_ = NULL;
            ValaArrayType* _tmp653_;
            ValaArrayType* array_type;
            _tmp652_ = vala_method_get_return_type (m);
            _tmp653_ = _vala_code_node_ref0 (VALA_ARRAY_TYPE (_tmp652_));
            array_type = _tmp653_;
            {
                  gint dim;
                  dim = 1;
                  {
                        gboolean _tmp654_;
                        _tmp654_ = TRUE;
                        while (TRUE) {
                              gint _tmp655_;
                              gboolean _tmp656_;
                              if (!_tmp654_) {
                                    dim++;
                              }
                              _tmp654_ = FALSE;
                              _tmp655_ = vala_array_type_get_rank (array_type);
                              if (!(dim <= _tmp655_)) {
                                    break;
                              }
                              _tmp656_ = vala_method_get_array_null_terminated (m);
                              if (_tmp656_) {
                                    ValaDataType* _tmp657_ = NULL;
                                    ValaDataType* _tmp658_;
                                    ValaLocalVariable* _tmp659_ = NULL;
                                    ValaLocalVariable* _tmp660_;
                                    ValaLocalVariable* temp_var;
                                    const gchar* _tmp661_ = NULL;
                                    ValaCCodeExpression* _tmp662_ = NULL;
                                    ValaCCodeExpression* temp_ref;
                                    ValaCCodeAssignment* _tmp663_ = NULL;
                                    ValaCCodeIdentifier* _tmp664_ = NULL;
                                    ValaCCodeIdentifier* _tmp665_;
                                    ValaCCodeFunctionCall* _tmp666_ = NULL;
                                    ValaCCodeFunctionCall* _tmp667_;
                                    ValaCCodeFunctionCall* len_call;
                                    _tmp657_ = vala_data_type_get_return_type (itype);
                                    _tmp658_ = _tmp657_;
                                    _tmp659_ = vala_ccode_base_module_get_temp_variable ((ValaCCodeBaseModule*) self, _tmp658_, TRUE, NULL, FALSE);
                                    _tmp660_ = _tmp659_;
                                    _vala_code_node_unref0 (_tmp658_);
                                    temp_var = _tmp660_;
                                    _tmp661_ = vala_symbol_get_name ((ValaSymbol*) temp_var);
                                    _tmp662_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, _tmp661_);
                                    temp_ref = _tmp662_;
                                    vala_ccode_base_module_emit_temp_var ((ValaCCodeBaseModule*) self, temp_var, FALSE);
                                    _tmp663_ = vala_ccode_assignment_new (temp_ref, ccall_expr, VALA_CCODE_ASSIGNMENT_OPERATOR_SIMPLE);
                                    _vala_ccode_node_unref0 (ccall_expr);
                                    ccall_expr = (ValaCCodeExpression*) _tmp663_;
                                    ((ValaCCodeBaseModule*) self)->requires_array_length = TRUE;
                                    _tmp664_ = vala_ccode_identifier_new ("_vala_array_length");
                                    _tmp665_ = _tmp664_;
                                    _tmp666_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp665_);
                                    _tmp667_ = _tmp666_;
                                    _vala_ccode_node_unref0 (_tmp665_);
                                    len_call = _tmp667_;
                                    vala_ccode_function_call_add_argument (len_call, temp_ref);
                                    vala_ccode_base_module_append_array_length ((ValaCCodeBaseModule*) self, (ValaExpression*) expr, (ValaCCodeExpression*) len_call);
                                    _vala_ccode_node_unref0 (len_call);
                                    _vala_ccode_node_unref0 (temp_ref);
                                    _vala_code_node_unref0 (temp_var);
                              } else {
                                    gboolean _tmp668_;
                                    _tmp668_ = vala_method_get_no_array_length (m);
                                    if (!_tmp668_) {
                                          ValaLocalVariable* temp_var = NULL;
                                          const gchar* _tmp669_ = NULL;
                                          const gchar* _tmp675_ = NULL;
                                          ValaCCodeExpression* _tmp676_ = NULL;
                                          ValaCCodeExpression* temp_ref;
                                          gdouble _tmp677_;
                                          gint _tmp678_;
                                          ValaCCodeUnaryExpression* _tmp679_ = NULL;
                                          ValaCCodeUnaryExpression* _tmp680_;
                                          _tmp669_ = vala_method_get_array_length_type (m);
                                          if (_tmp669_ == NULL) {
                                                ValaLocalVariable* _tmp670_ = NULL;
                                                _tmp670_ = vala_ccode_base_module_get_temp_variable ((ValaCCodeBaseModule*) self, ((ValaCCodeBaseModule*) self)->int_type, TRUE, NULL, TRUE);
                                                _vala_code_node_unref0 (temp_var);
                                                temp_var = _tmp670_;
                                          } else {
                                                const gchar* _tmp671_ = NULL;
                                                ValaCType* _tmp672_ = NULL;
                                                ValaCType* _tmp673_;
                                                ValaLocalVariable* _tmp674_ = NULL;
                                                _tmp671_ = vala_method_get_array_length_type (m);
                                                _tmp672_ = vala_ctype_new (_tmp671_);
                                                _tmp673_ = _tmp672_;
                                                _tmp674_ = vala_ccode_base_module_get_temp_variable ((ValaCCodeBaseModule*) self, (ValaDataType*) _tmp673_, TRUE, NULL, TRUE);
                                                _vala_code_node_unref0 (temp_var);
                                                temp_var = _tmp674_;
                                                _vala_code_node_unref0 (_tmp673_);
                                          }
                                          _tmp675_ = vala_symbol_get_name ((ValaSymbol*) temp_var);
                                          _tmp676_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, _tmp675_);
                                          temp_ref = _tmp676_;
                                          vala_ccode_base_module_emit_temp_var ((ValaCCodeBaseModule*) self, temp_var, FALSE);
                                          _tmp677_ = vala_method_get_carray_length_parameter_position (m);
                                          _tmp678_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, _tmp677_ + (0.01 * dim), FALSE);
                                          _tmp679_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, temp_ref);
                                          _tmp680_ = _tmp679_;
                                          vala_map_set ((ValaMap*) out_arg_map, GINT_TO_POINTER (_tmp678_), (ValaCCodeExpression*) _tmp680_);
                                          _vala_ccode_node_unref0 (_tmp680_);
                                          vala_ccode_base_module_append_array_length ((ValaCCodeBaseModule*) self, (ValaExpression*) expr, temp_ref);
                                          _vala_ccode_node_unref0 (temp_ref);
                                          _vala_code_node_unref0 (temp_var);
                                    } else {
                                          ValaCCodeConstant* _tmp681_ = NULL;
                                          ValaCCodeConstant* _tmp682_;
                                          _tmp681_ = vala_ccode_constant_new ("-1");
                                          _tmp682_ = _tmp681_;
                                          vala_ccode_base_module_append_array_length ((ValaCCodeBaseModule*) self, (ValaExpression*) expr, (ValaCCodeExpression*) _tmp682_);
                                          _vala_ccode_node_unref0 (_tmp682_);
                                    }
                              }
                        }
                  }
            }
            _vala_code_node_unref0 (array_type);
      } else {
            gboolean _tmp683_ = FALSE;
            gboolean _tmp684_ = FALSE;
            if (m != NULL) {
                  ValaDataType* _tmp685_ = NULL;
                  _tmp685_ = vala_method_get_return_type (m);
                  _tmp684_ = VALA_IS_DELEGATE_TYPE (_tmp685_);
            } else {
                  _tmp684_ = FALSE;
            }
            if (_tmp684_) {
                  _tmp683_ = async_call != ccall;
            } else {
                  _tmp683_ = FALSE;
            }
            if (_tmp683_) {
                  ValaDataType* _tmp686_ = NULL;
                  ValaDelegateType* _tmp687_;
                  ValaDelegateType* deleg_type;
                  ValaDelegate* _tmp688_ = NULL;
                  ValaDelegate* _tmp689_;
                  ValaDelegate* d;
                  gboolean _tmp690_;
                  _tmp686_ = vala_method_get_return_type (m);
                  _tmp687_ = _vala_code_node_ref0 (VALA_DELEGATE_TYPE (_tmp686_));
                  deleg_type = _tmp687_;
                  _tmp688_ = vala_delegate_type_get_delegate_symbol (deleg_type);
                  _tmp689_ = _vala_code_node_ref0 (_tmp688_);
                  d = _tmp689_;
                  _tmp690_ = vala_delegate_get_has_target (d);
                  if (_tmp690_) {
                        ValaVoidType* _tmp691_ = NULL;
                        ValaVoidType* _tmp692_;
                        ValaPointerType* _tmp693_ = NULL;
                        ValaPointerType* _tmp694_;
                        ValaLocalVariable* _tmp695_ = NULL;
                        ValaLocalVariable* _tmp696_;
                        ValaLocalVariable* temp_var;
                        const gchar* _tmp697_ = NULL;
                        ValaCCodeExpression* _tmp698_ = NULL;
                        ValaCCodeExpression* temp_ref;
                        gdouble _tmp699_;
                        gint _tmp700_;
                        ValaCCodeUnaryExpression* _tmp701_ = NULL;
                        ValaCCodeUnaryExpression* _tmp702_;
                        gboolean _tmp703_;
                        _tmp691_ = vala_void_type_new (NULL);
                        _tmp692_ = _tmp691_;
                        _tmp693_ = vala_pointer_type_new ((ValaDataType*) _tmp692_, NULL);
                        _tmp694_ = _tmp693_;
                        _tmp695_ = vala_ccode_base_module_get_temp_variable ((ValaCCodeBaseModule*) self, (ValaDataType*) _tmp694_, TRUE, NULL, TRUE);
                        _tmp696_ = _tmp695_;
                        _vala_code_node_unref0 (_tmp694_);
                        _vala_code_node_unref0 (_tmp692_);
                        temp_var = _tmp696_;
                        _tmp697_ = vala_symbol_get_name ((ValaSymbol*) temp_var);
                        _tmp698_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, _tmp697_);
                        temp_ref = _tmp698_;
                        vala_ccode_base_module_emit_temp_var ((ValaCCodeBaseModule*) self, temp_var, FALSE);
                        _tmp699_ = vala_method_get_cdelegate_target_parameter_position (m);
                        _tmp700_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, _tmp699_, FALSE);
                        _tmp701_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, temp_ref);
                        _tmp702_ = _tmp701_;
                        vala_map_set ((ValaMap*) out_arg_map, GINT_TO_POINTER (_tmp700_), (ValaCCodeExpression*) _tmp702_);
                        _vala_ccode_node_unref0 (_tmp702_);
                        vala_ccode_base_module_set_delegate_target ((ValaCCodeBaseModule*) self, (ValaExpression*) expr, temp_ref);
                        _tmp703_ = vala_data_type_get_value_owned ((ValaDataType*) deleg_type);
                        if (_tmp703_) {
                              ValaLocalVariable* _tmp704_ = NULL;
                              const gchar* _tmp705_ = NULL;
                              ValaCCodeExpression* _tmp706_ = NULL;
                              gdouble _tmp707_;
                              gint _tmp708_;
                              ValaCCodeUnaryExpression* _tmp709_ = NULL;
                              ValaCCodeUnaryExpression* _tmp710_;
                              _tmp704_ = vala_ccode_base_module_get_temp_variable ((ValaCCodeBaseModule*) self, ((ValaCCodeBaseModule*) self)->gdestroynotify_type, TRUE, NULL, TRUE);
                              _vala_code_node_unref0 (temp_var);
                              temp_var = _tmp704_;
                              _tmp705_ = vala_symbol_get_name ((ValaSymbol*) temp_var);
                              _tmp706_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, _tmp705_);
                              _vala_ccode_node_unref0 (temp_ref);
                              temp_ref = _tmp706_;
                              vala_ccode_base_module_emit_temp_var ((ValaCCodeBaseModule*) self, temp_var, FALSE);
                              _tmp707_ = vala_method_get_cdelegate_target_parameter_position (m);
                              _tmp708_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, _tmp707_ + 0.01, FALSE);
                              _tmp709_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, temp_ref);
                              _tmp710_ = _tmp709_;
                              vala_map_set ((ValaMap*) out_arg_map, GINT_TO_POINTER (_tmp708_), (ValaCCodeExpression*) _tmp710_);
                              _vala_ccode_node_unref0 (_tmp710_);
                              vala_ccode_base_module_set_delegate_target_destroy_notify ((ValaCCodeBaseModule*) self, (ValaExpression*) expr, temp_ref);
                        }
                        _vala_ccode_node_unref0 (temp_ref);
                        _vala_code_node_unref0 (temp_var);
                  }
                  _vala_code_node_unref0 (d);
                  _vala_code_node_unref0 (deleg_type);
            }
      }
      if (deleg != NULL) {
            ValaDataType* _tmp712_ = NULL;
            _tmp712_ = vala_delegate_get_return_type (deleg);
            _tmp711_ = VALA_IS_ARRAY_TYPE (_tmp712_);
      } else {
            _tmp711_ = FALSE;
      }
      if (_tmp711_) {
            ValaDataType* _tmp713_ = NULL;
            ValaArrayType* _tmp714_;
            ValaArrayType* array_type;
            _tmp713_ = vala_delegate_get_return_type (deleg);
            _tmp714_ = _vala_code_node_ref0 (VALA_ARRAY_TYPE (_tmp713_));
            array_type = _tmp714_;
            {
                  gint dim;
                  dim = 1;
                  {
                        gboolean _tmp715_;
                        _tmp715_ = TRUE;
                        while (TRUE) {
                              gint _tmp716_;
                              gboolean _tmp717_;
                              if (!_tmp715_) {
                                    dim++;
                              }
                              _tmp715_ = FALSE;
                              _tmp716_ = vala_array_type_get_rank (array_type);
                              if (!(dim <= _tmp716_)) {
                                    break;
                              }
                              _tmp717_ = vala_delegate_get_array_null_terminated (deleg);
                              if (_tmp717_) {
                                    ValaDataType* _tmp718_ = NULL;
                                    ValaDataType* _tmp719_;
                                    ValaLocalVariable* _tmp720_ = NULL;
                                    ValaLocalVariable* _tmp721_;
                                    ValaLocalVariable* temp_var;
                                    const gchar* _tmp722_ = NULL;
                                    ValaCCodeExpression* _tmp723_ = NULL;
                                    ValaCCodeExpression* temp_ref;
                                    ValaCCodeAssignment* _tmp724_ = NULL;
                                    ValaCCodeIdentifier* _tmp725_ = NULL;
                                    ValaCCodeIdentifier* _tmp726_;
                                    ValaCCodeFunctionCall* _tmp727_ = NULL;
                                    ValaCCodeFunctionCall* _tmp728_;
                                    ValaCCodeFunctionCall* len_call;
                                    _tmp718_ = vala_data_type_get_return_type (itype);
                                    _tmp719_ = _tmp718_;
                                    _tmp720_ = vala_ccode_base_module_get_temp_variable ((ValaCCodeBaseModule*) self, _tmp719_, TRUE, NULL, FALSE);
                                    _tmp721_ = _tmp720_;
                                    _vala_code_node_unref0 (_tmp719_);
                                    temp_var = _tmp721_;
                                    _tmp722_ = vala_symbol_get_name ((ValaSymbol*) temp_var);
                                    _tmp723_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, _tmp722_);
                                    temp_ref = _tmp723_;
                                    vala_ccode_base_module_emit_temp_var ((ValaCCodeBaseModule*) self, temp_var, FALSE);
                                    _tmp724_ = vala_ccode_assignment_new (temp_ref, ccall_expr, VALA_CCODE_ASSIGNMENT_OPERATOR_SIMPLE);
                                    _vala_ccode_node_unref0 (ccall_expr);
                                    ccall_expr = (ValaCCodeExpression*) _tmp724_;
                                    ((ValaCCodeBaseModule*) self)->requires_array_length = TRUE;
                                    _tmp725_ = vala_ccode_identifier_new ("_vala_array_length");
                                    _tmp726_ = _tmp725_;
                                    _tmp727_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp726_);
                                    _tmp728_ = _tmp727_;
                                    _vala_ccode_node_unref0 (_tmp726_);
                                    len_call = _tmp728_;
                                    vala_ccode_function_call_add_argument (len_call, temp_ref);
                                    vala_ccode_base_module_append_array_length ((ValaCCodeBaseModule*) self, (ValaExpression*) expr, (ValaCCodeExpression*) len_call);
                                    _vala_ccode_node_unref0 (len_call);
                                    _vala_ccode_node_unref0 (temp_ref);
                                    _vala_code_node_unref0 (temp_var);
                              } else {
                                    gboolean _tmp729_;
                                    _tmp729_ = vala_delegate_get_no_array_length (deleg);
                                    if (!_tmp729_) {
                                          ValaLocalVariable* _tmp730_ = NULL;
                                          ValaLocalVariable* temp_var;
                                          const gchar* _tmp731_ = NULL;
                                          ValaCCodeExpression* _tmp732_ = NULL;
                                          ValaCCodeExpression* temp_ref;
                                          gdouble _tmp733_;
                                          gint _tmp734_;
                                          ValaCCodeUnaryExpression* _tmp735_ = NULL;
                                          ValaCCodeUnaryExpression* _tmp736_;
                                          _tmp730_ = vala_ccode_base_module_get_temp_variable ((ValaCCodeBaseModule*) self, ((ValaCCodeBaseModule*) self)->int_type, TRUE, NULL, TRUE);
                                          temp_var = _tmp730_;
                                          _tmp731_ = vala_symbol_get_name ((ValaSymbol*) temp_var);
                                          _tmp732_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, _tmp731_);
                                          temp_ref = _tmp732_;
                                          vala_ccode_base_module_emit_temp_var ((ValaCCodeBaseModule*) self, temp_var, FALSE);
                                          _tmp733_ = vala_delegate_get_carray_length_parameter_position (deleg);
                                          _tmp734_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, _tmp733_ + (0.01 * dim), FALSE);
                                          _tmp735_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, temp_ref);
                                          _tmp736_ = _tmp735_;
                                          vala_map_set ((ValaMap*) out_arg_map, GINT_TO_POINTER (_tmp734_), (ValaCCodeExpression*) _tmp736_);
                                          _vala_ccode_node_unref0 (_tmp736_);
                                          vala_ccode_base_module_append_array_length ((ValaCCodeBaseModule*) self, (ValaExpression*) expr, temp_ref);
                                          _vala_ccode_node_unref0 (temp_ref);
                                          _vala_code_node_unref0 (temp_var);
                                    } else {
                                          ValaCCodeConstant* _tmp737_ = NULL;
                                          ValaCCodeConstant* _tmp738_;
                                          _tmp737_ = vala_ccode_constant_new ("-1");
                                          _tmp738_ = _tmp737_;
                                          vala_ccode_base_module_append_array_length ((ValaCCodeBaseModule*) self, (ValaExpression*) expr, (ValaCCodeExpression*) _tmp738_);
                                          _vala_ccode_node_unref0 (_tmp738_);
                                    }
                              }
                        }
                  }
            }
            _vala_code_node_unref0 (array_type);
      } else {
            gboolean _tmp739_ = FALSE;
            if (deleg != NULL) {
                  ValaDataType* _tmp740_ = NULL;
                  _tmp740_ = vala_delegate_get_return_type (deleg);
                  _tmp739_ = VALA_IS_DELEGATE_TYPE (_tmp740_);
            } else {
                  _tmp739_ = FALSE;
            }
            if (_tmp739_) {
                  ValaDataType* _tmp741_ = NULL;
                  ValaDelegateType* _tmp742_;
                  ValaDelegateType* deleg_type;
                  ValaDelegate* _tmp743_ = NULL;
                  ValaDelegate* _tmp744_;
                  ValaDelegate* d;
                  gboolean _tmp745_;
                  _tmp741_ = vala_delegate_get_return_type (deleg);
                  _tmp742_ = _vala_code_node_ref0 (VALA_DELEGATE_TYPE (_tmp741_));
                  deleg_type = _tmp742_;
                  _tmp743_ = vala_delegate_type_get_delegate_symbol (deleg_type);
                  _tmp744_ = _vala_code_node_ref0 (_tmp743_);
                  d = _tmp744_;
                  _tmp745_ = vala_delegate_get_has_target (d);
                  if (_tmp745_) {
                        ValaVoidType* _tmp746_ = NULL;
                        ValaVoidType* _tmp747_;
                        ValaPointerType* _tmp748_ = NULL;
                        ValaPointerType* _tmp749_;
                        ValaLocalVariable* _tmp750_ = NULL;
                        ValaLocalVariable* _tmp751_;
                        ValaLocalVariable* temp_var;
                        const gchar* _tmp752_ = NULL;
                        ValaCCodeExpression* _tmp753_ = NULL;
                        ValaCCodeExpression* temp_ref;
                        gdouble _tmp754_;
                        gint _tmp755_;
                        ValaCCodeUnaryExpression* _tmp756_ = NULL;
                        ValaCCodeUnaryExpression* _tmp757_;
                        _tmp746_ = vala_void_type_new (NULL);
                        _tmp747_ = _tmp746_;
                        _tmp748_ = vala_pointer_type_new ((ValaDataType*) _tmp747_, NULL);
                        _tmp749_ = _tmp748_;
                        _tmp750_ = vala_ccode_base_module_get_temp_variable ((ValaCCodeBaseModule*) self, (ValaDataType*) _tmp749_, TRUE, NULL, TRUE);
                        _tmp751_ = _tmp750_;
                        _vala_code_node_unref0 (_tmp749_);
                        _vala_code_node_unref0 (_tmp747_);
                        temp_var = _tmp751_;
                        _tmp752_ = vala_symbol_get_name ((ValaSymbol*) temp_var);
                        _tmp753_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, _tmp752_);
                        temp_ref = _tmp753_;
                        vala_ccode_base_module_emit_temp_var ((ValaCCodeBaseModule*) self, temp_var, FALSE);
                        _tmp754_ = vala_delegate_get_cdelegate_target_parameter_position (deleg);
                        _tmp755_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, _tmp754_, FALSE);
                        _tmp756_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, temp_ref);
                        _tmp757_ = _tmp756_;
                        vala_map_set ((ValaMap*) out_arg_map, GINT_TO_POINTER (_tmp755_), (ValaCCodeExpression*) _tmp757_);
                        _vala_ccode_node_unref0 (_tmp757_);
                        vala_ccode_base_module_set_delegate_target ((ValaCCodeBaseModule*) self, (ValaExpression*) expr, temp_ref);
                        _vala_ccode_node_unref0 (temp_ref);
                        _vala_code_node_unref0 (temp_var);
                  }
                  _vala_code_node_unref0 (d);
                  _vala_code_node_unref0 (deleg_type);
            }
      }
      if (m != NULL) {
            gboolean _tmp759_;
            _tmp759_ = vala_method_get_coroutine (m);
            _tmp758_ = _tmp759_;
      } else {
            _tmp758_ = FALSE;
      }
      if (_tmp758_) {
            gboolean _tmp760_;
            _tmp760_ = vala_method_call_get_is_yield_expression (expr);
            if (_tmp760_) {
                  gint _tmp761_;
                  ValaMethod* _tmp762_ = NULL;
                  gchar* _tmp763_ = NULL;
                  gchar* _tmp764_;
                  ValaCCodeIdentifier* _tmp765_ = NULL;
                  ValaCCodeIdentifier* _tmp766_;
                  gint _tmp767_;
                  ValaCCodeIdentifier* _tmp768_ = NULL;
                  ValaCCodeIdentifier* _tmp769_;
                  _tmp761_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, (gdouble) (-1), FALSE);
                  _tmp762_ = vala_ccode_base_module_get_current_method ((ValaCCodeBaseModule*) self);
                  _tmp763_ = vala_ccode_base_module_generate_ready_function ((ValaCCodeBaseModule*) self, _tmp762_);
                  _tmp764_ = _tmp763_;
                  _tmp765_ = vala_ccode_identifier_new (_tmp764_);
                  _tmp766_ = _tmp765_;
                  vala_map_set ((ValaMap*) in_arg_map, GINT_TO_POINTER (_tmp761_), (ValaCCodeExpression*) _tmp766_);
                  _vala_ccode_node_unref0 (_tmp766_);
                  _g_free0 (_tmp764_);
                  _tmp767_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, -0.9, FALSE);
                  _tmp768_ = vala_ccode_identifier_new ("data");
                  _tmp769_ = _tmp768_;
                  vala_map_set ((ValaMap*) in_arg_map, GINT_TO_POINTER (_tmp767_), (ValaCCodeExpression*) _tmp769_);
                  _vala_ccode_node_unref0 (_tmp769_);
            }
      }
      _tmp770_ = vala_code_node_get_tree_can_fail ((ValaCodeNode*) expr);
      if (_tmp770_) {
            gint _tmp771_;
            ValaCCodeExpression* _tmp772_ = NULL;
            ValaCCodeExpression* _tmp773_;
            ValaCCodeUnaryExpression* _tmp774_ = NULL;
            ValaCCodeUnaryExpression* _tmp775_;
            vala_ccode_base_module_set_current_method_inner_error ((ValaCCodeBaseModule*) self, TRUE);
            _tmp771_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, (gdouble) (-1), FALSE);
            _tmp772_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, "_inner_error_");
            _tmp773_ = _tmp772_;
            _tmp774_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, _tmp773_);
            _tmp775_ = _tmp774_;
            vala_map_set ((ValaMap*) out_arg_map, GINT_TO_POINTER (_tmp771_), (ValaCCodeExpression*) _tmp775_);
            _vala_ccode_node_unref0 (_tmp775_);
            _vala_ccode_node_unref0 (_tmp773_);
      }
      if (ellipsis) {
            if (m == NULL) {
                  gint _tmp776_;
                  ValaCCodeConstant* _tmp777_ = NULL;
                  ValaCCodeConstant* _tmp778_;
                  _tmp776_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, (gdouble) (-1), TRUE);
                  _tmp777_ = vala_ccode_constant_new (VALA_METHOD_DEFAULT_SENTINEL);
                  _tmp778_ = _tmp777_;
                  vala_map_set ((ValaMap*) in_arg_map, GINT_TO_POINTER (_tmp776_), (ValaCCodeExpression*) _tmp778_);
                  _vala_ccode_node_unref0 (_tmp778_);
            } else {
                  gboolean _tmp779_ = FALSE;
                  gboolean _tmp780_ = FALSE;
                  gboolean _tmp781_;
                  _tmp781_ = vala_method_get_printf_format (m);
                  if (!_tmp781_) {
                        gboolean _tmp782_;
                        _tmp782_ = vala_method_get_scanf_format (m);
                        _tmp780_ = !_tmp782_;
                  } else {
                        _tmp780_ = FALSE;
                  }
                  if (_tmp780_) {
                        const gchar* _tmp783_ = NULL;
                        _tmp783_ = vala_method_get_sentinel (m);
                        _tmp779_ = g_strcmp0 (_tmp783_, "") != 0;
                  } else {
                        _tmp779_ = FALSE;
                  }
                  if (_tmp779_) {
                        gint _tmp784_;
                        const gchar* _tmp785_ = NULL;
                        ValaCCodeConstant* _tmp786_ = NULL;
                        ValaCCodeConstant* _tmp787_;
                        _tmp784_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, (gdouble) (-1), TRUE);
                        _tmp785_ = vala_method_get_sentinel (m);
                        _tmp786_ = vala_ccode_constant_new (_tmp785_);
                        _tmp787_ = _tmp786_;
                        vala_map_set ((ValaMap*) in_arg_map, GINT_TO_POINTER (_tmp784_), (ValaCCodeExpression*) _tmp787_);
                        _vala_ccode_node_unref0 (_tmp787_);
                  }
            }
      }
      if (VALA_IS_DELEGATE_TYPE (itype)) {
            ValaDelegateType* _tmp788_;
            ValaDelegateType* deleg_type;
            ValaDelegate* _tmp789_ = NULL;
            ValaDelegate* _tmp790_;
            ValaDelegate* d;
            gboolean _tmp791_;
            _tmp788_ = _vala_code_node_ref0 (VALA_DELEGATE_TYPE (itype));
            deleg_type = _tmp788_;
            _tmp789_ = vala_delegate_type_get_delegate_symbol (deleg_type);
            _tmp790_ = _vala_code_node_ref0 (_tmp789_);
            d = _tmp790_;
            _tmp791_ = vala_delegate_get_has_target (d);
            if (_tmp791_) {
                  ValaCCodeExpression* delegate_target_destroy_notify = NULL;
                  gdouble _tmp792_;
                  gint _tmp793_;
                  ValaExpression* _tmp794_ = NULL;
                  ValaCCodeExpression* _tmp795_ = NULL;
                  ValaCCodeExpression* _tmp796_ = NULL;
                  ValaCCodeExpression* _tmp797_;
                  gdouble _tmp798_;
                  gint _tmp799_;
                  ValaExpression* _tmp800_ = NULL;
                  ValaCCodeExpression* _tmp801_ = NULL;
                  ValaCCodeExpression* _tmp802_ = NULL;
                  ValaCCodeExpression* _tmp803_;
                  _tmp792_ = vala_delegate_get_cinstance_parameter_position (d);
                  _tmp793_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, _tmp792_, FALSE);
                  _tmp794_ = vala_method_call_get_call (expr);
                  _tmp796_ = vala_ccode_base_module_get_delegate_target_cexpression ((ValaCCodeBaseModule*) self, _tmp794_, &_tmp795_);
                  _vala_ccode_node_unref0 (delegate_target_destroy_notify);
                  delegate_target_destroy_notify = _tmp795_;
                  _tmp797_ = _tmp796_;
                  vala_map_set ((ValaMap*) in_arg_map, GINT_TO_POINTER (_tmp793_), _tmp797_);
                  _vala_ccode_node_unref0 (_tmp797_);
                  _tmp798_ = vala_delegate_get_cinstance_parameter_position (d);
                  _tmp799_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, _tmp798_, FALSE);
                  _tmp800_ = vala_method_call_get_call (expr);
                  _tmp802_ = vala_ccode_base_module_get_delegate_target_cexpression ((ValaCCodeBaseModule*) self, _tmp800_, &_tmp801_);
                  _vala_ccode_node_unref0 (delegate_target_destroy_notify);
                  delegate_target_destroy_notify = _tmp801_;
                  _tmp803_ = _tmp802_;
                  vala_map_set ((ValaMap*) out_arg_map, GINT_TO_POINTER (_tmp799_), _tmp803_);
                  _vala_ccode_node_unref0 (_tmp803_);
                  _vala_ccode_node_unref0 (delegate_target_destroy_notify);
            }
            _vala_code_node_unref0 (d);
            _vala_code_node_unref0 (deleg_type);
      }
      _tmp804_ = vala_data_type_get_return_type (itype);
      _tmp805_ = _tmp804_;
      _tmp806_ = vala_data_type_is_real_non_null_struct_type (_tmp805_);
      _tmp807_ = _tmp806_;
      _vala_code_node_unref0 (_tmp805_);
      return_result_via_out_param = _tmp807_;
      if (VALA_IS_SIGNAL_TYPE (itype)) {
            ValaDataType* _tmp809_ = NULL;
            ValaDataType* _tmp810_;
            _tmp809_ = vala_data_type_get_return_type (itype);
            _tmp810_ = _tmp809_;
            _tmp808_ = !VALA_IS_VOID_TYPE (_tmp810_);
            _vala_code_node_unref0 (_tmp810_);
      } else {
            _tmp808_ = FALSE;
      }
      if (_tmp808_) {
            ValaSignal* _tmp811_ = NULL;
            ValaSignal* _tmp812_;
            ValaSignal* sig;
            gboolean _tmp813_ = FALSE;
            gboolean _tmp814_ = FALSE;
            _tmp811_ = vala_signal_type_get_signal_symbol (VALA_SIGNAL_TYPE (itype));
            _tmp812_ = _vala_code_node_ref0 (_tmp811_);
            sig = _tmp812_;
            if (ma != NULL) {
                  ValaExpression* _tmp815_ = NULL;
                  _tmp815_ = vala_member_access_get_inner (ma);
                  _tmp814_ = VALA_IS_BASE_ACCESS (_tmp815_);
            } else {
                  _tmp814_ = FALSE;
            }
            if (_tmp814_) {
                  gboolean _tmp816_;
                  _tmp816_ = vala_signal_get_is_virtual (sig);
                  _tmp813_ = _tmp816_;
            } else {
                  _tmp813_ = FALSE;
            }
            if (_tmp813_) {
            } else {
                  gboolean _tmp817_;
                  _tmp817_ = vala_signal_get_has_emitter (sig);
                  if (!_tmp817_) {
                        return_result_via_out_param = TRUE;
                  }
            }
            _vala_code_node_unref0 (sig);
      }
      out_param_ref = NULL;
      if (return_result_via_out_param) {
            ValaDataType* _tmp818_ = NULL;
            ValaDataType* _tmp819_;
            ValaLocalVariable* _tmp820_ = NULL;
            ValaLocalVariable* _tmp821_;
            ValaLocalVariable* out_param_var;
            const gchar* _tmp822_ = NULL;
            ValaCCodeExpression* _tmp823_ = NULL;
            gint _tmp824_;
            ValaCCodeUnaryExpression* _tmp825_ = NULL;
            ValaCCodeUnaryExpression* _tmp826_;
            _tmp818_ = vala_data_type_get_return_type (itype);
            _tmp819_ = _tmp818_;
            _tmp820_ = vala_ccode_base_module_get_temp_variable ((ValaCCodeBaseModule*) self, _tmp819_, TRUE, NULL, TRUE);
            _tmp821_ = _tmp820_;
            _vala_code_node_unref0 (_tmp819_);
            out_param_var = _tmp821_;
            _tmp822_ = vala_symbol_get_name ((ValaSymbol*) out_param_var);
            _tmp823_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, _tmp822_);
            _vala_ccode_node_unref0 (out_param_ref);
            out_param_ref = _tmp823_;
            vala_ccode_base_module_emit_temp_var ((ValaCCodeBaseModule*) self, out_param_var, FALSE);
            _tmp824_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, (gdouble) (-3), FALSE);
            _tmp825_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, out_param_ref);
            _tmp826_ = _tmp825_;
            vala_map_set ((ValaMap*) out_arg_map, GINT_TO_POINTER (_tmp824_), (ValaCCodeExpression*) _tmp826_);
            _vala_ccode_node_unref0 (_tmp826_);
            _vala_code_node_unref0 (out_param_var);
      }
      if (async_call != ccall) {
            last_pos = -1;
            while (TRUE) {
                  gpointer _tmp835_ = NULL;
                  ValaCCodeExpression* _tmp836_;
                  min_pos = -1;
                  {
                        ValaSet* _tmp827_ = NULL;
                        ValaSet* _tmp828_;
                        ValaIterator* _tmp829_ = NULL;
                        ValaIterator* _tmp830_;
                        ValaIterator* _pos_it;
                        _tmp827_ = vala_map_get_keys ((ValaMap*) out_arg_map);
                        _tmp828_ = _tmp827_;
                        _tmp829_ = vala_iterable_iterator ((ValaIterable*) _tmp828_);
                        _tmp830_ = _tmp829_;
                        _vala_iterable_unref0 (_tmp828_);
                        _pos_it = _tmp830_;
                        while (TRUE) {
                              gboolean _tmp831_;
                              gpointer _tmp832_ = NULL;
                              gint pos;
                              gboolean _tmp833_ = FALSE;
                              _tmp831_ = vala_iterator_next (_pos_it);
                              if (!_tmp831_) {
                                    break;
                              }
                              _tmp832_ = vala_iterator_get (_pos_it);
                              pos = GPOINTER_TO_INT (_tmp832_);
                              if (pos > last_pos) {
                                    gboolean _tmp834_ = FALSE;
                                    if (min_pos == (-1)) {
                                          _tmp834_ = TRUE;
                                    } else {
                                          _tmp834_ = pos < min_pos;
                                    }
                                    _tmp833_ = _tmp834_;
                              } else {
                                    _tmp833_ = FALSE;
                              }
                              if (_tmp833_) {
                                    min_pos = pos;
                              }
                        }
                        _vala_iterator_unref0 (_pos_it);
                  }
                  if (min_pos == (-1)) {
                        break;
                  }
                  _tmp835_ = vala_map_get ((ValaMap*) out_arg_map, GINT_TO_POINTER (min_pos));
                  _tmp836_ = (ValaCCodeExpression*) _tmp835_;
                  vala_ccode_function_call_add_argument (ccall, _tmp836_);
                  _vala_ccode_node_unref0 (_tmp836_);
                  last_pos = min_pos;
            }
      }
      if (async_call != NULL) {
            last_pos = -1;
            while (TRUE) {
                  gpointer _tmp845_ = NULL;
                  ValaCCodeExpression* _tmp846_;
                  min_pos = -1;
                  {
                        ValaSet* _tmp837_ = NULL;
                        ValaSet* _tmp838_;
                        ValaIterator* _tmp839_ = NULL;
                        ValaIterator* _tmp840_;
                        ValaIterator* _pos_it;
                        _tmp837_ = vala_map_get_keys ((ValaMap*) in_arg_map);
                        _tmp838_ = _tmp837_;
                        _tmp839_ = vala_iterable_iterator ((ValaIterable*) _tmp838_);
                        _tmp840_ = _tmp839_;
                        _vala_iterable_unref0 (_tmp838_);
                        _pos_it = _tmp840_;
                        while (TRUE) {
                              gboolean _tmp841_;
                              gpointer _tmp842_ = NULL;
                              gint pos;
                              gboolean _tmp843_ = FALSE;
                              _tmp841_ = vala_iterator_next (_pos_it);
                              if (!_tmp841_) {
                                    break;
                              }
                              _tmp842_ = vala_iterator_get (_pos_it);
                              pos = GPOINTER_TO_INT (_tmp842_);
                              if (pos > last_pos) {
                                    gboolean _tmp844_ = FALSE;
                                    if (min_pos == (-1)) {
                                          _tmp844_ = TRUE;
                                    } else {
                                          _tmp844_ = pos < min_pos;
                                    }
                                    _tmp843_ = _tmp844_;
                              } else {
                                    _tmp843_ = FALSE;
                              }
                              if (_tmp843_) {
                                    min_pos = pos;
                              }
                        }
                        _vala_iterator_unref0 (_pos_it);
                  }
                  if (min_pos == (-1)) {
                        break;
                  }
                  _tmp845_ = vala_map_get ((ValaMap*) in_arg_map, GINT_TO_POINTER (min_pos));
                  _tmp846_ = (ValaCCodeExpression*) _tmp845_;
                  vala_ccode_function_call_add_argument (async_call, _tmp846_);
                  _vala_ccode_node_unref0 (_tmp846_);
                  last_pos = min_pos;
            }
      }
      _tmp847_ = vala_method_call_get_is_yield_expression (expr);
      if (_tmp847_) {
            gint _tmp848_;
            gint state;
            ValaCCodeFunction* _tmp849_ = NULL;
            ValaCCodeIdentifier* _tmp850_ = NULL;
            ValaCCodeIdentifier* _tmp851_;
            ValaCCodeMemberAccess* _tmp852_ = NULL;
            ValaCCodeMemberAccess* _tmp853_;
            gchar* _tmp854_ = NULL;
            gchar* _tmp855_;
            ValaCCodeConstant* _tmp856_ = NULL;
            ValaCCodeConstant* _tmp857_;
            ValaCCodeFunction* _tmp858_ = NULL;
            ValaCCodeFunction* _tmp859_ = NULL;
            ValaCCodeConstant* _tmp860_ = NULL;
            ValaCCodeConstant* _tmp861_;
            ValaCCodeFunction* _tmp862_ = NULL;
            gchar* _tmp863_ = NULL;
            gchar* _tmp864_;
            _tmp848_ = ((ValaCCodeBaseModule*) self)->next_coroutine_state;
            ((ValaCCodeBaseModule*) self)->next_coroutine_state = _tmp848_ + 1;
            state = _tmp848_;
            _tmp849_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
            _tmp850_ = vala_ccode_identifier_new ("data");
            _tmp851_ = _tmp850_;
            _tmp852_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp851_, "_state_");
            _tmp853_ = _tmp852_;
            _tmp854_ = g_strdup_printf ("%i", state);
            _tmp855_ = _tmp854_;
            _tmp856_ = vala_ccode_constant_new (_tmp855_);
            _tmp857_ = _tmp856_;
            vala_ccode_function_add_assignment (_tmp849_, (ValaCCodeExpression*) _tmp853_, (ValaCCodeExpression*) _tmp857_);
            _vala_ccode_node_unref0 (_tmp857_);
            _g_free0 (_tmp855_);
            _vala_ccode_node_unref0 (_tmp853_);
            _vala_ccode_node_unref0 (_tmp851_);
            _tmp858_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
            vala_ccode_function_add_expression (_tmp858_, (ValaCCodeExpression*) async_call);
            _tmp859_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
            _tmp860_ = vala_ccode_constant_new ("FALSE");
            _tmp861_ = _tmp860_;
            vala_ccode_function_add_return (_tmp859_, (ValaCCodeExpression*) _tmp861_);
            _vala_ccode_node_unref0 (_tmp861_);
            _tmp862_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
            _tmp863_ = g_strdup_printf ("_state_%d", state);
            _tmp864_ = _tmp863_;
            vala_ccode_function_add_label (_tmp862_, _tmp864_);
            _g_free0 (_tmp864_);
      }
      if (return_result_via_out_param) {
            ValaCCodeFunction* _tmp865_ = NULL;
            ValaCCodeExpression* _tmp866_;
            _tmp865_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
            vala_ccode_function_add_expression (_tmp865_, ccall_expr);
            _tmp866_ = _vala_ccode_node_ref0 (out_param_ref);
            _vala_ccode_node_unref0 (ccall_expr);
            ccall_expr = _tmp866_;
      }
      if (m != NULL) {
            ValaMemberBinding _tmp869_;
            _tmp869_ = vala_method_get_binding (m);
            _tmp868_ = _tmp869_ == VALA_MEMBER_BINDING_INSTANCE;
      } else {
            _tmp868_ = FALSE;
      }
      if (_tmp868_) {
            gboolean _tmp870_;
            _tmp870_ = vala_method_get_returns_modified_pointer (m);
            _tmp867_ = _tmp870_;
      } else {
            _tmp867_ = FALSE;
      }
      if (_tmp867_) {
            ValaCCodeAssignment* _tmp871_ = NULL;
            _tmp871_ = vala_ccode_assignment_new (instance, ccall_expr, VALA_CCODE_ASSIGNMENT_OPERATOR_SIMPLE);
            _vala_ccode_node_unref0 (ccall_expr);
            ccall_expr = (ValaCCodeExpression*) _tmp871_;
      }
      if (VALA_IS_ARRAY_RESIZE_METHOD (m)) {
            ValaList* _tmp872_ = NULL;
            ValaList* _tmp873_;
            ValaIterator* _tmp874_ = NULL;
            ValaIterator* _tmp875_;
            ValaIterator* arg_it;
            gpointer _tmp876_ = NULL;
            ValaExpression* _tmp877_;
            ValaCCodeExpression* _tmp878_ = NULL;
            ValaCCodeExpression* _tmp879_;
            ValaCCodeExpression* new_size;
            ValaLocalVariable* _tmp880_ = NULL;
            ValaLocalVariable* temp_decl;
            const gchar* _tmp881_ = NULL;
            ValaCCodeExpression* _tmp882_ = NULL;
            ValaCCodeExpression* temp_ref;
            ValaExpression* _tmp883_ = NULL;
            ValaCCodeExpression* _tmp884_ = NULL;
            ValaCCodeExpression* clen;
            ValaExpression* _tmp885_ = NULL;
            ValaCCodeExpression* _tmp886_ = NULL;
            ValaCCodeExpression* celems;
            ValaExpression* _tmp887_ = NULL;
            ValaDataType* _tmp888_ = NULL;
            ValaArrayType* _tmp889_;
            ValaArrayType* array_type;
            ValaDataType* _tmp890_ = NULL;
            gchar* _tmp891_ = NULL;
            gchar* _tmp892_;
            gchar* _tmp893_ = NULL;
            gchar* _tmp894_;
            ValaCCodeIdentifier* _tmp895_ = NULL;
            ValaCCodeIdentifier* _tmp896_;
            ValaCCodeIdentifier* csizeof;
            ValaCCodeBinaryExpression* _tmp897_ = NULL;
            ValaCCodeBinaryExpression* cdelta;
            ValaCCodeBinaryExpression* _tmp898_ = NULL;
            ValaCCodeBinaryExpression* ccheck;
            ValaCCodeIdentifier* _tmp899_ = NULL;
            ValaCCodeIdentifier* _tmp900_;
            ValaCCodeFunctionCall* _tmp901_ = NULL;
            ValaCCodeFunctionCall* _tmp902_;
            ValaCCodeFunctionCall* czero;
            ValaCCodeBinaryExpression* _tmp903_ = NULL;
            ValaCCodeBinaryExpression* _tmp904_;
            ValaCCodeConstant* _tmp905_ = NULL;
            ValaCCodeConstant* _tmp906_;
            ValaCCodeBinaryExpression* _tmp907_ = NULL;
            ValaCCodeBinaryExpression* _tmp908_;
            ValaCCodeFunction* _tmp909_ = NULL;
            ValaCCodeFunction* _tmp910_ = NULL;
            ValaCCodeFunction* _tmp911_ = NULL;
            ValaCCodeConstant* _tmp912_ = NULL;
            ValaCCodeConstant* _tmp913_;
            ValaCCodeConditionalExpression* _tmp914_ = NULL;
            ValaCCodeConditionalExpression* _tmp915_;
            ValaCCodeFunction* _tmp916_ = NULL;
            ValaExpression* _tmp917_ = NULL;
            ValaCCodeExpression* _tmp918_ = NULL;
            ValaCCodeExpression* _tmp919_;
            ValaExpression* _tmp920_ = NULL;
            ValaSymbol* _tmp921_ = NULL;
            ValaSymbol* _tmp922_;
            ValaSymbol* array_var;
            ValaSymbol* _tmp923_;
            ValaLocalVariable* _tmp924_;
            ValaLocalVariable* array_local;
            gboolean _tmp925_ = FALSE;
            gboolean _tmp926_ = FALSE;
            _tmp872_ = vala_method_call_get_argument_list (expr);
            _tmp873_ = _tmp872_;
            _tmp874_ = vala_iterable_iterator ((ValaIterable*) _tmp873_);
            _tmp875_ = _tmp874_;
            _vala_iterable_unref0 (_tmp873_);
            arg_it = _tmp875_;
            vala_iterator_next (arg_it);
            _tmp876_ = vala_iterator_get (arg_it);
            _tmp877_ = (ValaExpression*) _tmp876_;
            _tmp878_ = vala_ccode_base_module_get_cvalue ((ValaCCodeBaseModule*) self, _tmp877_);
            _tmp879_ = _tmp878_;
            _vala_code_node_unref0 (_tmp877_);
            new_size = _tmp879_;
            _tmp880_ = vala_ccode_base_module_get_temp_variable ((ValaCCodeBaseModule*) self, ((ValaCCodeBaseModule*) self)->int_type, TRUE, NULL, TRUE);
            temp_decl = _tmp880_;
            _tmp881_ = vala_symbol_get_name ((ValaSymbol*) temp_decl);
            _tmp882_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, _tmp881_);
            temp_ref = _tmp882_;
            vala_ccode_base_module_emit_temp_var ((ValaCCodeBaseModule*) self, temp_decl, FALSE);
            vala_ccode_file_add_include (((ValaCCodeBaseModule*) self)->cfile, "string.h", FALSE);
            _tmp883_ = vala_member_access_get_inner (ma);
            _tmp884_ = vala_ccode_base_module_get_array_length_cexpression ((ValaCCodeBaseModule*) self, _tmp883_, 1);
            clen = _tmp884_;
            _tmp885_ = vala_member_access_get_inner (ma);
            _tmp886_ = vala_ccode_base_module_get_cvalue ((ValaCCodeBaseModule*) self, _tmp885_);
            celems = _tmp886_;
            _tmp887_ = vala_member_access_get_inner (ma);
            _tmp888_ = vala_expression_get_value_type (_tmp887_);
            _tmp889_ = _vala_code_node_ref0 (VALA_ARRAY_TYPE (_tmp888_));
            array_type = _tmp889_;
            _tmp890_ = vala_array_type_get_element_type (array_type);
            _tmp891_ = vala_data_type_get_cname (_tmp890_);
            _tmp892_ = _tmp891_;
            _tmp893_ = g_strdup_printf ("sizeof (%s)", _tmp892_);
            _tmp894_ = _tmp893_;
            _tmp895_ = vala_ccode_identifier_new (_tmp894_);
            _tmp896_ = _tmp895_;
            _g_free0 (_tmp894_);
            _g_free0 (_tmp892_);
            csizeof = _tmp896_;
            _tmp897_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_MINUS, temp_ref, clen);
            cdelta = _tmp897_;
            _tmp898_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_GREATER_THAN, temp_ref, clen);
            ccheck = _tmp898_;
            _tmp899_ = vala_ccode_identifier_new ("memset");
            _tmp900_ = _tmp899_;
            _tmp901_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp900_);
            _tmp902_ = _tmp901_;
            _vala_ccode_node_unref0 (_tmp900_);
            czero = _tmp902_;
            _tmp903_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_PLUS, celems, clen);
            _tmp904_ = _tmp903_;
            vala_ccode_function_call_add_argument (czero, (ValaCCodeExpression*) _tmp904_);
            _vala_ccode_node_unref0 (_tmp904_);
            _tmp905_ = vala_ccode_constant_new ("0");
            _tmp906_ = _tmp905_;
            vala_ccode_function_call_add_argument (czero, (ValaCCodeExpression*) _tmp906_);
            _vala_ccode_node_unref0 (_tmp906_);
            _tmp907_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_MUL, (ValaCCodeExpression*) csizeof, (ValaCCodeExpression*) cdelta);
            _tmp908_ = _tmp907_;
            vala_ccode_function_call_add_argument (czero, (ValaCCodeExpression*) _tmp908_);
            _vala_ccode_node_unref0 (_tmp908_);
            _tmp909_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
            vala_ccode_function_add_assignment (_tmp909_, temp_ref, new_size);
            _tmp910_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
            vala_ccode_function_add_expression (_tmp910_, ccall_expr);
            _tmp911_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
            _tmp912_ = vala_ccode_constant_new ("NULL");
            _tmp913_ = _tmp912_;
            _tmp914_ = vala_ccode_conditional_expression_new ((ValaCCodeExpression*) ccheck, (ValaCCodeExpression*) czero, (ValaCCodeExpression*) _tmp913_);
            _tmp915_ = _tmp914_;
            vala_ccode_function_add_expression (_tmp911_, (ValaCCodeExpression*) _tmp915_);
            _vala_ccode_node_unref0 (_tmp915_);
            _vala_ccode_node_unref0 (_tmp913_);
            _tmp916_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
            _tmp917_ = vala_member_access_get_inner (ma);
            _tmp918_ = vala_ccode_base_module_get_array_length_cexpression ((ValaCCodeBaseModule*) self, _tmp917_, 1);
            _tmp919_ = _tmp918_;
            vala_ccode_function_add_assignment (_tmp916_, _tmp919_, temp_ref);
            _vala_ccode_node_unref0 (_tmp919_);
            _tmp920_ = vala_member_access_get_inner (ma);
            _tmp921_ = vala_expression_get_symbol_reference (_tmp920_);
            _tmp922_ = _vala_code_node_ref0 (_tmp921_);
            array_var = _tmp922_;
            _tmp923_ = array_var;
            _tmp924_ = _vala_code_node_ref0 (VALA_IS_LOCAL_VARIABLE (_tmp923_) ? ((ValaLocalVariable*) _tmp923_) : NULL);
            array_local = _tmp924_;
            if (array_var != NULL) {
                  gboolean _tmp927_;
                  _tmp927_ = vala_symbol_is_internal_symbol (array_var);
                  _tmp926_ = _tmp927_;
            } else {
                  _tmp926_ = FALSE;
            }
            if (_tmp926_) {
                  gboolean _tmp928_ = FALSE;
                  gboolean _tmp929_ = FALSE;
                  if (VALA_IS_LOCAL_VARIABLE (array_var)) {
                        gboolean _tmp930_;
                        _tmp930_ = vala_local_variable_get_captured (array_local);
                        _tmp929_ = !_tmp930_;
                  } else {
                        _tmp929_ = FALSE;
                  }
                  if (_tmp929_) {
                        _tmp928_ = TRUE;
                  } else {
                        _tmp928_ = VALA_IS_FIELD (array_var);
                  }
                  _tmp925_ = _tmp928_;
            } else {
                  _tmp925_ = FALSE;
            }
            if (_tmp925_) {
                  ValaCCodeFunction* _tmp931_ = NULL;
                  ValaExpression* _tmp932_ = NULL;
                  ValaTargetValue* _tmp933_ = NULL;
                  ValaCCodeExpression* _tmp934_ = NULL;
                  ValaCCodeExpression* _tmp935_;
                  _tmp931_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
                  _tmp932_ = vala_member_access_get_inner (ma);
                  _tmp933_ = vala_expression_get_target_value (_tmp932_);
                  _tmp934_ = vala_ccode_base_module_get_array_size_cvalue ((ValaCCodeBaseModule*) self, _tmp933_);
                  _tmp935_ = _tmp934_;
                  vala_ccode_function_add_assignment (_tmp931_, _tmp935_, temp_ref);
                  _vala_ccode_node_unref0 (_tmp935_);
            }
            _vala_code_node_unref0 (array_local);
            _vala_code_node_unref0 (array_var);
            _vala_ccode_node_unref0 (czero);
            _vala_ccode_node_unref0 (ccheck);
            _vala_ccode_node_unref0 (cdelta);
            _vala_ccode_node_unref0 (csizeof);
            _vala_code_node_unref0 (array_type);
            _vala_ccode_node_unref0 (celems);
            _vala_ccode_node_unref0 (clen);
            _vala_ccode_node_unref0 (temp_ref);
            _vala_code_node_unref0 (temp_decl);
            _vala_ccode_node_unref0 (new_size);
            _vala_iterator_unref0 (arg_it);
            _vala_ccode_node_unref0 (out_param_ref);
            _vala_iterator_unref0 (params_it);
            _vala_ccode_node_unref0 (instance);
            _vala_ccode_node_unref0 (ccall_expr);
            _vala_map_unref0 (out_arg_map);
            _vala_map_unref0 (in_arg_map);
            _vala_code_node_unref0 (itype);
            _vala_code_node_unref0 (ma);
            _vala_iterable_unref0 (params);
            _vala_code_node_unref0 (deleg);
            _vala_code_node_unref0 (m);
            _vala_ccode_node_unref0 (async_call);
            _vala_ccode_node_unref0 (ccall);
            return;
      }
      _tmp937_ = vala_code_node_get_parent_node ((ValaCodeNode*) expr);
      if (VALA_IS_EXPRESSION_STATEMENT (_tmp937_)) {
            ValaDataType* _tmp938_ = NULL;
            gboolean _tmp939_;
            _tmp938_ = vala_expression_get_value_type ((ValaExpression*) expr);
            _tmp939_ = vala_data_type_is_disposable (_tmp938_);
            _tmp936_ = !_tmp939_;
      } else {
            _tmp936_ = FALSE;
      }
      if (_tmp936_) {
            if (ccall_expr != NULL) {
                  ValaCCodeFunction* _tmp940_ = NULL;
                  _tmp940_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
                  vala_ccode_function_add_expression (_tmp940_, ccall_expr);
            }
      } else {
            ValaDataType* _tmp941_ = NULL;
            ValaDataType* result_type;
            gboolean _tmp942_ = FALSE;
            ValaDataType* _tmp943_ = NULL;
            gboolean _tmp960_;
            ValaLocalVariable* _tmp961_ = NULL;
            ValaLocalVariable* temp_var;
            const gchar* _tmp962_ = NULL;
            ValaCCodeExpression* _tmp963_ = NULL;
            ValaCCodeExpression* temp_ref;
            ValaCCodeFunction* _tmp964_ = NULL;
            _tmp941_ = vala_data_type_get_return_type (itype);
            result_type = _tmp941_;
            _tmp943_ = vala_expression_get_formal_value_type ((ValaExpression*) expr);
            if (VALA_IS_GENERIC_TYPE (_tmp943_)) {
                  ValaDataType* _tmp944_ = NULL;
                  _tmp944_ = vala_expression_get_value_type ((ValaExpression*) expr);
                  _tmp942_ = !VALA_IS_GENERIC_TYPE (_tmp944_);
            } else {
                  _tmp942_ = FALSE;
            }
            if (_tmp942_) {
                  ValaDataType* _tmp945_ = NULL;
                  ValaTypeParameter* _tmp946_ = NULL;
                  ValaSymbol* _tmp947_ = NULL;
                  ValaSymbol* _tmp948_ = NULL;
                  ValaSymbol* _tmp949_;
                  ValaStruct* _tmp950_;
                  ValaStruct* st;
                  gboolean _tmp951_ = FALSE;
                  ValaDataType* _tmp952_ = NULL;
                  ValaTypeParameter* _tmp953_ = NULL;
                  ValaSymbol* _tmp954_ = NULL;
                  _tmp945_ = vala_expression_get_formal_value_type ((ValaExpression*) expr);
                  _tmp946_ = vala_data_type_get_type_parameter (_tmp945_);
                  _tmp947_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp946_);
                  _tmp948_ = vala_symbol_get_parent_symbol (_tmp947_);
                  _tmp949_ = _tmp948_;
                  _tmp950_ = _vala_code_node_ref0 (VALA_IS_STRUCT (_tmp949_) ? ((ValaStruct*) _tmp949_) : NULL);
                  st = _tmp950_;
                  _tmp952_ = vala_expression_get_formal_value_type ((ValaExpression*) expr);
                  _tmp953_ = vala_data_type_get_type_parameter (_tmp952_);
                  _tmp954_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp953_);
                  if (_tmp954_ == VALA_SYMBOL (((ValaCCodeBaseModule*) self)->garray_type)) {
                        _tmp951_ = TRUE;
                  } else {
                        gboolean _tmp955_ = FALSE;
                        if (st != NULL) {
                              gchar* _tmp956_ = NULL;
                              gchar* _tmp957_;
                              _tmp956_ = vala_typesymbol_get_cname ((ValaTypeSymbol*) st, FALSE);
                              _tmp957_ = _tmp956_;
                              _tmp955_ = g_strcmp0 (_tmp957_, "va_list") == 0;
                              _g_free0 (_tmp957_);
                        } else {
                              _tmp955_ = FALSE;
                        }
                        _tmp951_ = _tmp955_;
                  }
                  if (_tmp951_) {
                        ValaDataType* _tmp958_ = NULL;
                        ValaDataType* _tmp959_;
                        _tmp958_ = vala_expression_get_value_type ((ValaExpression*) expr);
                        _tmp959_ = _vala_code_node_ref0 (_tmp958_);
                        _vala_code_node_unref0 (result_type);
                        result_type = _tmp959_;
                  }
                  _vala_code_node_unref0 (st);
            }
            _tmp960_ = vala_data_type_get_value_owned (result_type);
            _tmp961_ = vala_ccode_base_module_get_temp_variable ((ValaCCodeBaseModule*) self, result_type, _tmp960_, NULL, TRUE);
            temp_var = _tmp961_;
            _tmp962_ = vala_symbol_get_name ((ValaSymbol*) temp_var);
            _tmp963_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, _tmp962_);
            temp_ref = _tmp963_;
            vala_ccode_base_module_emit_temp_var ((ValaCCodeBaseModule*) self, temp_var, FALSE);
            _tmp964_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
            vala_ccode_function_add_assignment (_tmp964_, temp_ref, ccall_expr);
            vala_ccode_base_module_set_cvalue ((ValaCCodeBaseModule*) self, (ValaExpression*) expr, temp_ref);
            _vala_ccode_node_unref0 (temp_ref);
            _vala_code_node_unref0 (temp_var);
            _vala_code_node_unref0 (result_type);
      }
      _tmp965_ = vala_iterable_iterator ((ValaIterable*) params);
      _vala_iterator_unref0 (params_it);
      params_it = _tmp965_;
      {
            ValaList* _tmp966_ = NULL;
            ValaList* _arg_list;
            gint _tmp967_;
            gint _arg_size;
            gint _arg_index;
            _tmp966_ = vala_method_call_get_argument_list (expr);
            _arg_list = _tmp966_;
            _tmp967_ = vala_collection_get_size ((ValaCollection*) _arg_list);
            _arg_size = _tmp967_;
            _arg_index = -1;
            while (TRUE) {
                  gpointer _tmp968_ = NULL;
                  ValaExpression* arg;
                  gboolean _tmp969_;
                  ValaExpression* _tmp974_;
                  ValaUnaryExpression* _tmp975_;
                  ValaUnaryExpression* unary;
                  gboolean _tmp976_ = FALSE;
                  ValaDataType* _tmp978_ = NULL;
                  gboolean _tmp979_;
                  ValaCCodeFunction* _tmp989_ = NULL;
                  ValaExpression* _tmp990_ = NULL;
                  ValaCCodeExpression* _tmp991_ = NULL;
                  ValaCCodeExpression* _tmp992_;
                  ValaCCodeExpression* _tmp993_ = NULL;
                  ValaCCodeExpression* _tmp994_;
                  ValaDataType* _tmp995_ = NULL;
                  ValaExpression* _tmp996_ = NULL;
                  ValaDataType* _tmp997_ = NULL;
                  ValaCCodeExpression* _tmp998_ = NULL;
                  ValaCCodeExpression* _tmp999_;
                  ValaDataType* _tmp1000_ = NULL;
                  ValaDataType* _tmp1001_;
                  ValaArrayType* _tmp1002_;
                  ValaArrayType* array_type;
                  ValaDataType* _tmp1015_ = NULL;
                  ValaDataType* _tmp1016_;
                  ValaDelegateType* _tmp1017_;
                  ValaDelegateType* delegate_type;
                  _arg_index = _arg_index + 1;
                  if (!(_arg_index < _arg_size)) {
                        break;
                  }
                  _tmp968_ = vala_list_get (_arg_list, _arg_index);
                  arg = (ValaExpression*) _tmp968_;
                  _tmp969_ = vala_iterator_next (params_it);
                  if (_tmp969_) {
                        gpointer _tmp970_ = NULL;
                        ValaParameter* param;
                        gboolean _tmp971_ = FALSE;
                        gboolean _tmp972_;
                        _tmp970_ = vala_iterator_get (params_it);
                        param = (ValaParameter*) _tmp970_;
                        _tmp972_ = vala_parameter_get_params_array (param);
                        if (_tmp972_) {
                              _tmp971_ = TRUE;
                        } else {
                              gboolean _tmp973_;
                              _tmp973_ = vala_parameter_get_ellipsis (param);
                              _tmp971_ = _tmp973_;
                        }
                        if (_tmp971_) {
                              _vala_code_node_unref0 (param);
                              _vala_code_node_unref0 (arg);
                              break;
                        }
                        _vala_code_node_unref0 (param);
                  }
                  _tmp974_ = arg;
                  _tmp975_ = _vala_code_node_ref0 (VALA_IS_UNARY_EXPRESSION (_tmp974_) ? ((ValaUnaryExpression*) _tmp974_) : NULL);
                  unary = _tmp975_;
                  if (unary == NULL) {
                        _tmp976_ = TRUE;
                  } else {
                        ValaUnaryOperator _tmp977_;
                        _tmp977_ = vala_unary_expression_get_operator (unary);
                        _tmp976_ = _tmp977_ != VALA_UNARY_OPERATOR_OUT;
                  }
                  if (_tmp976_) {
                        _vala_code_node_unref0 (unary);
                        _vala_code_node_unref0 (arg);
                        continue;
                  }
                  _tmp978_ = vala_expression_get_value_type (arg);
                  _tmp979_ = vala_ccode_base_module_requires_destroy ((ValaCCodeBaseModule*) self, _tmp978_);
                  if (_tmp979_) {
                        ValaCCodeFunction* _tmp980_ = NULL;
                        ValaExpression* _tmp981_ = NULL;
                        ValaCCodeExpression* _tmp982_ = NULL;
                        ValaCCodeExpression* _tmp983_;
                        ValaExpression* _tmp984_ = NULL;
                        ValaDataType* _tmp985_ = NULL;
                        ValaExpression* _tmp986_ = NULL;
                        ValaCCodeExpression* _tmp987_ = NULL;
                        ValaCCodeExpression* _tmp988_;
                        _tmp980_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
                        _tmp981_ = vala_unary_expression_get_inner (unary);
                        _tmp982_ = vala_ccode_base_module_get_cvalue ((ValaCCodeBaseModule*) self, _tmp981_);
                        _tmp983_ = _tmp982_;
                        _tmp984_ = vala_unary_expression_get_inner (unary);
                        _tmp985_ = vala_expression_get_value_type (_tmp984_);
                        _tmp986_ = vala_unary_expression_get_inner (unary);
                        _tmp987_ = vala_ccode_base_module_get_unref_expression ((ValaCCodeBaseModule*) self, _tmp983_, _tmp985_, _tmp986_, FALSE);
                        _tmp988_ = _tmp987_;
                        vala_ccode_function_add_expression (_tmp980_, _tmp988_);
                        _vala_ccode_node_unref0 (_tmp988_);
                        _vala_ccode_node_unref0 (_tmp983_);
                  }
                  _tmp989_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
                  _tmp990_ = vala_unary_expression_get_inner (unary);
                  _tmp991_ = vala_ccode_base_module_get_cvalue ((ValaCCodeBaseModule*) self, _tmp990_);
                  _tmp992_ = _tmp991_;
                  _tmp993_ = vala_ccode_base_module_get_cvalue ((ValaCCodeBaseModule*) self, (ValaExpression*) unary);
                  _tmp994_ = _tmp993_;
                  _tmp995_ = vala_expression_get_target_type ((ValaExpression*) unary);
                  _tmp996_ = vala_unary_expression_get_inner (unary);
                  _tmp997_ = vala_expression_get_value_type (_tmp996_);
                  _tmp998_ = vala_ccode_base_module_transform_expression ((ValaCCodeBaseModule*) self, _tmp994_, _tmp995_, _tmp997_, arg);
                  _tmp999_ = _tmp998_;
                  vala_ccode_function_add_assignment (_tmp989_, _tmp992_, _tmp999_);
                  _vala_ccode_node_unref0 (_tmp999_);
                  _vala_ccode_node_unref0 (_tmp994_);
                  _vala_ccode_node_unref0 (_tmp992_);
                  _tmp1000_ = vala_expression_get_value_type (arg);
                  _tmp1001_ = _tmp1000_;
                  _tmp1002_ = _vala_code_node_ref0 (VALA_IS_ARRAY_TYPE (_tmp1001_) ? ((ValaArrayType*) _tmp1001_) : NULL);
                  array_type = _tmp1002_;
                  if (array_type != NULL) {
                        {
                              gint dim;
                              dim = 1;
                              {
                                    gboolean _tmp1003_;
                                    _tmp1003_ = TRUE;
                                    while (TRUE) {
                                          gint _tmp1004_;
                                          ValaCCodeFunction* _tmp1005_ = NULL;
                                          ValaExpression* _tmp1006_ = NULL;
                                          ValaList* _tmp1007_ = NULL;
                                          ValaList* _tmp1008_;
                                          gpointer _tmp1009_ = NULL;
                                          ValaCCodeExpression* _tmp1010_;
                                          ValaList* _tmp1011_ = NULL;
                                          ValaList* _tmp1012_;
                                          gpointer _tmp1013_ = NULL;
                                          ValaCCodeExpression* _tmp1014_;
                                          if (!_tmp1003_) {
                                                dim++;
                                          }
                                          _tmp1003_ = FALSE;
                                          _tmp1004_ = vala_array_type_get_rank (array_type);
                                          if (!(dim <= _tmp1004_)) {
                                                break;
                                          }
                                          _tmp1005_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
                                          _tmp1006_ = vala_unary_expression_get_inner (unary);
                                          _tmp1007_ = vala_ccode_base_module_get_array_lengths ((ValaCCodeBaseModule*) self, _tmp1006_);
                                          _tmp1008_ = _tmp1007_;
                                          _tmp1009_ = vala_list_get (_tmp1008_, dim - 1);
                                          _tmp1010_ = (ValaCCodeExpression*) _tmp1009_;
                                          _tmp1011_ = vala_ccode_base_module_get_array_lengths ((ValaCCodeBaseModule*) self, (ValaExpression*) unary);
                                          _tmp1012_ = _tmp1011_;
                                          _tmp1013_ = vala_list_get (_tmp1012_, dim - 1);
                                          _tmp1014_ = (ValaCCodeExpression*) _tmp1013_;
                                          vala_ccode_function_add_assignment (_tmp1005_, _tmp1010_, _tmp1014_);
                                          _vala_ccode_node_unref0 (_tmp1014_);
                                          _vala_iterable_unref0 (_tmp1012_);
                                          _vala_ccode_node_unref0 (_tmp1010_);
                                          _vala_iterable_unref0 (_tmp1008_);
                                    }
                              }
                        }
                  }
                  _tmp1015_ = vala_expression_get_value_type (arg);
                  _tmp1016_ = _tmp1015_;
                  _tmp1017_ = _vala_code_node_ref0 (VALA_IS_DELEGATE_TYPE (_tmp1016_) ? ((ValaDelegateType*) _tmp1016_) : NULL);
                  delegate_type = _tmp1017_;
                  if (delegate_type != NULL) {
                        ValaCCodeFunction* _tmp1018_ = NULL;
                        ValaExpression* _tmp1019_ = NULL;
                        ValaCCodeExpression* _tmp1020_ = NULL;
                        ValaCCodeExpression* _tmp1021_;
                        ValaCCodeExpression* _tmp1022_ = NULL;
                        ValaCCodeExpression* _tmp1023_;
                        _tmp1018_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
                        _tmp1019_ = vala_unary_expression_get_inner (unary);
                        _tmp1020_ = vala_ccode_base_module_get_delegate_target ((ValaCCodeBaseModule*) self, _tmp1019_);
                        _tmp1021_ = _tmp1020_;
                        _tmp1022_ = vala_ccode_base_module_get_delegate_target ((ValaCCodeBaseModule*) self, (ValaExpression*) unary);
                        _tmp1023_ = _tmp1022_;
                        vala_ccode_function_add_assignment (_tmp1018_, _tmp1021_, _tmp1023_);
                        _vala_ccode_node_unref0 (_tmp1023_);
                        _vala_ccode_node_unref0 (_tmp1021_);
                  }
                  _vala_code_node_unref0 (delegate_type);
                  _vala_code_node_unref0 (array_type);
                  _vala_code_node_unref0 (unary);
                  _vala_code_node_unref0 (arg);
            }
            _vala_iterable_unref0 (_arg_list);
      }
      _vala_ccode_node_unref0 (out_param_ref);
      _vala_iterator_unref0 (params_it);
      _vala_ccode_node_unref0 (instance);
      _vala_ccode_node_unref0 (ccall_expr);
      _vala_map_unref0 (out_arg_map);
      _vala_map_unref0 (in_arg_map);
      _vala_code_node_unref0 (itype);
      _vala_code_node_unref0 (ma);
      _vala_iterable_unref0 (params);
      _vala_code_node_unref0 (deleg);
      _vala_code_node_unref0 (m);
      _vala_ccode_node_unref0 (async_call);
      _vala_ccode_node_unref0 (ccall);
}


static gchar* vala_ccode_method_call_module_generate_enum_tostring_function (ValaCCodeMethodCallModule* self, ValaEnum* en) {
      gchar* result = NULL;
      gchar* _tmp0_ = NULL;
      gchar* _tmp1_;
      gchar* _tmp2_ = NULL;
      gchar* _tmp3_;
      gchar* to_string_func;
      gboolean _tmp4_;
      ValaCCodeFunction* _tmp5_ = NULL;
      ValaCCodeFunction* function;
      gchar* _tmp6_ = NULL;
      gchar* _tmp7_;
      ValaCCodeParameter* _tmp8_ = NULL;
      ValaCCodeParameter* _tmp9_;
      ValaCCodeBaseModuleEmitContext* _tmp10_ = NULL;
      ValaCCodeBaseModuleEmitContext* _tmp11_;
      ValaCCodeFunction* _tmp12_ = NULL;
      ValaCCodeConstant* _tmp13_ = NULL;
      ValaCCodeConstant* _tmp14_;
      ValaCCodeFunction* _tmp32_ = NULL;
      ValaCCodeFunction* _tmp33_ = NULL;
      ValaCCodeConstant* _tmp34_ = NULL;
      ValaCCodeConstant* _tmp35_;
      g_return_val_if_fail (self != NULL, NULL);
      g_return_val_if_fail (en != NULL, NULL);
      _tmp0_ = vala_symbol_get_lower_case_cname ((ValaSymbol*) en, NULL);
      _tmp1_ = _tmp0_;
      _tmp2_ = g_strdup_printf ("_%s_to_string", _tmp1_);
      _tmp3_ = _tmp2_;
      _g_free0 (_tmp1_);
      to_string_func = _tmp3_;
      _tmp4_ = vala_ccode_base_module_add_wrapper ((ValaCCodeBaseModule*) self, to_string_func);
      if (!_tmp4_) {
            result = to_string_func;
            return result;
      }
      _tmp5_ = vala_ccode_function_new (to_string_func, "const char*");
      function = _tmp5_;
      vala_ccode_function_set_modifiers (function, VALA_CCODE_MODIFIERS_STATIC);
      _tmp6_ = vala_typesymbol_get_cname ((ValaTypeSymbol*) en, FALSE);
      _tmp7_ = _tmp6_;
      _tmp8_ = vala_ccode_parameter_new ("value", _tmp7_);
      _tmp9_ = _tmp8_;
      vala_ccode_function_add_parameter (function, _tmp9_);
      _vala_ccode_node_unref0 (_tmp9_);
      _g_free0 (_tmp7_);
      _tmp10_ = vala_ccode_base_module_emit_context_new (NULL);
      _tmp11_ = _tmp10_;
      vala_ccode_base_module_push_context ((ValaCCodeBaseModule*) self, _tmp11_);
      _vala_ccode_base_module_emit_context_unref0 (_tmp11_);
      vala_ccode_base_module_push_function ((ValaCCodeBaseModule*) self, function);
      _tmp12_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
      _tmp13_ = vala_ccode_constant_new ("value");
      _tmp14_ = _tmp13_;
      vala_ccode_function_open_switch (_tmp12_, (ValaCCodeExpression*) _tmp14_);
      _vala_ccode_node_unref0 (_tmp14_);
      {
            ValaList* _tmp15_ = NULL;
            ValaList* _enum_value_list;
            gint _tmp16_;
            gint _enum_value_size;
            gint _enum_value_index;
            _tmp15_ = vala_enum_get_values (en);
            _enum_value_list = _tmp15_;
            _tmp16_ = vala_collection_get_size ((ValaCollection*) _enum_value_list);
            _enum_value_size = _tmp16_;
            _enum_value_index = -1;
            while (TRUE) {
                  gpointer _tmp17_ = NULL;
                  ValaEnumValue* enum_value;
                  ValaCCodeFunction* _tmp18_ = NULL;
                  gchar* _tmp19_ = NULL;
                  gchar* _tmp20_;
                  ValaCCodeIdentifier* _tmp21_ = NULL;
                  ValaCCodeIdentifier* _tmp22_;
                  ValaCCodeFunction* _tmp23_ = NULL;
                  gchar* _tmp24_ = NULL;
                  gchar* _tmp25_;
                  gchar* _tmp26_;
                  gchar* _tmp27_;
                  gchar* _tmp28_;
                  gchar* _tmp29_;
                  ValaCCodeConstant* _tmp30_ = NULL;
                  ValaCCodeConstant* _tmp31_;
                  _enum_value_index = _enum_value_index + 1;
                  if (!(_enum_value_index < _enum_value_size)) {
                        break;
                  }
                  _tmp17_ = vala_list_get (_enum_value_list, _enum_value_index);
                  enum_value = (ValaEnumValue*) _tmp17_;
                  _tmp18_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
                  _tmp19_ = vala_constant_get_cname ((ValaConstant*) enum_value);
                  _tmp20_ = _tmp19_;
                  _tmp21_ = vala_ccode_identifier_new (_tmp20_);
                  _tmp22_ = _tmp21_;
                  vala_ccode_function_add_case (_tmp18_, (ValaCCodeExpression*) _tmp22_);
                  _vala_ccode_node_unref0 (_tmp22_);
                  _g_free0 (_tmp20_);
                  _tmp23_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
                  _tmp24_ = vala_constant_get_cname ((ValaConstant*) enum_value);
                  _tmp25_ = _tmp24_;
                  _tmp26_ = g_strconcat ("\"", _tmp25_, NULL);
                  _tmp27_ = _tmp26_;
                  _tmp28_ = g_strconcat (_tmp27_, "\"", NULL);
                  _tmp29_ = _tmp28_;
                  _tmp30_ = vala_ccode_constant_new (_tmp29_);
                  _tmp31_ = _tmp30_;
                  vala_ccode_function_add_return (_tmp23_, (ValaCCodeExpression*) _tmp31_);
                  _vala_ccode_node_unref0 (_tmp31_);
                  _g_free0 (_tmp29_);
                  _g_free0 (_tmp27_);
                  _g_free0 (_tmp25_);
                  _vala_code_node_unref0 (enum_value);
            }
            _vala_iterable_unref0 (_enum_value_list);
      }
      _tmp32_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
      vala_ccode_function_close (_tmp32_);
      _tmp33_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
      _tmp34_ = vala_ccode_constant_new ("NULL");
      _tmp35_ = _tmp34_;
      vala_ccode_function_add_return (_tmp33_, (ValaCCodeExpression*) _tmp35_);
      _vala_ccode_node_unref0 (_tmp35_);
      vala_ccode_file_add_function_declaration (((ValaCCodeBaseModule*) self)->cfile, function);
      vala_ccode_file_add_function (((ValaCCodeBaseModule*) self)->cfile, function);
      vala_ccode_base_module_pop_context ((ValaCCodeBaseModule*) self);
      result = to_string_func;
      _vala_ccode_node_unref0 (function);
      return result;
}


ValaCCodeMethodCallModule* vala_ccode_method_call_module_construct (GType object_type) {
      ValaCCodeMethodCallModule* self = NULL;
      self = (ValaCCodeMethodCallModule*) vala_ccode_assignment_module_construct (object_type);
      return self;
}


ValaCCodeMethodCallModule* vala_ccode_method_call_module_new (void) {
      return vala_ccode_method_call_module_construct (VALA_TYPE_CCODE_METHOD_CALL_MODULE);
}


static void vala_ccode_method_call_module_class_init (ValaCCodeMethodCallModuleClass * klass) {
      vala_ccode_method_call_module_parent_class = g_type_class_peek_parent (klass);
      VALA_CODE_VISITOR_CLASS (klass)->visit_method_call = vala_ccode_method_call_module_real_visit_method_call;
}


static void vala_ccode_method_call_module_instance_init (ValaCCodeMethodCallModule * self) {
}


GType vala_ccode_method_call_module_get_type (void) {
      static volatile gsize vala_ccode_method_call_module_type_id__volatile = 0;
      if (g_once_init_enter (&vala_ccode_method_call_module_type_id__volatile)) {
            static const GTypeInfo g_define_type_info = { sizeof (ValaCCodeMethodCallModuleClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) vala_ccode_method_call_module_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ValaCCodeMethodCallModule), 0, (GInstanceInitFunc) vala_ccode_method_call_module_instance_init, NULL };
            GType vala_ccode_method_call_module_type_id;
            vala_ccode_method_call_module_type_id = g_type_register_static (VALA_TYPE_CCODE_ASSIGNMENT_MODULE, "ValaCCodeMethodCallModule", &g_define_type_info, 0);
            g_once_init_leave (&vala_ccode_method_call_module_type_id__volatile, vala_ccode_method_call_module_type_id);
      }
      return vala_ccode_method_call_module_type_id__volatile;
}


static void _vala_array_destroy (gpointer array, gint array_length, GDestroyNotify destroy_func) {
      if ((array != NULL) && (destroy_func != NULL)) {
            int i;
            for (i = 0; i < array_length; i = i + 1) {
                  if (((gpointer*) array)[i] != NULL) {
                        destroy_func (((gpointer*) array)[i]);
                  }
            }
      }
}


static void _vala_array_free (gpointer array, gint array_length, GDestroyNotify destroy_func) {
      _vala_array_destroy (array, array_length, destroy_func);
      g_free (array);
}


static gint _vala_array_length (gpointer array) {
      int length;
      length = 0;
      if (array) {
            while (((gpointer*) array)[length]) {
                  length++;
            }
      }
      return length;
}




Generated by  Doxygen 1.6.0   Back to index