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

/* valagerrormodule.vala
 *
 * Copyright (C) 2008-2010  Jürg Billeter
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.

 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.

 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
 *
 * Author:
 *	Jürg Billeter <j@bitron.ch>
 *	Thijs Vermeir <thijsvermeir@gmail.com>
 */

#include <glib.h>
#include <glib-object.h>
#include <vala.h>
#include <valaccode.h>
#include <valagee.h>
#include <stdlib.h>
#include <string.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_TYPE_CCODE_ARRAY_MODULE (vala_ccode_array_module_get_type ())
#define VALA_CCODE_ARRAY_MODULE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CCODE_ARRAY_MODULE, ValaCCodeArrayModule))
#define VALA_CCODE_ARRAY_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CCODE_ARRAY_MODULE, ValaCCodeArrayModuleClass))
#define VALA_IS_CCODE_ARRAY_MODULE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CCODE_ARRAY_MODULE))
#define VALA_IS_CCODE_ARRAY_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CCODE_ARRAY_MODULE))
#define VALA_CCODE_ARRAY_MODULE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CCODE_ARRAY_MODULE, ValaCCodeArrayModuleClass))

typedef struct _ValaCCodeArrayModule ValaCCodeArrayModule;
typedef struct _ValaCCodeArrayModuleClass ValaCCodeArrayModuleClass;
typedef struct _ValaCCodeArrayModulePrivate ValaCCodeArrayModulePrivate;

#define VALA_TYPE_CCODE_DELEGATE_MODULE (vala_ccode_delegate_module_get_type ())
#define VALA_CCODE_DELEGATE_MODULE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CCODE_DELEGATE_MODULE, ValaCCodeDelegateModule))
#define VALA_CCODE_DELEGATE_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CCODE_DELEGATE_MODULE, ValaCCodeDelegateModuleClass))
#define VALA_IS_CCODE_DELEGATE_MODULE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CCODE_DELEGATE_MODULE))
#define VALA_IS_CCODE_DELEGATE_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CCODE_DELEGATE_MODULE))
#define VALA_CCODE_DELEGATE_MODULE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CCODE_DELEGATE_MODULE, ValaCCodeDelegateModuleClass))

typedef struct _ValaCCodeDelegateModule ValaCCodeDelegateModule;
typedef struct _ValaCCodeDelegateModuleClass ValaCCodeDelegateModuleClass;
typedef struct _ValaCCodeDelegateModulePrivate ValaCCodeDelegateModulePrivate;

#define VALA_TYPE_GERROR_MODULE (vala_gerror_module_get_type ())
#define VALA_GERROR_MODULE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_GERROR_MODULE, ValaGErrorModule))
#define VALA_GERROR_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_GERROR_MODULE, ValaGErrorModuleClass))
#define VALA_IS_GERROR_MODULE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_GERROR_MODULE))
#define VALA_IS_GERROR_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_GERROR_MODULE))
#define VALA_GERROR_MODULE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_GERROR_MODULE, ValaGErrorModuleClass))

typedef struct _ValaGErrorModule ValaGErrorModule;
typedef struct _ValaGErrorModuleClass ValaGErrorModuleClass;
typedef struct _ValaGErrorModulePrivate ValaGErrorModulePrivate;
#define _g_free0(var) (var = (g_free (var), NULL))
#define _vala_ccode_node_unref0(var) ((var == NULL) ? NULL : (var = (vala_ccode_node_unref (var), NULL)))
#define _vala_code_node_unref0(var) ((var == NULL) ? NULL : (var = (vala_code_node_unref (var), NULL)))
#define _vala_iterable_unref0(var) ((var == NULL) ? NULL : (var = (vala_iterable_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)))

struct _ValaCCodeBaseModule {
	ValaCodeGenerator parent_instance;
	ValaCCodeBaseModulePrivate * priv;
	ValaSymbol* root_symbol;
	ValaCCodeBaseModuleEmitContext* emit_context;
	ValaCCodeLineDirective* current_line;
	ValaCCodeFile* header_file;
	ValaCCodeFile* internal_header_file;
	ValaCCodeFile* cfile;
	ValaCCodeBaseModuleEmitContext* class_init_context;
	ValaCCodeBaseModuleEmitContext* base_init_context;
	ValaCCodeBaseModuleEmitContext* class_finalize_context;
	ValaCCodeBaseModuleEmitContext* base_finalize_context;
	ValaCCodeBaseModuleEmitContext* instance_init_context;
	ValaCCodeBaseModuleEmitContext* instance_finalize_context;
	ValaCCodeStruct* param_spec_struct;
	ValaCCodeStruct* closure_struct;
	ValaCCodeEnum* prop_enum;
	ValaSet* user_marshal_set;
	ValaSet* predefined_marshal_set;
	gint next_regex_id;
	gint next_coroutine_state;
	ValaDataType* void_type;
	ValaDataType* bool_type;
	ValaDataType* char_type;
	ValaDataType* uchar_type;
	ValaDataType* unichar_type;
	ValaDataType* short_type;
	ValaDataType* ushort_type;
	ValaDataType* int_type;
	ValaDataType* uint_type;
	ValaDataType* long_type;
	ValaDataType* ulong_type;
	ValaDataType* int8_type;
	ValaDataType* uint8_type;
	ValaDataType* int16_type;
	ValaDataType* uint16_type;
	ValaDataType* int32_type;
	ValaDataType* uint32_type;
	ValaDataType* int64_type;
	ValaDataType* uint64_type;
	ValaDataType* string_type;
	ValaDataType* regex_type;
	ValaDataType* float_type;
	ValaDataType* double_type;
	ValaTypeSymbol* gtype_type;
	ValaTypeSymbol* gobject_type;
	ValaErrorType* gerror_type;
	ValaClass* glist_type;
	ValaClass* gslist_type;
	ValaClass* gnode_type;
	ValaClass* gqueue_type;
	ValaClass* gvaluearray_type;
	ValaTypeSymbol* gstringbuilder_type;
	ValaTypeSymbol* garray_type;
	ValaTypeSymbol* gbytearray_type;
	ValaTypeSymbol* gptrarray_type;
	ValaTypeSymbol* gthreadpool_type;
	ValaDataType* gdestroynotify_type;
	ValaDataType* gquark_type;
	ValaStruct* gvalue_type;
	ValaClass* gvariant_type;
	ValaStruct* mutex_type;
	ValaTypeSymbol* type_module_type;
	ValaTypeSymbol* dbus_proxy_type;
	gboolean in_plugin;
	gchar* module_init_param_name;
	gboolean gvaluecollector_h_needed;
	gboolean requires_array_free;
	gboolean requires_array_move;
	gboolean requires_array_length;
	ValaSet* wrappers;
};

struct _ValaCCodeBaseModuleClass {
	ValaCodeGeneratorClass parent_class;
	void (*append_vala_array_free) (ValaCCodeBaseModule* self);
	void (*append_vala_array_move) (ValaCCodeBaseModule* self);
	void (*append_vala_array_length) (ValaCCodeBaseModule* self);
	gboolean (*generate_enum_declaration) (ValaCCodeBaseModule* self, ValaEnum* en, ValaCCodeFile* decl_space);
	void (*generate_class_struct_declaration) (ValaCCodeBaseModule* self, ValaClass* cl, ValaCCodeFile* decl_space);
	void (*generate_struct_declaration) (ValaCCodeBaseModule* self, ValaStruct* st, ValaCCodeFile* decl_space);
	void (*generate_delegate_declaration) (ValaCCodeBaseModule* self, ValaDelegate* d, ValaCCodeFile* decl_space);
	void (*generate_cparameters) (ValaCCodeBaseModule* self, ValaMethod* m, ValaCCodeFile* decl_space, ValaMap* cparam_map, ValaCCodeFunction* func, ValaCCodeFunctionDeclarator* vdeclarator, ValaMap* carg_map, ValaCCodeFunctionCall* vcall, gint direction);
	ValaCCodeExpression* (*get_dup_func_expression) (ValaCCodeBaseModule* self, ValaDataType* type, ValaSourceReference* source_reference, gboolean is_chainup);
	gchar* (*append_struct_array_free) (ValaCCodeBaseModule* self, ValaStruct* st);
	ValaCCodeExpression* (*destroy_value) (ValaCCodeBaseModule* self, ValaTargetValue* value, gboolean is_macro_definition);
	void (*append_scope_free) (ValaCCodeBaseModule* self, ValaSymbol* sym, ValaCodeNode* stop_at);
	ValaTargetValue* (*get_local_cvalue) (ValaCCodeBaseModule* self, ValaLocalVariable* local);
	ValaTargetValue* (*get_parameter_cvalue) (ValaCCodeBaseModule* self, ValaParameter* param);
	ValaTargetValue* (*get_field_cvalue) (ValaCCodeBaseModule* self, ValaField* field, ValaTargetValue* instance);
	ValaTargetValue* (*load_variable) (ValaCCodeBaseModule* self, ValaVariable* variable, ValaTargetValue* value);
	ValaTargetValue* (*load_this_parameter) (ValaCCodeBaseModule* self, ValaTypeSymbol* sym);
	void (*store_value) (ValaCCodeBaseModule* self, ValaTargetValue* lvalue, ValaTargetValue* value);
	gchar* (*get_delegate_target_cname) (ValaCCodeBaseModule* self, const gchar* delegate_cname);
	ValaCCodeExpression* (*get_delegate_target_cexpression) (ValaCCodeBaseModule* self, ValaExpression* delegate_expr, ValaCCodeExpression** delegate_target_destroy_notify);
	ValaCCodeExpression* (*get_delegate_target_cvalue) (ValaCCodeBaseModule* self, ValaTargetValue* value);
	ValaCCodeExpression* (*get_delegate_target_destroy_notify_cvalue) (ValaCCodeBaseModule* self, ValaTargetValue* value);
	gchar* (*get_delegate_target_destroy_notify_cname) (ValaCCodeBaseModule* self, const gchar* delegate_cname);
	ValaTargetValue* (*copy_value) (ValaCCodeBaseModule* self, ValaTargetValue* value, ValaCodeNode* node);
	void (*generate_class_declaration) (ValaCCodeBaseModule* self, ValaClass* cl, ValaCCodeFile* decl_space);
	void (*generate_interface_declaration) (ValaCCodeBaseModule* self, ValaInterface* iface, ValaCCodeFile* decl_space);
	void (*generate_method_declaration) (ValaCCodeBaseModule* self, ValaMethod* m, ValaCCodeFile* decl_space);
	void (*generate_error_domain_declaration) (ValaCCodeBaseModule* self, ValaErrorDomain* edomain, ValaCCodeFile* decl_space);
	ValaCCodeExpression* (*deserialize_expression) (ValaCCodeBaseModule* self, ValaDataType* type, ValaCCodeExpression* variant_expr, ValaCCodeExpression* expr, ValaCCodeExpression* error_expr, gboolean* may_fail);
	ValaCCodeExpression* (*serialize_expression) (ValaCCodeBaseModule* self, ValaDataType* type, ValaCCodeExpression* expr);
	ValaCCodeExpression* (*get_implicit_cast_expression) (ValaCCodeBaseModule* self, ValaCCodeExpression* source_cexpr, ValaDataType* expression_type, ValaDataType* target_type, ValaCodeNode* node);
	void (*create_type_check_statement) (ValaCCodeBaseModule* self, ValaCodeNode* method_node, ValaDataType* ret_type, ValaTypeSymbol* t, gboolean non_null, const gchar* var_name);
	gboolean (*is_gobject_property) (ValaCCodeBaseModule* self, ValaProperty* prop);
	void (*generate_dynamic_method_wrapper) (ValaCCodeBaseModule* self, ValaDynamicMethod* method);
	gboolean (*method_has_wrapper) (ValaCCodeBaseModule* self, ValaMethod* method);
	ValaCCodeFunctionCall* (*get_param_spec) (ValaCCodeBaseModule* self, ValaProperty* prop);
	ValaCCodeFunctionCall* (*get_signal_creation) (ValaCCodeBaseModule* self, ValaSignal* sig, ValaTypeSymbol* type);
	void (*register_dbus_info) (ValaCCodeBaseModule* self, ValaCCodeBlock* block, ValaObjectTypeSymbol* bindable);
	gchar* (*get_dynamic_property_getter_cname) (ValaCCodeBaseModule* self, ValaDynamicProperty* node);
	gchar* (*get_dynamic_property_setter_cname) (ValaCCodeBaseModule* self, ValaDynamicProperty* node);
	gchar* (*get_dynamic_signal_cname) (ValaCCodeBaseModule* self, ValaDynamicSignal* node);
	gchar* (*get_dynamic_signal_connect_wrapper_name) (ValaCCodeBaseModule* self, ValaDynamicSignal* node);
	gchar* (*get_dynamic_signal_connect_after_wrapper_name) (ValaCCodeBaseModule* self, ValaDynamicSignal* node);
	gchar* (*get_dynamic_signal_disconnect_wrapper_name) (ValaCCodeBaseModule* self, ValaDynamicSignal* node);
	gchar* (*get_array_length_cname) (ValaCCodeBaseModule* self, const gchar* array_cname, gint dim);
	gchar* (*get_parameter_array_length_cname) (ValaCCodeBaseModule* self, ValaParameter* param, gint dim);
	ValaCCodeExpression* (*get_array_length_cexpression) (ValaCCodeBaseModule* self, ValaExpression* array_expr, gint dim);
	ValaCCodeExpression* (*get_array_length_cvalue) (ValaCCodeBaseModule* self, ValaTargetValue* value, gint dim);
	gchar* (*get_array_size_cname) (ValaCCodeBaseModule* self, const gchar* array_cname);
	void (*add_simple_check) (ValaCCodeBaseModule* self, ValaCodeNode* node, gboolean always_fails);
	gchar* (*generate_ready_function) (ValaCCodeBaseModule* self, ValaMethod* m);
};

struct _ValaCCodeStructModule {
	ValaCCodeBaseModule parent_instance;
	ValaCCodeStructModulePrivate * priv;
};

struct _ValaCCodeStructModuleClass {
	ValaCCodeBaseModuleClass parent_class;
};

struct _ValaCCodeMethodModule {
	ValaCCodeStructModule parent_instance;
	ValaCCodeMethodModulePrivate * priv;
};

struct _ValaCCodeMethodModuleClass {
	ValaCCodeStructModuleClass parent_class;
	void (*generate_method_result_declaration) (ValaCCodeMethodModule* self, ValaMethod* m, ValaCCodeFile* decl_space, ValaCCodeFunction* cfunc, ValaMap* cparam_map, ValaMap* carg_map);
	ValaCCodeParameter* (*generate_parameter) (ValaCCodeMethodModule* self, ValaParameter* param, ValaCCodeFile* decl_space, ValaMap* cparam_map, ValaMap* carg_map);
};

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;
};

