Logo Search packages:      
Sourcecode: vala-0.14 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_TYPE_GLIB_VALUE (vala_glib_value_get_type ())
#define VALA_GLIB_VALUE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_GLIB_VALUE, ValaGLibValue))
#define VALA_GLIB_VALUE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_GLIB_VALUE, ValaGLibValueClass))
#define VALA_IS_GLIB_VALUE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_GLIB_VALUE))
#define VALA_IS_GLIB_VALUE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_GLIB_VALUE))
#define VALA_GLIB_VALUE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_GLIB_VALUE, ValaGLibValueClass))

typedef struct _ValaGLibValue ValaGLibValue;
typedef struct _ValaGLibValueClass ValaGLibValueClass;
#define _vala_target_value_unref0(var) ((var == NULL) ? NULL : (var = (vala_target_value_unref (var), NULL)))
#define _vala_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;
      gboolean in_plugin;
      gchar* module_init_param_name;
      gboolean gvaluecollector_h_needed;
      gboolean requires_array_free;
      gboolean requires_array_move;
      gboolean requires_array_length;
      ValaSet* wrappers;
};

struct _ValaCCodeBaseModuleClass {
      ValaCodeGeneratorClass parent_class;
      void (*append_vala_array_free) (ValaCCodeBaseModule* self);
      void (*append_vala_array_move) (ValaCCodeBaseModule* self);
      void (*append_vala_array_length) (ValaCCodeBaseModule* self);
      gboolean (*generate_enum_declaration) (ValaCCodeBaseModule* self, ValaEnum* en, ValaCCodeFile* decl_space);
      void (*generate_class_struct_declaration) (ValaCCodeBaseModule* self, ValaClass* cl, ValaCCodeFile* decl_space);
      void (*generate_struct_declaration) (ValaCCodeBaseModule* self, ValaStruct* st, ValaCCodeFile* decl_space);
      void (*generate_delegate_declaration) (ValaCCodeBaseModule* self, ValaDelegate* d, ValaCCodeFile* decl_space);
      void (*generate_cparameters) (ValaCCodeBaseModule* self, ValaMethod* m, ValaCCodeFile* decl_space, ValaMap* cparam_map, ValaCCodeFunction* func, ValaCCodeFunctionDeclarator* vdeclarator, ValaMap* carg_map, ValaCCodeFunctionCall* vcall, gint direction);
      ValaCCodeExpression* (*get_dup_func_expression) (ValaCCodeBaseModule* self, ValaDataType* type, ValaSourceReference* source_reference, gboolean is_chainup);
      gchar* (*append_struct_array_free) (ValaCCodeBaseModule* self, ValaStruct* st);
      ValaCCodeExpression* (*destroy_value) (ValaCCodeBaseModule* self, ValaTargetValue* value, gboolean is_macro_definition);
      void (*append_scope_free) (ValaCCodeBaseModule* self, ValaSymbol* sym, ValaCodeNode* stop_at);
      ValaTargetValue* (*get_local_cvalue) (ValaCCodeBaseModule* self, ValaLocalVariable* local);
      ValaTargetValue* (*get_parameter_cvalue) (ValaCCodeBaseModule* self, ValaParameter* param);
      ValaTargetValue* (*get_field_cvalue) (ValaCCodeBaseModule* self, ValaField* field, ValaTargetValue* instance);
      ValaTargetValue* (*load_this_parameter) (ValaCCodeBaseModule* self, ValaTypeSymbol* sym);
      void (*store_value) (ValaCCodeBaseModule* self, ValaTargetValue* lvalue, ValaTargetValue* value);
      gchar* (*get_delegate_target_cname) (ValaCCodeBaseModule* self, const gchar* delegate_cname);
      ValaCCodeExpression* (*get_delegate_target_cexpression) (ValaCCodeBaseModule* self, ValaExpression* delegate_expr, ValaCCodeExpression** delegate_target_destroy_notify);
      ValaCCodeExpression* (*get_delegate_target_cvalue) (ValaCCodeBaseModule* self, ValaTargetValue* value);
      ValaCCodeExpression* (*get_delegate_target_destroy_notify_cvalue) (ValaCCodeBaseModule* self, ValaTargetValue* value);
      gchar* (*get_delegate_target_destroy_notify_cname) (ValaCCodeBaseModule* self, const gchar* delegate_cname);
      ValaTargetValue* (*copy_value) (ValaCCodeBaseModule* self, ValaTargetValue* value, ValaCodeNode* node);
      void (*generate_class_declaration) (ValaCCodeBaseModule* self, ValaClass* cl, ValaCCodeFile* decl_space);
      void (*generate_interface_declaration) (ValaCCodeBaseModule* self, ValaInterface* iface, ValaCCodeFile* decl_space);
      void (*generate_method_declaration) (ValaCCodeBaseModule* self, ValaMethod* m, ValaCCodeFile* decl_space);
      void (*generate_error_domain_declaration) (ValaCCodeBaseModule* self, ValaErrorDomain* edomain, ValaCCodeFile* decl_space);
      ValaCCodeExpression* (*deserialize_expression) (ValaCCodeBaseModule* self, ValaDataType* type, ValaCCodeExpression* variant_expr, ValaCCodeExpression* expr, ValaCCodeExpression* error_expr, gboolean* may_fail);
      ValaCCodeExpression* (*serialize_expression) (ValaCCodeBaseModule* self, ValaDataType* type, ValaCCodeExpression* expr);
      ValaCCodeExpression* (*get_implicit_cast_expression) (ValaCCodeBaseModule* self, ValaCCodeExpression* source_cexpr, ValaDataType* expression_type, ValaDataType* target_type, ValaCodeNode* node);
      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);
      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);