struct _ValaCCodeArrayModule {
	ValaCCodeMethodCallModule parent_instance;
	ValaCCodeArrayModulePrivate * priv;
};

struct _ValaCCodeArrayModuleClass {
	ValaCCodeMethodCallModuleClass parent_class;
};

struct _ValaCCodeDelegateModule {
	ValaCCodeArrayModule parent_instance;
	ValaCCodeDelegateModulePrivate * priv;
};

struct _ValaCCodeDelegateModuleClass {
	ValaCCodeArrayModuleClass parent_class;
};

struct _ValaGErrorModule {
	ValaCCodeDelegateModule parent_instance;
	ValaGErrorModulePrivate * priv;
};

struct _ValaGErrorModuleClass {
	ValaCCodeDelegateModuleClass parent_class;
	void (*return_with_exception) (ValaGErrorModule* self, ValaCCodeExpression* error_expr);
};

struct _ValaGErrorModulePrivate {
	gint current_try_id;
	gint next_try_id;
	gboolean is_in_catch;
};


static gpointer vala_gerror_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;
GType vala_ccode_array_module_get_type (void) G_GNUC_CONST;
GType vala_ccode_delegate_module_get_type (void) G_GNUC_CONST;
GType vala_gerror_module_get_type (void) G_GNUC_CONST;
#define VALA_GERROR_MODULE_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), VALA_TYPE_GERROR_MODULE, ValaGErrorModulePrivate))
enum  {
	VALA_GERROR_MODULE_DUMMY_PROPERTY
};
static void vala_gerror_module_real_generate_error_domain_declaration (ValaCCodeBaseModule* base, ValaErrorDomain* edomain, ValaCCodeFile* decl_space);
gboolean vala_ccode_base_module_add_symbol_declaration (ValaCCodeBaseModule* self, ValaCCodeFile* decl_space, ValaSymbol* sym, const gchar* name);
gchar* vala_ccode_base_module_get_ccode_name (ValaCodeNode* node);
ValaCCodeExpression* vala_ccode_base_module_get_cvalue (ValaCCodeBaseModule* self, ValaExpression* expr);
gchar* vala_ccode_base_module_get_ccode_lower_case_prefix (ValaSymbol* sym);
gchar* vala_ccode_base_module_get_ccode_upper_case_name (ValaSymbol* sym, const gchar* infix);
static void vala_gerror_module_real_visit_error_domain (ValaCodeVisitor* base, ValaErrorDomain* edomain);
void vala_ccode_base_module_generate_error_domain_declaration (ValaCCodeBaseModule* self, ValaErrorDomain* edomain, ValaCCodeFile* decl_space);
void vala_ccode_base_module_push_function (ValaCCodeBaseModule* self, ValaCCodeFunction* func);
gchar* vala_ccode_base_module_get_ccode_lower_case_name (ValaCodeNode* node, const gchar* infix);
ValaCCodeFunction* vala_ccode_base_module_get_ccode (ValaCCodeBaseModule* self);
void vala_ccode_base_module_pop_function (ValaCCodeBaseModule* self);
static void vala_gerror_module_real_visit_throw_statement (ValaCodeVisitor* base, ValaThrowStatement* stmt);
void vala_ccode_base_module_set_current_method_inner_error (ValaCCodeBaseModule* self, gboolean value);
ValaCCodeExpression* vala_ccode_base_module_get_variable_cexpression (ValaCCodeBaseModule* self, const gchar* name);
void vala_ccode_base_module_add_simple_check (ValaCCodeBaseModule* self, ValaCodeNode* node, gboolean always_fails);
void vala_gerror_module_return_with_exception (ValaGErrorModule* self, ValaCCodeExpression* error_expr);
static void vala_gerror_module_real_return_with_exception (ValaGErrorModule* self, ValaCCodeExpression* error_expr);
void vala_ccode_base_module_append_local_free (ValaCCodeBaseModule* self, ValaSymbol* sym, gboolean stop_at_loop, ValaCodeNode* stop_at);
ValaSymbol* vala_ccode_base_module_get_current_symbol (ValaCCodeBaseModule* self);
ValaMethod* vala_ccode_base_module_get_current_method (ValaCCodeBaseModule* self);
ValaCCodeExpression* vala_ccode_base_module_destroy_value (ValaCCodeBaseModule* self, ValaTargetValue* value, gboolean is_macro_definition);
ValaGLibValue* vala_glib_value_new (ValaDataType* value_type, ValaCCodeExpression* cvalue, gboolean lvalue);
ValaGLibValue* vala_glib_value_construct (GType object_type, ValaDataType* value_type, ValaCCodeExpression* cvalue, gboolean lvalue);
GType vala_glib_value_get_type (void) G_GNUC_CONST;
gboolean vala_ccode_base_module_is_in_coroutine (ValaCCodeBaseModule* self);
void vala_ccode_base_module_return_default_value (ValaCCodeBaseModule* self, ValaDataType* return_type);
ValaDataType* vala_ccode_base_module_get_current_return_type (ValaCCodeBaseModule* self);
static void vala_gerror_module_uncaught_error_statement (ValaGErrorModule* self, ValaCCodeExpression* inner_error, gboolean unexpected);
gboolean vala_ccode_base_module_is_in_constructor (ValaCCodeBaseModule* self);
gboolean vala_ccode_base_module_is_in_destructor (ValaCCodeBaseModule* self);
static gboolean vala_gerror_module_in_finally_block (ValaGErrorModule* self, ValaCodeNode* node);
static void vala_gerror_module_real_add_simple_check (ValaCCodeBaseModule* base, ValaCodeNode* node, gboolean always_fails);
ValaTryStatement* vala_ccode_base_module_get_current_try (ValaCCodeBaseModule* self);
ValaCatchClause* vala_ccode_base_module_get_current_catch (ValaCCodeBaseModule* self);
static void vala_gerror_module_real_visit_try_statement (ValaCodeVisitor* base, ValaTryStatement* stmt);
void vala_ccode_base_module_set_current_try (ValaCCodeBaseModule* self, ValaTryStatement* value);
void vala_ccode_base_module_set_current_catch (ValaCCodeBaseModule* self, ValaCatchClause* value);
static void vala_gerror_module_real_visit_catch_clause (ValaCodeVisitor* base, ValaCatchClause* clause);
gchar* vala_ccode_base_module_get_local_cname (ValaCCodeBaseModule* self, ValaLocalVariable* local);
static void vala_gerror_module_real_append_scope_free (ValaCCodeBaseModule* base, ValaSymbol* sym, ValaCodeNode* stop_at);
void vala_ccode_base_module_append_scope_free (ValaCCodeBaseModule* self, ValaSymbol* sym, ValaCodeNode* stop_at);
ValaGErrorModule* vala_gerror_module_new (void);
ValaGErrorModule* vala_gerror_module_construct (GType object_type);
ValaCCodeDelegateModule* vala_ccode_delegate_module_new (void);
ValaCCodeDelegateModule* vala_ccode_delegate_module_construct (GType object_type);
static void vala_gerror_module_finalize (ValaCodeVisitor* obj);


static void vala_gerror_module_real_generate_error_domain_declaration (ValaCCodeBaseModule* base, ValaErrorDomain* edomain, ValaCCodeFile* decl_space) {
	ValaGErrorModule * self;
	ValaCCodeFile* _tmp0_;
	ValaErrorDomain* _tmp1_;
	ValaErrorDomain* _tmp2_;
	gchar* _tmp3_ = NULL;
	gchar* _tmp4_;
	gboolean _tmp5_ = FALSE;
	gboolean _tmp6_;
	ValaErrorDomain* _tmp7_;
	gchar* _tmp8_ = NULL;
	gchar* _tmp9_;
	ValaCCodeEnum* _tmp10_;
	ValaCCodeEnum* _tmp11_;
	ValaCCodeEnum* cenum;
	ValaCCodeFile* _tmp46_;
	ValaCCodeEnum* _tmp47_;
	ValaErrorDomain* _tmp48_;
	gchar* _tmp49_ = NULL;
	gchar* _tmp50_;
	gchar* _tmp51_;
	gchar* _tmp52_;
	gchar* quark_fun_name;
	ValaErrorDomain* _tmp53_;
	gchar* _tmp54_ = NULL;
	gchar* _tmp55_;
	const gchar* _tmp56_;
	gchar* _tmp57_;
	gchar* _tmp58_;
	ValaCCodeMacroReplacement* _tmp59_;
	ValaCCodeMacroReplacement* _tmp60_;
	ValaCCodeMacroReplacement* error_domain_define;
	ValaCCodeFile* _tmp61_;
	ValaCCodeMacroReplacement* _tmp62_;
	const gchar* _tmp63_;
	ValaDataType* _tmp64_;
	ValaTypeSymbol* _tmp65_;
	ValaTypeSymbol* _tmp66_;
	gchar* _tmp67_ = NULL;
	gchar* _tmp68_;
	ValaCCodeFunction* _tmp69_;
	ValaCCodeFunction* _tmp70_;
	ValaCCodeFunction* cquark_fun;
	ValaCCodeFile* _tmp71_;
	ValaCCodeFunction* _tmp72_;
	self = (ValaGErrorModule*) base;
	g_return_if_fail (edomain != NULL);
	g_return_if_fail (decl_space != NULL);
	_tmp0_ = decl_space;
	_tmp1_ = edomain;
	_tmp2_ = edomain;
	_tmp3_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp2_);
	_tmp4_ = _tmp3_;
	_tmp5_ = vala_ccode_base_module_add_symbol_declaration ((ValaCCodeBaseModule*) self, _tmp0_, (ValaSymbol*) _tmp1_, _tmp4_);
	_tmp6_ = _tmp5_;
	_g_free0 (_tmp4_);
	if (_tmp6_) {
		return;
	}
	_tmp7_ = edomain;
	_tmp8_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp7_);
	_tmp9_ = _tmp8_;
	_tmp10_ = vala_ccode_enum_new (_tmp9_);
	_tmp11_ = _tmp10_;
	_g_free0 (_tmp9_);
	cenum = _tmp11_;
	{
		ValaErrorDomain* _tmp12_;
		ValaList* _tmp13_ = NULL;
		ValaList* _ecode_list;
		ValaList* _tmp14_;
		gint _tmp15_;
		gint _tmp16_;
		gint _ecode_size;
		gint _ecode_index;
		_tmp12_ = edomain;
		_tmp13_ = vala_error_domain_get_codes (_tmp12_);
		_ecode_list = _tmp13_;
		_tmp14_ = _ecode_list;
		_tmp15_ = vala_collection_get_size ((ValaCollection*) _tmp14_);
		_tmp16_ = _tmp15_;
		_ecode_size = _tmp16_;
		_ecode_index = -1;
		while (TRUE) {
			gint _tmp17_;
			gint _tmp18_;
			gint _tmp19_;
			ValaList* _tmp20_;
			gint _tmp21_;
			gpointer _tmp22_ = NULL;
			ValaErrorCode* ecode;
			ValaErrorCode* _tmp23_;
			ValaExpression* _tmp24_;
			ValaExpression* _tmp25_;
			_tmp17_ = _ecode_index;
			_ecode_index = _tmp17_ + 1;
			_tmp18_ = _ecode_index;
			_tmp19_ = _ecode_size;
			if (!(_tmp18_ < _tmp19_)) {
				break;
			}
			_tmp20_ = _ecode_list;
			_tmp21_ = _ecode_index;
			_tmp22_ = vala_list_get (_tmp20_, _tmp21_);
			ecode = (ValaErrorCode*) _tmp22_;
			_tmp23_ = ecode;
			_tmp24_ = vala_error_code_get_value (_tmp23_);
			_tmp25_ = _tmp24_;
			if (_tmp25_ == NULL) {
				ValaCCodeEnum* _tmp26_;
				ValaErrorCode* _tmp27_;
				gchar* _tmp28_ = NULL;
				gchar* _tmp29_;
				ValaCCodeEnumValue* _tmp30_;
				ValaCCodeEnumValue* _tmp31_;
				_tmp26_ = cenum;
				_tmp27_ = ecode;
				_tmp28_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp27_);
				_tmp29_ = _tmp28_;
				_tmp30_ = vala_ccode_enum_value_new (_tmp29_, NULL);
				_tmp31_ = _tmp30_;
				vala_ccode_enum_add_value (_tmp26_, _tmp31_);
				_vala_ccode_node_unref0 (_tmp31_);
				_g_free0 (_tmp29_);
			} else {
				ValaErrorCode* _tmp32_;
				ValaExpression* _tmp33_;
				ValaExpression* _tmp34_;
				ValaCCodeEnum* _tmp35_;
				ValaErrorCode* _tmp36_;
				gchar* _tmp37_ = NULL;
				gchar* _tmp38_;
				ValaErrorCode* _tmp39_;
				ValaExpression* _tmp40_;
				ValaExpression* _tmp41_;
				ValaCCodeExpression* _tmp42_ = NULL;
				ValaCCodeExpression* _tmp43_;
				ValaCCodeEnumValue* _tmp44_;
				ValaCCodeEnumValue* _tmp45_;
				_tmp32_ = ecode;
				_tmp33_ = vala_error_code_get_value (_tmp32_);
				_tmp34_ = _tmp33_;
				vala_code_node_emit ((ValaCodeNode*) _tmp34_, (ValaCodeGenerator*) self);
				_tmp35_ = cenum;
				_tmp36_ = ecode;
				_tmp37_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp36_);
				_tmp38_ = _tmp37_;
				_tmp39_ = ecode;
				_tmp40_ = vala_error_code_get_value (_tmp39_);
				_tmp41_ = _tmp40_;
				_tmp42_ = vala_ccode_base_module_get_cvalue ((ValaCCodeBaseModule*) self, _tmp41_);
				_tmp43_ = _tmp42_;
				_tmp44_ = vala_ccode_enum_value_new (_tmp38_, _tmp43_);
				_tmp45_ = _tmp44_;
				vala_ccode_enum_add_value (_tmp35_, _tmp45_);
				_vala_ccode_node_unref0 (_tmp45_);
				_vala_ccode_node_unref0 (_tmp43_);
				_g_free0 (_tmp38_);
			}
			_vala_code_node_unref0 (ecode);
		}
		_vala_iterable_unref0 (_ecode_list);
	}
	_tmp46_ = decl_space;
	_tmp47_ = cenum;
	vala_ccode_file_add_type_definition (_tmp46_, (ValaCCodeNode*) _tmp47_);
	_tmp48_ = edomain;
	_tmp49_ = vala_ccode_base_module_get_ccode_lower_case_prefix ((ValaSymbol*) _tmp48_);
	_tmp50_ = _tmp49_;
	_tmp51_ = g_strconcat (_tmp50_, "quark", NULL);
	_tmp52_ = _tmp51_;
	_g_free0 (_tmp50_);
	quark_fun_name = _tmp52_;
	_tmp53_ = edomain;
	_tmp54_ = vala_ccode_base_module_get_ccode_upper_case_name ((ValaSymbol*) _tmp53_, NULL);
	_tmp55_ = _tmp54_;
	_tmp56_ = quark_fun_name;
	_tmp57_ = g_strconcat (_tmp56_, " ()", NULL);
	_tmp58_ = _tmp57_;
	_tmp59_ = vala_ccode_macro_replacement_new (_tmp55_, _tmp58_);
	_tmp60_ = _tmp59_;
	_g_free0 (_tmp58_);
	_g_free0 (_tmp55_);
	error_domain_define = _tmp60_;
	_tmp61_ = decl_space;
	_tmp62_ = error_domain_define;
	vala_ccode_file_add_type_definition (_tmp61_, (ValaCCodeNode*) _tmp62_);
	_tmp63_ = quark_fun_name;
	_tmp64_ = ((ValaCCodeBaseModule*) self)->gquark_type;
	_tmp65_ = vala_data_type_get_data_type (_tmp64_);
	_tmp66_ = _tmp65_;
	_tmp67_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp66_);
	_tmp68_ = _tmp67_;
	_tmp69_ = vala_ccode_function_new (_tmp63_, _tmp68_);
	_tmp70_ = _tmp69_;
	_g_free0 (_tmp68_);
	cquark_fun = _tmp70_;
	_tmp71_ = decl_space;
	_tmp72_ = cquark_fun;
	vala_ccode_file_add_function_declaration (_tmp71_, _tmp72_);
	_vala_ccode_node_unref0 (cquark_fun);
	_vala_ccode_node_unref0 (error_domain_define);
	_g_free0 (quark_fun_name);
	_vala_ccode_node_unref0 (cenum);
}


static void vala_gerror_module_real_visit_error_domain (ValaCodeVisitor* base, ValaErrorDomain* edomain) {
	ValaGErrorModule * self;
	ValaErrorDomain* _tmp0_;
	ValaComment* _tmp1_;
	ValaComment* _tmp2_;
	ValaErrorDomain* _tmp11_;
	ValaCCodeFile* _tmp12_;
	ValaErrorDomain* _tmp13_;
	gboolean _tmp14_ = FALSE;
	ValaErrorDomain* _tmp17_;
	gboolean _tmp18_ = FALSE;
	ValaErrorDomain* _tmp21_;
	gchar* _tmp22_ = NULL;
	gchar* _tmp23_;
	gchar* _tmp24_;
	gchar* _tmp25_;
	gchar* quark_fun_name;
	ValaDataType* _tmp26_;
	ValaTypeSymbol* _tmp27_;
	ValaTypeSymbol* _tmp28_;
	gchar* _tmp29_ = NULL;
	gchar* _tmp30_;
	ValaCCodeFunction* _tmp31_;
	ValaCCodeFunction* _tmp32_;
	ValaCCodeFunction* cquark_fun;
	ValaCCodeIdentifier* _tmp33_;
	ValaCCodeIdentifier* _tmp34_;
	ValaCCodeFunctionCall* _tmp35_;
	ValaCCodeFunctionCall* _tmp36_;
	ValaCCodeFunctionCall* cquark_call;
	ValaErrorDomain* _tmp37_;
	gchar* _tmp38_ = NULL;
	gchar* _tmp39_;
	gchar* _tmp40_;
	gchar* _tmp41_;
	gchar* _tmp42_;
	gchar* _tmp43_;
	ValaCCodeConstant* _tmp44_;
	ValaCCodeConstant* _tmp45_;
	ValaCCodeFunction* _tmp46_;
	ValaCCodeFunction* _tmp47_;
	ValaCCodeFile* _tmp48_;
	self = (ValaGErrorModule*) base;
	g_return_if_fail (edomain != NULL);
	_tmp0_ = edomain;
	_tmp1_ = vala_symbol_get_comment ((ValaSymbol*) _tmp0_);
	_tmp2_ = _tmp1_;
	if (_tmp2_ != NULL) {
		ValaCCodeFile* _tmp3_;
		ValaErrorDomain* _tmp4_;
		ValaComment* _tmp5_;
		ValaComment* _tmp6_;
		const gchar* _tmp7_;
		const gchar* _tmp8_;
		ValaCCodeComment* _tmp9_;
		ValaCCodeComment* _tmp10_;
		_tmp3_ = ((ValaCCodeBaseModule*) self)->cfile;
		_tmp4_ = edomain;
		_tmp5_ = vala_symbol_get_comment ((ValaSymbol*) _tmp4_);
		_tmp6_ = _tmp5_;
		_tmp7_ = vala_comment_get_content (_tmp6_);
		_tmp8_ = _tmp7_;
		_tmp9_ = vala_ccode_comment_new (_tmp8_);
		_tmp10_ = _tmp9_;
		vala_ccode_file_add_type_definition (_tmp3_, (ValaCCodeNode*) _tmp10_);
		_vala_ccode_node_unref0 (_tmp10_);
	}
	_tmp11_ = edomain;
	_tmp12_ = ((ValaCCodeBaseModule*) self)->cfile;
	vala_ccode_base_module_generate_error_domain_declaration ((ValaCCodeBaseModule*) self, _tmp11_, _tmp12_);
	_tmp13_ = edomain;
	_tmp14_ = vala_symbol_is_internal_symbol ((ValaSymbol*) _tmp13_);
	if (!_tmp14_) {
		ValaErrorDomain* _tmp15_;
		ValaCCodeFile* _tmp16_;
		_tmp15_ = edomain;
		_tmp16_ = ((ValaCCodeBaseModule*) self)->header_file;
		vala_ccode_base_module_generate_error_domain_declaration ((ValaCCodeBaseModule*) self, _tmp15_, _tmp16_);
	}
	_tmp17_ = edomain;
	_tmp18_ = vala_symbol_is_private_symbol ((ValaSymbol*) _tmp17_);
	if (!_tmp18_) {
		ValaErrorDomain* _tmp19_;
		ValaCCodeFile* _tmp20_;
		_tmp19_ = edomain;
		_tmp20_ = ((ValaCCodeBaseModule*) self)->internal_header_file;
		vala_ccode_base_module_generate_error_domain_declaration ((ValaCCodeBaseModule*) self, _tmp19_, _tmp20_);
	}
	_tmp21_ = edomain;
	_tmp22_ = vala_ccode_base_module_get_ccode_lower_case_prefix ((ValaSymbol*) _tmp21_);
	_tmp23_ = _tmp22_;
	_tmp24_ = g_strconcat (_tmp23_, "quark", NULL);
	_tmp25_ = _tmp24_;
	_g_free0 (_tmp23_);
	quark_fun_name = _tmp25_;
	_tmp26_ = ((ValaCCodeBaseModule*) self)->gquark_type;
	_tmp27_ = vala_data_type_get_data_type (_tmp26_);
	_tmp28_ = _tmp27_;
	_tmp29_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp28_);
	_tmp30_ = _tmp29_;
	_tmp31_ = vala_ccode_function_new (quark_fun_name, _tmp30_);
	_tmp32_ = _tmp31_;
	_g_free0 (_tmp30_);
	cquark_fun = _tmp32_;
	vala_ccode_base_module_push_function ((ValaCCodeBaseModule*) self, cquark_fun);
	_tmp33_ = vala_ccode_identifier_new ("g_quark_from_static_string");
	_tmp34_ = _tmp33_;
	_tmp35_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp34_);
	_tmp36_ = _tmp35_;
	_vala_ccode_node_unref0 (_tmp34_);
	cquark_call = _tmp36_;
	_tmp37_ = edomain;
	_tmp38_ = vala_ccode_base_module_get_ccode_lower_case_name ((ValaCodeNode*) _tmp37_, NULL);
	_tmp39_ = _tmp38_;
	_tmp40_ = g_strconcat ("\"", _tmp39_, NULL);
	_tmp41_ = _tmp40_;
	_tmp42_ = g_strconcat (_tmp41_, "-quark\"", NULL);
	_tmp43_ = _tmp42_;
	_tmp44_ = vala_ccode_constant_new (_tmp43_);
	_tmp45_ = _tmp44_;
	vala_ccode_function_call_add_argument (cquark_call, (ValaCCodeExpression*) _tmp45_);
	_vala_ccode_node_unref0 (_tmp45_);
	_g_free0 (_tmp43_);
	_g_free0 (_tmp41_);
	_g_free0 (_tmp39_);
	_tmp46_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
	_tmp47_ = _tmp46_;
	vala_ccode_function_add_return (_tmp47_, (ValaCCodeExpression*) cquark_call);
	vala_ccode_base_module_pop_function ((ValaCCodeBaseModule*) self);
	_tmp48_ = ((ValaCCodeBaseModule*) self)->cfile;
	vala_ccode_file_add_function (_tmp48_, cquark_fun);
	_vala_ccode_node_unref0 (cquark_call);
	_vala_ccode_node_unref0 (cquark_fun);
	_g_free0 (quark_fun_name);
}


static void vala_gerror_module_real_visit_throw_statement (ValaCodeVisitor* base, ValaThrowStatement* stmt) {
	ValaGErrorModule * self;
	ValaCCodeFunction* _tmp0_;
	ValaCCodeFunction* _tmp1_;
	ValaCCodeExpression* _tmp2_ = NULL;
	ValaCCodeExpression* _tmp3_;
	ValaThrowStatement* _tmp4_;
	ValaExpression* _tmp5_;
	ValaExpression* _tmp6_;
	ValaCCodeExpression* _tmp7_ = NULL;
	ValaCCodeExpression* _tmp8_;
	ValaThrowStatement* _tmp9_;
	self = (ValaGErrorModule*) base;
	g_return_if_fail (stmt != NULL);
	vala_ccode_base_module_set_current_method_inner_error ((ValaCCodeBaseModule*) self, TRUE);
	_tmp0_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
	_tmp1_ = _tmp0_;
	_tmp2_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, "_inner_error_");
	_tmp3_ = _tmp2_;
	_tmp4_ = stmt;
	_tmp5_ = vala_throw_statement_get_error_expression (_tmp4_);
	_tmp6_ = _tmp5_;
	_tmp7_ = vala_ccode_base_module_get_cvalue ((ValaCCodeBaseModule*) self, _tmp6_);
	_tmp8_ = _tmp7_;
	vala_ccode_function_add_assignment (_tmp1_, _tmp3_, _tmp8_);
	_vala_ccode_node_unref0 (_tmp8_);
	_vala_ccode_node_unref0 (_tmp3_);
	_tmp9_ = stmt;
	vala_ccode_base_module_add_simple_check ((ValaCCodeBaseModule*) self, (ValaCodeNode*) _tmp9_, TRUE);
}


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


static void vala_gerror_module_real_return_with_exception (ValaGErrorModule* self, ValaCCodeExpression* error_expr) {
	ValaCCodeIdentifier* _tmp0_;
	ValaCCodeIdentifier* _tmp1_;
	ValaCCodeFunctionCall* _tmp2_;
	ValaCCodeFunctionCall* _tmp3_;
	ValaCCodeFunctionCall* cpropagate;
	ValaCCodeFunctionCall* _tmp4_;
	ValaCCodeIdentifier* _tmp5_;
	ValaCCodeIdentifier* _tmp6_;
	ValaCCodeFunctionCall* _tmp7_;
	ValaCCodeExpression* _tmp8_;
	ValaCCodeFunction* _tmp9_;
	ValaCCodeFunction* _tmp10_;
	ValaCCodeFunctionCall* _tmp11_;
	ValaSymbol* _tmp12_;
	ValaSymbol* _tmp13_;
	gboolean _tmp14_ = FALSE;
	ValaMethod* _tmp15_;
	ValaMethod* _tmp16_;
	gboolean _tmp21_;
	g_return_if_fail (error_expr != NULL);
	_tmp0_ = vala_ccode_identifier_new ("g_propagate_error");
	_tmp1_ = _tmp0_;
	_tmp2_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp1_);
	_tmp3_ = _tmp2_;
	_vala_ccode_node_unref0 (_tmp1_);
	cpropagate = _tmp3_;
	_tmp4_ = cpropagate;
	_tmp5_ = vala_ccode_identifier_new ("error");
	_tmp6_ = _tmp5_;
	vala_ccode_function_call_add_argument (_tmp4_, (ValaCCodeExpression*) _tmp6_);
	_vala_ccode_node_unref0 (_tmp6_);
	_tmp7_ = cpropagate;
	_tmp8_ = error_expr;
	vala_ccode_function_call_add_argument (_tmp7_, _tmp8_);
	_tmp9_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
	_tmp10_ = _tmp9_;
	_tmp11_ = cpropagate;
	vala_ccode_function_add_expression (_tmp10_, (ValaCCodeExpression*) _tmp11_);
	_tmp12_ = vala_ccode_base_module_get_current_symbol ((ValaCCodeBaseModule*) self);
	_tmp13_ = _tmp12_;
	vala_ccode_base_module_append_local_free ((ValaCCodeBaseModule*) self, _tmp13_, FALSE, NULL);
	_tmp15_ = vala_ccode_base_module_get_current_method ((ValaCCodeBaseModule*) self);
	_tmp16_ = _tmp15_;
	if (VALA_IS_CREATION_METHOD (_tmp16_)) {
		ValaMethod* _tmp17_;
		ValaMethod* _tmp18_;
		ValaSymbol* _tmp19_;
		ValaSymbol* _tmp20_;
		_tmp17_ = vala_ccode_base_module_get_current_method ((ValaCCodeBaseModule*) self);
		_tmp18_ = _tmp17_;
		_tmp19_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp18_);
		_tmp20_ = _tmp19_;
		_tmp14_ = VALA_IS_CLASS (_tmp20_);
	} else {
		_tmp14_ = FALSE;
	}
	_tmp21_ = _tmp14_;
	if (_tmp21_) {
		ValaMethod* _tmp22_;
		ValaMethod* _tmp23_;
		ValaSymbol* _tmp24_;
		ValaSymbol* _tmp25_;
		ValaClass* _tmp26_;
		ValaClass* cl;
		ValaCCodeFunction* _tmp27_;
		ValaCCodeFunction* _tmp28_;
		ValaClass* _tmp29_;
		ValaObjectType* _tmp30_;
		ValaObjectType* _tmp31_;
		ValaCCodeIdentifier* _tmp32_;
		ValaCCodeIdentifier* _tmp33_;
		ValaGLibValue* _tmp34_;
		ValaGLibValue* _tmp35_;
		ValaCCodeExpression* _tmp36_ = NULL;
		ValaCCodeExpression* _tmp37_;
		ValaCCodeFunction* _tmp38_;
		ValaCCodeFunction* _tmp39_;
		ValaCCodeConstant* _tmp40_;
		ValaCCodeConstant* _tmp41_;
		_tmp22_ = vala_ccode_base_module_get_current_method ((ValaCCodeBaseModule*) self);
		_tmp23_ = _tmp22_;
		_tmp24_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp23_);
		_tmp25_ = _tmp24_;
		_tmp26_ = _vala_code_node_ref0 (VALA_CLASS (_tmp25_));
		cl = _tmp26_;
		_tmp27_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
		_tmp28_ = _tmp27_;
		_tmp29_ = cl;
		_tmp30_ = vala_object_type_new ((ValaObjectTypeSymbol*) _tmp29_);
		_tmp31_ = _tmp30_;
		_tmp32_ = vala_ccode_identifier_new ("self");
		_tmp33_ = _tmp32_;
		_tmp34_ = vala_glib_value_new ((ValaDataType*) _tmp31_, (ValaCCodeExpression*) _tmp33_, TRUE);
		_tmp35_ = _tmp34_;
		_tmp36_ = vala_ccode_base_module_destroy_value ((ValaCCodeBaseModule*) self, (ValaTargetValue*) _tmp35_, FALSE);
		_tmp37_ = _tmp36_;
		vala_ccode_function_add_expression (_tmp28_, _tmp37_);
		_vala_ccode_node_unref0 (_tmp37_);
		_vala_target_value_unref0 (_tmp35_);
		_vala_ccode_node_unref0 (_tmp33_);
		_vala_code_node_unref0 (_tmp31_);
		_tmp38_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
		_tmp39_ = _tmp38_;
		_tmp40_ = vala_ccode_constant_new ("NULL");
		_tmp41_ = _tmp40_;
		vala_ccode_function_add_return (_tmp39_, (ValaCCodeExpression*) _tmp41_);
		_vala_ccode_node_unref0 (_tmp41_);
		_vala_code_node_unref0 (cl);
	} else {
		gboolean _tmp42_ = FALSE;
		_tmp42_ = vala_ccode_base_module_is_in_coroutine ((ValaCCodeBaseModule*) self);
		if (_tmp42_) {
			ValaCCodeFunction* _tmp43_;
			ValaCCodeFunction* _tmp44_;
			ValaCCodeConstant* _tmp45_;
			ValaCCodeConstant* _tmp46_;
			_tmp43_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
			_tmp44_ = _tmp43_;
			_tmp45_ = vala_ccode_constant_new ("FALSE");
			_tmp46_ = _tmp45_;
			vala_ccode_function_add_return (_tmp44_, (ValaCCodeExpression*) _tmp46_);
			_vala_ccode_node_unref0 (_tmp46_);
		} else {
			ValaDataType* _tmp47_;
			ValaDataType* _tmp48_;
			_tmp47_ = vala_ccode_base_module_get_current_return_type ((ValaCCodeBaseModule*) self);
			_tmp48_ = _tmp47_;
			vala_ccode_base_module_return_default_value ((ValaCCodeBaseModule*) self, _tmp48_);
		}
	}
	_vala_ccode_node_unref0 (cpropagate);
}