void vala_ccode_base_module_store_property (ValaCCodeBaseModule* self, ValaProperty* prop, ValaExpression* instance, ValaTargetValue* value);
ValaGLibValue* vala_glib_value_new (ValaDataType* value_type, ValaCCodeExpression* cvalue);
ValaGLibValue* vala_glib_value_construct (GType object_type, ValaDataType* value_type, ValaCCodeExpression* cvalue);
GType vala_glib_value_get_type (void) G_GNUC_CONST;
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_destroy_value (ValaCCodeBaseModule* self, ValaTargetValue* value, gboolean is_macro_definition);
void vala_ccode_base_module_store_value (ValaCCodeBaseModule* self, ValaTargetValue* lvalue, ValaTargetValue* value);
ValaTargetValue* vala_ccode_base_module_transform_value (ValaCCodeBaseModule* self, ValaTargetValue* value, ValaDataType* target_type, ValaCodeNode* node);
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 _tmp646_;
      gboolean _tmp651_ = FALSE;
      gboolean _tmp652_ = FALSE;
      gboolean _tmp717_ = FALSE;
      gboolean _tmp764_ = FALSE;
      gboolean _tmp776_;
      ValaDataType* _tmp810_ = NULL;
      ValaDataType* _tmp811_;
      gboolean _tmp812_;
      gboolean _tmp813_;
      gboolean return_result_via_out_param;
      gboolean _tmp814_ = FALSE;
      ValaCCodeExpression* out_param_ref;
      gint last_pos = 0;
      gint min_pos = 0;
      gboolean _tmp853_;
      gboolean _tmp873_ = FALSE;
      gboolean _tmp874_ = FALSE;
      gboolean _tmp955_ = FALSE;
      ValaCodeNode* _tmp956_ = NULL;
      ValaIterator* _tmp984_ = 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 _tmp633_ = 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 _tmp629_;
                        gint _tmp630_;
                        _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* _tmp625_ = 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_;
                                    ValaTargetValue* _tmp566_ = NULL;
                                    ValaDataType* _tmp567_ = NULL;
                                    ValaCCodeExpression* _tmp568_ = NULL;
                                    ValaCCodeExpression* _tmp569_;
                                    ValaCCodeUnaryExpression* _tmp570_ = NULL;
                                    gboolean _tmp571_ = FALSE;
                                    gboolean _tmp572_;
                                    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_expression_get_target_value (arg);
                                    _tmp567_ = vala_expression_get_target_type (arg);
                                    vala_target_value_set_value_type (_tmp566_, _tmp567_);
                                    _tmp568_ = vala_ccode_base_module_get_cvalue ((ValaCCodeBaseModule*) self, arg);
                                    _tmp569_ = _tmp568_;
                                    _tmp570_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, _tmp569_);
                                    _vala_ccode_node_unref0 (cexpr);
                                    cexpr = (ValaCCodeExpression*) _tmp570_;
                                    _vala_ccode_node_unref0 (_tmp569_);
                                    _tmp572_ = vala_variable_get_no_array_length ((ValaVariable*) param);
                                    if (!_tmp572_) {
                                          ValaDataType* _tmp573_ = NULL;
                                          _tmp573_ = vala_variable_get_variable_type ((ValaVariable*) param);
                                          _tmp571_ = VALA_IS_ARRAY_TYPE (_tmp573_);
                                    } else {
                                          _tmp571_ = FALSE;
                                    }
                                    if (_tmp571_) {
                                          ValaDataType* _tmp574_ = NULL;
                                          ValaArrayType* _tmp575_;
                                          ValaArrayType* array_type;
                                          ValaDataType* _tmp576_;
                                          ValaDataType* array_length_type;
                                          const gchar* _tmp577_ = NULL;
                                          _tmp574_ = vala_variable_get_variable_type ((ValaVariable*) param);
                                          _tmp575_ = _vala_code_node_ref0 (VALA_ARRAY_TYPE (_tmp574_));
                                          array_type = _tmp575_;
                                          _tmp576_ = _vala_code_node_ref0 (((ValaCCodeBaseModule*) self)->int_type);
                                          array_length_type = _tmp576_;
                                          _tmp577_ = vala_variable_get_array_length_type ((ValaVariable*) param);
                                          if (_tmp577_ != NULL) {
                                                const gchar* _tmp578_ = NULL;
                                                ValaCType* _tmp579_ = NULL;
                                                _tmp578_ = vala_variable_get_array_length_type ((ValaVariable*) param);
                                                _tmp579_ = vala_ctype_new (_tmp578_);
                                                _vala_code_node_unref0 (array_length_type);
                                                array_length_type = (ValaDataType*) _tmp579_;
                                          }
                                          {
                                                gint dim;
                                                dim = 1;
                                                {
                                                      gboolean _tmp580_;
                                                      _tmp580_ = TRUE;
                                                      while (TRUE) {
                                                            gint _tmp581_;
                                                            ValaLocalVariable* _tmp582_ = NULL;
                                                            ValaLocalVariable* temp_array_length;
                                                            const gchar* _tmp583_ = NULL;
                                                            ValaCCodeExpression* _tmp584_ = NULL;
                                                            ValaCCodeExpression* _tmp585_;
                                                            gdouble _tmp586_;
                                                            gint _tmp587_;
                                                            ValaList* _tmp588_ = NULL;
                                                            ValaList* _tmp589_;
                                                            gpointer _tmp590_ = NULL;
                                                            ValaCCodeExpression* _tmp591_;
                                                            ValaCCodeUnaryExpression* _tmp592_ = NULL;
                                                            ValaCCodeUnaryExpression* _tmp593_;
                                                            if (!_tmp580_) {
                                                                  dim++;
                                                            }
                                                            _tmp580_ = FALSE;
                                                            _tmp581_ = vala_array_type_get_rank (array_type);
                                                            if (!(dim <= _tmp581_)) {
                                                                  break;
                                                            }
                                                            _tmp582_ = vala_ccode_base_module_get_temp_variable ((ValaCCodeBaseModule*) self, array_length_type, TRUE, NULL, TRUE);
                                                            temp_array_length = _tmp582_;
                                                            vala_ccode_base_module_emit_temp_var ((ValaCCodeBaseModule*) self, temp_array_length, FALSE);
                                                            _tmp583_ = vala_symbol_get_name ((ValaSymbol*) temp_array_length);
                                                            _tmp584_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, _tmp583_);
                                                            _tmp585_ = _tmp584_;
                                                            vala_ccode_base_module_append_array_length ((ValaCCodeBaseModule*) self, arg, _tmp585_);
                                                            _vala_ccode_node_unref0 (_tmp585_);
                                                            _tmp586_ = vala_parameter_get_carray_length_parameter_position (param);
                                                            _tmp587_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, _tmp586_ + (0.01 * dim), FALSE);
                                                            _tmp588_ = vala_ccode_base_module_get_array_lengths ((ValaCCodeBaseModule*) self, arg);
                                                            _tmp589_ = _tmp588_;
                                                            _tmp590_ = vala_list_get (_tmp589_, dim - 1);
                                                            _tmp591_ = (ValaCCodeExpression*) _tmp590_;
                                                            _tmp592_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, _tmp591_);
                                                            _tmp593_ = _tmp592_;
                                                            vala_map_set ((ValaMap*) carg_map, GINT_TO_POINTER (_tmp587_), (ValaCCodeExpression*) _tmp593_);
                                                            _vala_ccode_node_unref0 (_tmp593_);
                                                            _vala_ccode_node_unref0 (_tmp591_);
                                                            _vala_iterable_unref0 (_tmp589_);
                                                            _vala_code_node_unref0 (temp_array_length);
                                                      }
                                                }
                                          }
                                          _vala_code_node_unref0 (array_length_type);
                                          _vala_code_node_unref0 (array_type);
                                    } else {
                                          ValaDataType* _tmp594_ = NULL;
                                          _tmp594_ = vala_variable_get_variable_type ((ValaVariable*) param);
                                          if (VALA_IS_DELEGATE_TYPE (_tmp594_)) {
                                                ValaDataType* _tmp595_ = NULL;
                                                ValaDelegateType* _tmp596_;
                                                ValaDelegateType* deleg_type;
                                                ValaDelegate* _tmp597_ = NULL;
                                                ValaDelegate* _tmp598_;
                                                ValaDelegate* d;
                                                gboolean _tmp599_;
                                                _tmp595_ = vala_variable_get_variable_type ((ValaVariable*) param);
                                                _tmp596_ = _vala_code_node_ref0 (VALA_DELEGATE_TYPE (_tmp595_));
                                                deleg_type = _tmp596_;
                                                _tmp597_ = vala_delegate_type_get_delegate_symbol (deleg_type);
                                                _tmp598_ = _vala_code_node_ref0 (_tmp597_);
                                                d = _tmp598_;
                                                _tmp599_ = vala_delegate_get_has_target (d);
                                                if (_tmp599_) {
                                                      ValaVoidType* _tmp600_ = NULL;
                                                      ValaVoidType* _tmp601_;
                                                      ValaPointerType* _tmp602_ = NULL;
                                                      ValaPointerType* _tmp603_;
                                                      ValaLocalVariable* _tmp604_ = NULL;
                                                      const gchar* _tmp605_ = NULL;
                                                      ValaCCodeExpression* _tmp606_ = NULL;
                                                      ValaCCodeExpression* _tmp607_;
                                                      gdouble _tmp608_;
                                                      gint _tmp609_;
                                                      ValaCCodeExpression* _tmp610_ = NULL;
                                                      ValaCCodeExpression* _tmp611_;
                                                      ValaCCodeUnaryExpression* _tmp612_ = NULL;
                                                      ValaCCodeUnaryExpression* _tmp613_;
                                                      gboolean _tmp614_;
                                                      _tmp600_ = vala_void_type_new (NULL);
                                                      _tmp601_ = _tmp600_;
                                                      _tmp602_ = vala_pointer_type_new ((ValaDataType*) _tmp601_, NULL);
                                                      _tmp603_ = _tmp602_;
                                                      _tmp604_ = vala_ccode_base_module_get_temp_variable ((ValaCCodeBaseModule*) self, (ValaDataType*) _tmp603_, TRUE, NULL, TRUE);
                                                      _vala_code_node_unref0 (temp_var);
                                                      temp_var = _tmp604_;
                                                      _vala_code_node_unref0 (_tmp603_);
                                                      _vala_code_node_unref0 (_tmp601_);
                                                      vala_ccode_base_module_emit_temp_var ((ValaCCodeBaseModule*) self, temp_var, FALSE);
                                                      _tmp605_ = vala_symbol_get_name ((ValaSymbol*) temp_var);
                                                      _tmp606_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, _tmp605_);
                                                      _tmp607_ = _tmp606_;
                                                      vala_ccode_base_module_set_delegate_target ((ValaCCodeBaseModule*) self, arg, _tmp607_);
                                                      _vala_ccode_node_unref0 (_tmp607_);
                                                      _tmp608_ = vala_parameter_get_cdelegate_target_parameter_position (param);
                                                      _tmp609_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, _tmp608_, FALSE);
                                                      _tmp610_ = vala_ccode_base_module_get_delegate_target ((ValaCCodeBaseModule*) self, arg);
                                                      _tmp611_ = _tmp610_;
                                                      _tmp612_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, _tmp611_);
                                                      _tmp613_ = _tmp612_;
                                                      vala_map_set ((ValaMap*) carg_map, GINT_TO_POINTER (_tmp609_), (ValaCCodeExpression*) _tmp613_);
                                                      _vala_ccode_node_unref0 (_tmp613_);
                                                      _vala_ccode_node_unref0 (_tmp611_);
                                                      _tmp614_ = vala_data_type_get_value_owned ((ValaDataType*) deleg_type);
                                                      if (_tmp614_) {
                                                            ValaLocalVariable* _tmp615_ = NULL;
                                                            const gchar* _tmp616_ = NULL;
                                                            ValaCCodeExpression* _tmp617_ = NULL;
                                                            ValaCCodeExpression* _tmp618_;
                                                            gdouble _tmp619_;
                                                            gint _tmp620_;
                                                            ValaCCodeExpression* _tmp621_ = NULL;
                                                            ValaCCodeExpression* _tmp622_;
                                                            ValaCCodeUnaryExpression* _tmp623_ = NULL;
                                                            ValaCCodeUnaryExpression* _tmp624_;
                                                            _tmp615_ = vala_ccode_base_module_get_temp_variable ((ValaCCodeBaseModule*) self, ((ValaCCodeBaseModule*) self)->gdestroynotify_type, TRUE, NULL, TRUE);
                                                            _vala_code_node_unref0 (temp_var);
                                                            temp_var = _tmp615_;
                                                            vala_ccode_base_module_emit_temp_var ((ValaCCodeBaseModule*) self, temp_var, FALSE);
                                                            _tmp616_ = vala_symbol_get_name ((ValaSymbol*) temp_var);
                                                            _tmp617_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, _tmp616_);
                                                            _tmp618_ = _tmp617_;
                                                            vala_ccode_base_module_set_delegate_target_destroy_notify ((ValaCCodeBaseModule*) self, arg, _tmp618_);
                                                            _vala_ccode_node_unref0 (_tmp618_);
                                                            _tmp619_ = vala_parameter_get_cdelegate_target_parameter_position (param);
                                                            _tmp620_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, _tmp619_ + 0.01, FALSE);
                                                            _tmp621_ = vala_ccode_base_module_get_delegate_target_destroy_notify ((ValaCCodeBaseModule*) self, arg);
                                                            _tmp622_ = _tmp621_;
                                                            _tmp623_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, _tmp622_);
                                                            _tmp624_ = _tmp623_;
                                                            vala_map_set ((ValaMap*) carg_map, GINT_TO_POINTER (_tmp620_), (ValaCCodeExpression*) _tmp624_);
                                                            _vala_ccode_node_unref0 (_tmp624_);
                                                            _vala_ccode_node_unref0 (_tmp622_);
                                                      }
                                                }
                                                _vala_code_node_unref0 (d);
                                                _vala_code_node_unref0 (deleg_type);
                                          }
                                    }
                                    _vala_code_node_unref0 (temp_var);
                              }
                              _tmp625_ = vala_parameter_get_ctype (param);
                              if (_tmp625_ != NULL) {
                                    const gchar* _tmp626_ = NULL;
                                    ValaCCodeCastExpression* _tmp627_ = NULL;
                                    _tmp626_ = vala_parameter_get_ctype (param);
                                    _tmp627_ = vala_ccode_cast_expression_new (cexpr, _tmp626_);
                                    _vala_ccode_node_unref0 (cexpr);
                                    cexpr = (ValaCCodeExpression*) _tmp627_;
                              }
                              _vala_code_node_unref0 (unary);
                        } else {
                              ValaCCodeExpression* _tmp628_ = NULL;
                              _tmp628_ = vala_ccode_base_module_handle_struct_argument ((ValaCCodeBaseModule*) self, NULL, arg, cexpr);
                              _vala_ccode_node_unref0 (cexpr);
                              cexpr = _tmp628_;
                        }
                        _tmp629_ = vala_parameter_get_cparameter_position (param);
                        _tmp630_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, _tmp629_, ellipsis);
                        arg_pos = _tmp630_;
                        _vala_code_node_unref0 (param);
                  } else {
                        ValaCCodeExpression* _tmp631_ = NULL;
                        gint _tmp632_;
                        _tmp631_ = vala_ccode_base_module_handle_struct_argument ((ValaCCodeBaseModule*) self, NULL, arg, cexpr);
                        _vala_ccode_node_unref0 (cexpr);
                        cexpr = _tmp631_;
                        _tmp632_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, (gdouble) i, ellipsis);
                        arg_pos = _tmp632_;
                  }
                  vala_map_set ((ValaMap*) carg_map, GINT_TO_POINTER (arg_pos), cexpr);
                  if (VALA_IS_NAMED_ARGUMENT (arg)) {
                        _tmp633_ = ellipsis;
                  } else {
                        _tmp633_ = FALSE;
                  }
                  if (_tmp633_) {
                        ValaNamedArgument* _tmp634_;
                        ValaNamedArgument* named_arg;
                        const gchar* _tmp635_ = NULL;
                        gchar** _tmp636_;
                        gchar** _tmp637_ = NULL;
                        gchar** _tmp638_;
                        gint _tmp638__length1;
                        gchar* _tmp639_ = NULL;
                        gchar* _tmp640_;
                        gchar* name;
                        gint _tmp641_;
                        gchar* _tmp642_ = NULL;
                        gchar* _tmp643_;
                        ValaCCodeConstant* _tmp644_ = NULL;
                        ValaCCodeConstant* _tmp645_;
                        _tmp634_ = _vala_code_node_ref0 (VALA_NAMED_ARGUMENT (arg));
                        named_arg = _tmp634_;
                        _tmp635_ = vala_named_argument_get_name (named_arg);
                        _tmp637_ = _tmp636_ = g_strsplit (_tmp635_, "_", 0);
                        _tmp638_ = _tmp637_;
                        _tmp638__length1 = _vala_array_length (_tmp636_);
                        _tmp639_ = g_strjoinv ("-", _tmp638_);
                        _tmp640_ = _tmp639_;
                        _tmp638_ = (_vala_array_free (_tmp638_, _tmp638__length1, (GDestroyNotify) g_free), NULL);
                        name = _tmp640_;
                        _tmp641_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, i - 0.1, ellipsis);
                        _tmp642_ = g_strdup_printf ("\"%s\"", name);
                        _tmp643_ = _tmp642_;
                        _tmp644_ = vala_ccode_constant_new (_tmp643_);
                        _tmp645_ = _tmp644_;
                        vala_map_set ((ValaMap*) carg_map, GINT_TO_POINTER (_tmp641_), (ValaCCodeExpression*) _tmp645_);
                        _vala_ccode_node_unref0 (_tmp645_);
                        _g_free0 (_tmp643_);
                        _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);
      }
      _tmp646_ = vala_iterator_next (params_it);
      if (_tmp646_) {
            gpointer _tmp647_ = NULL;
            ValaParameter* param;
            gboolean _tmp648_ = FALSE;
            gboolean _tmp649_;
            _tmp647_ = vala_iterator_get (params_it);
            param = (ValaParameter*) _tmp647_;
            _tmp649_ = vala_parameter_get_params_array (param);
            if (_tmp649_) {
                  _tmp648_ = TRUE;
            } else {
                  gboolean _tmp650_;
                  _tmp650_ = vala_parameter_get_ellipsis (param);
                  _tmp648_ = _tmp650_;
            }
            g_assert (_tmp648_);
            ellipsis = TRUE;
            _vala_code_node_unref0 (param);
      }
      if (m != NULL) {
            ValaDataType* _tmp653_ = NULL;
            _tmp653_ = vala_method_get_return_type (m);
            _tmp652_ = VALA_IS_ARRAY_TYPE (_tmp653_);
      } else {
            _tmp652_ = FALSE;
      }
      if (_tmp652_) {
            _tmp651_ = async_call != ccall;
      } else {
            _tmp651_ = FALSE;
      }
      if (_tmp651_) {
            ValaDataType* _tmp654_ = NULL;
            ValaArrayType* _tmp655_;
            ValaArrayType* array_type;
            _tmp654_ = vala_method_get_return_type (m);
            _tmp655_ = _vala_code_node_ref0 (VALA_ARRAY_TYPE (_tmp654_));
            array_type = _tmp655_;
            {
                  gint dim;
                  dim = 1;
                  {
                        gboolean _tmp656_;
                        _tmp656_ = TRUE;
                        while (TRUE) {
                              gint _tmp657_;
                              gboolean _tmp658_;
                              if (!_tmp656_) {
                                    dim++;
                              }
                              _tmp656_ = FALSE;
                              _tmp657_ = vala_array_type_get_rank (array_type);
                              if (!(dim <= _tmp657_)) {
                                    break;
                              }
                              _tmp658_ = vala_method_get_array_null_terminated (m);
                              if (_tmp658_) {
                                    ValaDataType* _tmp659_ = NULL;
                                    ValaDataType* _tmp660_;
                                    ValaLocalVariable* _tmp661_ = NULL;
                                    ValaLocalVariable* _tmp662_;
                                    ValaLocalVariable* temp_var;
                                    const gchar* _tmp663_ = NULL;
                                    ValaCCodeExpression* _tmp664_ = NULL;
                                    ValaCCodeExpression* temp_ref;
                                    ValaCCodeAssignment* _tmp665_ = NULL;
                                    ValaCCodeIdentifier* _tmp666_ = NULL;
                                    ValaCCodeIdentifier* _tmp667_;
                                    ValaCCodeFunctionCall* _tmp668_ = NULL;
                                    ValaCCodeFunctionCall* _tmp669_;
                                    ValaCCodeFunctionCall* len_call;
                                    _tmp659_ = vala_data_type_get_return_type (itype);
                                    _tmp660_ = _tmp659_;
                                    _tmp661_ = vala_ccode_base_module_get_temp_variable ((ValaCCodeBaseModule*) self, _tmp660_, TRUE, NULL, FALSE);
                                    _tmp662_ = _tmp661_;
                                    _vala_code_node_unref0 (_tmp660_);
                                    temp_var = _tmp662_;
                                    _tmp663_ = vala_symbol_get_name ((ValaSymbol*) temp_var);
                                    _tmp664_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, _tmp663_);
                                    temp_ref = _tmp664_;
                                    vala_ccode_base_module_emit_temp_var ((ValaCCodeBaseModule*) self, temp_var, FALSE);
                                    _tmp665_ = vala_ccode_assignment_new (temp_ref, ccall_expr, VALA_CCODE_ASSIGNMENT_OPERATOR_SIMPLE);
                                    _vala_ccode_node_unref0 (ccall_expr);
                                    ccall_expr = (ValaCCodeExpression*) _tmp665_;
                                    ((ValaCCodeBaseModule*) self)->requires_array_length = TRUE;
                                    _tmp666_ = vala_ccode_identifier_new ("_vala_array_length");
                                    _tmp667_ = _tmp666_;
                                    _tmp668_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp667_);
                                    _tmp669_ = _tmp668_;
                                    _vala_ccode_node_unref0 (_tmp667_);
                                    len_call = _tmp669_;
                                    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 _tmp670_;
                                    _tmp670_ = vala_method_get_no_array_length (m);
                                    if (!_tmp670_) {
                                          ValaLocalVariable* temp_var = NULL;
                                          const gchar* _tmp671_ = NULL;
                                          const gchar* _tmp677_ = NULL;
                                          ValaCCodeExpression* _tmp678_ = NULL;
                                          ValaCCodeExpression* temp_ref;
                                          gdouble _tmp679_;
                                          gint _tmp680_;
                                          ValaCCodeUnaryExpression* _tmp681_ = NULL;
                                          ValaCCodeUnaryExpression* _tmp682_;
                                          _tmp671_ = vala_method_get_array_length_type (m);
                                          if (_tmp671_ == NULL) {
                                                ValaLocalVariable* _tmp672_ = NULL;
                                                _tmp672_ = vala_ccode_base_module_get_temp_variable ((ValaCCodeBaseModule*) self, ((ValaCCodeBaseModule*) self)->int_type, TRUE, NULL, TRUE);
                                                _vala_code_node_unref0 (temp_var);
                                                temp_var = _tmp672_;
                                          } else {
                                                const gchar* _tmp673_ = NULL;
                                                ValaCType* _tmp674_ = NULL;
                                                ValaCType* _tmp675_;
                                                ValaLocalVariable* _tmp676_ = NULL;
                                                _tmp673_ = vala_method_get_array_length_type (m);
                                                _tmp674_ = vala_ctype_new (_tmp673_);
                                                _tmp675_ = _tmp674_;
                                                _tmp676_ = vala_ccode_base_module_get_temp_variable ((ValaCCodeBaseModule*) self, (ValaDataType*) _tmp675_, TRUE, NULL, TRUE);
                                                _vala_code_node_unref0 (temp_var);
                                                temp_var = _tmp676_;
                                                _vala_code_node_unref0 (_tmp675_);
                                          }
                                          _tmp677_ = vala_symbol_get_name ((ValaSymbol*) temp_var);
                                          _tmp678_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, _tmp677_);
                                          temp_ref = _tmp678_;
                                          vala_ccode_base_module_emit_temp_var ((ValaCCodeBaseModule*) self, temp_var, FALSE);
                                          _tmp679_ = vala_method_get_carray_length_parameter_position (m);
                                          _tmp680_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, _tmp679_ + (0.01 * dim), FALSE);
                                          _tmp681_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, temp_ref);
                                          _tmp682_ = _tmp681_;
                                          vala_map_set ((ValaMap*) out_arg_map, GINT_TO_POINTER (_tmp680_), (ValaCCodeExpression*) _tmp682_);
                                          _vala_ccode_node_unref0 (_tmp682_);
                                          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* _tmp683_ = NULL;
                                          ValaCCodeConstant* _tmp684_;
                                          _tmp683_ = vala_ccode_constant_new ("-1");
                                          _tmp684_ = _tmp683_;
                                          vala_ccode_base_module_append_array_length ((ValaCCodeBaseModule*) self, (ValaExpression*) expr, (ValaCCodeExpression*) _tmp684_);
                                          _vala_ccode_node_unref0 (_tmp684_);
                                    }
                              }
                        }
                  }
            }
            _vala_code_node_unref0 (array_type);
      } else {
            gboolean _tmp685_ = FALSE;
            gboolean _tmp686_ = FALSE;
            if (m != NULL) {
                  ValaDataType* _tmp687_ = NULL;
                  _tmp687_ = vala_method_get_return_type (m);
                  _tmp686_ = VALA_IS_DELEGATE_TYPE (_tmp687_);
            } else {
                  _tmp686_ = FALSE;
            }
            if (_tmp686_) {
                  _tmp685_ = async_call != ccall;
            } else {
                  _tmp685_ = FALSE;
            }
            if (_tmp685_) {
                  ValaDataType* _tmp688_ = NULL;
                  ValaDelegateType* _tmp689_;
                  ValaDelegateType* deleg_type;
                  ValaDelegate* _tmp690_ = NULL;
                  ValaDelegate* _tmp691_;
                  ValaDelegate* d;
                  gboolean _tmp692_;
                  _tmp688_ = vala_method_get_return_type (m);
                  _tmp689_ = _vala_code_node_ref0 (VALA_DELEGATE_TYPE (_tmp688_));
                  deleg_type = _tmp689_;
                  _tmp690_ = vala_delegate_type_get_delegate_symbol (deleg_type);
                  _tmp691_ = _vala_code_node_ref0 (_tmp690_);
                  d = _tmp691_;
                  _tmp692_ = vala_delegate_get_has_target (d);
                  if (_tmp692_) {
                        ValaVoidType* _tmp693_ = NULL;
                        ValaVoidType* _tmp694_;
                        ValaPointerType* _tmp695_ = NULL;
                        ValaPointerType* _tmp696_;
                        ValaLocalVariable* _tmp697_ = NULL;
                        ValaLocalVariable* _tmp698_;
                        ValaLocalVariable* temp_var;
                        const gchar* _tmp699_ = NULL;
                        ValaCCodeExpression* _tmp700_ = NULL;
                        ValaCCodeExpression* temp_ref;
                        gdouble _tmp701_;
                        gint _tmp702_;
                        ValaCCodeUnaryExpression* _tmp703_ = NULL;
                        ValaCCodeUnaryExpression* _tmp704_;
                        gboolean _tmp705_;
                        _tmp693_ = vala_void_type_new (NULL);
                        _tmp694_ = _tmp693_;
                        _tmp695_ = vala_pointer_type_new ((ValaDataType*) _tmp694_, NULL);
                        _tmp696_ = _tmp695_;
                        _tmp697_ = vala_ccode_base_module_get_temp_variable ((ValaCCodeBaseModule*) self, (ValaDataType*) _tmp696_, TRUE, NULL, TRUE);
                        _tmp698_ = _tmp697_;
                        _vala_code_node_unref0 (_tmp696_);
                        _vala_code_node_unref0 (_tmp694_);
                        temp_var = _tmp698_;
                        _tmp699_ = vala_symbol_get_name ((ValaSymbol*) temp_var);
                        _tmp700_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, _tmp699_);
                        temp_ref = _tmp700_;
                        vala_ccode_base_module_emit_temp_var ((ValaCCodeBaseModule*) self, temp_var, FALSE);
                        _tmp701_ = vala_method_get_cdelegate_target_parameter_position (m);
                        _tmp702_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, _tmp701_, FALSE);
                        _tmp703_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, temp_ref);
                        _tmp704_ = _tmp703_;
                        vala_map_set ((ValaMap*) out_arg_map, GINT_TO_POINTER (_tmp702_), (ValaCCodeExpression*) _tmp704_);
                        _vala_ccode_node_unref0 (_tmp704_);
                        vala_ccode_base_module_set_delegate_target ((ValaCCodeBaseModule*) self, (ValaExpression*) expr, temp_ref);
                        _tmp705_ = vala_data_type_get_value_owned ((ValaDataType*) deleg_type);
                        if (_tmp705_) {
                              ValaLocalVariable* _tmp706_ = NULL;
                              const gchar* _tmp707_ = NULL;
                              ValaCCodeExpression* _tmp708_ = NULL;
                              gdouble _tmp709_;
                              gint _tmp710_;
                              ValaCCodeUnaryExpression* _tmp711_ = NULL;
                              ValaCCodeUnaryExpression* _tmp712_;
                              _tmp706_ = vala_ccode_base_module_get_temp_variable ((ValaCCodeBaseModule*) self, ((ValaCCodeBaseModule*) self)->gdestroynotify_type, TRUE, NULL, TRUE);
                              _vala_code_node_unref0 (temp_var);
                              temp_var = _tmp706_;
                              _tmp707_ = vala_symbol_get_name ((ValaSymbol*) temp_var);
                              _tmp708_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, _tmp707_);
                              _vala_ccode_node_unref0 (temp_ref);
                              temp_ref = _tmp708_;
                              vala_ccode_base_module_emit_temp_var ((ValaCCodeBaseModule*) self, temp_var, FALSE);
                              _tmp709_ = vala_method_get_cdelegate_target_parameter_position (m);
                              _tmp710_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, _tmp709_ + 0.01, FALSE);
                              _tmp711_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, temp_ref);
                              _tmp712_ = _tmp711_;
                              vala_map_set ((ValaMap*) out_arg_map, GINT_TO_POINTER (_tmp710_), (ValaCCodeExpression*) _tmp712_);
                              _vala_ccode_node_unref0 (_tmp712_);
                              vala_ccode_base_module_set_delegate_target_destroy_notify ((ValaCCodeBaseModule*) self, (ValaExpression*) expr, temp_ref);
                        } else {
                              ValaCCodeConstant* _tmp713_ = NULL;
                              ValaCCodeConstant* _tmp714_;
                              _tmp713_ = vala_ccode_constant_new ("NULL");
                              _tmp714_ = _tmp713_;
                              vala_ccode_base_module_set_delegate_target_destroy_notify ((ValaCCodeBaseModule*) self, (ValaExpression*) expr, (ValaCCodeExpression*) _tmp714_);
                              _vala_ccode_node_unref0 (_tmp714_);
                        }
                        _vala_ccode_node_unref0 (temp_ref);
                        _vala_code_node_unref0 (temp_var);
                  } else {
                        ValaCCodeConstant* _tmp715_ = NULL;
                        ValaCCodeConstant* _tmp716_;
                        _tmp715_ = vala_ccode_constant_new ("NULL");
                        _tmp716_ = _tmp715_;
                        vala_ccode_base_module_set_delegate_target ((ValaCCodeBaseModule*) self, (ValaExpression*) expr, (ValaCCodeExpression*) _tmp716_);
                        _vala_ccode_node_unref0 (_tmp716_);
                  }
                  _vala_code_node_unref0 (d);
                  _vala_code_node_unref0 (deleg_type);
            }
      }
      if (deleg != NULL) {
            ValaDataType* _tmp718_ = NULL;
            _tmp718_ = vala_delegate_get_return_type (deleg);
            _tmp717_ = VALA_IS_ARRAY_TYPE (_tmp718_);
      } else {
            _tmp717_ = FALSE;
      }
      if (_tmp717_) {
            ValaDataType* _tmp719_ = NULL;
            ValaArrayType* _tmp720_;
            ValaArrayType* array_type;
            _tmp719_ = vala_delegate_get_return_type (deleg);
            _tmp720_ = _vala_code_node_ref0 (VALA_ARRAY_TYPE (_tmp719_));
            array_type = _tmp720_;
            {
                  gint dim;
                  dim = 1;
                  {
                        gboolean _tmp721_;
                        _tmp721_ = TRUE;
                        while (TRUE) {
                              gint _tmp722_;
                              gboolean _tmp723_;
                              if (!_tmp721_) {
                                    dim++;
                              }
                              _tmp721_ = FALSE;
                              _tmp722_ = vala_array_type_get_rank (array_type);
                              if (!(dim <= _tmp722_)) {
                                    break;
                              }
                              _tmp723_ = vala_delegate_get_array_null_terminated (deleg);
                              if (_tmp723_) {
                                    ValaDataType* _tmp724_ = NULL;
                                    ValaDataType* _tmp725_;
                                    ValaLocalVariable* _tmp726_ = NULL;
                                    ValaLocalVariable* _tmp727_;
                                    ValaLocalVariable* temp_var;
                                    const gchar* _tmp728_ = NULL;
                                    ValaCCodeExpression* _tmp729_ = NULL;
                                    ValaCCodeExpression* temp_ref;
                                    ValaCCodeAssignment* _tmp730_ = NULL;
                                    ValaCCodeIdentifier* _tmp731_ = NULL;
                                    ValaCCodeIdentifier* _tmp732_;
                                    ValaCCodeFunctionCall* _tmp733_ = NULL;
                                    ValaCCodeFunctionCall* _tmp734_;
                                    ValaCCodeFunctionCall* len_call;
                                    _tmp724_ = vala_data_type_get_return_type (itype);
                                    _tmp725_ = _tmp724_;
                                    _tmp726_ = vala_ccode_base_module_get_temp_variable ((ValaCCodeBaseModule*) self, _tmp725_, TRUE, NULL, FALSE);
                                    _tmp727_ = _tmp726_;
                                    _vala_code_node_unref0 (_tmp725_);
                                    temp_var = _tmp727_;
                                    _tmp728_ = vala_symbol_get_name ((ValaSymbol*) temp_var);
                                    _tmp729_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, _tmp728_);
                                    temp_ref = _tmp729_;
                                    vala_ccode_base_module_emit_temp_var ((ValaCCodeBaseModule*) self, temp_var, FALSE);
                                    _tmp730_ = vala_ccode_assignment_new (temp_ref, ccall_expr, VALA_CCODE_ASSIGNMENT_OPERATOR_SIMPLE);
                                    _vala_ccode_node_unref0 (ccall_expr);
                                    ccall_expr = (ValaCCodeExpression*) _tmp730_;
                                    ((ValaCCodeBaseModule*) self)->requires_array_length = TRUE;
                                    _tmp731_ = vala_ccode_identifier_new ("_vala_array_length");
                                    _tmp732_ = _tmp731_;
                                    _tmp733_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp732_);
                                    _tmp734_ = _tmp733_;
                                    _vala_ccode_node_unref0 (_tmp732_);
                                    len_call = _tmp734_;
                                    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 _tmp735_;
                                    _tmp735_ = vala_delegate_get_no_array_length (deleg);
                                    if (!_tmp735_) {
                                          ValaLocalVariable* _tmp736_ = NULL;
                                          ValaLocalVariable* temp_var;
                                          const gchar* _tmp737_ = NULL;
                                          ValaCCodeExpression* _tmp738_ = NULL;
                                          ValaCCodeExpression* temp_ref;
                                          gdouble _tmp739_;
                                          gint _tmp740_;
                                          ValaCCodeUnaryExpression* _tmp741_ = NULL;
                                          ValaCCodeUnaryExpression* _tmp742_;
                                          _tmp736_ = vala_ccode_base_module_get_temp_variable ((ValaCCodeBaseModule*) self, ((ValaCCodeBaseModule*) self)->int_type, TRUE, NULL, TRUE);
                                          temp_var = _tmp736_;
                                          _tmp737_ = vala_symbol_get_name ((ValaSymbol*) temp_var);
                                          _tmp738_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, _tmp737_);
                                          temp_ref = _tmp738_;
                                          vala_ccode_base_module_emit_temp_var ((ValaCCodeBaseModule*) self, temp_var, FALSE);
                                          _tmp739_ = vala_delegate_get_carray_length_parameter_position (deleg);
                                          _tmp740_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, _tmp739_ + (0.01 * dim), FALSE);
                                          _tmp741_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, temp_ref);
                                          _tmp742_ = _tmp741_;
                                          vala_map_set ((ValaMap*) out_arg_map, GINT_TO_POINTER (_tmp740_), (ValaCCodeExpression*) _tmp742_);
                                          _vala_ccode_node_unref0 (_tmp742_);
                                          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* _tmp743_ = NULL;
                                          ValaCCodeConstant* _tmp744_;
                                          _tmp743_ = vala_ccode_constant_new ("-1");
                                          _tmp744_ = _tmp743_;
                                          vala_ccode_base_module_append_array_length ((ValaCCodeBaseModule*) self, (ValaExpression*) expr, (ValaCCodeExpression*) _tmp744_);
                                          _vala_ccode_node_unref0 (_tmp744_);
                                    }
                              }
                        }
                  }
            }
            _vala_code_node_unref0 (array_type);
      } else {
            gboolean _tmp745_ = FALSE;
            if (deleg != NULL) {
                  ValaDataType* _tmp746_ = NULL;
                  _tmp746_ = vala_delegate_get_return_type (deleg);
                  _tmp745_ = VALA_IS_DELEGATE_TYPE (_tmp746_);
            } else {
                  _tmp745_ = FALSE;
            }
            if (_tmp745_) {
                  ValaDataType* _tmp747_ = NULL;
                  ValaDelegateType* _tmp748_;
                  ValaDelegateType* deleg_type;
                  ValaDelegate* _tmp749_ = NULL;
                  ValaDelegate* _tmp750_;
                  ValaDelegate* d;
                  gboolean _tmp751_;
                  _tmp747_ = vala_delegate_get_return_type (deleg);
                  _tmp748_ = _vala_code_node_ref0 (VALA_DELEGATE_TYPE (_tmp747_));
                  deleg_type = _tmp748_;
                  _tmp749_ = vala_delegate_type_get_delegate_symbol (deleg_type);
                  _tmp750_ = _vala_code_node_ref0 (_tmp749_);
                  d = _tmp750_;
                  _tmp751_ = vala_delegate_get_has_target (d);
                  if (_tmp751_) {
                        ValaVoidType* _tmp752_ = NULL;
                        ValaVoidType* _tmp753_;
                        ValaPointerType* _tmp754_ = NULL;
                        ValaPointerType* _tmp755_;
                        ValaLocalVariable* _tmp756_ = NULL;
                        ValaLocalVariable* _tmp757_;
                        ValaLocalVariable* temp_var;
                        const gchar* _tmp758_ = NULL;
                        ValaCCodeExpression* _tmp759_ = NULL;
                        ValaCCodeExpression* temp_ref;
                        gdouble _tmp760_;
                        gint _tmp761_;
                        ValaCCodeUnaryExpression* _tmp762_ = NULL;
                        ValaCCodeUnaryExpression* _tmp763_;
                        _tmp752_ = vala_void_type_new (NULL);
                        _tmp753_ = _tmp752_;
                        _tmp754_ = vala_pointer_type_new ((ValaDataType*) _tmp753_, NULL);
                        _tmp755_ = _tmp754_;
                        _tmp756_ = vala_ccode_base_module_get_temp_variable ((ValaCCodeBaseModule*) self, (ValaDataType*) _tmp755_, TRUE, NULL, TRUE);
                        _tmp757_ = _tmp756_;
                        _vala_code_node_unref0 (_tmp755_);
                        _vala_code_node_unref0 (_tmp753_);
                        temp_var = _tmp757_;
                        _tmp758_ = vala_symbol_get_name ((ValaSymbol*) temp_var);
                        _tmp759_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, _tmp758_);
                        temp_ref = _tmp759_;
                        vala_ccode_base_module_emit_temp_var ((ValaCCodeBaseModule*) self, temp_var, FALSE);
                        _tmp760_ = vala_delegate_get_cdelegate_target_parameter_position (deleg);
                        _tmp761_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, _tmp760_, FALSE);
                        _tmp762_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, temp_ref);
                        _tmp763_ = _tmp762_;
                        vala_map_set ((ValaMap*) out_arg_map, GINT_TO_POINTER (_tmp761_), (ValaCCodeExpression*) _tmp763_);
                        _vala_ccode_node_unref0 (_tmp763_);
                        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 _tmp765_;
            _tmp765_ = vala_method_get_coroutine (m);
            _tmp764_ = _tmp765_;
      } else {
            _tmp764_ = FALSE;
      }
      if (_tmp764_) {
            gboolean _tmp766_;
            _tmp766_ = vala_method_call_get_is_yield_expression (expr);
            if (_tmp766_) {
                  gint _tmp767_;
                  ValaMethod* _tmp768_ = NULL;
                  gchar* _tmp769_ = NULL;
                  gchar* _tmp770_;
                  ValaCCodeIdentifier* _tmp771_ = NULL;
                  ValaCCodeIdentifier* _tmp772_;
                  gint _tmp773_;
                  ValaCCodeIdentifier* _tmp774_ = NULL;
                  ValaCCodeIdentifier* _tmp775_;
                  _tmp767_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, (gdouble) (-1), FALSE);
                  _tmp768_ = vala_ccode_base_module_get_current_method ((ValaCCodeBaseModule*) self);
                  _tmp769_ = vala_ccode_base_module_generate_ready_function ((ValaCCodeBaseModule*) self, _tmp768_);
                  _tmp770_ = _tmp769_;
                  _tmp771_ = vala_ccode_identifier_new (_tmp770_);
                  _tmp772_ = _tmp771_;
                  vala_map_set ((ValaMap*) in_arg_map, GINT_TO_POINTER (_tmp767_), (ValaCCodeExpression*) _tmp772_);
                  _vala_ccode_node_unref0 (_tmp772_);
                  _g_free0 (_tmp770_);
                  _tmp773_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, -0.9, FALSE);
                  _tmp774_ = vala_ccode_identifier_new ("_data_");
                  _tmp775_ = _tmp774_;
                  vala_map_set ((ValaMap*) in_arg_map, GINT_TO_POINTER (_tmp773_), (ValaCCodeExpression*) _tmp775_);
                  _vala_ccode_node_unref0 (_tmp775_);
            }
      }
      _tmp776_ = vala_code_node_get_tree_can_fail ((ValaCodeNode*) expr);
      if (_tmp776_) {
            gint _tmp777_;
            ValaCCodeExpression* _tmp778_ = NULL;
            ValaCCodeExpression* _tmp779_;
            ValaCCodeUnaryExpression* _tmp780_ = NULL;
            ValaCCodeUnaryExpression* _tmp781_;
            vala_ccode_base_module_set_current_method_inner_error ((ValaCCodeBaseModule*) self, TRUE);
            _tmp777_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, (gdouble) (-1), FALSE);
            _tmp778_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, "_inner_error_");
            _tmp779_ = _tmp778_;
            _tmp780_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, _tmp779_);
            _tmp781_ = _tmp780_;
            vala_map_set ((ValaMap*) out_arg_map, GINT_TO_POINTER (_tmp777_), (ValaCCodeExpression*) _tmp781_);
            _vala_ccode_node_unref0 (_tmp781_);
            _vala_ccode_node_unref0 (_tmp779_);
      }
      if (ellipsis) {
            if (m == NULL) {
                  gint _tmp782_;
                  ValaCCodeConstant* _tmp783_ = NULL;
                  ValaCCodeConstant* _tmp784_;
                  _tmp782_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, (gdouble) (-1), TRUE);
                  _tmp783_ = vala_ccode_constant_new (VALA_METHOD_DEFAULT_SENTINEL);
                  _tmp784_ = _tmp783_;
                  vala_map_set ((ValaMap*) in_arg_map, GINT_TO_POINTER (_tmp782_), (ValaCCodeExpression*) _tmp784_);
                  _vala_ccode_node_unref0 (_tmp784_);
            } else {
                  gboolean _tmp785_ = FALSE;
                  gboolean _tmp786_ = FALSE;
                  gboolean _tmp787_;
                  _tmp787_ = vala_method_get_printf_format (m);
                  if (!_tmp787_) {
                        gboolean _tmp788_;
                        _tmp788_ = vala_method_get_scanf_format (m);
                        _tmp786_ = !_tmp788_;
                  } else {
                        _tmp786_ = FALSE;
                  }
                  if (_tmp786_) {
                        const gchar* _tmp789_ = NULL;
                        _tmp789_ = vala_method_get_sentinel (m);
                        _tmp785_ = g_strcmp0 (_tmp789_, "") != 0;
                  } else {
                        _tmp785_ = FALSE;
                  }
                  if (_tmp785_) {
                        gint _tmp790_;
                        const gchar* _tmp791_ = NULL;
                        ValaCCodeConstant* _tmp792_ = NULL;
                        ValaCCodeConstant* _tmp793_;
                        _tmp790_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, (gdouble) (-1), TRUE);
                        _tmp791_ = vala_method_get_sentinel (m);
                        _tmp792_ = vala_ccode_constant_new (_tmp791_);
                        _tmp793_ = _tmp792_;
                        vala_map_set ((ValaMap*) in_arg_map, GINT_TO_POINTER (_tmp790_), (ValaCCodeExpression*) _tmp793_);
                        _vala_ccode_node_unref0 (_tmp793_);
                  }
            }
      }
      if (VALA_IS_DELEGATE_TYPE (itype)) {
            ValaDelegateType* _tmp794_;
            ValaDelegateType* deleg_type;
            ValaDelegate* _tmp795_ = NULL;
            ValaDelegate* _tmp796_;
            ValaDelegate* d;
            gboolean _tmp797_;
            _tmp794_ = _vala_code_node_ref0 (VALA_DELEGATE_TYPE (itype));
            deleg_type = _tmp794_;
            _tmp795_ = vala_delegate_type_get_delegate_symbol (deleg_type);
            _tmp796_ = _vala_code_node_ref0 (_tmp795_);
            d = _tmp796_;
            _tmp797_ = vala_delegate_get_has_target (d);
            if (_tmp797_) {
                  ValaCCodeExpression* delegate_target_destroy_notify = NULL;
                  gdouble _tmp798_;
                  gint _tmp799_;
                  ValaExpression* _tmp800_ = NULL;
                  ValaCCodeExpression* _tmp801_ = NULL;
                  ValaCCodeExpression* _tmp802_ = NULL;
                  ValaCCodeExpression* _tmp803_;
                  gdouble _tmp804_;
                  gint _tmp805_;
                  ValaExpression* _tmp806_ = NULL;
                  ValaCCodeExpression* _tmp807_ = NULL;
                  ValaCCodeExpression* _tmp808_ = NULL;
                  ValaCCodeExpression* _tmp809_;
                  _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*) in_arg_map, GINT_TO_POINTER (_tmp799_), _tmp803_);
                  _vala_ccode_node_unref0 (_tmp803_);
                  _tmp804_ = vala_delegate_get_cinstance_parameter_position (d);
                  _tmp805_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, _tmp804_, FALSE);
                  _tmp806_ = vala_method_call_get_call (expr);
                  _tmp808_ = vala_ccode_base_module_get_delegate_target_cexpression ((ValaCCodeBaseModule*) self, _tmp806_, &_tmp807_);
                  _vala_ccode_node_unref0 (delegate_target_destroy_notify);
                  delegate_target_destroy_notify = _tmp807_;
                  _tmp809_ = _tmp808_;
                  vala_map_set ((ValaMap*) out_arg_map, GINT_TO_POINTER (_tmp805_), _tmp809_);
                  _vala_ccode_node_unref0 (_tmp809_);
                  _vala_ccode_node_unref0 (delegate_target_destroy_notify);
            }
            _vala_code_node_unref0 (d);
            _vala_code_node_unref0 (deleg_type);
      }
      _tmp810_ = vala_data_type_get_return_type (itype);
      _tmp811_ = _tmp810_;
      _tmp812_ = vala_data_type_is_real_non_null_struct_type (_tmp811_);
      _tmp813_ = _tmp812_;
      _vala_code_node_unref0 (_tmp811_);
      return_result_via_out_param = _tmp813_;
      if (VALA_IS_SIGNAL_TYPE (itype)) {
            ValaDataType* _tmp815_ = NULL;
            ValaDataType* _tmp816_;
            _tmp815_ = vala_data_type_get_return_type (itype);
            _tmp816_ = _tmp815_;
            _tmp814_ = !VALA_IS_VOID_TYPE (_tmp816_);
            _vala_code_node_unref0 (_tmp816_);
      } else {
            _tmp814_ = FALSE;
      }
      if (_tmp814_) {
            ValaSignal* _tmp817_ = NULL;
            ValaSignal* _tmp818_;
            ValaSignal* sig;
            gboolean _tmp819_ = FALSE;
            gboolean _tmp820_ = FALSE;
            _tmp817_ = vala_signal_type_get_signal_symbol (VALA_SIGNAL_TYPE (itype));
            _tmp818_ = _vala_code_node_ref0 (_tmp817_);
            sig = _tmp818_;
            if (ma != NULL) {
                  ValaExpression* _tmp821_ = NULL;
                  _tmp821_ = vala_member_access_get_inner (ma);
                  _tmp820_ = VALA_IS_BASE_ACCESS (_tmp821_);
            } else {
                  _tmp820_ = FALSE;
            }
            if (_tmp820_) {
                  gboolean _tmp822_;
                  _tmp822_ = vala_signal_get_is_virtual (sig);
                  _tmp819_ = _tmp822_;
            } else {
                  _tmp819_ = FALSE;
            }
            if (_tmp819_) {
            } else {
                  gboolean _tmp823_;
                  _tmp823_ = vala_signal_get_has_emitter (sig);
                  if (!_tmp823_) {
                        return_result_via_out_param = TRUE;
                  }
            }
            _vala_code_node_unref0 (sig);
      }
      out_param_ref = NULL;
      if (return_result_via_out_param) {
            ValaDataType* _tmp824_ = NULL;
            ValaDataType* _tmp825_;
            ValaLocalVariable* _tmp826_ = NULL;
            ValaLocalVariable* _tmp827_;
            ValaLocalVariable* out_param_var;
            const gchar* _tmp828_ = NULL;
            ValaCCodeExpression* _tmp829_ = NULL;
            gint _tmp830_;
            ValaCCodeUnaryExpression* _tmp831_ = NULL;
            ValaCCodeUnaryExpression* _tmp832_;
            _tmp824_ = vala_data_type_get_return_type (itype);
            _tmp825_ = _tmp824_;
            _tmp826_ = vala_ccode_base_module_get_temp_variable ((ValaCCodeBaseModule*) self, _tmp825_, TRUE, NULL, TRUE);
            _tmp827_ = _tmp826_;
            _vala_code_node_unref0 (_tmp825_);
            out_param_var = _tmp827_;
            _tmp828_ = vala_symbol_get_name ((ValaSymbol*) out_param_var);
            _tmp829_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, _tmp828_);
            _vala_ccode_node_unref0 (out_param_ref);
            out_param_ref = _tmp829_;
            vala_ccode_base_module_emit_temp_var ((ValaCCodeBaseModule*) self, out_param_var, FALSE);
            _tmp830_ = vala_ccode_base_module_get_param_pos ((ValaCCodeBaseModule*) self, (gdouble) (-3), FALSE);
            _tmp831_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, out_param_ref);
            _tmp832_ = _tmp831_;
            vala_map_set ((ValaMap*) out_arg_map, GINT_TO_POINTER (_tmp830_), (ValaCCodeExpression*) _tmp832_);
            _vala_ccode_node_unref0 (_tmp832_);
            _vala_code_node_unref0 (out_param_var);
      }
      if (async_call != ccall) {
            last_pos = -1;
            while (TRUE) {
                  gpointer _tmp841_ = NULL;
                  ValaCCodeExpression* _tmp842_;
                  min_pos = -1;
                  {
                        ValaSet* _tmp833_ = NULL;
                        ValaSet* _tmp834_;
                        ValaIterator* _tmp835_ = NULL;
                        ValaIterator* _tmp836_;
                        ValaIterator* _pos_it;
                        _tmp833_ = vala_map_get_keys ((ValaMap*) out_arg_map);
                        _tmp834_ = _tmp833_;
                        _tmp835_ = vala_iterable_iterator ((ValaIterable*) _tmp834_);
                        _tmp836_ = _tmp835_;
                        _vala_iterable_unref0 (_tmp834_);
                        _pos_it = _tmp836_;
                        while (TRUE) {
                              gboolean _tmp837_;
                              gpointer _tmp838_ = NULL;
                              gint pos;
                              gboolean _tmp839_ = FALSE;
                              _tmp837_ = vala_iterator_next (_pos_it);
                              if (!_tmp837_) {
                                    break;
                              }
                              _tmp838_ = vala_iterator_get (_pos_it);
                              pos = GPOINTER_TO_INT (_tmp838_);
                              if (pos > last_pos) {
                                    gboolean _tmp840_ = FALSE;
                                    if (min_pos == (-1)) {
                                          _tmp840_ = TRUE;
                                    } else {
                                          _tmp840_ = pos < min_pos;
                                    }
                                    _tmp839_ = _tmp840_;
                              } else {
                                    _tmp839_ = FALSE;
                              }
                              if (_tmp839_) {
                                    min_pos = pos;
                              }
                        }
                        _vala_iterator_unref0 (_pos_it);
                  }
                  if (min_pos == (-1)) {
                        break;
                  }
                  _tmp841_ = vala_map_get ((ValaMap*) out_arg_map, GINT_TO_POINTER (min_pos));
                  _tmp842_ = (ValaCCodeExpression*) _tmp841_;
                  vala_ccode_function_call_add_argument (ccall, _tmp842_);
                  _vala_ccode_node_unref0 (_tmp842_);
                  last_pos = min_pos;
            }
      }
      if (async_call != NULL) {
            last_pos = -1;
            while (TRUE) {
                  gpointer _tmp851_ = NULL;
                  ValaCCodeExpression* _tmp852_;
                  min_pos = -1;
                  {
                        ValaSet* _tmp843_ = NULL;
                        ValaSet* _tmp844_;
                        ValaIterator* _tmp845_ = NULL;
                        ValaIterator* _tmp846_;
                        ValaIterator* _pos_it;
                        _tmp843_ = vala_map_get_keys ((ValaMap*) in_arg_map);
                        _tmp844_ = _tmp843_;
                        _tmp845_ = vala_iterable_iterator ((ValaIterable*) _tmp844_);
                        _tmp846_ = _tmp845_;
                        _vala_iterable_unref0 (_tmp844_);
                        _pos_it = _tmp846_;
                        while (TRUE) {
                              gboolean _tmp847_;
                              gpointer _tmp848_ = NULL;
                              gint pos;
                              gboolean _tmp849_ = FALSE;
                              _tmp847_ = vala_iterator_next (_pos_it);
                              if (!_tmp847_) {
                                    break;
                              }
                              _tmp848_ = vala_iterator_get (_pos_it);
                              pos = GPOINTER_TO_INT (_tmp848_);
                              if (pos > last_pos) {
                                    gboolean _tmp850_ = FALSE;
                                    if (min_pos == (-1)) {
                                          _tmp850_ = TRUE;
                                    } else {
                                          _tmp850_ = pos < min_pos;
                                    }
                                    _tmp849_ = _tmp850_;
                              } else {
                                    _tmp849_ = FALSE;
                              }
                              if (_tmp849_) {
                                    min_pos = pos;
                              }
                        }
                        _vala_iterator_unref0 (_pos_it);
                  }
                  if (min_pos == (-1)) {
                        break;
                  }
                  _tmp851_ = vala_map_get ((ValaMap*) in_arg_map, GINT_TO_POINTER (min_pos));
                  _tmp852_ = (ValaCCodeExpression*) _tmp851_;
                  vala_ccode_function_call_add_argument (async_call, _tmp852_);
                  _vala_ccode_node_unref0 (_tmp852_);
                  last_pos = min_pos;
            }
      }
      _tmp853_ = vala_method_call_get_is_yield_expression (expr);
      if (_tmp853_) {
            gint _tmp854_;
            gint state;
            ValaCCodeFunction* _tmp855_ = NULL;
            ValaCCodeIdentifier* _tmp856_ = NULL;
            ValaCCodeIdentifier* _tmp857_;
            ValaCCodeMemberAccess* _tmp858_ = NULL;
            ValaCCodeMemberAccess* _tmp859_;
            gchar* _tmp860_ = NULL;
            gchar* _tmp861_;
            ValaCCodeConstant* _tmp862_ = NULL;
            ValaCCodeConstant* _tmp863_;
            ValaCCodeFunction* _tmp864_ = NULL;
            ValaCCodeFunction* _tmp865_ = NULL;
            ValaCCodeConstant* _tmp866_ = NULL;
            ValaCCodeConstant* _tmp867_;
            ValaCCodeFunction* _tmp868_ = NULL;
            gchar* _tmp869_ = NULL;
            gchar* _tmp870_;
            _tmp854_ = ((ValaCCodeBaseModule*) self)->next_coroutine_state;
            ((ValaCCodeBaseModule*) self)->next_coroutine_state = _tmp854_ + 1;
            state = _tmp854_;
            _tmp855_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
            _tmp856_ = vala_ccode_identifier_new ("_data_");
            _tmp857_ = _tmp856_;
            _tmp858_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp857_, "_state_");
            _tmp859_ = _tmp858_;
            _tmp860_ = g_strdup_printf ("%i", state);
            _tmp861_ = _tmp860_;
            _tmp862_ = vala_ccode_constant_new (_tmp861_);
            _tmp863_ = _tmp862_;
            vala_ccode_function_add_assignment (_tmp855_, (ValaCCodeExpression*) _tmp859_, (ValaCCodeExpression*) _tmp863_);
            _vala_ccode_node_unref0 (_tmp863_);
            _g_free0 (_tmp861_);
            _vala_ccode_node_unref0 (_tmp859_);
            _vala_ccode_node_unref0 (_tmp857_);
            _tmp864_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
            vala_ccode_function_add_expression (_tmp864_, (ValaCCodeExpression*) async_call);
            _tmp865_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
            _tmp866_ = vala_ccode_constant_new ("FALSE");
            _tmp867_ = _tmp866_;
            vala_ccode_function_add_return (_tmp865_, (ValaCCodeExpression*) _tmp867_);
            _vala_ccode_node_unref0 (_tmp867_);
            _tmp868_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
            _tmp869_ = g_strdup_printf ("_state_%d", state);
            _tmp870_ = _tmp869_;
            vala_ccode_function_add_label (_tmp868_, _tmp870_);
            _g_free0 (_tmp870_);
      }
      if (return_result_via_out_param) {
            ValaCCodeFunction* _tmp871_ = NULL;
            ValaCCodeExpression* _tmp872_;
            _tmp871_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
            vala_ccode_function_add_expression (_tmp871_, ccall_expr);
            _tmp872_ = _vala_ccode_node_ref0 (out_param_ref);
            _vala_ccode_node_unref0 (ccall_expr);
            ccall_expr = _tmp872_;
      }
      if (m != NULL) {
            ValaMemberBinding _tmp875_;
            _tmp875_ = vala_method_get_binding (m);
            _tmp874_ = _tmp875_ == VALA_MEMBER_BINDING_INSTANCE;
      } else {
            _tmp874_ = FALSE;
      }
      if (_tmp874_) {
            gboolean _tmp876_;
            _tmp876_ = vala_method_get_returns_modified_pointer (m);
            _tmp873_ = _tmp876_;
      } else {
            _tmp873_ = FALSE;
      }
      if (_tmp873_) {
            gboolean _tmp877_ = FALSE;
            gboolean _tmp878_ = FALSE;
            if (ma != NULL) {
                  ValaExpression* _tmp879_ = NULL;
                  ValaSymbol* _tmp880_ = NULL;
                  _tmp879_ = vala_member_access_get_inner (ma);
                  _tmp880_ = vala_expression_get_symbol_reference (_tmp879_);
                  _tmp878_ = VALA_IS_PROPERTY (_tmp880_);
            } else {
                  _tmp878_ = FALSE;
            }
            if (_tmp878_) {
                  ValaExpression* _tmp881_ = NULL;
                  _tmp881_ = vala_member_access_get_inner (ma);
                  _tmp877_ = VALA_IS_MEMBER_ACCESS (_tmp881_);
            } else {
                  _tmp877_ = FALSE;
            }
            if (_tmp877_) {
                  ValaExpression* _tmp882_ = NULL;
                  ValaSymbol* _tmp883_ = NULL;
                  ValaProperty* _tmp884_;
                  ValaProperty* prop;
                  ValaExpression* _tmp885_ = NULL;
                  ValaExpression* _tmp886_ = NULL;
                  ValaDataType* _tmp887_ = NULL;
                  ValaGLibValue* _tmp888_ = NULL;
                  ValaGLibValue* _tmp889_;
                  _tmp882_ = vala_member_access_get_inner (ma);
                  _tmp883_ = vala_expression_get_symbol_reference (_tmp882_);
                  _tmp884_ = _vala_code_node_ref0 (VALA_PROPERTY (_tmp883_));
                  prop = _tmp884_;
                  _tmp885_ = vala_member_access_get_inner (ma);
                  _tmp886_ = vala_member_access_get_inner (VALA_MEMBER_ACCESS (_tmp885_));
                  _tmp887_ = vala_expression_get_value_type ((ValaExpression*) expr);
                  _tmp888_ = vala_glib_value_new (_tmp887_, ccall_expr);
                  _tmp889_ = _tmp888_;
                  vala_ccode_base_module_store_property ((ValaCCodeBaseModule*) self, prop, _tmp886_, (ValaTargetValue*) _tmp889_);
                  _vala_target_value_unref0 (_tmp889_);
                  _vala_ccode_node_unref0 (ccall_expr);
                  ccall_expr = NULL;
                  _vala_code_node_unref0 (prop);
            } else {
                  ValaCCodeAssignment* _tmp890_ = NULL;
                  _tmp890_ = vala_ccode_assignment_new (instance, ccall_expr, VALA_CCODE_ASSIGNMENT_OPERATOR_SIMPLE);
                  _vala_ccode_node_unref0 (ccall_expr);
                  ccall_expr = (ValaCCodeExpression*) _tmp890_;
            }
      }
      if (VALA_IS_ARRAY_RESIZE_METHOD (m)) {
            ValaList* _tmp891_ = NULL;
            ValaList* _tmp892_;
            ValaIterator* _tmp893_ = NULL;
            ValaIterator* _tmp894_;
            ValaIterator* arg_it;
            gpointer _tmp895_ = NULL;
            ValaExpression* _tmp896_;
            ValaCCodeExpression* _tmp897_ = NULL;
            ValaCCodeExpression* _tmp898_;
            ValaCCodeExpression* new_size;
            ValaLocalVariable* _tmp899_ = NULL;
            ValaLocalVariable* temp_decl;
            const gchar* _tmp900_ = NULL;
            ValaCCodeExpression* _tmp901_ = NULL;
            ValaCCodeExpression* temp_ref;
            ValaExpression* _tmp902_ = NULL;
            ValaCCodeExpression* _tmp903_ = NULL;
            ValaCCodeExpression* clen;
            ValaExpression* _tmp904_ = NULL;
            ValaCCodeExpression* _tmp905_ = NULL;
            ValaCCodeExpression* celems;
            ValaExpression* _tmp906_ = NULL;
            ValaDataType* _tmp907_ = NULL;
            ValaArrayType* _tmp908_;
            ValaArrayType* array_type;
            ValaDataType* _tmp909_ = NULL;
            gchar* _tmp910_ = NULL;
            gchar* _tmp911_;
            gchar* _tmp912_ = NULL;
            gchar* _tmp913_;
            ValaCCodeIdentifier* _tmp914_ = NULL;
            ValaCCodeIdentifier* _tmp915_;
            ValaCCodeIdentifier* csizeof;
            ValaCCodeBinaryExpression* _tmp916_ = NULL;
            ValaCCodeBinaryExpression* cdelta;
            ValaCCodeBinaryExpression* _tmp917_ = NULL;
            ValaCCodeBinaryExpression* ccheck;
            ValaCCodeIdentifier* _tmp918_ = NULL;
            ValaCCodeIdentifier* _tmp919_;
            ValaCCodeFunctionCall* _tmp920_ = NULL;
            ValaCCodeFunctionCall* _tmp921_;
            ValaCCodeFunctionCall* czero;
            ValaCCodeBinaryExpression* _tmp922_ = NULL;
            ValaCCodeBinaryExpression* _tmp923_;
            ValaCCodeConstant* _tmp924_ = NULL;
            ValaCCodeConstant* _tmp925_;
            ValaCCodeBinaryExpression* _tmp926_ = NULL;
            ValaCCodeBinaryExpression* _tmp927_;
            ValaCCodeFunction* _tmp928_ = NULL;
            ValaCCodeFunction* _tmp929_ = NULL;
            ValaCCodeFunction* _tmp930_ = NULL;
            ValaCCodeConstant* _tmp931_ = NULL;
            ValaCCodeConstant* _tmp932_;
            ValaCCodeConditionalExpression* _tmp933_ = NULL;
            ValaCCodeConditionalExpression* _tmp934_;
            ValaCCodeFunction* _tmp935_ = NULL;
            ValaExpression* _tmp936_ = NULL;
            ValaCCodeExpression* _tmp937_ = NULL;
            ValaCCodeExpression* _tmp938_;
            ValaExpression* _tmp939_ = NULL;
            ValaSymbol* _tmp940_ = NULL;
            ValaSymbol* _tmp941_;
            ValaSymbol* array_var;
            ValaSymbol* _tmp942_;
            ValaLocalVariable* _tmp943_;
            ValaLocalVariable* array_local;
            gboolean _tmp944_ = FALSE;
            gboolean _tmp945_ = FALSE;
            _tmp891_ = vala_method_call_get_argument_list (expr);
            _tmp892_ = _tmp891_;
            _tmp893_ = vala_iterable_iterator ((ValaIterable*) _tmp892_);
            _tmp894_ = _tmp893_;
            _vala_iterable_unref0 (_tmp892_);
            arg_it = _tmp894_;
            vala_iterator_next (arg_it);
            _tmp895_ = vala_iterator_get (arg_it);
            _tmp896_ = (ValaExpression*) _tmp895_;
            _tmp897_ = vala_ccode_base_module_get_cvalue ((ValaCCodeBaseModule*) self, _tmp896_);
            _tmp898_ = _tmp897_;
            _vala_code_node_unref0 (_tmp896_);
            new_size = _tmp898_;
            _tmp899_ = vala_ccode_base_module_get_temp_variable ((ValaCCodeBaseModule*) self, ((ValaCCodeBaseModule*) self)->int_type, TRUE, NULL, TRUE);
            temp_decl = _tmp899_;
            _tmp900_ = vala_symbol_get_name ((ValaSymbol*) temp_decl);
            _tmp901_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, _tmp900_);
            temp_ref = _tmp901_;
            vala_ccode_base_module_emit_temp_var ((ValaCCodeBaseModule*) self, temp_decl, FALSE);
            vala_ccode_file_add_include (((ValaCCodeBaseModule*) self)->cfile, "string.h", FALSE);
            _tmp902_ = vala_member_access_get_inner (ma);
            _tmp903_ = vala_ccode_base_module_get_array_length_cexpression ((ValaCCodeBaseModule*) self, _tmp902_, 1);
            clen = _tmp903_;
            _tmp904_ = vala_member_access_get_inner (ma);
            _tmp905_ = vala_ccode_base_module_get_cvalue ((ValaCCodeBaseModule*) self, _tmp904_);
            celems = _tmp905_;
            _tmp906_ = vala_member_access_get_inner (ma);
            _tmp907_ = vala_expression_get_value_type (_tmp906_);
            _tmp908_ = _vala_code_node_ref0 (VALA_ARRAY_TYPE (_tmp907_));
            array_type = _tmp908_;
            _tmp909_ = vala_array_type_get_element_type (array_type);
            _tmp910_ = vala_data_type_get_cname (_tmp909_);
            _tmp911_ = _tmp910_;
            _tmp912_ = g_strdup_printf ("sizeof (%s)", _tmp911_);
            _tmp913_ = _tmp912_;
            _tmp914_ = vala_ccode_identifier_new (_tmp913_);
            _tmp915_ = _tmp914_;
            _g_free0 (_tmp913_);
            _g_free0 (_tmp911_);
            csizeof = _tmp915_;
            _tmp916_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_MINUS, temp_ref, clen);
            cdelta = _tmp916_;
            _tmp917_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_GREATER_THAN, temp_ref, clen);
            ccheck = _tmp917_;
            _tmp918_ = vala_ccode_identifier_new ("memset");
            _tmp919_ = _tmp918_;
            _tmp920_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp919_);
            _tmp921_ = _tmp920_;
            _vala_ccode_node_unref0 (_tmp919_);
            czero = _tmp921_;
            _tmp922_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_PLUS, celems, clen);
            _tmp923_ = _tmp922_;
            vala_ccode_function_call_add_argument (czero, (ValaCCodeExpression*) _tmp923_);
            _vala_ccode_node_unref0 (_tmp923_);
            _tmp924_ = vala_ccode_constant_new ("0");
            _tmp925_ = _tmp924_;
            vala_ccode_function_call_add_argument (czero, (ValaCCodeExpression*) _tmp925_);
            _vala_ccode_node_unref0 (_tmp925_);
            _tmp926_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_MUL, (ValaCCodeExpression*) csizeof, (ValaCCodeExpression*) cdelta);
            _tmp927_ = _tmp926_;
            vala_ccode_function_call_add_argument (czero, (ValaCCodeExpression*) _tmp927_);
            _vala_ccode_node_unref0 (_tmp927_);
            _tmp928_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
            vala_ccode_function_add_assignment (_tmp928_, temp_ref, new_size);
            _tmp929_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
            vala_ccode_function_add_expression (_tmp929_, ccall_expr);
            _tmp930_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
            _tmp931_ = vala_ccode_constant_new ("NULL");
            _tmp932_ = _tmp931_;
            _tmp933_ = vala_ccode_conditional_expression_new ((ValaCCodeExpression*) ccheck, (ValaCCodeExpression*) czero, (ValaCCodeExpression*) _tmp932_);
            _tmp934_ = _tmp933_;
            vala_ccode_function_add_expression (_tmp930_, (ValaCCodeExpression*) _tmp934_);
            _vala_ccode_node_unref0 (_tmp934_);
            _vala_ccode_node_unref0 (_tmp932_);
            _tmp935_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
            _tmp936_ = vala_member_access_get_inner (ma);
            _tmp937_ = vala_ccode_base_module_get_array_length_cexpression ((ValaCCodeBaseModule*) self, _tmp936_, 1);
            _tmp938_ = _tmp937_;
            vala_ccode_function_add_assignment (_tmp935_, _tmp938_, temp_ref);
            _vala_ccode_node_unref0 (_tmp938_);
            _tmp939_ = vala_member_access_get_inner (ma);
            _tmp940_ = vala_expression_get_symbol_reference (_tmp939_);
            _tmp941_ = _vala_code_node_ref0 (_tmp940_);
            array_var = _tmp941_;
            _tmp942_ = array_var;
            _tmp943_ = _vala_code_node_ref0 (VALA_IS_LOCAL_VARIABLE (_tmp942_) ? ((ValaLocalVariable*) _tmp942_) : NULL);
            array_local = _tmp943_;
            if (array_var != NULL) {
                  gboolean _tmp946_;
                  _tmp946_ = vala_symbol_is_internal_symbol (array_var);
                  _tmp945_ = _tmp946_;
            } else {
                  _tmp945_ = FALSE;
            }
            if (_tmp945_) {
                  gboolean _tmp947_ = FALSE;
                  gboolean _tmp948_ = FALSE;
                  if (VALA_IS_LOCAL_VARIABLE (array_var)) {
                        gboolean _tmp949_;
                        _tmp949_ = vala_local_variable_get_captured (array_local);
                        _tmp948_ = !_tmp949_;
                  } else {
                        _tmp948_ = FALSE;
                  }
                  if (_tmp948_) {
                        _tmp947_ = TRUE;
                  } else {
                        _tmp947_ = VALA_IS_FIELD (array_var);
                  }
                  _tmp944_ = _tmp947_;
            } else {
                  _tmp944_ = FALSE;
            }
            if (_tmp944_) {
                  ValaCCodeFunction* _tmp950_ = NULL;
                  ValaExpression* _tmp951_ = NULL;
                  ValaTargetValue* _tmp952_ = NULL;
                  ValaCCodeExpression* _tmp953_ = NULL;
                  ValaCCodeExpression* _tmp954_;
                  _tmp950_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
                  _tmp951_ = vala_member_access_get_inner (ma);
                  _tmp952_ = vala_expression_get_target_value (_tmp951_);
                  _tmp953_ = vala_ccode_base_module_get_array_size_cvalue ((ValaCCodeBaseModule*) self, _tmp952_);
                  _tmp954_ = _tmp953_;
                  vala_ccode_function_add_assignment (_tmp950_, _tmp954_, temp_ref);
                  _vala_ccode_node_unref0 (_tmp954_);
            }
            _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;
      }
      _tmp956_ = vala_code_node_get_parent_node ((ValaCodeNode*) expr);
      if (VALA_IS_EXPRESSION_STATEMENT (_tmp956_)) {
            ValaDataType* _tmp957_ = NULL;
            gboolean _tmp958_;
            _tmp957_ = vala_expression_get_value_type ((ValaExpression*) expr);
            _tmp958_ = vala_data_type_is_disposable (_tmp957_);
            _tmp955_ = !_tmp958_;
      } else {
            _tmp955_ = FALSE;
      }
      if (_tmp955_) {
            if (ccall_expr != NULL) {
                  ValaCCodeFunction* _tmp959_ = NULL;
                  _tmp959_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
                  vala_ccode_function_add_expression (_tmp959_, ccall_expr);
            }
      } else {
            ValaDataType* _tmp960_ = NULL;
            ValaDataType* result_type;
            gboolean _tmp961_ = FALSE;
            ValaDataType* _tmp962_ = NULL;
            gboolean _tmp979_;
            ValaLocalVariable* _tmp980_ = NULL;
            ValaLocalVariable* temp_var;
            const gchar* _tmp981_ = NULL;
            ValaCCodeExpression* _tmp982_ = NULL;
            ValaCCodeExpression* temp_ref;
            ValaCCodeFunction* _tmp983_ = NULL;
            _tmp960_ = vala_data_type_get_return_type (itype);
            result_type = _tmp960_;
            _tmp962_ = vala_expression_get_formal_value_type ((ValaExpression*) expr);
            if (VALA_IS_GENERIC_TYPE (_tmp962_)) {
                  ValaDataType* _tmp963_ = NULL;
                  _tmp963_ = vala_expression_get_value_type ((ValaExpression*) expr);
                  _tmp961_ = !VALA_IS_GENERIC_TYPE (_tmp963_);
            } else {
                  _tmp961_ = FALSE;
            }
            if (_tmp961_) {
                  ValaDataType* _tmp964_ = NULL;
                  ValaTypeParameter* _tmp965_ = NULL;
                  ValaSymbol* _tmp966_ = NULL;
                  ValaSymbol* _tmp967_ = NULL;
                  ValaSymbol* _tmp968_;
                  ValaStruct* _tmp969_;
                  ValaStruct* st;
                  gboolean _tmp970_ = FALSE;
                  ValaDataType* _tmp971_ = NULL;
                  ValaTypeParameter* _tmp972_ = NULL;
                  ValaSymbol* _tmp973_ = NULL;
                  _tmp964_ = vala_expression_get_formal_value_type ((ValaExpression*) expr);
                  _tmp965_ = vala_data_type_get_type_parameter (_tmp964_);
                  _tmp966_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp965_);
                  _tmp967_ = vala_symbol_get_parent_symbol (_tmp966_);
                  _tmp968_ = _tmp967_;
                  _tmp969_ = _vala_code_node_ref0 (VALA_IS_STRUCT (_tmp968_) ? ((ValaStruct*) _tmp968_) : NULL);
                  st = _tmp969_;
                  _tmp971_ = vala_expression_get_formal_value_type ((ValaExpression*) expr);
                  _tmp972_ = vala_data_type_get_type_parameter (_tmp971_);
                  _tmp973_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp972_);
                  if (_tmp973_ == VALA_SYMBOL (((ValaCCodeBaseModule*) self)->garray_type)) {
                        _tmp970_ = TRUE;
                  } else {
                        gboolean _tmp974_ = FALSE;
                        if (st != NULL) {
                              gchar* _tmp975_ = NULL;
                              gchar* _tmp976_;
                              _tmp975_ = vala_typesymbol_get_cname ((ValaTypeSymbol*) st, FALSE);
                              _tmp976_ = _tmp975_;
                              _tmp974_ = g_strcmp0 (_tmp976_, "va_list") == 0;
                              _g_free0 (_tmp976_);
                        } else {
                              _tmp974_ = FALSE;
                        }
                        _tmp970_ = _tmp974_;
                  }
                  if (_tmp970_) {
                        ValaDataType* _tmp977_ = NULL;
                        ValaDataType* _tmp978_;
                        _tmp977_ = vala_expression_get_value_type ((ValaExpression*) expr);
                        _tmp978_ = _vala_code_node_ref0 (_tmp977_);
                        _vala_code_node_unref0 (result_type);
                        result_type = _tmp978_;
                  }
                  _vala_code_node_unref0 (st);
            }
            _tmp979_ = vala_data_type_get_value_owned (result_type);
            _tmp980_ = vala_ccode_base_module_get_temp_variable ((ValaCCodeBaseModule*) self, result_type, _tmp979_, NULL, TRUE);
            temp_var = _tmp980_;
            _tmp981_ = vala_symbol_get_name ((ValaSymbol*) temp_var);
            _tmp982_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, _tmp981_);
            temp_ref = _tmp982_;
            vala_ccode_base_module_emit_temp_var ((ValaCCodeBaseModule*) self, temp_var, FALSE);
            _tmp983_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
            vala_ccode_function_add_assignment (_tmp983_, 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);
      }
      _tmp984_ = vala_iterable_iterator ((ValaIterable*) params);
      _vala_iterator_unref0 (params_it);
      params_it = _tmp984_;
      {
            ValaList* _tmp985_ = NULL;
            ValaList* _arg_list;
            gint _tmp986_;
            gint _arg_size;
            gint _arg_index;
            _tmp985_ = vala_method_call_get_argument_list (expr);
            _arg_list = _tmp985_;
            _tmp986_ = vala_collection_get_size ((ValaCollection*) _arg_list);
            _arg_size = _tmp986_;
            _arg_index = -1;
            while (TRUE) {
                  gpointer _tmp987_ = NULL;
                  ValaExpression* arg;
                  gboolean _tmp988_;
                  ValaExpression* _tmp993_;
                  ValaUnaryExpression* _tmp994_;
                  ValaUnaryExpression* unary;
                  gboolean _tmp995_ = FALSE;
                  ValaExpression* _tmp997_ = NULL;
                  ValaDataType* _tmp998_ = NULL;
                  gboolean _tmp999_;
                  ValaExpression* _tmp1005_ = NULL;
                  ValaTargetValue* _tmp1006_ = NULL;
                  ValaTargetValue* _tmp1007_ = NULL;
                  ValaExpression* _tmp1008_ = NULL;
                  ValaDataType* _tmp1009_ = NULL;
                  ValaTargetValue* _tmp1010_ = NULL;
                  ValaTargetValue* _tmp1011_;
                  _arg_index = _arg_index + 1;
                  if (!(_arg_index < _arg_size)) {
                        break;
                  }
                  _tmp987_ = vala_list_get (_arg_list, _arg_index);
                  arg = (ValaExpression*) _tmp987_;
                  _tmp988_ = vala_iterator_next (params_it);
                  if (_tmp988_) {
                        gpointer _tmp989_ = NULL;
                        ValaParameter* param;
                        gboolean _tmp990_ = FALSE;
                        gboolean _tmp991_;
                        _tmp989_ = vala_iterator_get (params_it);
                        param = (ValaParameter*) _tmp989_;
                        _tmp991_ = vala_parameter_get_params_array (param);
                        if (_tmp991_) {
                              _tmp990_ = TRUE;
                        } else {
                              gboolean _tmp992_;
                              _tmp992_ = vala_parameter_get_ellipsis (param);
                              _tmp990_ = _tmp992_;
                        }
                        if (_tmp990_) {
                              _vala_code_node_unref0 (param);
                              _vala_code_node_unref0 (arg);
                              break;
                        }
                        _vala_code_node_unref0 (param);
                  }
                  _tmp993_ = arg;
                  _tmp994_ = _vala_code_node_ref0 (VALA_IS_UNARY_EXPRESSION (_tmp993_) ? ((ValaUnaryExpression*) _tmp993_) : NULL);
                  unary = _tmp994_;
                  if (unary == NULL) {
                        _tmp995_ = TRUE;
                  } else {
                        ValaUnaryOperator _tmp996_;
                        _tmp996_ = vala_unary_expression_get_operator (unary);
                        _tmp995_ = _tmp996_ != VALA_UNARY_OPERATOR_OUT;
                  }
                  if (_tmp995_) {
                        _vala_code_node_unref0 (unary);
                        _vala_code_node_unref0 (arg);
                        continue;
                  }
                  _tmp997_ = vala_unary_expression_get_inner (unary);
                  _tmp998_ = vala_expression_get_value_type (_tmp997_);
                  _tmp999_ = vala_ccode_base_module_requires_destroy ((ValaCCodeBaseModule*) self, _tmp998_);
                  if (_tmp999_) {
                        ValaCCodeFunction* _tmp1000_ = NULL;
                        ValaExpression* _tmp1001_ = NULL;
                        ValaTargetValue* _tmp1002_ = NULL;
                        ValaCCodeExpression* _tmp1003_ = NULL;
                        ValaCCodeExpression* _tmp1004_;
                        _tmp1000_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
                        _tmp1001_ = vala_unary_expression_get_inner (unary);
                        _tmp1002_ = vala_expression_get_target_value (_tmp1001_);
                        _tmp1003_ = vala_ccode_base_module_destroy_value ((ValaCCodeBaseModule*) self, _tmp1002_, FALSE);
                        _tmp1004_ = _tmp1003_;
                        vala_ccode_function_add_expression (_tmp1000_, _tmp1004_);
                        _vala_ccode_node_unref0 (_tmp1004_);
                  }
                  _tmp1005_ = vala_unary_expression_get_inner (unary);
                  _tmp1006_ = vala_expression_get_target_value (_tmp1005_);
                  _tmp1007_ = vala_expression_get_target_value ((ValaExpression*) unary);
                  _tmp1008_ = vala_unary_expression_get_inner (unary);
                  _tmp1009_ = vala_expression_get_value_type (_tmp1008_);
                  _tmp1010_ = vala_ccode_base_module_transform_value ((ValaCCodeBaseModule*) self, _tmp1007_, _tmp1009_, (ValaCodeNode*) arg);
                  _tmp1011_ = _tmp1010_;
                  vala_ccode_base_module_store_value ((ValaCCodeBaseModule*) self, _tmp1006_, _tmp1011_);
                  _vala_target_value_unref0 (_tmp1011_);
                  _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