void vala_gerror_module_return_with_exception (ValaGErrorModule* self, ValaCCodeExpression* error_expr) {
	g_return_if_fail (self != NULL);
	VALA_GERROR_MODULE_GET_CLASS (self)->return_with_exception (self, error_expr);
}


static void vala_gerror_module_uncaught_error_statement (ValaGErrorModule* self, ValaCCodeExpression* inner_error, gboolean unexpected) {
	ValaSymbol* _tmp0_;
	ValaSymbol* _tmp1_;
	ValaCCodeIdentifier* _tmp2_;
	ValaCCodeIdentifier* _tmp3_;
	ValaCCodeFunctionCall* _tmp4_;
	ValaCCodeFunctionCall* _tmp5_;
	ValaCCodeFunctionCall* ccritical;
	const gchar* _tmp6_ = NULL;
	gboolean _tmp7_;
	ValaCCodeFunctionCall* _tmp8_;
	const gchar* _tmp9_;
	ValaCCodeConstant* _tmp10_;
	ValaCCodeConstant* _tmp11_;
	ValaCCodeFunctionCall* _tmp12_;
	ValaCCodeConstant* _tmp13_;
	ValaCCodeConstant* _tmp14_;
	ValaCCodeFunctionCall* _tmp15_;
	ValaCCodeConstant* _tmp16_;
	ValaCCodeConstant* _tmp17_;
	ValaCCodeFunctionCall* _tmp18_;
	ValaCCodeExpression* _tmp19_;
	ValaCCodeMemberAccess* _tmp20_;
	ValaCCodeMemberAccess* _tmp21_;
	ValaCCodeIdentifier* _tmp22_;
	ValaCCodeIdentifier* _tmp23_;
	ValaCCodeFunctionCall* _tmp24_;
	ValaCCodeFunctionCall* _tmp25_;
	ValaCCodeFunctionCall* domain_name;
	ValaCCodeFunctionCall* _tmp26_;
	ValaCCodeExpression* _tmp27_;
	ValaCCodeMemberAccess* _tmp28_;
	ValaCCodeMemberAccess* _tmp29_;
	ValaCCodeFunctionCall* _tmp30_;
	ValaCCodeFunctionCall* _tmp31_;
	ValaCCodeFunctionCall* _tmp32_;
	ValaCCodeExpression* _tmp33_;
	ValaCCodeMemberAccess* _tmp34_;
	ValaCCodeMemberAccess* _tmp35_;
	ValaCCodeIdentifier* _tmp36_;
	ValaCCodeIdentifier* _tmp37_;
	ValaCCodeFunctionCall* _tmp38_;
	ValaCCodeFunctionCall* _tmp39_;
	ValaCCodeFunctionCall* cclear;
	ValaCCodeFunctionCall* _tmp40_;
	ValaCCodeExpression* _tmp41_;
	ValaCCodeUnaryExpression* _tmp42_;
	ValaCCodeUnaryExpression* _tmp43_;
	ValaCCodeFunction* _tmp44_;
	ValaCCodeFunction* _tmp45_;
	ValaCCodeFunctionCall* _tmp46_;
	ValaCCodeFunction* _tmp47_;
	ValaCCodeFunction* _tmp48_;
	ValaCCodeFunctionCall* _tmp49_;
	gboolean _tmp50_ = FALSE;
	gboolean _tmp51_ = FALSE;
	gboolean _tmp53_;
	g_return_if_fail (self != NULL);
	g_return_if_fail (inner_error != NULL);
	_tmp0_ = vala_ccode_base_module_get_current_symbol ((ValaCCodeBaseModule*) self);
	_tmp1_ = _tmp0_;
	vala_ccode_base_module_append_local_free ((ValaCCodeBaseModule*) self, _tmp1_, FALSE, NULL);
	_tmp2_ = vala_ccode_identifier_new ("g_critical");
	_tmp3_ = _tmp2_;
	_tmp4_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp3_);
	_tmp5_ = _tmp4_;
	_vala_ccode_node_unref0 (_tmp3_);
	ccritical = _tmp5_;
	_tmp7_ = unexpected;
	if (_tmp7_) {
		_tmp6_ = "\"file %s: line %d: unexpected error: %s (%s, %d)\"";
	} else {
		_tmp6_ = "\"file %s: line %d: uncaught error: %s (%s, %d)\"";
	}
	_tmp8_ = ccritical;
	_tmp9_ = _tmp6_;
	_tmp10_ = vala_ccode_constant_new (_tmp9_);
	_tmp11_ = _tmp10_;
	vala_ccode_function_call_add_argument (_tmp8_, (ValaCCodeExpression*) _tmp11_);
	_vala_ccode_node_unref0 (_tmp11_);
	_tmp12_ = ccritical;
	_tmp13_ = vala_ccode_constant_new ("__FILE__");
	_tmp14_ = _tmp13_;
	vala_ccode_function_call_add_argument (_tmp12_, (ValaCCodeExpression*) _tmp14_);
	_vala_ccode_node_unref0 (_tmp14_);
	_tmp15_ = ccritical;
	_tmp16_ = vala_ccode_constant_new ("__LINE__");
	_tmp17_ = _tmp16_;
	vala_ccode_function_call_add_argument (_tmp15_, (ValaCCodeExpression*) _tmp17_);
	_vala_ccode_node_unref0 (_tmp17_);
	_tmp18_ = ccritical;
	_tmp19_ = inner_error;
	_tmp20_ = vala_ccode_member_access_new_pointer (_tmp19_, "message");
	_tmp21_ = _tmp20_;
	vala_ccode_function_call_add_argument (_tmp18_, (ValaCCodeExpression*) _tmp21_);
	_vala_ccode_node_unref0 (_tmp21_);
	_tmp22_ = vala_ccode_identifier_new ("g_quark_to_string");
	_tmp23_ = _tmp22_;
	_tmp24_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp23_);
	_tmp25_ = _tmp24_;
	_vala_ccode_node_unref0 (_tmp23_);
	domain_name = _tmp25_;
	_tmp26_ = domain_name;
	_tmp27_ = inner_error;
	_tmp28_ = vala_ccode_member_access_new_pointer (_tmp27_, "domain");
	_tmp29_ = _tmp28_;
	vala_ccode_function_call_add_argument (_tmp26_, (ValaCCodeExpression*) _tmp29_);
	_vala_ccode_node_unref0 (_tmp29_);
	_tmp30_ = ccritical;
	_tmp31_ = domain_name;
	vala_ccode_function_call_add_argument (_tmp30_, (ValaCCodeExpression*) _tmp31_);
	_tmp32_ = ccritical;
	_tmp33_ = inner_error;
	_tmp34_ = vala_ccode_member_access_new_pointer (_tmp33_, "code");
	_tmp35_ = _tmp34_;
	vala_ccode_function_call_add_argument (_tmp32_, (ValaCCodeExpression*) _tmp35_);
	_vala_ccode_node_unref0 (_tmp35_);
	_tmp36_ = vala_ccode_identifier_new ("g_clear_error");
	_tmp37_ = _tmp36_;
	_tmp38_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp37_);
	_tmp39_ = _tmp38_;
	_vala_ccode_node_unref0 (_tmp37_);
	cclear = _tmp39_;
	_tmp40_ = cclear;
	_tmp41_ = inner_error;
	_tmp42_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, _tmp41_);
	_tmp43_ = _tmp42_;
	vala_ccode_function_call_add_argument (_tmp40_, (ValaCCodeExpression*) _tmp43_);
	_vala_ccode_node_unref0 (_tmp43_);
	_tmp44_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
	_tmp45_ = _tmp44_;
	_tmp46_ = ccritical;
	vala_ccode_function_add_expression (_tmp45_, (ValaCCodeExpression*) _tmp46_);
	_tmp47_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
	_tmp48_ = _tmp47_;
	_tmp49_ = cclear;
	vala_ccode_function_add_expression (_tmp48_, (ValaCCodeExpression*) _tmp49_);
	_tmp51_ = vala_ccode_base_module_is_in_constructor ((ValaCCodeBaseModule*) self);
	if (_tmp51_) {
		_tmp50_ = TRUE;
	} else {
		gboolean _tmp52_ = FALSE;
		_tmp52_ = vala_ccode_base_module_is_in_destructor ((ValaCCodeBaseModule*) self);
		_tmp50_ = _tmp52_;
	}
	_tmp53_ = _tmp50_;
	if (_tmp53_) {
	} else {
		ValaMethod* _tmp54_;
		ValaMethod* _tmp55_;
		_tmp54_ = vala_ccode_base_module_get_current_method ((ValaCCodeBaseModule*) self);
		_tmp55_ = _tmp54_;
		if (VALA_IS_CREATION_METHOD (_tmp55_)) {
			ValaMethod* _tmp56_;
			ValaMethod* _tmp57_;
			ValaSymbol* _tmp58_;
			ValaSymbol* _tmp59_;
			_tmp56_ = vala_ccode_base_module_get_current_method ((ValaCCodeBaseModule*) self);
			_tmp57_ = _tmp56_;
			_tmp58_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp57_);
			_tmp59_ = _tmp58_;
			if (VALA_IS_STRUCT (_tmp59_)) {
				ValaCCodeFunction* _tmp60_;
				ValaCCodeFunction* _tmp61_;
				_tmp60_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
				_tmp61_ = _tmp60_;
				vala_ccode_function_add_return (_tmp61_, NULL);
			} else {
				ValaCCodeFunction* _tmp62_;
				ValaCCodeFunction* _tmp63_;
				ValaCCodeConstant* _tmp64_;
				ValaCCodeConstant* _tmp65_;
				_tmp62_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
				_tmp63_ = _tmp62_;
				_tmp64_ = vala_ccode_constant_new ("NULL");
				_tmp65_ = _tmp64_;
				vala_ccode_function_add_return (_tmp63_, (ValaCCodeExpression*) _tmp65_);
				_vala_ccode_node_unref0 (_tmp65_);
			}
		} else {
			gboolean _tmp66_ = FALSE;
			_tmp66_ = vala_ccode_base_module_is_in_coroutine ((ValaCCodeBaseModule*) self);
			if (_tmp66_) {
				ValaCCodeFunction* _tmp67_;
				ValaCCodeFunction* _tmp68_;
				ValaCCodeConstant* _tmp69_;
				ValaCCodeConstant* _tmp70_;
				_tmp67_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
				_tmp68_ = _tmp67_;
				_tmp69_ = vala_ccode_constant_new ("FALSE");
				_tmp70_ = _tmp69_;
				vala_ccode_function_add_return (_tmp68_, (ValaCCodeExpression*) _tmp70_);
				_vala_ccode_node_unref0 (_tmp70_);
			} else {
				ValaDataType* _tmp71_;
				ValaDataType* _tmp72_;
				_tmp71_ = vala_ccode_base_module_get_current_return_type ((ValaCCodeBaseModule*) self);
				_tmp72_ = _tmp71_;
				if (_tmp72_ != NULL) {
					ValaDataType* _tmp73_;
					ValaDataType* _tmp74_;
					_tmp73_ = vala_ccode_base_module_get_current_return_type ((ValaCCodeBaseModule*) self);
					_tmp74_ = _tmp73_;
					vala_ccode_base_module_return_default_value ((ValaCCodeBaseModule*) self, _tmp74_);
				}
			}
		}
	}
	_vala_ccode_node_unref0 (cclear);
	_vala_ccode_node_unref0 (domain_name);
	_vala_ccode_node_unref0 (ccritical);
}


static gboolean vala_gerror_module_in_finally_block (ValaGErrorModule* self, ValaCodeNode* node) {
	gboolean result = FALSE;
	ValaCodeNode* _tmp0_;
	ValaCodeNode* _tmp1_;
	ValaCodeNode* current_node;
	g_return_val_if_fail (self != NULL, FALSE);
	g_return_val_if_fail (node != NULL, FALSE);
	_tmp0_ = node;
	_tmp1_ = _vala_code_node_ref0 (_tmp0_);
	current_node = _tmp1_;
	while (TRUE) {
		ValaCodeNode* _tmp2_;
		ValaCodeNode* _tmp3_;
		ValaCodeNode* _tmp4_;
		ValaCodeNode* _tmp5_;
		ValaTryStatement* _tmp6_;
		ValaTryStatement* try_stmt;
		gboolean _tmp7_ = FALSE;
		ValaTryStatement* _tmp8_;
		gboolean _tmp13_;
		ValaCodeNode* _tmp14_;
		ValaCodeNode* _tmp15_;
		ValaCodeNode* _tmp16_;
		ValaCodeNode* _tmp17_;
		_tmp2_ = current_node;
		if (!(_tmp2_ != NULL)) {
			break;
		}
		_tmp3_ = current_node;
		_tmp4_ = vala_code_node_get_parent_node (_tmp3_);
		_tmp5_ = _tmp4_;
		_tmp6_ = _vala_code_node_ref0 (VALA_IS_TRY_STATEMENT (_tmp5_) ? ((ValaTryStatement*) _tmp5_) : NULL);
		try_stmt = _tmp6_;
		_tmp8_ = try_stmt;
		if (_tmp8_ != NULL) {
			ValaTryStatement* _tmp9_;
			ValaBlock* _tmp10_;
			ValaBlock* _tmp11_;
			ValaCodeNode* _tmp12_;
			_tmp9_ = try_stmt;
			_tmp10_ = vala_try_statement_get_finally_body (_tmp9_);
			_tmp11_ = _tmp10_;
			_tmp12_ = current_node;
			_tmp7_ = VALA_CODE_NODE (_tmp11_) == _tmp12_;
		} else {
			_tmp7_ = FALSE;
		}
		_tmp13_ = _tmp7_;
		if (_tmp13_) {
			result = TRUE;
			_vala_code_node_unref0 (try_stmt);
			_vala_code_node_unref0 (current_node);
			return result;
		}
		_tmp14_ = current_node;
		_tmp15_ = vala_code_node_get_parent_node (_tmp14_);
		_tmp16_ = _tmp15_;
		_tmp17_ = _vala_code_node_ref0 (_tmp16_);
		_vala_code_node_unref0 (current_node);
		current_node = _tmp17_;
		_vala_code_node_unref0 (try_stmt);
	}
	result = FALSE;
	_vala_code_node_unref0 (current_node);
	return result;
}


static gpointer _vala_iterable_ref0 (gpointer self) {
	return self ? vala_iterable_ref (self) : NULL;
}


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


static void vala_gerror_module_real_add_simple_check (ValaCCodeBaseModule* base, ValaCodeNode* node, gboolean always_fails) {
	ValaGErrorModule * self;
	ValaCCodeExpression* _tmp0_ = NULL;
	ValaCCodeExpression* inner_error;
	gboolean _tmp1_;
	ValaTryStatement* _tmp10_;
	ValaTryStatement* _tmp11_;
	gboolean _tmp221_;
	self = (ValaGErrorModule*) base;
	g_return_if_fail (node != NULL);
	vala_ccode_base_module_set_current_method_inner_error ((ValaCCodeBaseModule*) self, TRUE);
	_tmp0_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, "_inner_error_");
	inner_error = _tmp0_;
	_tmp1_ = always_fails;
	if (_tmp1_) {
	} else {
		ValaCCodeExpression* _tmp2_;
		ValaCCodeConstant* _tmp3_;
		ValaCCodeConstant* _tmp4_;
		ValaCCodeBinaryExpression* _tmp5_;
		ValaCCodeBinaryExpression* _tmp6_;
		ValaCCodeBinaryExpression* ccond;
		ValaCCodeFunction* _tmp7_;
		ValaCCodeFunction* _tmp8_;
		ValaCCodeBinaryExpression* _tmp9_;
		_tmp2_ = inner_error;
		_tmp3_ = vala_ccode_constant_new ("NULL");
		_tmp4_ = _tmp3_;
		_tmp5_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_INEQUALITY, _tmp2_, (ValaCCodeExpression*) _tmp4_);
		_tmp6_ = _tmp5_;
		_vala_ccode_node_unref0 (_tmp4_);
		ccond = _tmp6_;
		_tmp7_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
		_tmp8_ = _tmp7_;
		_tmp9_ = ccond;
		vala_ccode_function_open_if (_tmp8_, (ValaCCodeExpression*) _tmp9_);
		_vala_ccode_node_unref0 (ccond);
	}
	_tmp10_ = vala_ccode_base_module_get_current_try ((ValaCCodeBaseModule*) self);
	_tmp11_ = _tmp10_;
	if (_tmp11_ != NULL) {
		gboolean _tmp12_;
		GEqualFunc _tmp21_;
		ValaArrayList* _tmp22_;
		ValaArrayList* error_types;
		gboolean has_general_catch_clause;
		gboolean _tmp36_;
		gboolean _tmp154_;
		_tmp12_ = self->priv->is_in_catch;
		if (_tmp12_) {
			ValaSymbol* _tmp13_;
			ValaSymbol* _tmp14_;
			ValaCatchClause* _tmp15_;
			ValaCatchClause* _tmp16_;
			_tmp13_ = vala_ccode_base_module_get_current_symbol ((ValaCCodeBaseModule*) self);
			_tmp14_ = _tmp13_;
			_tmp15_ = vala_ccode_base_module_get_current_catch ((ValaCCodeBaseModule*) self);
			_tmp16_ = _tmp15_;
			vala_ccode_base_module_append_local_free ((ValaCCodeBaseModule*) self, _tmp14_, FALSE, (ValaCodeNode*) _tmp16_);
		} else {
			ValaSymbol* _tmp17_;
			ValaSymbol* _tmp18_;
			ValaTryStatement* _tmp19_;
			ValaTryStatement* _tmp20_;
			_tmp17_ = vala_ccode_base_module_get_current_symbol ((ValaCCodeBaseModule*) self);
			_tmp18_ = _tmp17_;
			_tmp19_ = vala_ccode_base_module_get_current_try ((ValaCCodeBaseModule*) self);
			_tmp20_ = _tmp19_;
			vala_ccode_base_module_append_local_free ((ValaCCodeBaseModule*) self, _tmp18_, FALSE, (ValaCodeNode*) _tmp20_);
		}
		_tmp21_ = g_direct_equal;
		_tmp22_ = vala_array_list_new (VALA_TYPE_DATA_TYPE, (GBoxedCopyFunc) vala_code_node_ref, vala_code_node_unref, _tmp21_);
		error_types = _tmp22_;
		{
			ValaCodeNode* _tmp23_;
			ValaList* _tmp24_ = NULL;
			ValaList* _node_error_type_list;
			ValaList* _tmp25_;
			gint _tmp26_;
			gint _tmp27_;
			gint _node_error_type_size;
			gint _node_error_type_index;
			_tmp23_ = node;
			_tmp24_ = vala_code_node_get_error_types (_tmp23_);
			_node_error_type_list = _tmp24_;
			_tmp25_ = _node_error_type_list;
			_tmp26_ = vala_collection_get_size ((ValaCollection*) _tmp25_);
			_tmp27_ = _tmp26_;
			_node_error_type_size = _tmp27_;
			_node_error_type_index = -1;
			while (TRUE) {
				gint _tmp28_;
				gint _tmp29_;
				gint _tmp30_;
				ValaList* _tmp31_;
				gint _tmp32_;
				gpointer _tmp33_ = NULL;
				ValaDataType* node_error_type;
				ValaArrayList* _tmp34_;
				ValaDataType* _tmp35_;
				_tmp28_ = _node_error_type_index;
				_node_error_type_index = _tmp28_ + 1;
				_tmp29_ = _node_error_type_index;
				_tmp30_ = _node_error_type_size;
				if (!(_tmp29_ < _tmp30_)) {
					break;
				}
				_tmp31_ = _node_error_type_list;
				_tmp32_ = _node_error_type_index;
				_tmp33_ = vala_list_get (_tmp31_, _tmp32_);
				node_error_type = (ValaDataType*) _tmp33_;
				_tmp34_ = error_types;
				_tmp35_ = node_error_type;
				vala_collection_add ((ValaCollection*) _tmp34_, _tmp35_);
				_vala_code_node_unref0 (node_error_type);
			}
			_vala_iterable_unref0 (_node_error_type_list);
		}
		has_general_catch_clause = FALSE;
		_tmp36_ = self->priv->is_in_catch;
		if (!_tmp36_) {
			GEqualFunc _tmp37_;
			ValaArrayList* _tmp38_;
			ValaArrayList* handled_error_types;
			_tmp37_ = g_direct_equal;
			_tmp38_ = vala_array_list_new (VALA_TYPE_DATA_TYPE, (GBoxedCopyFunc) vala_code_node_ref, vala_code_node_unref, _tmp37_);
			handled_error_types = _tmp38_;
			{
				ValaTryStatement* _tmp39_;
				ValaTryStatement* _tmp40_;
				ValaList* _tmp41_ = NULL;
				ValaList* _clause_list;
				ValaList* _tmp42_;
				gint _tmp43_;
				gint _tmp44_;
				gint _clause_size;
				gint _clause_index;
				_tmp39_ = vala_ccode_base_module_get_current_try ((ValaCCodeBaseModule*) self);
				_tmp40_ = _tmp39_;
				_tmp41_ = vala_try_statement_get_catch_clauses (_tmp40_);
				_clause_list = _tmp41_;
				_tmp42_ = _clause_list;
				_tmp43_ = vala_collection_get_size ((ValaCollection*) _tmp42_);
				_tmp44_ = _tmp43_;
				_clause_size = _tmp44_;
				_clause_index = -1;
				while (TRUE) {
					gint _tmp45_;
					gint _tmp46_;
					gint _tmp47_;
					ValaList* _tmp48_;
					gint _tmp49_;
					gpointer _tmp50_ = NULL;
					ValaCatchClause* clause;
					ValaArrayList* _tmp87_;
					ValaCatchClause* _tmp88_;
					ValaDataType* _tmp89_;
					ValaDataType* _tmp90_;
					ValaErrorType* _tmp91_;
					gboolean _tmp92_ = FALSE;
					_tmp45_ = _clause_index;
					_clause_index = _tmp45_ + 1;
					_tmp46_ = _clause_index;
					_tmp47_ = _clause_size;
					if (!(_tmp46_ < _tmp47_)) {
						break;
					}
					_tmp48_ = _clause_list;
					_tmp49_ = _clause_index;
					_tmp50_ = vala_list_get (_tmp48_, _tmp49_);
					clause = (ValaCatchClause*) _tmp50_;
					{
						ValaArrayList* _tmp51_;
						ValaArrayList* _tmp52_;
						ValaArrayList* _node_error_type_list;
						ValaArrayList* _tmp53_;
						gint _tmp54_;
						gint _tmp55_;
						gint _node_error_type_size;
						gint _node_error_type_index;
						_tmp51_ = error_types;
						_tmp52_ = _vala_iterable_ref0 (_tmp51_);
						_node_error_type_list = _tmp52_;
						_tmp53_ = _node_error_type_list;
						_tmp54_ = vala_collection_get_size ((ValaCollection*) _tmp53_);
						_tmp55_ = _tmp54_;
						_node_error_type_size = _tmp55_;
						_node_error_type_index = -1;
						while (TRUE) {
							gint _tmp56_;
							gint _tmp57_;
							gint _tmp58_;
							ValaArrayList* _tmp59_;
							gint _tmp60_;
							gpointer _tmp61_ = NULL;
							ValaDataType* node_error_type;
							gboolean _tmp62_ = FALSE;
							ValaCatchClause* _tmp63_;
							ValaDataType* _tmp64_;
							ValaDataType* _tmp65_;
							gboolean _tmp71_;
							_tmp56_ = _node_error_type_index;
							_node_error_type_index = _tmp56_ + 1;
							_tmp57_ = _node_error_type_index;
							_tmp58_ = _node_error_type_size;
							if (!(_tmp57_ < _tmp58_)) {
								break;
							}
							_tmp59_ = _node_error_type_list;
							_tmp60_ = _node_error_type_index;
							_tmp61_ = vala_list_get ((ValaList*) _tmp59_, _tmp60_);
							node_error_type = (ValaDataType*) _tmp61_;
							_tmp63_ = clause;
							_tmp64_ = vala_catch_clause_get_error_type (_tmp63_);
							_tmp65_ = _tmp64_;
							if (_tmp65_ == NULL) {
								_tmp62_ = TRUE;
							} else {
								ValaDataType* _tmp66_;
								ValaCatchClause* _tmp67_;
								ValaDataType* _tmp68_;
								ValaDataType* _tmp69_;
								gboolean _tmp70_ = FALSE;
								_tmp66_ = node_error_type;
								_tmp67_ = clause;
								_tmp68_ = vala_catch_clause_get_error_type (_tmp67_);
								_tmp69_ = _tmp68_;
								_tmp70_ = vala_data_type_compatible (_tmp66_, _tmp69_);
								_tmp62_ = _tmp70_;
							}
							_tmp71_ = _tmp62_;
							if (_tmp71_) {
								ValaArrayList* _tmp72_;
								ValaDataType* _tmp73_;
								_tmp72_ = handled_error_types;
								_tmp73_ = node_error_type;
								vala_collection_add ((ValaCollection*) _tmp72_, _tmp73_);
							}
							_vala_code_node_unref0 (node_error_type);
						}
						_vala_iterable_unref0 (_node_error_type_list);
					}
					{
						ValaArrayList* _tmp74_;
						ValaArrayList* _tmp75_;
						ValaArrayList* _handled_error_type_list;
						ValaArrayList* _tmp76_;
						gint _tmp77_;
						gint _tmp78_;
						gint _handled_error_type_size;
						gint _handled_error_type_index;
						_tmp74_ = handled_error_types;
						_tmp75_ = _vala_iterable_ref0 (_tmp74_);
						_handled_error_type_list = _tmp75_;
						_tmp76_ = _handled_error_type_list;
						_tmp77_ = vala_collection_get_size ((ValaCollection*) _tmp76_);
						_tmp78_ = _tmp77_;
						_handled_error_type_size = _tmp78_;
						_handled_error_type_index = -1;
						while (TRUE) {
							gint _tmp79_;
							gint _tmp80_;
							gint _tmp81_;
							ValaArrayList* _tmp82_;
							gint _tmp83_;
							gpointer _tmp84_ = NULL;
							ValaDataType* handled_error_type;
							ValaArrayList* _tmp85_;
							ValaDataType* _tmp86_;
							_tmp79_ = _handled_error_type_index;
							_handled_error_type_index = _tmp79_ + 1;
							_tmp80_ = _handled_error_type_index;
							_tmp81_ = _handled_error_type_size;
							if (!(_tmp80_ < _tmp81_)) {
								break;
							}
							_tmp82_ = _handled_error_type_list;
							_tmp83_ = _handled_error_type_index;
							_tmp84_ = vala_list_get ((ValaList*) _tmp82_, _tmp83_);
							handled_error_type = (ValaDataType*) _tmp84_;
							_tmp85_ = error_types;
							_tmp86_ = handled_error_type;
							vala_collection_remove ((ValaCollection*) _tmp85_, _tmp86_);
							_vala_code_node_unref0 (handled_error_type);
						}
						_vala_iterable_unref0 (_handled_error_type_list);
					}
					_tmp87_ = handled_error_types;
					vala_collection_clear ((ValaCollection*) _tmp87_);
					_tmp88_ = clause;
					_tmp89_ = vala_catch_clause_get_error_type (_tmp88_);
					_tmp90_ = _tmp89_;
					_tmp91_ = ((ValaCCodeBaseModule*) self)->gerror_type;
					_tmp92_ = vala_data_type_equals (_tmp90_, (ValaDataType*) _tmp91_);
					if (_tmp92_) {
						ValaCCodeFunction* _tmp93_;
						ValaCCodeFunction* _tmp94_;
						ValaCatchClause* _tmp95_;
						const gchar* _tmp96_;
						const gchar* _tmp97_;
						has_general_catch_clause = TRUE;
						_tmp93_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
						_tmp94_ = _tmp93_;
						_tmp95_ = clause;
						_tmp96_ = vala_catch_clause_get_clabel_name (_tmp95_);
						_tmp97_ = _tmp96_;
						vala_ccode_function_add_goto (_tmp94_, _tmp97_);
						_vala_code_node_unref0 (clause);
						break;
					} else {
						ValaCatchClause* _tmp98_;
						ValaDataType* _tmp99_;
						ValaDataType* _tmp100_;
						ValaErrorType* _tmp101_;
						ValaErrorType* catch_type;
						ValaErrorType* _tmp102_;
						ValaErrorCode* _tmp103_;
						ValaErrorCode* _tmp104_;
						ValaCCodeFunction* _tmp147_;
						ValaCCodeFunction* _tmp148_;
						ValaCatchClause* _tmp149_;
						const gchar* _tmp150_;
						const gchar* _tmp151_;
						ValaCCodeFunction* _tmp152_;
						ValaCCodeFunction* _tmp153_;
						_tmp98_ = clause;
						_tmp99_ = vala_catch_clause_get_error_type (_tmp98_);
						_tmp100_ = _tmp99_;
						_tmp101_ = _vala_code_node_ref0 (VALA_IS_ERROR_TYPE (_tmp100_) ? ((ValaErrorType*) _tmp100_) : NULL);
						catch_type = _tmp101_;
						_tmp102_ = catch_type;
						_tmp103_ = vala_error_type_get_error_code (_tmp102_);
						_tmp104_ = _tmp103_;
						if (_tmp104_ != NULL) {
							ValaCCodeIdentifier* _tmp105_;
							ValaCCodeIdentifier* _tmp106_;
							ValaCCodeFunctionCall* _tmp107_;
							ValaCCodeFunctionCall* _tmp108_;
							ValaCCodeFunctionCall* error_match;
							ValaCCodeFunctionCall* _tmp109_;
							ValaCCodeExpression* _tmp110_;
							ValaCCodeFunctionCall* _tmp111_;
							ValaErrorType* _tmp112_;
							ValaTypeSymbol* _tmp113_;
							ValaTypeSymbol* _tmp114_;
							gchar* _tmp115_ = NULL;
							gchar* _tmp116_;
							ValaCCodeIdentifier* _tmp117_;
							ValaCCodeIdentifier* _tmp118_;
							ValaCCodeFunctionCall* _tmp119_;
							ValaErrorType* _tmp120_;
							ValaErrorCode* _tmp121_;
							ValaErrorCode* _tmp122_;
							gchar* _tmp123_ = NULL;
							gchar* _tmp124_;
							ValaCCodeIdentifier* _tmp125_;
							ValaCCodeIdentifier* _tmp126_;
							ValaCCodeFunction* _tmp127_;
							ValaCCodeFunction* _tmp128_;
							ValaCCodeFunctionCall* _tmp129_;
							_tmp105_ = vala_ccode_identifier_new ("g_error_matches");
							_tmp106_ = _tmp105_;
							_tmp107_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp106_);
							_tmp108_ = _tmp107_;
							_vala_ccode_node_unref0 (_tmp106_);
							error_match = _tmp108_;
							_tmp109_ = error_match;
							_tmp110_ = inner_error;
							vala_ccode_function_call_add_argument (_tmp109_, _tmp110_);
							_tmp111_ = error_match;
							_tmp112_ = catch_type;
							_tmp113_ = vala_data_type_get_data_type ((ValaDataType*) _tmp112_);
							_tmp114_ = _tmp113_;
							_tmp115_ = vala_ccode_base_module_get_ccode_upper_case_name ((ValaSymbol*) _tmp114_, NULL);
							_tmp116_ = _tmp115_;
							_tmp117_ = vala_ccode_identifier_new (_tmp116_);
							_tmp118_ = _tmp117_;
							vala_ccode_function_call_add_argument (_tmp111_, (ValaCCodeExpression*) _tmp118_);
							_vala_ccode_node_unref0 (_tmp118_);
							_g_free0 (_tmp116_);
							_tmp119_ = error_match;
							_tmp120_ = catch_type;
							_tmp121_ = vala_error_type_get_error_code (_tmp120_);
							_tmp122_ = _tmp121_;
							_tmp123_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp122_);
							_tmp124_ = _tmp123_;
							_tmp125_ = vala_ccode_identifier_new (_tmp124_);
							_tmp126_ = _tmp125_;
							vala_ccode_function_call_add_argument (_tmp119_, (ValaCCodeExpression*) _tmp126_);
							_vala_ccode_node_unref0 (_tmp126_);
							_g_free0 (_tmp124_);
							_tmp127_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
							_tmp128_ = _tmp127_;
							_tmp129_ = error_match;
							vala_ccode_function_open_if (_tmp128_, (ValaCCodeExpression*) _tmp129_);
							_vala_ccode_node_unref0 (error_match);
						} else {
							ValaCCodeExpression* _tmp130_;
							ValaCCodeMemberAccess* _tmp131_;
							ValaCCodeMemberAccess* _tmp132_;
							ValaCatchClause* _tmp133_;
							ValaDataType* _tmp134_;
							ValaDataType* _tmp135_;
							ValaTypeSymbol* _tmp136_;
							ValaTypeSymbol* _tmp137_;
							gchar* _tmp138_ = NULL;
							gchar* _tmp139_;
							ValaCCodeIdentifier* _tmp140_;
							ValaCCodeIdentifier* _tmp141_;
							ValaCCodeBinaryExpression* _tmp142_;
							ValaCCodeBinaryExpression* _tmp143_;
							ValaCCodeBinaryExpression* ccond;
							ValaCCodeFunction* _tmp144_;
							ValaCCodeFunction* _tmp145_;
							ValaCCodeBinaryExpression* _tmp146_;
							_tmp130_ = inner_error;
							_tmp131_ = vala_ccode_member_access_new_pointer (_tmp130_, "domain");
							_tmp132_ = _tmp131_;
							_tmp133_ = clause;
							_tmp134_ = vala_catch_clause_get_error_type (_tmp133_);
							_tmp135_ = _tmp134_;
							_tmp136_ = vala_data_type_get_data_type (_tmp135_);
							_tmp137_ = _tmp136_;
							_tmp138_ = vala_ccode_base_module_get_ccode_upper_case_name ((ValaSymbol*) _tmp137_, NULL);
							_tmp139_ = _tmp138_;
							_tmp140_ = vala_ccode_identifier_new (_tmp139_);
							_tmp141_ = _tmp140_;
							_tmp142_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_EQUALITY, (ValaCCodeExpression*) _tmp132_, (ValaCCodeExpression*) _tmp141_);
							_tmp143_ = _tmp142_;
							_vala_ccode_node_unref0 (_tmp141_);
							_g_free0 (_tmp139_);
							_vala_ccode_node_unref0 (_tmp132_);
							ccond = _tmp143_;
							_tmp144_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
							_tmp145_ = _tmp144_;
							_tmp146_ = ccond;
							vala_ccode_function_open_if (_tmp145_, (ValaCCodeExpression*) _tmp146_);
							_vala_ccode_node_unref0 (ccond);
						}
						_tmp147_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
						_tmp148_ = _tmp147_;
						_tmp149_ = clause;
						_tmp150_ = vala_catch_clause_get_clabel_name (_tmp149_);
						_tmp151_ = _tmp150_;
						vala_ccode_function_add_goto (_tmp148_, _tmp151_);
						_tmp152_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
						_tmp153_ = _tmp152_;
						vala_ccode_function_close (_tmp153_);
						_vala_code_node_unref0 (catch_type);
					}
					_vala_code_node_unref0 (clause);
				}
				_vala_iterable_unref0 (_clause_list);
			}
			_vala_iterable_unref0 (handled_error_types);
		}
		_tmp154_ = has_general_catch_clause;
		if (_tmp154_) {
		} else {
			ValaArrayList* _tmp155_;
			gint _tmp156_;
			gint _tmp157_;
			_tmp155_ = error_types;
			_tmp156_ = vala_collection_get_size ((ValaCollection*) _tmp155_);
			_tmp157_ = _tmp156_;
			if (_tmp157_ > 0) {
				ValaCCodeFunction* _tmp158_;
				ValaCCodeFunction* _tmp159_;
				gint _tmp160_;
				gchar* _tmp161_ = NULL;
				gchar* _tmp162_;
				_tmp158_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
				_tmp159_ = _tmp158_;
				_tmp160_ = self->priv->current_try_id;
				_tmp161_ = g_strdup_printf ("__finally%d", _tmp160_);
				_tmp162_ = _tmp161_;
				vala_ccode_function_add_goto (_tmp159_, _tmp162_);
				_g_free0 (_tmp162_);
			} else {
				ValaCodeNode* _tmp163_;
				gboolean _tmp164_ = FALSE;
				_tmp163_ = node;
				_tmp164_ = vala_gerror_module_in_finally_block (self, _tmp163_);
				if (_tmp164_) {
				} else {
					ValaCCodeExpression* _tmp165_;
					_tmp165_ = inner_error;
					vala_gerror_module_uncaught_error_statement (self, _tmp165_, TRUE);
				}
			}
		}
		_vala_iterable_unref0 (error_types);
	} else {
		gboolean _tmp166_ = FALSE;
		ValaMethod* _tmp167_;
		ValaMethod* _tmp168_;
		gboolean _tmp175_;
		_tmp167_ = vala_ccode_base_module_get_current_method ((ValaCCodeBaseModule*) self);
		_tmp168_ = _tmp167_;
		if (_tmp168_ != NULL) {
			ValaMethod* _tmp169_;
			ValaMethod* _tmp170_;
			ValaList* _tmp171_ = NULL;
			ValaList* _tmp172_;
			gint _tmp173_;
			gint _tmp174_;
			_tmp169_ = vala_ccode_base_module_get_current_method ((ValaCCodeBaseModule*) self);
			_tmp170_ = _tmp169_;
			_tmp171_ = vala_code_node_get_error_types ((ValaCodeNode*) _tmp170_);
			_tmp172_ = _tmp171_;
			_tmp173_ = vala_collection_get_size ((ValaCollection*) _tmp172_);
			_tmp174_ = _tmp173_;
			_tmp166_ = _tmp174_ > 0;
			_vala_iterable_unref0 (_tmp172_);
		} else {
			_tmp166_ = FALSE;
		}
		_tmp175_ = _tmp166_;
		if (_tmp175_) {
			ValaCCodeBinaryExpression* ccond;
			ValaCCodeBinaryExpression* _tmp209_;
			ccond = NULL;
			{
				ValaMethod* _tmp176_;
				ValaMethod* _tmp177_;
				ValaList* _tmp178_ = NULL;
				ValaList* _error_type_list;
				ValaList* _tmp179_;
				gint _tmp180_;
				gint _tmp181_;
				gint _error_type_size;
				gint _error_type_index;
				_tmp176_ = vala_ccode_base_module_get_current_method ((ValaCCodeBaseModule*) self);
				_tmp177_ = _tmp176_;
				_tmp178_ = vala_code_node_get_error_types ((ValaCodeNode*) _tmp177_);
				_error_type_list = _tmp178_;
				_tmp179_ = _error_type_list;
				_tmp180_ = vala_collection_get_size ((ValaCollection*) _tmp179_);
				_tmp181_ = _tmp180_;
				_error_type_size = _tmp181_;
				_error_type_index = -1;
				while (TRUE) {
					gint _tmp182_;
					gint _tmp183_;
					gint _tmp184_;
					ValaList* _tmp185_;
					gint _tmp186_;
					gpointer _tmp187_ = NULL;
					ValaDataType* error_type;
					ValaDataType* _tmp188_;
					ValaErrorType* _tmp189_;
					gboolean _tmp190_ = FALSE;
					ValaCCodeExpression* _tmp191_;
					ValaCCodeMemberAccess* _tmp192_;
					ValaCCodeMemberAccess* _tmp193_;
					ValaDataType* _tmp194_;
					ValaTypeSymbol* _tmp195_;
					ValaTypeSymbol* _tmp196_;
					gchar* _tmp197_ = NULL;
					gchar* _tmp198_;
					ValaCCodeIdentifier* _tmp199_;
					ValaCCodeIdentifier* _tmp200_;
					ValaCCodeBinaryExpression* _tmp201_;
					ValaCCodeBinaryExpression* _tmp202_;
					ValaCCodeBinaryExpression* domain_check;
					ValaCCodeBinaryExpression* _tmp203_;
					_tmp182_ = _error_type_index;
					_error_type_index = _tmp182_ + 1;
					_tmp183_ = _error_type_index;
					_tmp184_ = _error_type_size;
					if (!(_tmp183_ < _tmp184_)) {
						break;
					}
					_tmp185_ = _error_type_list;
					_tmp186_ = _error_type_index;
					_tmp187_ = vala_list_get (_tmp185_, _tmp186_);
					error_type = (ValaDataType*) _tmp187_;
					_tmp188_ = error_type;
					_tmp189_ = ((ValaCCodeBaseModule*) self)->gerror_type;
					_tmp190_ = vala_data_type_equals (_tmp188_, (ValaDataType*) _tmp189_);
					if (_tmp190_) {
						_vala_ccode_node_unref0 (ccond);
						ccond = NULL;
						_vala_code_node_unref0 (error_type);
						break;
					}
					_tmp191_ = inner_error;
					_tmp192_ = vala_ccode_member_access_new_pointer (_tmp191_, "domain");
					_tmp193_ = _tmp192_;
					_tmp194_ = error_type;
					_tmp195_ = vala_data_type_get_data_type (_tmp194_);
					_tmp196_ = _tmp195_;
					_tmp197_ = vala_ccode_base_module_get_ccode_upper_case_name ((ValaSymbol*) _tmp196_, NULL);
					_tmp198_ = _tmp197_;
					_tmp199_ = vala_ccode_identifier_new (_tmp198_);
					_tmp200_ = _tmp199_;
					_tmp201_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_EQUALITY, (ValaCCodeExpression*) _tmp193_, (ValaCCodeExpression*) _tmp200_);
					_tmp202_ = _tmp201_;
					_vala_ccode_node_unref0 (_tmp200_);
					_g_free0 (_tmp198_);
					_vala_ccode_node_unref0 (_tmp193_);
					domain_check = _tmp202_;
					_tmp203_ = ccond;
					if (_tmp203_ == NULL) {
						ValaCCodeBinaryExpression* _tmp204_;
						ValaCCodeBinaryExpression* _tmp205_;
						_tmp204_ = domain_check;
						_tmp205_ = _vala_ccode_node_ref0 (_tmp204_);
						_vala_ccode_node_unref0 (ccond);
						ccond = _tmp205_;
					} else {
						ValaCCodeBinaryExpression* _tmp206_;
						ValaCCodeBinaryExpression* _tmp207_;
						ValaCCodeBinaryExpression* _tmp208_;
						_tmp206_ = ccond;
						_tmp207_ = domain_check;
						_tmp208_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_OR, (ValaCCodeExpression*) _tmp206_, (ValaCCodeExpression*) _tmp207_);
						_vala_ccode_node_unref0 (ccond);
						ccond = _tmp208_;
					}
					_vala_ccode_node_unref0 (domain_check);
					_vala_code_node_unref0 (error_type);
				}
				_vala_iterable_unref0 (_error_type_list);
			}
			_tmp209_ = ccond;
			if (_tmp209_ != NULL) {
				ValaCCodeFunction* _tmp210_;
				ValaCCodeFunction* _tmp211_;
				ValaCCodeBinaryExpression* _tmp212_;
				ValaCCodeExpression* _tmp213_;
				ValaCCodeFunction* _tmp214_;
				ValaCCodeFunction* _tmp215_;
				ValaCCodeExpression* _tmp216_;
				ValaCCodeFunction* _tmp217_;
				ValaCCodeFunction* _tmp218_;
				_tmp210_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
				_tmp211_ = _tmp210_;
				_tmp212_ = ccond;
				vala_ccode_function_open_if (_tmp211_, (ValaCCodeExpression*) _tmp212_);
				_tmp213_ = inner_error;
				vala_gerror_module_return_with_exception (self, _tmp213_);
				_tmp214_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
				_tmp215_ = _tmp214_;
				vala_ccode_function_add_else (_tmp215_);
				_tmp216_ = inner_error;
				vala_gerror_module_uncaught_error_statement (self, _tmp216_, FALSE);
				_tmp217_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
				_tmp218_ = _tmp217_;
				vala_ccode_function_close (_tmp218_);
			} else {
				ValaCCodeExpression* _tmp219_;
				_tmp219_ = inner_error;
				vala_gerror_module_return_with_exception (self, _tmp219_);
			}
			_vala_ccode_node_unref0 (ccond);
		} else {
			ValaCCodeExpression* _tmp220_;
			_tmp220_ = inner_error;
			vala_gerror_module_uncaught_error_statement (self, _tmp220_, FALSE);
		}
	}
	_tmp221_ = always_fails;
	if (!_tmp221_) {
		ValaCCodeFunction* _tmp222_;
		ValaCCodeFunction* _tmp223_;
		_tmp222_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
		_tmp223_ = _tmp222_;
		vala_ccode_function_close (_tmp223_);
	}
	_vala_ccode_node_unref0 (inner_error);
}


static void vala_gerror_module_real_visit_try_statement (ValaCodeVisitor* base, ValaTryStatement* stmt) {
	ValaGErrorModule * self;
	gint _tmp0_;
	gint this_try_id;
	ValaTryStatement* _tmp1_;
	ValaTryStatement* _tmp2_;
	ValaTryStatement* _tmp3_;
	ValaTryStatement* old_try;
	gint _tmp4_;
	gint old_try_id;
	gboolean _tmp5_;
	gboolean old_is_in_catch;
	ValaCatchClause* _tmp6_;
	ValaCatchClause* _tmp7_;
	ValaCatchClause* _tmp8_;
	ValaCatchClause* old_catch;
	ValaTryStatement* _tmp9_;
	gint _tmp10_;
	ValaTryStatement* _tmp31_;
	ValaBlock* _tmp32_;
	ValaBlock* _tmp33_;
	ValaTryStatement* _tmp52_;
	gint _tmp53_;
	gboolean _tmp54_;
	ValaCatchClause* _tmp55_;
	ValaCCodeFunction* _tmp56_;
	ValaCCodeFunction* _tmp57_;
	gint _tmp58_;
	gchar* _tmp59_ = NULL;
	gchar* _tmp60_;
	ValaTryStatement* _tmp61_;
	ValaBlock* _tmp62_;
	ValaBlock* _tmp63_;
	ValaTryStatement* _tmp67_;
	ValaTryStatement* _tmp68_;
	gboolean _tmp69_;
	gboolean _tmp70_;
	self = (ValaGErrorModule*) base;
	g_return_if_fail (stmt != NULL);
	_tmp0_ = self->priv->next_try_id;
	self->priv->next_try_id = _tmp0_ + 1;
	this_try_id = _tmp0_;
	_tmp1_ = vala_ccode_base_module_get_current_try ((ValaCCodeBaseModule*) self);
	_tmp2_ = _tmp1_;
	_tmp3_ = _vala_code_node_ref0 (_tmp2_);
	old_try = _tmp3_;
	_tmp4_ = self->priv->current_try_id;
	old_try_id = _tmp4_;
	_tmp5_ = self->priv->is_in_catch;
	old_is_in_catch = _tmp5_;
	_tmp6_ = vala_ccode_base_module_get_current_catch ((ValaCCodeBaseModule*) self);
	_tmp7_ = _tmp6_;
	_tmp8_ = _vala_code_node_ref0 (_tmp7_);
	old_catch = _tmp8_;
	_tmp9_ = stmt;
	vala_ccode_base_module_set_current_try ((ValaCCodeBaseModule*) self, _tmp9_);
	_tmp10_ = this_try_id;
	self->priv->current_try_id = _tmp10_;
	self->priv->is_in_catch = TRUE;
	{
		ValaTryStatement* _tmp11_;
		ValaList* _tmp12_ = NULL;
		ValaList* _clause_list;
		ValaList* _tmp13_;
		gint _tmp14_;
		gint _tmp15_;
		gint _clause_size;
		gint _clause_index;
		_tmp11_ = stmt;
		_tmp12_ = vala_try_statement_get_catch_clauses (_tmp11_);
		_clause_list = _tmp12_;
		_tmp13_ = _clause_list;
		_tmp14_ = vala_collection_get_size ((ValaCollection*) _tmp13_);
		_tmp15_ = _tmp14_;
		_clause_size = _tmp15_;
		_clause_index = -1;
		while (TRUE) {
			gint _tmp16_;
			gint _tmp17_;
			gint _tmp18_;
			ValaList* _tmp19_;
			gint _tmp20_;
			gpointer _tmp21_ = NULL;
			ValaCatchClause* clause;
			ValaCatchClause* _tmp22_;
			gint _tmp23_;
			ValaCatchClause* _tmp24_;
			ValaDataType* _tmp25_;
			ValaDataType* _tmp26_;
			gchar* _tmp27_ = NULL;
			gchar* _tmp28_;
			gchar* _tmp29_ = NULL;
			gchar* _tmp30_;
			_tmp16_ = _clause_index;
			_clause_index = _tmp16_ + 1;
			_tmp17_ = _clause_index;
			_tmp18_ = _clause_size;
			if (!(_tmp17_ < _tmp18_)) {
				break;
			}
			_tmp19_ = _clause_list;
			_tmp20_ = _clause_index;
			_tmp21_ = vala_list_get (_tmp19_, _tmp20_);
			clause = (ValaCatchClause*) _tmp21_;
			_tmp22_ = clause;
			_tmp23_ = this_try_id;
			_tmp24_ = clause;
			_tmp25_ = vala_catch_clause_get_error_type (_tmp24_);
			_tmp26_ = _tmp25_;
			_tmp27_ = vala_ccode_base_module_get_ccode_lower_case_name ((ValaCodeNode*) _tmp26_, NULL);
			_tmp28_ = _tmp27_;
			_tmp29_ = g_strdup_printf ("__catch%d_%s", _tmp23_, _tmp28_);
			_tmp30_ = _tmp29_;
			vala_catch_clause_set_clabel_name (_tmp22_, _tmp30_);
			_g_free0 (_tmp30_);
			_g_free0 (_tmp28_);
			_vala_code_node_unref0 (clause);
		}
		_vala_iterable_unref0 (_clause_list);
	}
	self->priv->is_in_catch = FALSE;
	_tmp31_ = stmt;
	_tmp32_ = vala_try_statement_get_body (_tmp31_);
	_tmp33_ = _tmp32_;
	vala_code_node_emit ((ValaCodeNode*) _tmp33_, (ValaCodeGenerator*) self);
	self->priv->is_in_catch = TRUE;
	{
		ValaTryStatement* _tmp34_;
		ValaList* _tmp35_ = NULL;
		ValaList* _clause_list;
		ValaList* _tmp36_;
		gint _tmp37_;
		gint _tmp38_;
		gint _clause_size;
		gint _clause_index;
		_tmp34_ = stmt;
		_tmp35_ = vala_try_statement_get_catch_clauses (_tmp34_);
		_clause_list = _tmp35_;
		_tmp36_ = _clause_list;
		_tmp37_ = vala_collection_get_size ((ValaCollection*) _tmp36_);
		_tmp38_ = _tmp37_;
		_clause_size = _tmp38_;
		_clause_index = -1;
		while (TRUE) {
			gint _tmp39_;
			gint _tmp40_;
			gint _tmp41_;
			ValaList* _tmp42_;
			gint _tmp43_;
			gpointer _tmp44_ = NULL;
			ValaCatchClause* clause;
			ValaCatchClause* _tmp45_;
			ValaCCodeFunction* _tmp46_;
			ValaCCodeFunction* _tmp47_;
			gint _tmp48_;
			gchar* _tmp49_ = NULL;
			gchar* _tmp50_;
			ValaCatchClause* _tmp51_;
			_tmp39_ = _clause_index;
			_clause_index = _tmp39_ + 1;
			_tmp40_ = _clause_index;
			_tmp41_ = _clause_size;
			if (!(_tmp40_ < _tmp41_)) {
				break;
			}
			_tmp42_ = _clause_list;
			_tmp43_ = _clause_index;
			_tmp44_ = vala_list_get (_tmp42_, _tmp43_);
			clause = (ValaCatchClause*) _tmp44_;
			_tmp45_ = clause;
			vala_ccode_base_module_set_current_catch ((ValaCCodeBaseModule*) self, _tmp45_);
			_tmp46_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
			_tmp47_ = _tmp46_;
			_tmp48_ = this_try_id;
			_tmp49_ = g_strdup_printf ("__finally%d", _tmp48_);
			_tmp50_ = _tmp49_;
			vala_ccode_function_add_goto (_tmp47_, _tmp50_);
			_g_free0 (_tmp50_);
			_tmp51_ = clause;
			vala_code_node_emit ((ValaCodeNode*) _tmp51_, (ValaCodeGenerator*) self);
			_vala_code_node_unref0 (clause);
		}
		_vala_iterable_unref0 (_clause_list);
	}
	_tmp52_ = old_try;
	vala_ccode_base_module_set_current_try ((ValaCCodeBaseModule*) self, _tmp52_);
	_tmp53_ = old_try_id;
	self->priv->current_try_id = _tmp53_;
	_tmp54_ = old_is_in_catch;
	self->priv->is_in_catch = _tmp54_;
	_tmp55_ = old_catch;
	vala_ccode_base_module_set_current_catch ((ValaCCodeBaseModule*) self, _tmp55_);
	_tmp56_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
	_tmp57_ = _tmp56_;
	_tmp58_ = this_try_id;
	_tmp59_ = g_strdup_printf ("__finally%d", _tmp58_);
	_tmp60_ = _tmp59_;
	vala_ccode_function_add_label (_tmp57_, _tmp60_);
	_g_free0 (_tmp60_);
	_tmp61_ = stmt;
	_tmp62_ = vala_try_statement_get_finally_body (_tmp61_);
	_tmp63_ = _tmp62_;
	if (_tmp63_ != NULL) {
		ValaTryStatement* _tmp64_;
		ValaBlock* _tmp65_;
		ValaBlock* _tmp66_;
		_tmp64_ = stmt;
		_tmp65_ = vala_try_statement_get_finally_body (_tmp64_);
		_tmp66_ = _tmp65_;
		vala_code_node_emit ((ValaCodeNode*) _tmp66_, (ValaCodeGenerator*) self);
	}
	_tmp67_ = stmt;
	_tmp68_ = stmt;
	_tmp69_ = vala_try_statement_get_after_try_block_reachable (_tmp68_);
	_tmp70_ = _tmp69_;
	vala_ccode_base_module_add_simple_check ((ValaCCodeBaseModule*) self, (ValaCodeNode*) _tmp67_, !_tmp70_);
	_vala_code_node_unref0 (old_catch);
	_vala_code_node_unref0 (old_try);
}


static void vala_gerror_module_real_visit_catch_clause (ValaCodeVisitor* base, ValaCatchClause* clause) {
	ValaGErrorModule * self;
	ValaCatchClause* _tmp0_;
	ValaDataType* _tmp1_;
	ValaDataType* _tmp2_;
	ValaErrorType* _tmp3_;
	ValaErrorType* error_type;
	ValaErrorType* _tmp4_;
	ValaErrorDomain* _tmp5_;
	ValaErrorDomain* _tmp6_;
	ValaCCodeFunction* _tmp11_;
	ValaCCodeFunction* _tmp12_;
	ValaCatchClause* _tmp13_;
	const gchar* _tmp14_;
	const gchar* _tmp15_;
	ValaCCodeFunction* _tmp16_;
	ValaCCodeFunction* _tmp17_;
	ValaCatchClause* _tmp18_;
	ValaLocalVariable* _tmp19_;
	ValaLocalVariable* _tmp20_;
	ValaCCodeFunction* _tmp47_;
	ValaCCodeFunction* _tmp48_;
	ValaCCodeExpression* _tmp49_ = NULL;
	ValaCCodeExpression* _tmp50_;
	ValaCCodeConstant* _tmp51_;
	ValaCCodeConstant* _tmp52_;
	ValaCatchClause* _tmp53_;
	ValaBlock* _tmp54_;
	ValaBlock* _tmp55_;
	ValaCCodeFunction* _tmp56_;
	ValaCCodeFunction* _tmp57_;
	self = (ValaGErrorModule*) base;
	g_return_if_fail (clause != NULL);
	vala_ccode_base_module_set_current_method_inner_error ((ValaCCodeBaseModule*) self, TRUE);
	_tmp0_ = clause;
	_tmp1_ = vala_catch_clause_get_error_type (_tmp0_);
	_tmp2_ = _tmp1_;
	_tmp3_ = _vala_code_node_ref0 (VALA_ERROR_TYPE (_tmp2_));
	error_type = _tmp3_;
	_tmp4_ = error_type;
	_tmp5_ = vala_error_type_get_error_domain (_tmp4_);
	_tmp6_ = _tmp5_;
	if (_tmp6_ != NULL) {
		ValaErrorType* _tmp7_;
		ValaErrorDomain* _tmp8_;
		ValaErrorDomain* _tmp9_;
		ValaCCodeFile* _tmp10_;
		_tmp7_ = error_type;
		_tmp8_ = vala_error_type_get_error_domain (_tmp7_);
		_tmp9_ = _tmp8_;
		_tmp10_ = ((ValaCCodeBaseModule*) self)->cfile;
		vala_ccode_base_module_generate_error_domain_declaration ((ValaCCodeBaseModule*) self, _tmp9_, _tmp10_);
	}
	_tmp11_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
	_tmp12_ = _tmp11_;
	_tmp13_ = clause;
	_tmp14_ = vala_catch_clause_get_clabel_name (_tmp13_);
	_tmp15_ = _tmp14_;
	vala_ccode_function_add_label (_tmp12_, _tmp15_);
	_tmp16_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
	_tmp17_ = _tmp16_;
	vala_ccode_function_open_block (_tmp17_);
	_tmp18_ = clause;
	_tmp19_ = vala_catch_clause_get_error_variable (_tmp18_);
	_tmp20_ = _tmp19_;
	if (_tmp20_ != NULL) {
		ValaCatchClause* _tmp21_;
		ValaLocalVariable* _tmp22_;
		ValaLocalVariable* _tmp23_;
		ValaCCodeFunction* _tmp24_;
		ValaCCodeFunction* _tmp25_;
		ValaCatchClause* _tmp26_;
		ValaLocalVariable* _tmp27_;
		ValaLocalVariable* _tmp28_;
		gchar* _tmp29_ = NULL;
		gchar* _tmp30_;
		ValaCCodeExpression* _tmp31_ = NULL;
		ValaCCodeExpression* _tmp32_;
		ValaCCodeExpression* _tmp33_ = NULL;
		ValaCCodeExpression* _tmp34_;
		_tmp21_ = clause;
		_tmp22_ = vala_catch_clause_get_error_variable (_tmp21_);
		_tmp23_ = _tmp22_;
		vala_code_visitor_visit_local_variable ((ValaCodeVisitor*) self, _tmp23_);
		_tmp24_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
		_tmp25_ = _tmp24_;
		_tmp26_ = clause;
		_tmp27_ = vala_catch_clause_get_error_variable (_tmp26_);
		_tmp28_ = _tmp27_;
		_tmp29_ = vala_ccode_base_module_get_local_cname ((ValaCCodeBaseModule*) self, _tmp28_);
		_tmp30_ = _tmp29_;
		_tmp31_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, _tmp30_);
		_tmp32_ = _tmp31_;
		_tmp33_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, "_inner_error_");
		_tmp34_ = _tmp33_;
		vala_ccode_function_add_assignment (_tmp25_, _tmp32_, _tmp34_);
		_vala_ccode_node_unref0 (_tmp34_);
		_vala_ccode_node_unref0 (_tmp32_);
		_g_free0 (_tmp30_);
	} else {
		ValaCCodeIdentifier* _tmp35_;
		ValaCCodeIdentifier* _tmp36_;
		ValaCCodeFunctionCall* _tmp37_;
		ValaCCodeFunctionCall* _tmp38_;
		ValaCCodeFunctionCall* cclear;
		ValaCCodeFunctionCall* _tmp39_;
		ValaCCodeExpression* _tmp40_ = NULL;
		ValaCCodeExpression* _tmp41_;
		ValaCCodeUnaryExpression* _tmp42_;
		ValaCCodeUnaryExpression* _tmp43_;
		ValaCCodeFunction* _tmp44_;
		ValaCCodeFunction* _tmp45_;
		ValaCCodeFunctionCall* _tmp46_;
		_tmp35_ = vala_ccode_identifier_new ("g_clear_error");
		_tmp36_ = _tmp35_;
		_tmp37_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp36_);
		_tmp38_ = _tmp37_;
		_vala_ccode_node_unref0 (_tmp36_);
		cclear = _tmp38_;
		_tmp39_ = cclear;
		_tmp40_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, "_inner_error_");
		_tmp41_ = _tmp40_;
		_tmp42_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, _tmp41_);
		_tmp43_ = _tmp42_;
		vala_ccode_function_call_add_argument (_tmp39_, (ValaCCodeExpression*) _tmp43_);
		_vala_ccode_node_unref0 (_tmp43_);
		_vala_ccode_node_unref0 (_tmp41_);
		_tmp44_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
		_tmp45_ = _tmp44_;
		_tmp46_ = cclear;
		vala_ccode_function_add_expression (_tmp45_, (ValaCCodeExpression*) _tmp46_);
		_vala_ccode_node_unref0 (cclear);
	}
	_tmp47_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
	_tmp48_ = _tmp47_;
	_tmp49_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, "_inner_error_");
	_tmp50_ = _tmp49_;
	_tmp51_ = vala_ccode_constant_new ("NULL");
	_tmp52_ = _tmp51_;
	vala_ccode_function_add_assignment (_tmp48_, _tmp50_, (ValaCCodeExpression*) _tmp52_);
	_vala_ccode_node_unref0 (_tmp52_);
	_vala_ccode_node_unref0 (_tmp50_);
	_tmp53_ = clause;
	_tmp54_ = vala_catch_clause_get_body (_tmp53_);
	_tmp55_ = _tmp54_;
	vala_code_node_emit ((ValaCodeNode*) _tmp55_, (ValaCodeGenerator*) self);
	_tmp56_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);
	_tmp57_ = _tmp56_;
	vala_ccode_function_close (_tmp57_);
	_vala_code_node_unref0 (error_type);
}


static void vala_gerror_module_real_append_scope_free (ValaCCodeBaseModule* base, ValaSymbol* sym, ValaCodeNode* stop_at) {
	ValaGErrorModule * self;
	ValaSymbol* _tmp0_;
	ValaCodeNode* _tmp1_;
	gboolean _tmp2_ = FALSE;
	ValaCodeNode* _tmp3_;
	gboolean _tmp5_;
	self = (ValaGErrorModule*) base;
	g_return_if_fail (sym != NULL);
	_tmp0_ = sym;
	_tmp1_ = stop_at;
	VALA_CCODE_BASE_MODULE_CLASS (vala_gerror_module_parent_class)->append_scope_free ((ValaCCodeBaseModule*) VALA_CCODE_DELEGATE_MODULE (self), _tmp0_, _tmp1_);
	_tmp3_ = stop_at;
	if (VALA_IS_TRY_STATEMENT (_tmp3_)) {
		_tmp2_ = TRUE;
	} else {
		ValaCodeNode* _tmp4_;
		_tmp4_ = stop_at;
		_tmp2_ = VALA_IS_CATCH_CLAUSE (_tmp4_);
	}
	_tmp5_ = _tmp2_;
	if (!_tmp5_) {
		ValaBlock* _tmp6_;
		ValaBlock* finally_block;
		ValaSymbol* _tmp7_;
		ValaCodeNode* _tmp8_;
		ValaCodeNode* _tmp9_;
		gboolean _tmp27_ = FALSE;
		ValaBlock* _tmp28_;
		gboolean _tmp31_;
		_tmp6_ = _vala_code_node_ref0 (VALA_BLOCK (NULL));
		finally_block = _tmp6_;
		_tmp7_ = sym;
		_tmp8_ = vala_code_node_get_parent_node ((ValaCodeNode*) _tmp7_);
		_tmp9_ = _tmp8_;
		if (VALA_IS_TRY_STATEMENT (_tmp9_)) {
			ValaSymbol* _tmp10_;
			ValaCodeNode* _tmp11_;
			ValaCodeNode* _tmp12_;
			ValaBlock* _tmp13_;
			ValaBlock* _tmp14_;
			ValaBlock* _tmp15_;
			_tmp10_ = sym;
			_tmp11_ = vala_code_node_get_parent_node ((ValaCodeNode*) _tmp10_);
			_tmp12_ = _tmp11_;
			_tmp13_ = vala_try_statement_get_finally_body (VALA_IS_TRY_STATEMENT (_tmp12_) ? ((ValaTryStatement*) _tmp12_) : NULL);
			_tmp14_ = _tmp13_;
			_tmp15_ = _vala_code_node_ref0 (_tmp14_);
			_vala_code_node_unref0 (finally_block);
			finally_block = _tmp15_;
		} else {
			ValaSymbol* _tmp16_;
			ValaCodeNode* _tmp17_;
			ValaCodeNode* _tmp18_;
			_tmp16_ = sym;
			_tmp17_ = vala_code_node_get_parent_node ((ValaCodeNode*) _tmp16_);
			_tmp18_ = _tmp17_;
			if (VALA_IS_CATCH_CLAUSE (_tmp18_)) {
				ValaSymbol* _tmp19_;
				ValaCodeNode* _tmp20_;
				ValaCodeNode* _tmp21_;
				ValaCodeNode* _tmp22_;
				ValaCodeNode* _tmp23_;
				ValaBlock* _tmp24_;
				ValaBlock* _tmp25_;
				ValaBlock* _tmp26_;
				_tmp19_ = sym;
				_tmp20_ = vala_code_node_get_parent_node ((ValaCodeNode*) _tmp19_);
				_tmp21_ = _tmp20_;
				_tmp22_ = vala_code_node_get_parent_node (_tmp21_);
				_tmp23_ = _tmp22_;
				_tmp24_ = vala_try_statement_get_finally_body (VALA_IS_TRY_STATEMENT (_tmp23_) ? ((ValaTryStatement*) _tmp23_) : NULL);
				_tmp25_ = _tmp24_;
				_tmp26_ = _vala_code_node_ref0 (_tmp25_);
				_vala_code_node_unref0 (finally_block);
				finally_block = _tmp26_;
			}
		}
		_tmp28_ = finally_block;
		if (_tmp28_ != NULL) {
			ValaBlock* _tmp29_;
			ValaSymbol* _tmp30_;
			_tmp29_ = finally_block;
			_tmp30_ = sym;
			_tmp27_ = VALA_SYMBOL (_tmp29_) != _tmp30_;
		} else {
			_tmp27_ = FALSE;
		}
		_tmp31_ = _tmp27_;
		if (_tmp31_) {
			ValaBlock* _tmp32_;
			_tmp32_ = finally_block;
			vala_code_node_emit ((ValaCodeNode*) _tmp32_, (ValaCodeGenerator*) self);
		}
		_vala_code_node_unref0 (finally_block);
	}
}


ValaGErrorModule* vala_gerror_module_construct (GType object_type) {
	ValaGErrorModule* self = NULL;
	self = (ValaGErrorModule*) vala_ccode_delegate_module_construct (object_type);
	return self;
}


ValaGErrorModule* vala_gerror_module_new (void) {
	return vala_gerror_module_construct (VALA_TYPE_GERROR_MODULE);
}


static void vala_gerror_module_class_init (ValaGErrorModuleClass * klass) {
	vala_gerror_module_parent_class = g_type_class_peek_parent (klass);
	VALA_CODE_VISITOR_CLASS (klass)->finalize = vala_gerror_module_finalize;
	g_type_class_add_private (klass, sizeof (ValaGErrorModulePrivate));
	VALA_CCODE_BASE_MODULE_CLASS (klass)->generate_error_domain_declaration = vala_gerror_module_real_generate_error_domain_declaration;
	VALA_CODE_VISITOR_CLASS (klass)->visit_error_domain = vala_gerror_module_real_visit_error_domain;
	VALA_CODE_VISITOR_CLASS (klass)->visit_throw_statement = vala_gerror_module_real_visit_throw_statement;
	VALA_GERROR_MODULE_CLASS (klass)->return_with_exception = vala_gerror_module_real_return_with_exception;
	VALA_CCODE_BASE_MODULE_CLASS (klass)->add_simple_check = vala_gerror_module_real_add_simple_check;
	VALA_CODE_VISITOR_CLASS (klass)->visit_try_statement = vala_gerror_module_real_visit_try_statement;
	VALA_CODE_VISITOR_CLASS (klass)->visit_catch_clause = vala_gerror_module_real_visit_catch_clause;
	VALA_CCODE_BASE_MODULE_CLASS (klass)->append_scope_free = vala_gerror_module_real_append_scope_free;
}


static void vala_gerror_module_instance_init (ValaGErrorModule * self) {
	self->priv = VALA_GERROR_MODULE_GET_PRIVATE (self);
	self->priv->current_try_id = 0;
	self->priv->next_try_id = 0;
	self->priv->is_in_catch = FALSE;
}


static void vala_gerror_module_finalize (ValaCodeVisitor* obj) {
	ValaGErrorModule * self;
	self = VALA_GERROR_MODULE (obj);
	VALA_CODE_VISITOR_CLASS (vala_gerror_module_parent_class)->finalize (obj);
}


GType vala_gerror_module_get_type (void) {
	static volatile gsize vala_gerror_module_type_id__volatile = 0;
	if (g_once_init_enter (&vala_gerror_module_type_id__volatile)) {
		static const GTypeInfo g_define_type_info = { sizeof (ValaGErrorModuleClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) vala_gerror_module_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ValaGErrorModule), 0, (GInstanceInitFunc) vala_gerror_module_instance_init, NULL };
		GType vala_gerror_module_type_id;
		vala_gerror_module_type_id = g_type_register_static (VALA_TYPE_CCODE_DELEGATE_MODULE, "ValaGErrorModule", &g_define_type_info, 0);
		g_once_init_leave (&vala_gerror_module_type_id__volatile, vala_gerror_module_type_id);
	}
	return vala_gerror_module_type_id__volatile;
}