~ubuntu-branches/ubuntu/raring/vala-0.20/raring-proposed

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

100

101

#define VALA_TYPE_CCODE_ASSIGNMENT_MODULE (vala_ccode_assignment_module_get_type ())

102

#define VALA_CCODE_ASSIGNMENT_MODULE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CCODE_ASSIGNMENT_MODULE, ValaCCodeAssignmentModule))

103

#define VALA_CCODE_ASSIGNMENT_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CCODE_ASSIGNMENT_MODULE, ValaCCodeAssignmentModuleClass))

104

#define VALA_IS_CCODE_ASSIGNMENT_MODULE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CCODE_ASSIGNMENT_MODULE))

105

#define VALA_IS_CCODE_ASSIGNMENT_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CCODE_ASSIGNMENT_MODULE))

106

#define VALA_CCODE_ASSIGNMENT_MODULE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CCODE_ASSIGNMENT_MODULE, ValaCCodeAssignmentModuleClass))

107

108

typedef struct _ValaCCodeAssignmentModule ValaCCodeAssignmentModule;

109

typedef struct _ValaCCodeAssignmentModuleClass ValaCCodeAssignmentModuleClass;

110

typedef struct _ValaCCodeAssignmentModulePrivate ValaCCodeAssignmentModulePrivate;

111

112

#define VALA_TYPE_CCODE_METHOD_CALL_MODULE (vala_ccode_method_call_module_get_type ())

113

#define VALA_CCODE_METHOD_CALL_MODULE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CCODE_METHOD_CALL_MODULE, ValaCCodeMethodCallModule))

114

#define VALA_CCODE_METHOD_CALL_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CCODE_METHOD_CALL_MODULE, ValaCCodeMethodCallModuleClass))

115

#define VALA_IS_CCODE_METHOD_CALL_MODULE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CCODE_METHOD_CALL_MODULE))

116

#define VALA_IS_CCODE_METHOD_CALL_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CCODE_METHOD_CALL_MODULE))

117

#define VALA_CCODE_METHOD_CALL_MODULE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CCODE_METHOD_CALL_MODULE, ValaCCodeMethodCallModuleClass))

118

119

typedef struct _ValaCCodeMethodCallModule ValaCCodeMethodCallModule;

120

typedef struct _ValaCCodeMethodCallModuleClass ValaCCodeMethodCallModuleClass;

121

typedef struct _ValaCCodeMethodCallModulePrivate ValaCCodeMethodCallModulePrivate;

122

123

#define VALA_TYPE_CCODE_ARRAY_MODULE (vala_ccode_array_module_get_type ())

124

#define VALA_CCODE_ARRAY_MODULE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CCODE_ARRAY_MODULE, ValaCCodeArrayModule))

125

#define VALA_CCODE_ARRAY_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CCODE_ARRAY_MODULE, ValaCCodeArrayModuleClass))

126

#define VALA_IS_CCODE_ARRAY_MODULE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CCODE_ARRAY_MODULE))

127

#define VALA_IS_CCODE_ARRAY_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CCODE_ARRAY_MODULE))

128

#define VALA_CCODE_ARRAY_MODULE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CCODE_ARRAY_MODULE, ValaCCodeArrayModuleClass))

129

130

typedef struct _ValaCCodeArrayModule ValaCCodeArrayModule;

131

typedef struct _ValaCCodeArrayModuleClass ValaCCodeArrayModuleClass;

132

typedef struct _ValaCCodeArrayModulePrivate ValaCCodeArrayModulePrivate;

133

134

#define VALA_TYPE_CCODE_DELEGATE_MODULE (vala_ccode_delegate_module_get_type ())

135

#define VALA_CCODE_DELEGATE_MODULE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CCODE_DELEGATE_MODULE, ValaCCodeDelegateModule))

136

#define VALA_CCODE_DELEGATE_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CCODE_DELEGATE_MODULE, ValaCCodeDelegateModuleClass))

137

#define VALA_IS_CCODE_DELEGATE_MODULE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CCODE_DELEGATE_MODULE))

138

#define VALA_IS_CCODE_DELEGATE_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CCODE_DELEGATE_MODULE))

139

#define VALA_CCODE_DELEGATE_MODULE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CCODE_DELEGATE_MODULE, ValaCCodeDelegateModuleClass))

140

141

typedef struct _ValaCCodeDelegateModule ValaCCodeDelegateModule;

142

typedef struct _ValaCCodeDelegateModuleClass ValaCCodeDelegateModuleClass;

143

typedef struct _ValaCCodeDelegateModulePrivate ValaCCodeDelegateModulePrivate;

144

145

#define VALA_TYPE_GERROR_MODULE (vala_gerror_module_get_type ())

146

#define VALA_GERROR_MODULE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_GERROR_MODULE, ValaGErrorModule))

147

#define VALA_GERROR_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_GERROR_MODULE, ValaGErrorModuleClass))

148

#define VALA_IS_GERROR_MODULE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_GERROR_MODULE))

149

#define VALA_IS_GERROR_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_GERROR_MODULE))

150

#define VALA_GERROR_MODULE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_GERROR_MODULE, ValaGErrorModuleClass))

151

152

typedef struct _ValaGErrorModule ValaGErrorModule;

153

typedef struct _ValaGErrorModuleClass ValaGErrorModuleClass;

154

typedef struct _ValaGErrorModulePrivate ValaGErrorModulePrivate;

155

#define _g_free0(var) (var = (g_free (var), NULL))

156

#define _vala_ccode_node_unref0(var) ((var == NULL) ? NULL : (var = (vala_ccode_node_unref (var), NULL)))

157

#define _vala_code_node_unref0(var) ((var == NULL) ? NULL : (var = (vala_code_node_unref (var), NULL)))

158

#define _vala_iterable_unref0(var) ((var == NULL) ? NULL : (var = (vala_iterable_unref (var), NULL)))

159

160

#define VALA_TYPE_GLIB_VALUE (vala_glib_value_get_type ())

161

#define VALA_GLIB_VALUE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_GLIB_VALUE, ValaGLibValue))

162

#define VALA_GLIB_VALUE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_GLIB_VALUE, ValaGLibValueClass))

163

#define VALA_IS_GLIB_VALUE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_GLIB_VALUE))

164

#define VALA_IS_GLIB_VALUE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_GLIB_VALUE))

165

#define VALA_GLIB_VALUE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_GLIB_VALUE, ValaGLibValueClass))

166

167

typedef struct _ValaGLibValue ValaGLibValue;

168

typedef struct _ValaGLibValueClass ValaGLibValueClass;

169

#define _vala_target_value_unref0(var) ((var == NULL) ? NULL : (var = (vala_target_value_unref (var), NULL)))

170

171

struct _ValaCCodeBaseModule {

172

ValaCodeGenerator parent_instance;

173

ValaCCodeBaseModulePrivate * priv;

174

ValaSymbol* root_symbol;

175

ValaCCodeBaseModuleEmitContext* emit_context;

176

ValaCCodeLineDirective* current_line;

177

ValaCCodeFile* header_file;

178

ValaCCodeFile* internal_header_file;

179

ValaCCodeFile* cfile;

180

ValaCCodeBaseModuleEmitContext* class_init_context;

181

ValaCCodeBaseModuleEmitContext* base_init_context;

182

ValaCCodeBaseModuleEmitContext* class_finalize_context;

183

ValaCCodeBaseModuleEmitContext* base_finalize_context;

184

ValaCCodeBaseModuleEmitContext* instance_init_context;

185

ValaCCodeBaseModuleEmitContext* instance_finalize_context;

186

ValaCCodeStruct* param_spec_struct;

187

ValaCCodeStruct* closure_struct;

188

ValaCCodeEnum* prop_enum;

189

ValaSet* user_marshal_set;

190

ValaSet* predefined_marshal_set;

191

gint next_regex_id;

192

gint next_coroutine_state;

193

ValaDataType* void_type;

194

ValaDataType* bool_type;

195

ValaDataType* char_type;

196

ValaDataType* uchar_type;

197

ValaDataType* unichar_type;

198

ValaDataType* short_type;

199

ValaDataType* ushort_type;

200

ValaDataType* int_type;

201

ValaDataType* uint_type;

202

ValaDataType* long_type;

203

ValaDataType* ulong_type;

204

ValaDataType* int8_type;

205

ValaDataType* uint8_type;

206

ValaDataType* int16_type;

207

ValaDataType* uint16_type;

208

ValaDataType* int32_type;

209

ValaDataType* uint32_type;

210

ValaDataType* int64_type;

211

ValaDataType* uint64_type;

212

ValaDataType* string_type;

213

ValaDataType* regex_type;

214

ValaDataType* float_type;

215

ValaDataType* double_type;

216

ValaTypeSymbol* gtype_type;

217

ValaTypeSymbol* gobject_type;

218

ValaErrorType* gerror_type;

219

ValaClass* glist_type;

220

ValaClass* gslist_type;

221

ValaClass* gnode_type;

222

ValaClass* gqueue_type;

223

ValaClass* gvaluearray_type;

224

ValaTypeSymbol* gstringbuilder_type;

225

ValaTypeSymbol* garray_type;

226

ValaTypeSymbol* gbytearray_type;

227

ValaTypeSymbol* gptrarray_type;

228

ValaTypeSymbol* gthreadpool_type;

229

ValaDataType* gdestroynotify_type;

230

ValaDataType* gquark_type;

231

ValaStruct* gvalue_type;

232

ValaClass* gvariant_type;

233

ValaStruct* mutex_type;

234

ValaStruct* gmutex_type;

235

ValaStruct* grecmutex_type;

236

ValaStruct* grwlock_type;

237

ValaStruct* gcond_type;

238

ValaClass* gsource_type;

239

ValaTypeSymbol* type_module_type;

240

ValaTypeSymbol* dbus_proxy_type;

241

gboolean in_plugin;

242

gchar* module_init_param_name;

243

gboolean gvaluecollector_h_needed;

244

gboolean requires_assert;

245

gboolean requires_array_free;

246

gboolean requires_array_move;

247

gboolean requires_array_length;

248

gboolean requires_clear_mutex;

249

ValaSet* wrappers;

250

};

251

252

struct _ValaCCodeBaseModuleClass {

253

ValaCodeGeneratorClass parent_class;

254

void (*append_vala_array_free) (ValaCCodeBaseModule* self);

255

void (*append_vala_array_move) (ValaCCodeBaseModule* self);

256

void (*append_vala_array_length) (ValaCCodeBaseModule* self);

257

gboolean (*generate_enum_declaration) (ValaCCodeBaseModule* self, ValaEnum* en, ValaCCodeFile* decl_space);

258

void (*generate_class_struct_declaration) (ValaCCodeBaseModule* self, ValaClass* cl, ValaCCodeFile* decl_space);

259

void (*generate_struct_declaration) (ValaCCodeBaseModule* self, ValaStruct* st, ValaCCodeFile* decl_space);

260

void (*generate_delegate_declaration) (ValaCCodeBaseModule* self, ValaDelegate* d, ValaCCodeFile* decl_space);

261

void (*generate_cparameters) (ValaCCodeBaseModule* self, ValaMethod* m, ValaCCodeFile* decl_space, ValaMap* cparam_map, ValaCCodeFunction* func, ValaCCodeFunctionDeclarator* vdeclarator, ValaMap* carg_map, ValaCCodeFunctionCall* vcall, gint direction);

262

ValaCCodeExpression* (*get_dup_func_expression) (ValaCCodeBaseModule* self, ValaDataType* type, ValaSourceReference* source_reference, gboolean is_chainup);

263

gchar* (*append_struct_array_free) (ValaCCodeBaseModule* self, ValaStruct* st);

264

ValaCCodeExpression* (*destroy_value) (ValaCCodeBaseModule* self, ValaTargetValue* value, gboolean is_macro_definition);

265

void (*append_scope_free) (ValaCCodeBaseModule* self, ValaSymbol* sym, ValaCodeNode* stop_at);

266

ValaTargetValue* (*get_local_cvalue) (ValaCCodeBaseModule* self, ValaLocalVariable* local);

267

ValaTargetValue* (*get_parameter_cvalue) (ValaCCodeBaseModule* self, ValaParameter* param);

268

ValaTargetValue* (*get_field_cvalue) (ValaCCodeBaseModule* self, ValaField* field, ValaTargetValue* instance);

269

ValaTargetValue* (*load_variable) (ValaCCodeBaseModule* self, ValaVariable* variable, ValaTargetValue* value);

270

ValaTargetValue* (*load_this_parameter) (ValaCCodeBaseModule* self, ValaTypeSymbol* sym);

271

void (*store_value) (ValaCCodeBaseModule* self, ValaTargetValue* lvalue, ValaTargetValue* value);

272

gchar* (*get_delegate_target_cname) (ValaCCodeBaseModule* self, const gchar* delegate_cname);

273

ValaCCodeExpression* (*get_delegate_target_cexpression) (ValaCCodeBaseModule* self, ValaExpression* delegate_expr, ValaCCodeExpression** delegate_target_destroy_notify);

274

ValaCCodeExpression* (*get_delegate_target_cvalue) (ValaCCodeBaseModule* self, ValaTargetValue* value);

275

ValaCCodeExpression* (*get_delegate_target_destroy_notify_cvalue) (ValaCCodeBaseModule* self, ValaTargetValue* value);

276

gchar* (*get_delegate_target_destroy_notify_cname) (ValaCCodeBaseModule* self, const gchar* delegate_cname);

277

ValaTargetValue* (*copy_value) (ValaCCodeBaseModule* self, ValaTargetValue* value, ValaCodeNode* node);

278

void (*generate_class_declaration) (ValaCCodeBaseModule* self, ValaClass* cl, ValaCCodeFile* decl_space);

279

void (*generate_interface_declaration) (ValaCCodeBaseModule* self, ValaInterface* iface, ValaCCodeFile* decl_space);

280

void (*generate_method_declaration) (ValaCCodeBaseModule* self, ValaMethod* m, ValaCCodeFile* decl_space);

281

void (*generate_error_domain_declaration) (ValaCCodeBaseModule* self, ValaErrorDomain* edomain, ValaCCodeFile* decl_space);

282

ValaCCodeExpression* (*deserialize_expression) (ValaCCodeBaseModule* self, ValaDataType* type, ValaCCodeExpression* variant_expr, ValaCCodeExpression* expr, ValaCCodeExpression* error_expr, gboolean* may_fail);

283

ValaCCodeExpression* (*serialize_expression) (ValaCCodeBaseModule* self, ValaDataType* type, ValaCCodeExpression* expr);

284

ValaCCodeExpression* (*get_implicit_cast_expression) (ValaCCodeBaseModule* self, ValaCCodeExpression* source_cexpr, ValaDataType* expression_type, ValaDataType* target_type, ValaCodeNode* node);

285

void (*create_type_check_statement) (ValaCCodeBaseModule* self, ValaCodeNode* method_node, ValaDataType* ret_type, ValaTypeSymbol* t, gboolean non_null, const gchar* var_name);

286

gboolean (*is_gobject_property) (ValaCCodeBaseModule* self, ValaProperty* prop);

287

void (*generate_dynamic_method_wrapper) (ValaCCodeBaseModule* self, ValaDynamicMethod* method);

288

gboolean (*method_has_wrapper) (ValaCCodeBaseModule* self, ValaMethod* method);

289

ValaCCodeFunctionCall* (*get_param_spec) (ValaCCodeBaseModule* self, ValaProperty* prop);

290

ValaCCodeFunctionCall* (*get_signal_creation) (ValaCCodeBaseModule* self, ValaSignal* sig, ValaTypeSymbol* type);

291

void (*register_dbus_info) (ValaCCodeBaseModule* self, ValaCCodeBlock* block, ValaObjectTypeSymbol* bindable);

292

gchar* (*get_dynamic_property_getter_cname) (ValaCCodeBaseModule* self, ValaDynamicProperty* node);

293

gchar* (*get_dynamic_property_setter_cname) (ValaCCodeBaseModule* self, ValaDynamicProperty* node);

294

gchar* (*get_dynamic_signal_cname) (ValaCCodeBaseModule* self, ValaDynamicSignal* node);

295

gchar* (*get_dynamic_signal_connect_wrapper_name) (ValaCCodeBaseModule* self, ValaDynamicSignal* node);

296

gchar* (*get_dynamic_signal_connect_after_wrapper_name) (ValaCCodeBaseModule* self, ValaDynamicSignal* node);

297

gchar* (*get_dynamic_signal_disconnect_wrapper_name) (ValaCCodeBaseModule* self, ValaDynamicSignal* node);

298

gchar* (*get_array_length_cname) (ValaCCodeBaseModule* self, const gchar* array_cname, gint dim);

299

gchar* (*get_parameter_array_length_cname) (ValaCCodeBaseModule* self, ValaParameter* param, gint dim);

300

ValaCCodeExpression* (*get_array_length_cexpression) (ValaCCodeBaseModule* self, ValaExpression* array_expr, gint dim);

301

ValaCCodeExpression* (*get_array_length_cvalue) (ValaCCodeBaseModule* self, ValaTargetValue* value, gint dim);

302

gchar* (*get_array_size_cname) (ValaCCodeBaseModule* self, const gchar* array_cname);

303

void (*add_simple_check) (ValaCCodeBaseModule* self, ValaCodeNode* node, gboolean always_fails);

304

gchar* (*generate_ready_function) (ValaCCodeBaseModule* self, ValaMethod* m);

305

};

306

307

struct _ValaCCodeStructModule {

308

ValaCCodeBaseModule parent_instance;

309

ValaCCodeStructModulePrivate * priv;

310

};

311

312

struct _ValaCCodeStructModuleClass {

313

ValaCCodeBaseModuleClass parent_class;

314

};

315

316

struct _ValaCCodeMethodModule {

317

ValaCCodeStructModule parent_instance;

318

ValaCCodeMethodModulePrivate * priv;

319

};

320

321

struct _ValaCCodeMethodModuleClass {

322

ValaCCodeStructModuleClass parent_class;

323

void (*generate_method_result_declaration) (ValaCCodeMethodModule* self, ValaMethod* m, ValaCCodeFile* decl_space, ValaCCodeFunction* cfunc, ValaMap* cparam_map, ValaMap* carg_map);

324

ValaCCodeParameter* (*generate_parameter) (ValaCCodeMethodModule* self, ValaParameter* param, ValaCCodeFile* decl_space, ValaMap* cparam_map, ValaMap* carg_map);

325

};

326

327

struct _ValaCCodeControlFlowModule {

328

ValaCCodeMethodModule parent_instance;

329

ValaCCodeControlFlowModulePrivate * priv;

330

};

331

332

struct _ValaCCodeControlFlowModuleClass {

333

ValaCCodeMethodModuleClass parent_class;

334

};

335

336

struct _ValaCCodeMemberAccessModule {

337

ValaCCodeControlFlowModule parent_instance;

338

ValaCCodeMemberAccessModulePrivate * priv;

339

};

340

341

struct _ValaCCodeMemberAccessModuleClass {

342

ValaCCodeControlFlowModuleClass parent_class;

343

};

344

345

struct _ValaCCodeAssignmentModule {

346

ValaCCodeMemberAccessModule parent_instance;

347

ValaCCodeAssignmentModulePrivate * priv;

348

};

349

350

struct _ValaCCodeAssignmentModuleClass {

351

ValaCCodeMemberAccessModuleClass parent_class;

352

};

353

354

struct _ValaCCodeMethodCallModule {

355

ValaCCodeAssignmentModule parent_instance;

356

ValaCCodeMethodCallModulePrivate * priv;

357

};

358

359

struct _ValaCCodeMethodCallModuleClass {

360

ValaCCodeAssignmentModuleClass parent_class;

361

};

362

363

struct _ValaCCodeArrayModule {

364

ValaCCodeMethodCallModule parent_instance;

365

ValaCCodeArrayModulePrivate * priv;

366

};

367

368

struct _ValaCCodeArrayModuleClass {

369

ValaCCodeMethodCallModuleClass parent_class;

370

};

371

372

struct _ValaCCodeDelegateModule {

373

ValaCCodeArrayModule parent_instance;

374

ValaCCodeDelegateModulePrivate * priv;

375

};

376

377

struct _ValaCCodeDelegateModuleClass {

378

ValaCCodeArrayModuleClass parent_class;

379

};

380

381

struct _ValaGErrorModule {

382

ValaCCodeDelegateModule parent_instance;

383

ValaGErrorModulePrivate * priv;

384

};

385

386

struct _ValaGErrorModuleClass {

387

ValaCCodeDelegateModuleClass parent_class;

388

void (*return_with_exception) (ValaGErrorModule* self, ValaCCodeExpression* error_expr);

389

};

390

391

struct _ValaGErrorModulePrivate {

392

gint current_try_id;

393

gint next_try_id;

394

gboolean is_in_catch;

395

};

396

397

398

static gpointer vala_gerror_module_parent_class = NULL;

399

400

GType vala_ccode_base_module_get_type (void) G_GNUC_CONST;

401

gpointer vala_ccode_base_module_emit_context_ref (gpointer instance);

402

void vala_ccode_base_module_emit_context_unref (gpointer instance);

403

GParamSpec* vala_ccode_base_module_param_spec_emit_context (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags);

404

void vala_ccode_base_module_value_set_emit_context (GValue* value, gpointer v_object);

405

void vala_ccode_base_module_value_take_emit_context (GValue* value, gpointer v_object);

406

gpointer vala_ccode_base_module_value_get_emit_context (const GValue* value);

407

GType vala_ccode_base_module_emit_context_get_type (void) G_GNUC_CONST;

408

GType vala_ccode_struct_module_get_type (void) G_GNUC_CONST;

409

GType vala_ccode_method_module_get_type (void) G_GNUC_CONST;

410

GType vala_ccode_control_flow_module_get_type (void) G_GNUC_CONST;

411

GType vala_ccode_member_access_module_get_type (void) G_GNUC_CONST;

412

GType vala_ccode_assignment_module_get_type (void) G_GNUC_CONST;

413

GType vala_ccode_method_call_module_get_type (void) G_GNUC_CONST;

414

GType vala_ccode_array_module_get_type (void) G_GNUC_CONST;

415

GType vala_ccode_delegate_module_get_type (void) G_GNUC_CONST;

416

GType vala_gerror_module_get_type (void) G_GNUC_CONST;

417

#define VALA_GERROR_MODULE_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), VALA_TYPE_GERROR_MODULE, ValaGErrorModulePrivate))

418

enum {

419

VALA_GERROR_MODULE_DUMMY_PROPERTY

420

};

421

static void vala_gerror_module_real_generate_error_domain_declaration (ValaCCodeBaseModule* base, ValaErrorDomain* edomain, ValaCCodeFile* decl_space);

422

gboolean vala_ccode_base_module_add_symbol_declaration (ValaCCodeBaseModule* self, ValaCCodeFile* decl_space, ValaSymbol* sym, const gchar* name);

423

gchar* vala_ccode_base_module_get_ccode_name (ValaCodeNode* node);

424

ValaCCodeExpression* vala_ccode_base_module_get_cvalue (ValaCCodeBaseModule* self, ValaExpression* expr);

425

gchar* vala_ccode_base_module_get_ccode_lower_case_prefix (ValaSymbol* sym);

426

gchar* vala_ccode_base_module_get_ccode_upper_case_name (ValaSymbol* sym, const gchar* infix);

427

static void vala_gerror_module_real_visit_error_domain (ValaCodeVisitor* base, ValaErrorDomain* edomain);

428

void vala_ccode_base_module_generate_error_domain_declaration (ValaCCodeBaseModule* self, ValaErrorDomain* edomain, ValaCCodeFile* decl_space);

429

void vala_ccode_base_module_push_function (ValaCCodeBaseModule* self, ValaCCodeFunction* func);

430

gchar* vala_ccode_base_module_get_ccode_lower_case_name (ValaCodeNode* node, const gchar* infix);

431

ValaCCodeFunction* vala_ccode_base_module_get_ccode (ValaCCodeBaseModule* self);

432

void vala_ccode_base_module_pop_function (ValaCCodeBaseModule* self);

433

static void vala_gerror_module_real_visit_throw_statement (ValaCodeVisitor* base, ValaThrowStatement* stmt);

434

void vala_ccode_base_module_set_current_method_inner_error (ValaCCodeBaseModule* self, gboolean value);

435

ValaCCodeExpression* vala_ccode_base_module_get_variable_cexpression (ValaCCodeBaseModule* self, const gchar* name);

436

void vala_ccode_base_module_add_simple_check (ValaCCodeBaseModule* self, ValaCodeNode* node, gboolean always_fails);

437

void vala_gerror_module_return_with_exception (ValaGErrorModule* self, ValaCCodeExpression* error_expr);

438

static void vala_gerror_module_real_return_with_exception (ValaGErrorModule* self, ValaCCodeExpression* error_expr);

439

void vala_ccode_base_module_append_local_free (ValaCCodeBaseModule* self, ValaSymbol* sym, gboolean stop_at_loop, ValaCodeNode* stop_at);

440

ValaSymbol* vala_ccode_base_module_get_current_symbol (ValaCCodeBaseModule* self);

441

ValaMethod* vala_ccode_base_module_get_current_method (ValaCCodeBaseModule* self);

442

ValaCCodeExpression* vala_ccode_base_module_destroy_value (ValaCCodeBaseModule* self, ValaTargetValue* value, gboolean is_macro_definition);

443

ValaGLibValue* vala_glib_value_new (ValaDataType* value_type, ValaCCodeExpression* cvalue, gboolean lvalue);

444

ValaGLibValue* vala_glib_value_construct (GType object_type, ValaDataType* value_type, ValaCCodeExpression* cvalue, gboolean lvalue);

445

GType vala_glib_value_get_type (void) G_GNUC_CONST;

446

gboolean vala_ccode_base_module_is_in_coroutine (ValaCCodeBaseModule* self);

447

void vala_ccode_base_module_return_default_value (ValaCCodeBaseModule* self, ValaDataType* return_type);

448

ValaDataType* vala_ccode_base_module_get_current_return_type (ValaCCodeBaseModule* self);

449

static void vala_gerror_module_uncaught_error_statement (ValaGErrorModule* self, ValaCCodeExpression* inner_error, gboolean unexpected);

450

gboolean vala_ccode_base_module_is_in_constructor (ValaCCodeBaseModule* self);

451

gboolean vala_ccode_base_module_is_in_destructor (ValaCCodeBaseModule* self);

452

static gboolean vala_gerror_module_in_finally_block (ValaGErrorModule* self, ValaCodeNode* node);

453

static void vala_gerror_module_real_add_simple_check (ValaCCodeBaseModule* base, ValaCodeNode* node, gboolean always_fails);

454

ValaTryStatement* vala_ccode_base_module_get_current_try (ValaCCodeBaseModule* self);

455

ValaCatchClause* vala_ccode_base_module_get_current_catch (ValaCCodeBaseModule* self);

456

static void vala_gerror_module_real_visit_try_statement (ValaCodeVisitor* base, ValaTryStatement* stmt);

457

void vala_ccode_base_module_set_current_try (ValaCCodeBaseModule* self, ValaTryStatement* value);

458

void vala_ccode_base_module_set_current_catch (ValaCCodeBaseModule* self, ValaCatchClause* value);

459

static void vala_gerror_module_real_visit_catch_clause (ValaCodeVisitor* base, ValaCatchClause* clause);

460

gchar* vala_ccode_base_module_get_local_cname (ValaCCodeBaseModule* self, ValaLocalVariable* local);

461

static void vala_gerror_module_real_append_scope_free (ValaCCodeBaseModule* base, ValaSymbol* sym, ValaCodeNode* stop_at);

462

void vala_ccode_base_module_append_scope_free (ValaCCodeBaseModule* self, ValaSymbol* sym, ValaCodeNode* stop_at);

463

ValaGErrorModule* vala_gerror_module_new (void);

464

ValaGErrorModule* vala_gerror_module_construct (GType object_type);

465

ValaCCodeDelegateModule* vala_ccode_delegate_module_new (void);

466

ValaCCodeDelegateModule* vala_ccode_delegate_module_construct (GType object_type);

467

static void vala_gerror_module_finalize (ValaCodeVisitor* obj);

468

469

470

static void vala_gerror_module_real_generate_error_domain_declaration (ValaCCodeBaseModule* base, ValaErrorDomain* edomain, ValaCCodeFile* decl_space) {

471

ValaGErrorModule * self;

472

ValaCCodeFile* _tmp0_;

473

ValaErrorDomain* _tmp1_;

474

ValaErrorDomain* _tmp2_;

475

gchar* _tmp3_ = NULL;

476

gchar* _tmp4_;

477

gboolean _tmp5_ = FALSE;

478

gboolean _tmp6_;

479

ValaErrorDomain* _tmp7_;

480

gchar* _tmp8_ = NULL;

481

gchar* _tmp9_;

482

ValaCCodeEnum* _tmp10_;

483

ValaCCodeEnum* _tmp11_;

484

ValaCCodeEnum* cenum;

485

ValaCCodeFile* _tmp46_;

486

ValaCCodeEnum* _tmp47_;

487

ValaErrorDomain* _tmp48_;

488

gchar* _tmp49_ = NULL;

489

gchar* _tmp50_;

490

gchar* _tmp51_;

491

gchar* _tmp52_;

492

gchar* quark_fun_name;

493

ValaErrorDomain* _tmp53_;

494

gchar* _tmp54_ = NULL;

495

gchar* _tmp55_;

496

const gchar* _tmp56_;

497

gchar* _tmp57_;

498

gchar* _tmp58_;

499

ValaCCodeMacroReplacement* _tmp59_;

500

ValaCCodeMacroReplacement* _tmp60_;

501

ValaCCodeMacroReplacement* error_domain_define;

502

ValaCCodeFile* _tmp61_;

503

ValaCCodeMacroReplacement* _tmp62_;

504

const gchar* _tmp63_;

505

ValaDataType* _tmp64_;

506

ValaTypeSymbol* _tmp65_;

507

ValaTypeSymbol* _tmp66_;

508

gchar* _tmp67_ = NULL;

509

gchar* _tmp68_;

510

ValaCCodeFunction* _tmp69_;

511

ValaCCodeFunction* _tmp70_;

512

ValaCCodeFunction* cquark_fun;

513

ValaCCodeFile* _tmp71_;

514

ValaCCodeFunction* _tmp72_;

515

self = (ValaGErrorModule*) base;

516

g_return_if_fail (edomain != NULL);

517

g_return_if_fail (decl_space != NULL);

518

_tmp0_ = decl_space;

519

_tmp1_ = edomain;

520

_tmp2_ = edomain;

521

_tmp3_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp2_);

522

_tmp4_ = _tmp3_;

523

_tmp5_ = vala_ccode_base_module_add_symbol_declaration ((ValaCCodeBaseModule*) self, _tmp0_, (ValaSymbol*) _tmp1_, _tmp4_);

524

_tmp6_ = _tmp5_;

525

_g_free0 (_tmp4_);

526

if (_tmp6_) {

527

return;

528

}

529

_tmp7_ = edomain;

530

_tmp8_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp7_);

531

_tmp9_ = _tmp8_;

532

_tmp10_ = vala_ccode_enum_new (_tmp9_);

533

_tmp11_ = _tmp10_;

534

_g_free0 (_tmp9_);

535

cenum = _tmp11_;

536

{

537

ValaErrorDomain* _tmp12_;

538

ValaList* _tmp13_ = NULL;

539

ValaList* _ecode_list;

540

ValaList* _tmp14_;

541

gint _tmp15_;

542

gint _tmp16_;

543

gint _ecode_size;

544

gint _ecode_index;

545

_tmp12_ = edomain;

546

_tmp13_ = vala_error_domain_get_codes (_tmp12_);

547

_ecode_list = _tmp13_;

548

_tmp14_ = _ecode_list;

549

_tmp15_ = vala_collection_get_size ((ValaCollection*) _tmp14_);

550

_tmp16_ = _tmp15_;

551

_ecode_size = _tmp16_;

552

_ecode_index = -1;

553

while (TRUE) {

554

gint _tmp17_;

555

gint _tmp18_;

556

gint _tmp19_;

557

ValaList* _tmp20_;

558

gint _tmp21_;

559

gpointer _tmp22_ = NULL;

560

ValaErrorCode* ecode;

561

ValaErrorCode* _tmp23_;

562

ValaExpression* _tmp24_;

563

ValaExpression* _tmp25_;

564

_tmp17_ = _ecode_index;

565

_ecode_index = _tmp17_ + 1;

566

_tmp18_ = _ecode_index;

567

_tmp19_ = _ecode_size;

568

if (!(_tmp18_ < _tmp19_)) {

569

break;

570

}

571

_tmp20_ = _ecode_list;

572

_tmp21_ = _ecode_index;

573

_tmp22_ = vala_list_get (_tmp20_, _tmp21_);

574

ecode = (ValaErrorCode*) _tmp22_;

575

_tmp23_ = ecode;

576

_tmp24_ = vala_error_code_get_value (_tmp23_);

577

_tmp25_ = _tmp24_;

578

if (_tmp25_ == NULL) {

579

ValaCCodeEnum* _tmp26_;

580

ValaErrorCode* _tmp27_;

581

gchar* _tmp28_ = NULL;

582

gchar* _tmp29_;

583

ValaCCodeEnumValue* _tmp30_;

584

ValaCCodeEnumValue* _tmp31_;

585

_tmp26_ = cenum;

586

_tmp27_ = ecode;

587

_tmp28_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp27_);

588

_tmp29_ = _tmp28_;

589

_tmp30_ = vala_ccode_enum_value_new (_tmp29_, NULL);

590

_tmp31_ = _tmp30_;

591

vala_ccode_enum_add_value (_tmp26_, _tmp31_);

592

_vala_ccode_node_unref0 (_tmp31_);

593

_g_free0 (_tmp29_);

594

} else {

595

ValaErrorCode* _tmp32_;

596

ValaExpression* _tmp33_;

597

ValaExpression* _tmp34_;

598

ValaCCodeEnum* _tmp35_;

599

ValaErrorCode* _tmp36_;

600

gchar* _tmp37_ = NULL;

601

gchar* _tmp38_;

602

ValaErrorCode* _tmp39_;

603

ValaExpression* _tmp40_;

604

ValaExpression* _tmp41_;

605

ValaCCodeExpression* _tmp42_ = NULL;

606

ValaCCodeExpression* _tmp43_;

607

ValaCCodeEnumValue* _tmp44_;

608

ValaCCodeEnumValue* _tmp45_;

609

_tmp32_ = ecode;

610

_tmp33_ = vala_error_code_get_value (_tmp32_);

611

_tmp34_ = _tmp33_;

612

vala_code_node_emit ((ValaCodeNode*) _tmp34_, (ValaCodeGenerator*) self);

613

_tmp35_ = cenum;

614

_tmp36_ = ecode;

615

_tmp37_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp36_);

616

_tmp38_ = _tmp37_;

617

_tmp39_ = ecode;

618

_tmp40_ = vala_error_code_get_value (_tmp39_);

619

_tmp41_ = _tmp40_;

620

_tmp42_ = vala_ccode_base_module_get_cvalue ((ValaCCodeBaseModule*) self, _tmp41_);

621

_tmp43_ = _tmp42_;

622

_tmp44_ = vala_ccode_enum_value_new (_tmp38_, _tmp43_);

623

_tmp45_ = _tmp44_;

624

vala_ccode_enum_add_value (_tmp35_, _tmp45_);

625

_vala_ccode_node_unref0 (_tmp45_);

626

_vala_ccode_node_unref0 (_tmp43_);

627

_g_free0 (_tmp38_);

628

}

629

_vala_code_node_unref0 (ecode);

630

}

631

_vala_iterable_unref0 (_ecode_list);

632

}

633

_tmp46_ = decl_space;

634

_tmp47_ = cenum;

635

vala_ccode_file_add_type_definition (_tmp46_, (ValaCCodeNode*) _tmp47_);

636

_tmp48_ = edomain;

637

_tmp49_ = vala_ccode_base_module_get_ccode_lower_case_prefix ((ValaSymbol*) _tmp48_);

638

_tmp50_ = _tmp49_;

639

_tmp51_ = g_strconcat (_tmp50_, "quark", NULL);

640

_tmp52_ = _tmp51_;

641

_g_free0 (_tmp50_);

642

quark_fun_name = _tmp52_;

643

_tmp53_ = edomain;

644

_tmp54_ = vala_ccode_base_module_get_ccode_upper_case_name ((ValaSymbol*) _tmp53_, NULL);

645

_tmp55_ = _tmp54_;

646

_tmp56_ = quark_fun_name;

647

_tmp57_ = g_strconcat (_tmp56_, " ()", NULL);

648

_tmp58_ = _tmp57_;

649

_tmp59_ = vala_ccode_macro_replacement_new (_tmp55_, _tmp58_);

650

_tmp60_ = _tmp59_;

651

_g_free0 (_tmp58_);

652

_g_free0 (_tmp55_);

653

error_domain_define = _tmp60_;

654

_tmp61_ = decl_space;

655

_tmp62_ = error_domain_define;

656

vala_ccode_file_add_type_definition (_tmp61_, (ValaCCodeNode*) _tmp62_);

657

_tmp63_ = quark_fun_name;

658

_tmp64_ = ((ValaCCodeBaseModule*) self)->gquark_type;

659

_tmp65_ = vala_data_type_get_data_type (_tmp64_);

660

_tmp66_ = _tmp65_;

661

_tmp67_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp66_);

662

_tmp68_ = _tmp67_;

663

_tmp69_ = vala_ccode_function_new (_tmp63_, _tmp68_);

664

_tmp70_ = _tmp69_;

665

_g_free0 (_tmp68_);

666

cquark_fun = _tmp70_;

667

_tmp71_ = decl_space;

668

_tmp72_ = cquark_fun;

669

vala_ccode_file_add_function_declaration (_tmp71_, _tmp72_);

670

_vala_ccode_node_unref0 (cquark_fun);

671

_vala_ccode_node_unref0 (error_domain_define);

672

_g_free0 (quark_fun_name);

673

_vala_ccode_node_unref0 (cenum);

674

}

675

676

677

static void vala_gerror_module_real_visit_error_domain (ValaCodeVisitor* base, ValaErrorDomain* edomain) {

678

ValaGErrorModule * self;

679

ValaErrorDomain* _tmp0_;

680

ValaComment* _tmp1_;

681

ValaComment* _tmp2_;

682

ValaErrorDomain* _tmp11_;

683

ValaCCodeFile* _tmp12_;

684

ValaErrorDomain* _tmp13_;

685

gboolean _tmp14_ = FALSE;

686

ValaErrorDomain* _tmp17_;

687

gboolean _tmp18_ = FALSE;

688

ValaErrorDomain* _tmp21_;

689

gchar* _tmp22_ = NULL;

690

gchar* _tmp23_;

691

gchar* _tmp24_;

692

gchar* _tmp25_;

693

gchar* quark_fun_name;

694

ValaDataType* _tmp26_;

695

ValaTypeSymbol* _tmp27_;

696

ValaTypeSymbol* _tmp28_;

697

gchar* _tmp29_ = NULL;

698

gchar* _tmp30_;

699

ValaCCodeFunction* _tmp31_;

700

ValaCCodeFunction* _tmp32_;

701

ValaCCodeFunction* cquark_fun;

702

ValaCCodeIdentifier* _tmp33_;

703

ValaCCodeIdentifier* _tmp34_;

704

ValaCCodeFunctionCall* _tmp35_;

705

ValaCCodeFunctionCall* _tmp36_;

706

ValaCCodeFunctionCall* cquark_call;

707

ValaErrorDomain* _tmp37_;

708

gchar* _tmp38_ = NULL;

709

gchar* _tmp39_;

710

gchar* _tmp40_;

711

gchar* _tmp41_;

712

gchar* _tmp42_;

713

gchar* _tmp43_;

714

ValaCCodeConstant* _tmp44_;

715

ValaCCodeConstant* _tmp45_;

716

ValaCCodeFunction* _tmp46_;

717

ValaCCodeFunction* _tmp47_;

718

ValaCCodeFile* _tmp48_;

719

self = (ValaGErrorModule*) base;

720

g_return_if_fail (edomain != NULL);

721

_tmp0_ = edomain;

722

_tmp1_ = vala_symbol_get_comment ((ValaSymbol*) _tmp0_);

723

_tmp2_ = _tmp1_;

724

if (_tmp2_ != NULL) {

725

ValaCCodeFile* _tmp3_;

726

ValaErrorDomain* _tmp4_;

727

ValaComment* _tmp5_;

728

ValaComment* _tmp6_;

729

const gchar* _tmp7_;

730

const gchar* _tmp8_;

731

ValaCCodeComment* _tmp9_;

732

ValaCCodeComment* _tmp10_;

733

_tmp3_ = ((ValaCCodeBaseModule*) self)->cfile;

734

_tmp4_ = edomain;

735

_tmp5_ = vala_symbol_get_comment ((ValaSymbol*) _tmp4_);

736

_tmp6_ = _tmp5_;

737

_tmp7_ = vala_comment_get_content (_tmp6_);

738

_tmp8_ = _tmp7_;

739

_tmp9_ = vala_ccode_comment_new (_tmp8_);

740

_tmp10_ = _tmp9_;

741

vala_ccode_file_add_type_definition (_tmp3_, (ValaCCodeNode*) _tmp10_);

742

_vala_ccode_node_unref0 (_tmp10_);

743

}

744

_tmp11_ = edomain;

745

_tmp12_ = ((ValaCCodeBaseModule*) self)->cfile;

746

vala_ccode_base_module_generate_error_domain_declaration ((ValaCCodeBaseModule*) self, _tmp11_, _tmp12_);

747

_tmp13_ = edomain;

748

_tmp14_ = vala_symbol_is_internal_symbol ((ValaSymbol*) _tmp13_);

749

if (!_tmp14_) {

750

ValaErrorDomain* _tmp15_;

751

ValaCCodeFile* _tmp16_;

752

_tmp15_ = edomain;

753

_tmp16_ = ((ValaCCodeBaseModule*) self)->header_file;

754

vala_ccode_base_module_generate_error_domain_declaration ((ValaCCodeBaseModule*) self, _tmp15_, _tmp16_);

755

}

756

_tmp17_ = edomain;

757

_tmp18_ = vala_symbol_is_private_symbol ((ValaSymbol*) _tmp17_);

758

if (!_tmp18_) {

759

ValaErrorDomain* _tmp19_;

760

ValaCCodeFile* _tmp20_;

761

_tmp19_ = edomain;

762

_tmp20_ = ((ValaCCodeBaseModule*) self)->internal_header_file;

763

vala_ccode_base_module_generate_error_domain_declaration ((ValaCCodeBaseModule*) self, _tmp19_, _tmp20_);

764

}

765

_tmp21_ = edomain;

766

_tmp22_ = vala_ccode_base_module_get_ccode_lower_case_prefix ((ValaSymbol*) _tmp21_);

767

_tmp23_ = _tmp22_;

768

_tmp24_ = g_strconcat (_tmp23_, "quark", NULL);

769

_tmp25_ = _tmp24_;

770

_g_free0 (_tmp23_);

771

quark_fun_name = _tmp25_;

772

_tmp26_ = ((ValaCCodeBaseModule*) self)->gquark_type;

773

_tmp27_ = vala_data_type_get_data_type (_tmp26_);

774

_tmp28_ = _tmp27_;

775

_tmp29_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp28_);

776

_tmp30_ = _tmp29_;

777

_tmp31_ = vala_ccode_function_new (quark_fun_name, _tmp30_);

778

_tmp32_ = _tmp31_;

779

_g_free0 (_tmp30_);

780

cquark_fun = _tmp32_;

781

vala_ccode_base_module_push_function ((ValaCCodeBaseModule*) self, cquark_fun);

782

_tmp33_ = vala_ccode_identifier_new ("g_quark_from_static_string");

783

_tmp34_ = _tmp33_;

784

_tmp35_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp34_);

785

_tmp36_ = _tmp35_;

786

_vala_ccode_node_unref0 (_tmp34_);

787

cquark_call = _tmp36_;

788

_tmp37_ = edomain;

789

_tmp38_ = vala_ccode_base_module_get_ccode_lower_case_name ((ValaCodeNode*) _tmp37_, NULL);

790

_tmp39_ = _tmp38_;

791

_tmp40_ = g_strconcat ("\"", _tmp39_, NULL);

792

_tmp41_ = _tmp40_;

793

_tmp42_ = g_strconcat (_tmp41_, "-quark\"", NULL);

794

_tmp43_ = _tmp42_;

795

_tmp44_ = vala_ccode_constant_new (_tmp43_);

796

_tmp45_ = _tmp44_;

797

vala_ccode_function_call_add_argument (cquark_call, (ValaCCodeExpression*) _tmp45_);

798

_vala_ccode_node_unref0 (_tmp45_);

799

_g_free0 (_tmp43_);

800

_g_free0 (_tmp41_);

801

_g_free0 (_tmp39_);

802

_tmp46_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

803

_tmp47_ = _tmp46_;

804

vala_ccode_function_add_return (_tmp47_, (ValaCCodeExpression*) cquark_call);

805

vala_ccode_base_module_pop_function ((ValaCCodeBaseModule*) self);

806

_tmp48_ = ((ValaCCodeBaseModule*) self)->cfile;

807

vala_ccode_file_add_function (_tmp48_, cquark_fun);

808

_vala_ccode_node_unref0 (cquark_call);

809

_vala_ccode_node_unref0 (cquark_fun);

810

_g_free0 (quark_fun_name);

811

}

812

813

814

static void vala_gerror_module_real_visit_throw_statement (ValaCodeVisitor* base, ValaThrowStatement* stmt) {

815

ValaGErrorModule * self;

816

ValaCCodeFunction* _tmp0_;

817

ValaCCodeFunction* _tmp1_;

818

ValaCCodeExpression* _tmp2_ = NULL;

819

ValaCCodeExpression* _tmp3_;

820

ValaThrowStatement* _tmp4_;

821

ValaExpression* _tmp5_;

822

ValaExpression* _tmp6_;

823

ValaCCodeExpression* _tmp7_ = NULL;

824

ValaCCodeExpression* _tmp8_;

825

ValaThrowStatement* _tmp9_;

826

self = (ValaGErrorModule*) base;

827

g_return_if_fail (stmt != NULL);

828

vala_ccode_base_module_set_current_method_inner_error ((ValaCCodeBaseModule*) self, TRUE);

829

_tmp0_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

830

_tmp1_ = _tmp0_;

831

_tmp2_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, "_inner_error_");

832

_tmp3_ = _tmp2_;

833

_tmp4_ = stmt;

834

_tmp5_ = vala_throw_statement_get_error_expression (_tmp4_);

835

_tmp6_ = _tmp5_;

836

_tmp7_ = vala_ccode_base_module_get_cvalue ((ValaCCodeBaseModule*) self, _tmp6_);

837

_tmp8_ = _tmp7_;

838

vala_ccode_function_add_assignment (_tmp1_, _tmp3_, _tmp8_);

839

_vala_ccode_node_unref0 (_tmp8_);

840

_vala_ccode_node_unref0 (_tmp3_);

841

_tmp9_ = stmt;

842

vala_ccode_base_module_add_simple_check ((ValaCCodeBaseModule*) self, (ValaCodeNode*) _tmp9_, TRUE);

843

}

844

845

846

static gpointer _vala_code_node_ref0 (gpointer self) {

847

return self ? vala_code_node_ref (self) : NULL;

848

}

849

850

851

static void vala_gerror_module_real_return_with_exception (ValaGErrorModule* self, ValaCCodeExpression* error_expr) {

852

ValaCCodeIdentifier* _tmp0_;

853

ValaCCodeIdentifier* _tmp1_;

854

ValaCCodeFunctionCall* _tmp2_;

855

ValaCCodeFunctionCall* _tmp3_;

856

ValaCCodeFunctionCall* cpropagate;

857

ValaCCodeFunctionCall* _tmp4_;

858

ValaCCodeIdentifier* _tmp5_;

859

ValaCCodeIdentifier* _tmp6_;

860

ValaCCodeFunctionCall* _tmp7_;

861

ValaCCodeExpression* _tmp8_;

862

ValaCCodeFunction* _tmp9_;

863

ValaCCodeFunction* _tmp10_;

864

ValaCCodeFunctionCall* _tmp11_;

865

ValaSymbol* _tmp12_;

866

ValaSymbol* _tmp13_;

867

gboolean _tmp14_ = FALSE;

868

ValaMethod* _tmp15_;

869

ValaMethod* _tmp16_;

870

gboolean _tmp21_;

871

g_return_if_fail (error_expr != NULL);

872

_tmp0_ = vala_ccode_identifier_new ("g_propagate_error");

873

_tmp1_ = _tmp0_;

874

_tmp2_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp1_);

875

_tmp3_ = _tmp2_;

876

_vala_ccode_node_unref0 (_tmp1_);

877

cpropagate = _tmp3_;

878

_tmp4_ = cpropagate;

879

_tmp5_ = vala_ccode_identifier_new ("error");

880

_tmp6_ = _tmp5_;

881

vala_ccode_function_call_add_argument (_tmp4_, (ValaCCodeExpression*) _tmp6_);

882

_vala_ccode_node_unref0 (_tmp6_);

883

_tmp7_ = cpropagate;

884

_tmp8_ = error_expr;

885

vala_ccode_function_call_add_argument (_tmp7_, _tmp8_);

886

_tmp9_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

887

_tmp10_ = _tmp9_;

888

_tmp11_ = cpropagate;

889

vala_ccode_function_add_expression (_tmp10_, (ValaCCodeExpression*) _tmp11_);

890

_tmp12_ = vala_ccode_base_module_get_current_symbol ((ValaCCodeBaseModule*) self);

891

_tmp13_ = _tmp12_;

892

vala_ccode_base_module_append_local_free ((ValaCCodeBaseModule*) self, _tmp13_, FALSE, NULL);

893

_tmp15_ = vala_ccode_base_module_get_current_method ((ValaCCodeBaseModule*) self);

894

_tmp16_ = _tmp15_;

895

if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp16_, VALA_TYPE_CREATION_METHOD)) {

896

ValaMethod* _tmp17_;

897

ValaMethod* _tmp18_;

898

ValaSymbol* _tmp19_;

899

ValaSymbol* _tmp20_;

900

_tmp17_ = vala_ccode_base_module_get_current_method ((ValaCCodeBaseModule*) self);

901

_tmp18_ = _tmp17_;

902

_tmp19_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp18_);

903

_tmp20_ = _tmp19_;

904

_tmp14_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp20_, VALA_TYPE_CLASS);

905

} else {

906

_tmp14_ = FALSE;

907

}

908

_tmp21_ = _tmp14_;

909

if (_tmp21_) {

910

ValaMethod* _tmp22_;

911

ValaMethod* _tmp23_;

912

ValaSymbol* _tmp24_;

913

ValaSymbol* _tmp25_;

914

ValaClass* _tmp26_;

915

ValaClass* cl;

916

ValaCCodeFunction* _tmp27_;

917

ValaCCodeFunction* _tmp28_;

918

ValaClass* _tmp29_;

919

ValaObjectType* _tmp30_;

920

ValaObjectType* _tmp31_;

921

ValaCCodeIdentifier* _tmp32_;

922

ValaCCodeIdentifier* _tmp33_;

923

ValaGLibValue* _tmp34_;

924

ValaGLibValue* _tmp35_;

925

ValaCCodeExpression* _tmp36_ = NULL;

926

ValaCCodeExpression* _tmp37_;

927

ValaCCodeFunction* _tmp38_;

928

ValaCCodeFunction* _tmp39_;

929

ValaCCodeConstant* _tmp40_;

930

ValaCCodeConstant* _tmp41_;

931

_tmp22_ = vala_ccode_base_module_get_current_method ((ValaCCodeBaseModule*) self);

932

_tmp23_ = _tmp22_;

933

_tmp24_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp23_);

934

_tmp25_ = _tmp24_;

935

_tmp26_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp25_, VALA_TYPE_CLASS, ValaClass));

936

cl = _tmp26_;

937

_tmp27_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

938

_tmp28_ = _tmp27_;

939

_tmp29_ = cl;

940

_tmp30_ = vala_object_type_new ((ValaObjectTypeSymbol*) _tmp29_);

941

_tmp31_ = _tmp30_;

942

_tmp32_ = vala_ccode_identifier_new ("self");

943

_tmp33_ = _tmp32_;

944

_tmp34_ = vala_glib_value_new ((ValaDataType*) _tmp31_, (ValaCCodeExpression*) _tmp33_, TRUE);

945

_tmp35_ = _tmp34_;

946

_tmp36_ = vala_ccode_base_module_destroy_value ((ValaCCodeBaseModule*) self, (ValaTargetValue*) _tmp35_, FALSE);

947

_tmp37_ = _tmp36_;

948

vala_ccode_function_add_expression (_tmp28_, _tmp37_);

949

_vala_ccode_node_unref0 (_tmp37_);

950

_vala_target_value_unref0 (_tmp35_);

951

_vala_ccode_node_unref0 (_tmp33_);

952

_vala_code_node_unref0 (_tmp31_);

953

_tmp38_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

954

_tmp39_ = _tmp38_;

955

_tmp40_ = vala_ccode_constant_new ("NULL");

956

_tmp41_ = _tmp40_;

957

vala_ccode_function_add_return (_tmp39_, (ValaCCodeExpression*) _tmp41_);

958

_vala_ccode_node_unref0 (_tmp41_);

959

_vala_code_node_unref0 (cl);

960

} else {

961

gboolean _tmp42_ = FALSE;

962

_tmp42_ = vala_ccode_base_module_is_in_coroutine ((ValaCCodeBaseModule*) self);

963

if (_tmp42_) {

964

ValaCCodeFunction* _tmp43_;

965

ValaCCodeFunction* _tmp44_;

966

ValaCCodeConstant* _tmp45_;

967

ValaCCodeConstant* _tmp46_;

968

_tmp43_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

969

_tmp44_ = _tmp43_;

970

_tmp45_ = vala_ccode_constant_new ("FALSE");

971

_tmp46_ = _tmp45_;

972

vala_ccode_function_add_return (_tmp44_, (ValaCCodeExpression*) _tmp46_);

973

_vala_ccode_node_unref0 (_tmp46_);

974

} else {

975

ValaDataType* _tmp47_;

976

ValaDataType* _tmp48_;

977

_tmp47_ = vala_ccode_base_module_get_current_return_type ((ValaCCodeBaseModule*) self);

978

_tmp48_ = _tmp47_;

979

vala_ccode_base_module_return_default_value ((ValaCCodeBaseModule*) self, _tmp48_);

980

}

981

}

982

_vala_ccode_node_unref0 (cpropagate);

983

}

984

985

986

void vala_gerror_module_return_with_exception (ValaGErrorModule* self, ValaCCodeExpression* error_expr) {

987

g_return_if_fail (self != NULL);

988

VALA_GERROR_MODULE_GET_CLASS (self)->return_with_exception (self, error_expr);

989

}

990

991

992

static void vala_gerror_module_uncaught_error_statement (ValaGErrorModule* self, ValaCCodeExpression* inner_error, gboolean unexpected) {

993

ValaSymbol* _tmp0_;

994

ValaSymbol* _tmp1_;

995

ValaCCodeIdentifier* _tmp2_;

996

ValaCCodeIdentifier* _tmp3_;

997

ValaCCodeFunctionCall* _tmp4_;

998

ValaCCodeFunctionCall* _tmp5_;

999

ValaCCodeFunctionCall* ccritical;

1000

const gchar* _tmp6_ = NULL;

1001

gboolean _tmp7_;

1002

ValaCCodeFunctionCall* _tmp8_;

1003

const gchar* _tmp9_;

1004

ValaCCodeConstant* _tmp10_;

1005

ValaCCodeConstant* _tmp11_;

1006

ValaCCodeFunctionCall* _tmp12_;

1007

ValaCCodeConstant* _tmp13_;

1008

ValaCCodeConstant* _tmp14_;

1009

ValaCCodeFunctionCall* _tmp15_;

1010

ValaCCodeConstant* _tmp16_;

1011

ValaCCodeConstant* _tmp17_;

1012

ValaCCodeFunctionCall* _tmp18_;

1013

ValaCCodeExpression* _tmp19_;

1014

ValaCCodeMemberAccess* _tmp20_;

1015

ValaCCodeMemberAccess* _tmp21_;

1016

ValaCCodeIdentifier* _tmp22_;

1017

ValaCCodeIdentifier* _tmp23_;

1018

ValaCCodeFunctionCall* _tmp24_;

1019

ValaCCodeFunctionCall* _tmp25_;

1020

ValaCCodeFunctionCall* domain_name;

1021

ValaCCodeFunctionCall* _tmp26_;

1022

ValaCCodeExpression* _tmp27_;

1023

ValaCCodeMemberAccess* _tmp28_;

1024

ValaCCodeMemberAccess* _tmp29_;

1025

ValaCCodeFunctionCall* _tmp30_;

1026

ValaCCodeFunctionCall* _tmp31_;

1027

ValaCCodeFunctionCall* _tmp32_;

1028

ValaCCodeExpression* _tmp33_;

1029

ValaCCodeMemberAccess* _tmp34_;

1030

ValaCCodeMemberAccess* _tmp35_;

1031

ValaCCodeIdentifier* _tmp36_;

1032

ValaCCodeIdentifier* _tmp37_;

1033

ValaCCodeFunctionCall* _tmp38_;

1034

ValaCCodeFunctionCall* _tmp39_;

1035

ValaCCodeFunctionCall* cclear;

1036

ValaCCodeFunctionCall* _tmp40_;

1037

ValaCCodeExpression* _tmp41_;

1038

ValaCCodeUnaryExpression* _tmp42_;

1039

ValaCCodeUnaryExpression* _tmp43_;

1040

ValaCCodeFunction* _tmp44_;

1041

ValaCCodeFunction* _tmp45_;

1042

ValaCCodeFunctionCall* _tmp46_;

1043

ValaCCodeFunction* _tmp47_;

1044

ValaCCodeFunction* _tmp48_;

1045

ValaCCodeFunctionCall* _tmp49_;

1046

gboolean _tmp50_ = FALSE;

1047

gboolean _tmp51_ = FALSE;

1048

gboolean _tmp53_;

1049

g_return_if_fail (self != NULL);

1050

g_return_if_fail (inner_error != NULL);

1051

_tmp0_ = vala_ccode_base_module_get_current_symbol ((ValaCCodeBaseModule*) self);

1052

_tmp1_ = _tmp0_;

1053

vala_ccode_base_module_append_local_free ((ValaCCodeBaseModule*) self, _tmp1_, FALSE, NULL);

1054

_tmp2_ = vala_ccode_identifier_new ("g_critical");

1055

_tmp3_ = _tmp2_;

1056

_tmp4_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp3_);

1057

_tmp5_ = _tmp4_;

1058

_vala_ccode_node_unref0 (_tmp3_);

1059

ccritical = _tmp5_;

1060

_tmp7_ = unexpected;

1061

if (_tmp7_) {

1062

_tmp6_ = "\"file %s: line %d: unexpected error: %s (%s, %d)\"";

1063

} else {

1064

_tmp6_ = "\"file %s: line %d: uncaught error: %s (%s, %d)\"";

1065

}

1066

_tmp8_ = ccritical;

1067

_tmp9_ = _tmp6_;

1068

_tmp10_ = vala_ccode_constant_new (_tmp9_);

1069

_tmp11_ = _tmp10_;

1070

vala_ccode_function_call_add_argument (_tmp8_, (ValaCCodeExpression*) _tmp11_);

1071

_vala_ccode_node_unref0 (_tmp11_);

1072

_tmp12_ = ccritical;

1073

_tmp13_ = vala_ccode_constant_new ("__FILE__");

1074

_tmp14_ = _tmp13_;

1075

vala_ccode_function_call_add_argument (_tmp12_, (ValaCCodeExpression*) _tmp14_);

1076

_vala_ccode_node_unref0 (_tmp14_);

1077

_tmp15_ = ccritical;

1078

_tmp16_ = vala_ccode_constant_new ("__LINE__");

1079

_tmp17_ = _tmp16_;

1080

vala_ccode_function_call_add_argument (_tmp15_, (ValaCCodeExpression*) _tmp17_);

1081

_vala_ccode_node_unref0 (_tmp17_);

1082

_tmp18_ = ccritical;

1083

_tmp19_ = inner_error;

1084

_tmp20_ = vala_ccode_member_access_new_pointer (_tmp19_, "message");

1085

_tmp21_ = _tmp20_;

1086

vala_ccode_function_call_add_argument (_tmp18_, (ValaCCodeExpression*) _tmp21_);

1087

_vala_ccode_node_unref0 (_tmp21_);

1088

_tmp22_ = vala_ccode_identifier_new ("g_quark_to_string");

1089

_tmp23_ = _tmp22_;

1090

_tmp24_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp23_);

1091

_tmp25_ = _tmp24_;

1092

_vala_ccode_node_unref0 (_tmp23_);

1093

domain_name = _tmp25_;

1094

_tmp26_ = domain_name;

1095

_tmp27_ = inner_error;

1096

_tmp28_ = vala_ccode_member_access_new_pointer (_tmp27_, "domain");

1097

_tmp29_ = _tmp28_;

1098

vala_ccode_function_call_add_argument (_tmp26_, (ValaCCodeExpression*) _tmp29_);

1099

_vala_ccode_node_unref0 (_tmp29_);

1100

_tmp30_ = ccritical;

1101

_tmp31_ = domain_name;

1102

vala_ccode_function_call_add_argument (_tmp30_, (ValaCCodeExpression*) _tmp31_);

1103

_tmp32_ = ccritical;

1104

_tmp33_ = inner_error;

1105

_tmp34_ = vala_ccode_member_access_new_pointer (_tmp33_, "code");

1106

_tmp35_ = _tmp34_;

1107

vala_ccode_function_call_add_argument (_tmp32_, (ValaCCodeExpression*) _tmp35_);

1108

_vala_ccode_node_unref0 (_tmp35_);

1109

_tmp36_ = vala_ccode_identifier_new ("g_clear_error");

1110

_tmp37_ = _tmp36_;

1111

_tmp38_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp37_);

1112

_tmp39_ = _tmp38_;

1113

_vala_ccode_node_unref0 (_tmp37_);

1114

cclear = _tmp39_;

1115

_tmp40_ = cclear;

1116

_tmp41_ = inner_error;

1117

_tmp42_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, _tmp41_);

1118

_tmp43_ = _tmp42_;

1119

vala_ccode_function_call_add_argument (_tmp40_, (ValaCCodeExpression*) _tmp43_);

1120

_vala_ccode_node_unref0 (_tmp43_);

1121

_tmp44_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

1122

_tmp45_ = _tmp44_;

1123

_tmp46_ = ccritical;

1124

vala_ccode_function_add_expression (_tmp45_, (ValaCCodeExpression*) _tmp46_);

1125

_tmp47_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

1126

_tmp48_ = _tmp47_;

1127

_tmp49_ = cclear;

1128

vala_ccode_function_add_expression (_tmp48_, (ValaCCodeExpression*) _tmp49_);

1129

_tmp51_ = vala_ccode_base_module_is_in_constructor ((ValaCCodeBaseModule*) self);

1130

if (_tmp51_) {

1131

_tmp50_ = TRUE;

1132

} else {

1133

gboolean _tmp52_ = FALSE;

1134

_tmp52_ = vala_ccode_base_module_is_in_destructor ((ValaCCodeBaseModule*) self);

1135

_tmp50_ = _tmp52_;

1136

}

1137

_tmp53_ = _tmp50_;

1138

if (_tmp53_) {

1139

} else {

1140

ValaMethod* _tmp54_;

1141

ValaMethod* _tmp55_;

1142

_tmp54_ = vala_ccode_base_module_get_current_method ((ValaCCodeBaseModule*) self);

1143

_tmp55_ = _tmp54_;

1144

if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp55_, VALA_TYPE_CREATION_METHOD)) {

1145

ValaMethod* _tmp56_;

1146

ValaMethod* _tmp57_;

1147

ValaSymbol* _tmp58_;

1148

ValaSymbol* _tmp59_;

1149

_tmp56_ = vala_ccode_base_module_get_current_method ((ValaCCodeBaseModule*) self);

1150

_tmp57_ = _tmp56_;

1151

_tmp58_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp57_);

1152

_tmp59_ = _tmp58_;

1153

if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp59_, VALA_TYPE_STRUCT)) {

1154

ValaCCodeFunction* _tmp60_;

1155

ValaCCodeFunction* _tmp61_;

1156

_tmp60_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

1157

_tmp61_ = _tmp60_;

1158

vala_ccode_function_add_return (_tmp61_, NULL);

1159

} else {

1160

ValaCCodeFunction* _tmp62_;

1161

ValaCCodeFunction* _tmp63_;

1162

ValaCCodeConstant* _tmp64_;

1163

ValaCCodeConstant* _tmp65_;

1164

_tmp62_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

1165

_tmp63_ = _tmp62_;

1166

_tmp64_ = vala_ccode_constant_new ("NULL");

1167

_tmp65_ = _tmp64_;

1168

vala_ccode_function_add_return (_tmp63_, (ValaCCodeExpression*) _tmp65_);

1169

_vala_ccode_node_unref0 (_tmp65_);

1170

}

1171

} else {

1172

gboolean _tmp66_ = FALSE;

1173

_tmp66_ = vala_ccode_base_module_is_in_coroutine ((ValaCCodeBaseModule*) self);

1174

if (_tmp66_) {

1175

ValaCCodeFunction* _tmp67_;

1176

ValaCCodeFunction* _tmp68_;

1177

ValaCCodeConstant* _tmp69_;

1178

ValaCCodeConstant* _tmp70_;

1179

_tmp67_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

1180

_tmp68_ = _tmp67_;

1181

_tmp69_ = vala_ccode_constant_new ("FALSE");

1182

_tmp70_ = _tmp69_;

1183

vala_ccode_function_add_return (_tmp68_, (ValaCCodeExpression*) _tmp70_);

1184

_vala_ccode_node_unref0 (_tmp70_);

1185

} else {

1186

ValaDataType* _tmp71_;

1187

ValaDataType* _tmp72_;

1188

_tmp71_ = vala_ccode_base_module_get_current_return_type ((ValaCCodeBaseModule*) self);

1189

_tmp72_ = _tmp71_;

1190

if (_tmp72_ != NULL) {

1191

ValaDataType* _tmp73_;

1192

ValaDataType* _tmp74_;

1193

_tmp73_ = vala_ccode_base_module_get_current_return_type ((ValaCCodeBaseModule*) self);

1194

_tmp74_ = _tmp73_;

1195

vala_ccode_base_module_return_default_value ((ValaCCodeBaseModule*) self, _tmp74_);

1196

}

1197

}

1198

}

1199

}

1200

_vala_ccode_node_unref0 (cclear);

1201

_vala_ccode_node_unref0 (domain_name);

1202

_vala_ccode_node_unref0 (ccritical);

1203

}

1204

1205

1206

static gboolean vala_gerror_module_in_finally_block (ValaGErrorModule* self, ValaCodeNode* node) {

1207

gboolean result = FALSE;

1208

ValaCodeNode* _tmp0_;

1209

ValaCodeNode* _tmp1_;

1210

ValaCodeNode* current_node;

1211

g_return_val_if_fail (self != NULL, FALSE);

1212

g_return_val_if_fail (node != NULL, FALSE);

1213

_tmp0_ = node;

1214

_tmp1_ = _vala_code_node_ref0 (_tmp0_);

1215

current_node = _tmp1_;

1216

while (TRUE) {

1217

ValaCodeNode* _tmp2_;

1218

ValaCodeNode* _tmp3_;

1219

ValaCodeNode* _tmp4_;

1220

ValaCodeNode* _tmp5_;

1221

ValaTryStatement* _tmp6_;

1222

ValaTryStatement* try_stmt;

1223

gboolean _tmp7_ = FALSE;

1224

ValaTryStatement* _tmp8_;

1225

gboolean _tmp13_;

1226

ValaCodeNode* _tmp14_;

1227

ValaCodeNode* _tmp15_;

1228

ValaCodeNode* _tmp16_;

1229

ValaCodeNode* _tmp17_;

1230

_tmp2_ = current_node;

1231

if (!(_tmp2_ != NULL)) {

1232

break;

1233

}

1234

_tmp3_ = current_node;

1235

_tmp4_ = vala_code_node_get_parent_node (_tmp3_);

1236

_tmp5_ = _tmp4_;

1237

_tmp6_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp5_, VALA_TYPE_TRY_STATEMENT) ? ((ValaTryStatement*) _tmp5_) : NULL);

1238

try_stmt = _tmp6_;

1239

_tmp8_ = try_stmt;

1240

if (_tmp8_ != NULL) {

1241

ValaTryStatement* _tmp9_;

1242

ValaBlock* _tmp10_;

1243

ValaBlock* _tmp11_;

1244

ValaCodeNode* _tmp12_;

1245

_tmp9_ = try_stmt;

1246

_tmp10_ = vala_try_statement_get_finally_body (_tmp9_);

1247

_tmp11_ = _tmp10_;

1248

_tmp12_ = current_node;

1249

_tmp7_ = G_TYPE_CHECK_INSTANCE_CAST (_tmp11_, VALA_TYPE_CODE_NODE, ValaCodeNode) == _tmp12_;

1250

} else {

1251

_tmp7_ = FALSE;

1252

}

1253

_tmp13_ = _tmp7_;

1254

if (_tmp13_) {

1255

result = TRUE;

1256

_vala_code_node_unref0 (try_stmt);

1257

_vala_code_node_unref0 (current_node);

1258

return result;

1259

}

1260

_tmp14_ = current_node;

1261

_tmp15_ = vala_code_node_get_parent_node (_tmp14_);

1262

_tmp16_ = _tmp15_;

1263

_tmp17_ = _vala_code_node_ref0 (_tmp16_);

1264

_vala_code_node_unref0 (current_node);

1265

current_node = _tmp17_;

1266

_vala_code_node_unref0 (try_stmt);

1267

}

1268

result = FALSE;

1269

_vala_code_node_unref0 (current_node);

1270

return result;

1271

}

1272

1273

1274

static gpointer _vala_iterable_ref0 (gpointer self) {

1275

return self ? vala_iterable_ref (self) : NULL;

1276

}

1277

1278

1279

static gpointer _vala_ccode_node_ref0 (gpointer self) {

1280

return self ? vala_ccode_node_ref (self) : NULL;

1281

}

1282

1283

1284

static void vala_gerror_module_real_add_simple_check (ValaCCodeBaseModule* base, ValaCodeNode* node, gboolean always_fails) {

1285

ValaGErrorModule * self;

1286

ValaCCodeExpression* _tmp0_ = NULL;

1287

ValaCCodeExpression* inner_error;

1288

gboolean _tmp1_;

1289

ValaTryStatement* _tmp10_;

1290

ValaTryStatement* _tmp11_;

1291

gboolean _tmp221_;

1292

self = (ValaGErrorModule*) base;

1293

g_return_if_fail (node != NULL);

1294

vala_ccode_base_module_set_current_method_inner_error ((ValaCCodeBaseModule*) self, TRUE);

1295

_tmp0_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, "_inner_error_");

1296

inner_error = _tmp0_;

1297

_tmp1_ = always_fails;

1298

if (_tmp1_) {

1299

} else {

1300

ValaCCodeExpression* _tmp2_;

1301

ValaCCodeConstant* _tmp3_;

1302

ValaCCodeConstant* _tmp4_;

1303

ValaCCodeBinaryExpression* _tmp5_;

1304

ValaCCodeBinaryExpression* _tmp6_;

1305

ValaCCodeBinaryExpression* ccond;

1306

ValaCCodeFunction* _tmp7_;

1307

ValaCCodeFunction* _tmp8_;

1308

ValaCCodeBinaryExpression* _tmp9_;

1309

_tmp2_ = inner_error;

1310

_tmp3_ = vala_ccode_constant_new ("NULL");

1311

_tmp4_ = _tmp3_;

1312

_tmp5_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_INEQUALITY, _tmp2_, (ValaCCodeExpression*) _tmp4_);

1313

_tmp6_ = _tmp5_;

1314

_vala_ccode_node_unref0 (_tmp4_);

1315

ccond = _tmp6_;

1316

_tmp7_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

1317

_tmp8_ = _tmp7_;

1318

_tmp9_ = ccond;

1319

vala_ccode_function_open_if (_tmp8_, (ValaCCodeExpression*) _tmp9_);

1320

_vala_ccode_node_unref0 (ccond);

1321

}

1322

_tmp10_ = vala_ccode_base_module_get_current_try ((ValaCCodeBaseModule*) self);

1323

_tmp11_ = _tmp10_;

1324

if (_tmp11_ != NULL) {

1325

gboolean _tmp12_;

1326

GEqualFunc _tmp21_;

1327

ValaArrayList* _tmp22_;

1328

ValaArrayList* error_types;

1329

gboolean has_general_catch_clause;

1330

gboolean _tmp36_;

1331

gboolean _tmp154_;

1332

_tmp12_ = self->priv->is_in_catch;

1333

if (_tmp12_) {

1334

ValaSymbol* _tmp13_;

1335

ValaSymbol* _tmp14_;

1336

ValaCatchClause* _tmp15_;

1337

ValaCatchClause* _tmp16_;

1338

_tmp13_ = vala_ccode_base_module_get_current_symbol ((ValaCCodeBaseModule*) self);

1339

_tmp14_ = _tmp13_;

1340

_tmp15_ = vala_ccode_base_module_get_current_catch ((ValaCCodeBaseModule*) self);

1341

_tmp16_ = _tmp15_;

1342

vala_ccode_base_module_append_local_free ((ValaCCodeBaseModule*) self, _tmp14_, FALSE, (ValaCodeNode*) _tmp16_);

1343

} else {

1344

ValaSymbol* _tmp17_;

1345

ValaSymbol* _tmp18_;

1346

ValaTryStatement* _tmp19_;

1347

ValaTryStatement* _tmp20_;

1348

_tmp17_ = vala_ccode_base_module_get_current_symbol ((ValaCCodeBaseModule*) self);

1349

_tmp18_ = _tmp17_;

1350

_tmp19_ = vala_ccode_base_module_get_current_try ((ValaCCodeBaseModule*) self);

1351

_tmp20_ = _tmp19_;

1352

vala_ccode_base_module_append_local_free ((ValaCCodeBaseModule*) self, _tmp18_, FALSE, (ValaCodeNode*) _tmp20_);

1353

}

1354

_tmp21_ = g_direct_equal;

1355

_tmp22_ = vala_array_list_new (VALA_TYPE_DATA_TYPE, (GBoxedCopyFunc) vala_code_node_ref, vala_code_node_unref, _tmp21_);

1356

error_types = _tmp22_;

1357

{

1358

ValaCodeNode* _tmp23_;

1359

ValaList* _tmp24_ = NULL;

1360

ValaList* _node_error_type_list;

1361

ValaList* _tmp25_;

1362

gint _tmp26_;

1363

gint _tmp27_;

1364

gint _node_error_type_size;

1365

gint _node_error_type_index;

1366

_tmp23_ = node;

1367

_tmp24_ = vala_code_node_get_error_types (_tmp23_);

1368

_node_error_type_list = _tmp24_;

1369

_tmp25_ = _node_error_type_list;

1370

_tmp26_ = vala_collection_get_size ((ValaCollection*) _tmp25_);

1371

_tmp27_ = _tmp26_;

1372

_node_error_type_size = _tmp27_;

1373

_node_error_type_index = -1;

1374

while (TRUE) {

1375

gint _tmp28_;

1376

gint _tmp29_;

1377

gint _tmp30_;

1378

ValaList* _tmp31_;

1379

gint _tmp32_;

1380

gpointer _tmp33_ = NULL;

1381

ValaDataType* node_error_type;

1382

ValaArrayList* _tmp34_;

1383

ValaDataType* _tmp35_;

1384

_tmp28_ = _node_error_type_index;

1385

_node_error_type_index = _tmp28_ + 1;

1386

_tmp29_ = _node_error_type_index;

1387

_tmp30_ = _node_error_type_size;

1388

if (!(_tmp29_ < _tmp30_)) {

1389

break;

1390

}

1391

_tmp31_ = _node_error_type_list;

1392

_tmp32_ = _node_error_type_index;

1393

_tmp33_ = vala_list_get (_tmp31_, _tmp32_);

1394

node_error_type = (ValaDataType*) _tmp33_;

1395

_tmp34_ = error_types;

1396

_tmp35_ = node_error_type;

1397

vala_collection_add ((ValaCollection*) _tmp34_, _tmp35_);

1398

_vala_code_node_unref0 (node_error_type);

1399

}

1400

_vala_iterable_unref0 (_node_error_type_list);

1401

}

1402

has_general_catch_clause = FALSE;

1403

_tmp36_ = self->priv->is_in_catch;

1404

if (!_tmp36_) {

1405

GEqualFunc _tmp37_;

1406

ValaArrayList* _tmp38_;

1407

ValaArrayList* handled_error_types;

1408

_tmp37_ = g_direct_equal;

1409

_tmp38_ = vala_array_list_new (VALA_TYPE_DATA_TYPE, (GBoxedCopyFunc) vala_code_node_ref, vala_code_node_unref, _tmp37_);

1410

handled_error_types = _tmp38_;

1411

{

1412

ValaTryStatement* _tmp39_;

1413

ValaTryStatement* _tmp40_;

1414

ValaList* _tmp41_ = NULL;

1415

ValaList* _clause_list;

1416

ValaList* _tmp42_;

1417

gint _tmp43_;

1418

gint _tmp44_;

1419

gint _clause_size;

1420

gint _clause_index;

1421

_tmp39_ = vala_ccode_base_module_get_current_try ((ValaCCodeBaseModule*) self);

1422

_tmp40_ = _tmp39_;

1423

_tmp41_ = vala_try_statement_get_catch_clauses (_tmp40_);

1424

_clause_list = _tmp41_;

1425

_tmp42_ = _clause_list;

1426

_tmp43_ = vala_collection_get_size ((ValaCollection*) _tmp42_);

1427

_tmp44_ = _tmp43_;

1428

_clause_size = _tmp44_;

1429

_clause_index = -1;

1430

while (TRUE) {

1431

gint _tmp45_;

1432

gint _tmp46_;

1433

gint _tmp47_;

1434

ValaList* _tmp48_;

1435

gint _tmp49_;

1436

gpointer _tmp50_ = NULL;

1437

ValaCatchClause* clause;

1438

ValaArrayList* _tmp87_;

1439

ValaCatchClause* _tmp88_;

1440

ValaDataType* _tmp89_;

1441

ValaDataType* _tmp90_;

1442

ValaErrorType* _tmp91_;

1443

gboolean _tmp92_ = FALSE;

1444

_tmp45_ = _clause_index;

1445

_clause_index = _tmp45_ + 1;

1446

_tmp46_ = _clause_index;

1447

_tmp47_ = _clause_size;

1448

if (!(_tmp46_ < _tmp47_)) {

1449

break;

1450

}

1451

_tmp48_ = _clause_list;

1452

_tmp49_ = _clause_index;

1453

_tmp50_ = vala_list_get (_tmp48_, _tmp49_);

1454

clause = (ValaCatchClause*) _tmp50_;

1455

{

1456

ValaArrayList* _tmp51_;

1457

ValaArrayList* _tmp52_;

1458

ValaArrayList* _node_error_type_list;

1459

ValaArrayList* _tmp53_;

1460

gint _tmp54_;

1461

gint _tmp55_;

1462

gint _node_error_type_size;

1463

gint _node_error_type_index;

1464

_tmp51_ = error_types;

1465

_tmp52_ = _vala_iterable_ref0 (_tmp51_);

1466

_node_error_type_list = _tmp52_;

1467

_tmp53_ = _node_error_type_list;

1468

_tmp54_ = vala_collection_get_size ((ValaCollection*) _tmp53_);

1469

_tmp55_ = _tmp54_;

1470

_node_error_type_size = _tmp55_;

1471

_node_error_type_index = -1;

1472

while (TRUE) {

1473

gint _tmp56_;

1474

gint _tmp57_;

1475

gint _tmp58_;

1476

ValaArrayList* _tmp59_;

1477

gint _tmp60_;

1478

gpointer _tmp61_ = NULL;

1479

ValaDataType* node_error_type;

1480

gboolean _tmp62_ = FALSE;

1481

ValaCatchClause* _tmp63_;

1482

ValaDataType* _tmp64_;

1483

ValaDataType* _tmp65_;

1484

gboolean _tmp71_;

1485

_tmp56_ = _node_error_type_index;

1486

_node_error_type_index = _tmp56_ + 1;

1487

_tmp57_ = _node_error_type_index;

1488

_tmp58_ = _node_error_type_size;

1489

if (!(_tmp57_ < _tmp58_)) {

1490

break;

1491

}

1492

_tmp59_ = _node_error_type_list;

1493

_tmp60_ = _node_error_type_index;

1494

_tmp61_ = vala_list_get ((ValaList*) _tmp59_, _tmp60_);

1495

node_error_type = (ValaDataType*) _tmp61_;

1496

_tmp63_ = clause;

1497

_tmp64_ = vala_catch_clause_get_error_type (_tmp63_);

1498

_tmp65_ = _tmp64_;

1499

if (_tmp65_ == NULL) {

1500

_tmp62_ = TRUE;

1501

} else {

1502

ValaDataType* _tmp66_;

1503

ValaCatchClause* _tmp67_;

1504

ValaDataType* _tmp68_;

1505

ValaDataType* _tmp69_;

1506

gboolean _tmp70_ = FALSE;

1507

_tmp66_ = node_error_type;

1508

_tmp67_ = clause;

1509

_tmp68_ = vala_catch_clause_get_error_type (_tmp67_);

1510

_tmp69_ = _tmp68_;

1511

_tmp70_ = vala_data_type_compatible (_tmp66_, _tmp69_);

1512

_tmp62_ = _tmp70_;

1513

}

1514

_tmp71_ = _tmp62_;

1515

if (_tmp71_) {

1516

ValaArrayList* _tmp72_;

1517

ValaDataType* _tmp73_;

1518

_tmp72_ = handled_error_types;

1519

_tmp73_ = node_error_type;

1520

vala_collection_add ((ValaCollection*) _tmp72_, _tmp73_);

1521

}

1522

_vala_code_node_unref0 (node_error_type);

1523

}

1524

_vala_iterable_unref0 (_node_error_type_list);

1525

}

1526

{

1527

ValaArrayList* _tmp74_;

1528

ValaArrayList* _tmp75_;

1529

ValaArrayList* _handled_error_type_list;

1530

ValaArrayList* _tmp76_;

1531

gint _tmp77_;

1532

gint _tmp78_;

1533

gint _handled_error_type_size;

1534

gint _handled_error_type_index;

1535

_tmp74_ = handled_error_types;

1536

_tmp75_ = _vala_iterable_ref0 (_tmp74_);

1537

_handled_error_type_list = _tmp75_;

1538

_tmp76_ = _handled_error_type_list;

1539

_tmp77_ = vala_collection_get_size ((ValaCollection*) _tmp76_);

1540

_tmp78_ = _tmp77_;

1541

_handled_error_type_size = _tmp78_;

1542

_handled_error_type_index = -1;

1543

while (TRUE) {

1544

gint _tmp79_;

1545

gint _tmp80_;

1546

gint _tmp81_;

1547

ValaArrayList* _tmp82_;

1548

gint _tmp83_;

1549

gpointer _tmp84_ = NULL;

1550

ValaDataType* handled_error_type;

1551

ValaArrayList* _tmp85_;

1552

ValaDataType* _tmp86_;

1553

_tmp79_ = _handled_error_type_index;

1554

_handled_error_type_index = _tmp79_ + 1;

1555

_tmp80_ = _handled_error_type_index;

1556

_tmp81_ = _handled_error_type_size;

1557

if (!(_tmp80_ < _tmp81_)) {

1558

break;

1559

}

1560

_tmp82_ = _handled_error_type_list;

1561

_tmp83_ = _handled_error_type_index;

1562

_tmp84_ = vala_list_get ((ValaList*) _tmp82_, _tmp83_);

1563

handled_error_type = (ValaDataType*) _tmp84_;

1564

_tmp85_ = error_types;

1565

_tmp86_ = handled_error_type;

1566

vala_collection_remove ((ValaCollection*) _tmp85_, _tmp86_);

1567

_vala_code_node_unref0 (handled_error_type);

1568

}

1569

_vala_iterable_unref0 (_handled_error_type_list);

1570

}

1571

_tmp87_ = handled_error_types;

1572

vala_collection_clear ((ValaCollection*) _tmp87_);

1573

_tmp88_ = clause;

1574

_tmp89_ = vala_catch_clause_get_error_type (_tmp88_);

1575

_tmp90_ = _tmp89_;

1576

_tmp91_ = ((ValaCCodeBaseModule*) self)->gerror_type;

1577

_tmp92_ = vala_data_type_equals (_tmp90_, (ValaDataType*) _tmp91_);

1578

if (_tmp92_) {

1579

ValaCCodeFunction* _tmp93_;

1580

ValaCCodeFunction* _tmp94_;

1581

ValaCatchClause* _tmp95_;

1582

const gchar* _tmp96_;

1583

const gchar* _tmp97_;

1584

has_general_catch_clause = TRUE;

1585

_tmp93_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

1586

_tmp94_ = _tmp93_;

1587

_tmp95_ = clause;

1588

_tmp96_ = vala_catch_clause_get_clabel_name (_tmp95_);

1589

_tmp97_ = _tmp96_;

1590

vala_ccode_function_add_goto (_tmp94_, _tmp97_);

1591

_vala_code_node_unref0 (clause);

1592

break;

1593

} else {

1594

ValaCatchClause* _tmp98_;

1595

ValaDataType* _tmp99_;

1596

ValaDataType* _tmp100_;

1597

ValaErrorType* _tmp101_;

1598

ValaErrorType* catch_type;

1599

ValaErrorType* _tmp102_;

1600

ValaErrorCode* _tmp103_;

1601

ValaErrorCode* _tmp104_;

1602

ValaCCodeFunction* _tmp147_;

1603

ValaCCodeFunction* _tmp148_;

1604

ValaCatchClause* _tmp149_;

1605

const gchar* _tmp150_;

1606

const gchar* _tmp151_;

1607

ValaCCodeFunction* _tmp152_;

1608

ValaCCodeFunction* _tmp153_;

1609

_tmp98_ = clause;

1610

_tmp99_ = vala_catch_clause_get_error_type (_tmp98_);

1611

_tmp100_ = _tmp99_;

1612

_tmp101_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp100_, VALA_TYPE_ERROR_TYPE) ? ((ValaErrorType*) _tmp100_) : NULL);

1613

catch_type = _tmp101_;

1614

_tmp102_ = catch_type;

1615

_tmp103_ = vala_error_type_get_error_code (_tmp102_);

1616

_tmp104_ = _tmp103_;

1617

if (_tmp104_ != NULL) {

1618

ValaCCodeIdentifier* _tmp105_;

1619

ValaCCodeIdentifier* _tmp106_;

1620

ValaCCodeFunctionCall* _tmp107_;

1621

ValaCCodeFunctionCall* _tmp108_;

1622

ValaCCodeFunctionCall* error_match;

1623

ValaCCodeFunctionCall* _tmp109_;

1624

ValaCCodeExpression* _tmp110_;

1625

ValaCCodeFunctionCall* _tmp111_;

1626

ValaErrorType* _tmp112_;

1627

ValaTypeSymbol* _tmp113_;

1628

ValaTypeSymbol* _tmp114_;

1629

gchar* _tmp115_ = NULL;

1630

gchar* _tmp116_;

1631

ValaCCodeIdentifier* _tmp117_;

1632

ValaCCodeIdentifier* _tmp118_;

1633

ValaCCodeFunctionCall* _tmp119_;

1634

ValaErrorType* _tmp120_;

1635

ValaErrorCode* _tmp121_;

1636

ValaErrorCode* _tmp122_;

1637

gchar* _tmp123_ = NULL;

1638

gchar* _tmp124_;

1639

ValaCCodeIdentifier* _tmp125_;

1640

ValaCCodeIdentifier* _tmp126_;

1641

ValaCCodeFunction* _tmp127_;

1642

ValaCCodeFunction* _tmp128_;

1643

ValaCCodeFunctionCall* _tmp129_;

1644

_tmp105_ = vala_ccode_identifier_new ("g_error_matches");

1645

_tmp106_ = _tmp105_;

1646

_tmp107_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp106_);

1647

_tmp108_ = _tmp107_;

1648

_vala_ccode_node_unref0 (_tmp106_);

1649

error_match = _tmp108_;

1650

_tmp109_ = error_match;

1651

_tmp110_ = inner_error;

1652

vala_ccode_function_call_add_argument (_tmp109_, _tmp110_);

1653

_tmp111_ = error_match;

1654

_tmp112_ = catch_type;

1655

_tmp113_ = vala_data_type_get_data_type ((ValaDataType*) _tmp112_);

1656

_tmp114_ = _tmp113_;

1657

_tmp115_ = vala_ccode_base_module_get_ccode_upper_case_name ((ValaSymbol*) _tmp114_, NULL);

1658

_tmp116_ = _tmp115_;

1659

_tmp117_ = vala_ccode_identifier_new (_tmp116_);

1660

_tmp118_ = _tmp117_;

1661

vala_ccode_function_call_add_argument (_tmp111_, (ValaCCodeExpression*) _tmp118_);

1662

_vala_ccode_node_unref0 (_tmp118_);

1663

_g_free0 (_tmp116_);

1664

_tmp119_ = error_match;

1665

_tmp120_ = catch_type;

1666

_tmp121_ = vala_error_type_get_error_code (_tmp120_);

1667

_tmp122_ = _tmp121_;

1668

_tmp123_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp122_);

1669

_tmp124_ = _tmp123_;

1670

_tmp125_ = vala_ccode_identifier_new (_tmp124_);

1671

_tmp126_ = _tmp125_;

1672

vala_ccode_function_call_add_argument (_tmp119_, (ValaCCodeExpression*) _tmp126_);

1673

_vala_ccode_node_unref0 (_tmp126_);

1674

_g_free0 (_tmp124_);

1675

_tmp127_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

1676

_tmp128_ = _tmp127_;

1677

_tmp129_ = error_match;

1678

vala_ccode_function_open_if (_tmp128_, (ValaCCodeExpression*) _tmp129_);

1679

_vala_ccode_node_unref0 (error_match);

1680

} else {

1681

ValaCCodeExpression* _tmp130_;

1682

ValaCCodeMemberAccess* _tmp131_;

1683

ValaCCodeMemberAccess* _tmp132_;

1684

ValaCatchClause* _tmp133_;

1685

ValaDataType* _tmp134_;

1686

ValaDataType* _tmp135_;

1687

ValaTypeSymbol* _tmp136_;

1688

ValaTypeSymbol* _tmp137_;

1689

gchar* _tmp138_ = NULL;

1690

gchar* _tmp139_;

1691

ValaCCodeIdentifier* _tmp140_;

1692

ValaCCodeIdentifier* _tmp141_;

1693

ValaCCodeBinaryExpression* _tmp142_;

1694

ValaCCodeBinaryExpression* _tmp143_;

1695

ValaCCodeBinaryExpression* ccond;

1696

ValaCCodeFunction* _tmp144_;

1697

ValaCCodeFunction* _tmp145_;

1698

ValaCCodeBinaryExpression* _tmp146_;

1699

_tmp130_ = inner_error;

1700

_tmp131_ = vala_ccode_member_access_new_pointer (_tmp130_, "domain");

1701

_tmp132_ = _tmp131_;

1702

_tmp133_ = clause;

1703

_tmp134_ = vala_catch_clause_get_error_type (_tmp133_);

1704

_tmp135_ = _tmp134_;

1705

_tmp136_ = vala_data_type_get_data_type (_tmp135_);

1706

_tmp137_ = _tmp136_;

1707

_tmp138_ = vala_ccode_base_module_get_ccode_upper_case_name ((ValaSymbol*) _tmp137_, NULL);

1708

_tmp139_ = _tmp138_;

1709

_tmp140_ = vala_ccode_identifier_new (_tmp139_);

1710

_tmp141_ = _tmp140_;

1711

_tmp142_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_EQUALITY, (ValaCCodeExpression*) _tmp132_, (ValaCCodeExpression*) _tmp141_);

1712

_tmp143_ = _tmp142_;

1713

_vala_ccode_node_unref0 (_tmp141_);

1714

_g_free0 (_tmp139_);

1715

_vala_ccode_node_unref0 (_tmp132_);

1716

ccond = _tmp143_;

1717

_tmp144_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

1718

_tmp145_ = _tmp144_;

1719

_tmp146_ = ccond;

1720

vala_ccode_function_open_if (_tmp145_, (ValaCCodeExpression*) _tmp146_);

1721

_vala_ccode_node_unref0 (ccond);

1722

}

1723

_tmp147_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

1724

_tmp148_ = _tmp147_;

1725

_tmp149_ = clause;

1726

_tmp150_ = vala_catch_clause_get_clabel_name (_tmp149_);

1727

_tmp151_ = _tmp150_;

1728

vala_ccode_function_add_goto (_tmp148_, _tmp151_);

1729

_tmp152_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

1730

_tmp153_ = _tmp152_;

1731

vala_ccode_function_close (_tmp153_);

1732

_vala_code_node_unref0 (catch_type);

1733

}

1734

_vala_code_node_unref0 (clause);

1735

}

1736

_vala_iterable_unref0 (_clause_list);

1737

}

1738

_vala_iterable_unref0 (handled_error_types);

1739

}

1740

_tmp154_ = has_general_catch_clause;

1741

if (_tmp154_) {

1742

} else {

1743

ValaArrayList* _tmp155_;

1744

gint _tmp156_;

1745

gint _tmp157_;

1746

_tmp155_ = error_types;

1747

_tmp156_ = vala_collection_get_size ((ValaCollection*) _tmp155_);

1748

_tmp157_ = _tmp156_;

1749

if (_tmp157_ > 0) {

1750

ValaCCodeFunction* _tmp158_;

1751

ValaCCodeFunction* _tmp159_;

1752

gint _tmp160_;

1753

gchar* _tmp161_ = NULL;

1754

gchar* _tmp162_;

1755

_tmp158_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

1756

_tmp159_ = _tmp158_;

1757

_tmp160_ = self->priv->current_try_id;

1758

_tmp161_ = g_strdup_printf ("__finally%d", _tmp160_);

1759

_tmp162_ = _tmp161_;

1760

vala_ccode_function_add_goto (_tmp159_, _tmp162_);

1761

_g_free0 (_tmp162_);

1762

} else {

1763

ValaCodeNode* _tmp163_;

1764

gboolean _tmp164_ = FALSE;

1765

_tmp163_ = node;

1766

_tmp164_ = vala_gerror_module_in_finally_block (self, _tmp163_);

1767

if (_tmp164_) {

1768

} else {

1769

ValaCCodeExpression* _tmp165_;

1770

_tmp165_ = inner_error;

1771

vala_gerror_module_uncaught_error_statement (self, _tmp165_, TRUE);

1772

}

1773

}

1774

}

1775

_vala_iterable_unref0 (error_types);

1776

} else {

1777

gboolean _tmp166_ = FALSE;

1778

ValaMethod* _tmp167_;

1779

ValaMethod* _tmp168_;

1780

gboolean _tmp175_;

1781

_tmp167_ = vala_ccode_base_module_get_current_method ((ValaCCodeBaseModule*) self);

1782

_tmp168_ = _tmp167_;

1783

if (_tmp168_ != NULL) {

1784

ValaMethod* _tmp169_;

1785

ValaMethod* _tmp170_;

1786

ValaList* _tmp171_ = NULL;

1787

ValaList* _tmp172_;

1788

gint _tmp173_;

1789

gint _tmp174_;

1790

_tmp169_ = vala_ccode_base_module_get_current_method ((ValaCCodeBaseModule*) self);

1791

_tmp170_ = _tmp169_;

1792

_tmp171_ = vala_code_node_get_error_types ((ValaCodeNode*) _tmp170_);

1793

_tmp172_ = _tmp171_;

1794

_tmp173_ = vala_collection_get_size ((ValaCollection*) _tmp172_);

1795

_tmp174_ = _tmp173_;

1796

_tmp166_ = _tmp174_ > 0;

1797

_vala_iterable_unref0 (_tmp172_);

1798

} else {

1799

_tmp166_ = FALSE;

1800

}

1801

_tmp175_ = _tmp166_;

1802

if (_tmp175_) {

1803

ValaCCodeBinaryExpression* ccond;

1804

ValaCCodeBinaryExpression* _tmp209_;

1805

ccond = NULL;

1806

{

1807

ValaMethod* _tmp176_;

1808

ValaMethod* _tmp177_;

1809

ValaList* _tmp178_ = NULL;

1810

ValaList* _error_type_list;

1811

ValaList* _tmp179_;

1812

gint _tmp180_;

1813

gint _tmp181_;

1814

gint _error_type_size;

1815

gint _error_type_index;

1816

_tmp176_ = vala_ccode_base_module_get_current_method ((ValaCCodeBaseModule*) self);

1817

_tmp177_ = _tmp176_;

1818

_tmp178_ = vala_code_node_get_error_types ((ValaCodeNode*) _tmp177_);

1819

_error_type_list = _tmp178_;

1820

_tmp179_ = _error_type_list;

1821

_tmp180_ = vala_collection_get_size ((ValaCollection*) _tmp179_);

1822

_tmp181_ = _tmp180_;

1823

_error_type_size = _tmp181_;

1824

_error_type_index = -1;

1825

while (TRUE) {

1826

gint _tmp182_;

1827

gint _tmp183_;

1828

gint _tmp184_;

1829

ValaList* _tmp185_;

1830

gint _tmp186_;

1831

gpointer _tmp187_ = NULL;

1832

ValaDataType* error_type;

1833

ValaDataType* _tmp188_;

1834

ValaErrorType* _tmp189_;

1835

gboolean _tmp190_ = FALSE;

1836

ValaCCodeExpression* _tmp191_;

1837

ValaCCodeMemberAccess* _tmp192_;

1838

ValaCCodeMemberAccess* _tmp193_;

1839

ValaDataType* _tmp194_;

1840

ValaTypeSymbol* _tmp195_;

1841

ValaTypeSymbol* _tmp196_;

1842

gchar* _tmp197_ = NULL;

1843

gchar* _tmp198_;

1844

ValaCCodeIdentifier* _tmp199_;

1845

ValaCCodeIdentifier* _tmp200_;

1846

ValaCCodeBinaryExpression* _tmp201_;

1847

ValaCCodeBinaryExpression* _tmp202_;

1848

ValaCCodeBinaryExpression* domain_check;

1849

ValaCCodeBinaryExpression* _tmp203_;

1850

_tmp182_ = _error_type_index;

1851

_error_type_index = _tmp182_ + 1;

1852

_tmp183_ = _error_type_index;

1853

_tmp184_ = _error_type_size;

1854

if (!(_tmp183_ < _tmp184_)) {

1855

break;

1856

}

1857

_tmp185_ = _error_type_list;

1858

_tmp186_ = _error_type_index;

1859

_tmp187_ = vala_list_get (_tmp185_, _tmp186_);

1860

error_type = (ValaDataType*) _tmp187_;

1861

_tmp188_ = error_type;

1862

_tmp189_ = ((ValaCCodeBaseModule*) self)->gerror_type;

1863

_tmp190_ = vala_data_type_equals (_tmp188_, (ValaDataType*) _tmp189_);

1864

if (_tmp190_) {

1865

_vala_ccode_node_unref0 (ccond);

1866

ccond = NULL;

1867

_vala_code_node_unref0 (error_type);

1868

break;

1869

}

1870

_tmp191_ = inner_error;

1871

_tmp192_ = vala_ccode_member_access_new_pointer (_tmp191_, "domain");

1872

_tmp193_ = _tmp192_;

1873

_tmp194_ = error_type;

1874

_tmp195_ = vala_data_type_get_data_type (_tmp194_);

1875

_tmp196_ = _tmp195_;

1876

_tmp197_ = vala_ccode_base_module_get_ccode_upper_case_name ((ValaSymbol*) _tmp196_, NULL);

1877

_tmp198_ = _tmp197_;

1878

_tmp199_ = vala_ccode_identifier_new (_tmp198_);

1879

_tmp200_ = _tmp199_;

1880

_tmp201_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_EQUALITY, (ValaCCodeExpression*) _tmp193_, (ValaCCodeExpression*) _tmp200_);

1881

_tmp202_ = _tmp201_;

1882

_vala_ccode_node_unref0 (_tmp200_);

1883

_g_free0 (_tmp198_);

1884

_vala_ccode_node_unref0 (_tmp193_);

1885

domain_check = _tmp202_;

1886

_tmp203_ = ccond;

1887

if (_tmp203_ == NULL) {

1888

ValaCCodeBinaryExpression* _tmp204_;

1889

ValaCCodeBinaryExpression* _tmp205_;

1890

_tmp204_ = domain_check;

1891

_tmp205_ = _vala_ccode_node_ref0 (_tmp204_);

1892

_vala_ccode_node_unref0 (ccond);

1893

ccond = _tmp205_;

1894

} else {

1895

ValaCCodeBinaryExpression* _tmp206_;

1896

ValaCCodeBinaryExpression* _tmp207_;

1897

ValaCCodeBinaryExpression* _tmp208_;

1898

_tmp206_ = ccond;

1899

_tmp207_ = domain_check;

1900

_tmp208_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_OR, (ValaCCodeExpression*) _tmp206_, (ValaCCodeExpression*) _tmp207_);

1901

_vala_ccode_node_unref0 (ccond);

1902

ccond = _tmp208_;

1903

}

1904

_vala_ccode_node_unref0 (domain_check);

1905

_vala_code_node_unref0 (error_type);

1906

}

1907

_vala_iterable_unref0 (_error_type_list);

1908

}

1909

_tmp209_ = ccond;

1910

if (_tmp209_ != NULL) {

1911

ValaCCodeFunction* _tmp210_;

1912

ValaCCodeFunction* _tmp211_;

1913

ValaCCodeBinaryExpression* _tmp212_;

1914

ValaCCodeExpression* _tmp213_;

1915

ValaCCodeFunction* _tmp214_;

1916

ValaCCodeFunction* _tmp215_;

1917

ValaCCodeExpression* _tmp216_;

1918

ValaCCodeFunction* _tmp217_;

1919

ValaCCodeFunction* _tmp218_;

1920

_tmp210_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

1921

_tmp211_ = _tmp210_;

1922

_tmp212_ = ccond;

1923

vala_ccode_function_open_if (_tmp211_, (ValaCCodeExpression*) _tmp212_);

1924

_tmp213_ = inner_error;

1925

vala_gerror_module_return_with_exception (self, _tmp213_);

1926

_tmp214_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

1927

_tmp215_ = _tmp214_;

1928

vala_ccode_function_add_else (_tmp215_);

1929

_tmp216_ = inner_error;

1930

vala_gerror_module_uncaught_error_statement (self, _tmp216_, FALSE);

1931

_tmp217_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

1932

_tmp218_ = _tmp217_;

1933

vala_ccode_function_close (_tmp218_);

1934

} else {

1935

ValaCCodeExpression* _tmp219_;

1936

_tmp219_ = inner_error;

1937

vala_gerror_module_return_with_exception (self, _tmp219_);

1938

}

1939

_vala_ccode_node_unref0 (ccond);

1940

} else {

1941

ValaCCodeExpression* _tmp220_;

1942

_tmp220_ = inner_error;

1943

vala_gerror_module_uncaught_error_statement (self, _tmp220_, FALSE);

1944

}

1945

}

1946

_tmp221_ = always_fails;

1947

if (!_tmp221_) {

1948

ValaCCodeFunction* _tmp222_;

1949

ValaCCodeFunction* _tmp223_;

1950

_tmp222_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

1951

_tmp223_ = _tmp222_;

1952

vala_ccode_function_close (_tmp223_);

1953

}

1954

_vala_ccode_node_unref0 (inner_error);

1955

}

1956

1957

1958

static void vala_gerror_module_real_visit_try_statement (ValaCodeVisitor* base, ValaTryStatement* stmt) {

1959

ValaGErrorModule * self;

1960

gint _tmp0_;

1961

gint this_try_id;

1962

ValaTryStatement* _tmp1_;

1963

ValaTryStatement* _tmp2_;

1964

ValaTryStatement* _tmp3_;

1965

ValaTryStatement* old_try;

1966

gint _tmp4_;

1967

gint old_try_id;

1968

gboolean _tmp5_;

1969

gboolean old_is_in_catch;

1970

ValaCatchClause* _tmp6_;

1971

ValaCatchClause* _tmp7_;

1972

ValaCatchClause* _tmp8_;

1973

ValaCatchClause* old_catch;

1974

ValaTryStatement* _tmp9_;

1975

gint _tmp10_;

1976

ValaTryStatement* _tmp31_;

1977

ValaBlock* _tmp32_;

1978

ValaBlock* _tmp33_;

1979

ValaTryStatement* _tmp52_;

1980

gint _tmp53_;

1981

gboolean _tmp54_;

1982

ValaCatchClause* _tmp55_;

1983

ValaCCodeFunction* _tmp56_;

1984

ValaCCodeFunction* _tmp57_;

1985

gint _tmp58_;

1986

gchar* _tmp59_ = NULL;

1987

gchar* _tmp60_;

1988

ValaTryStatement* _tmp61_;

1989

ValaBlock* _tmp62_;

1990

ValaBlock* _tmp63_;

1991

ValaTryStatement* _tmp67_;

1992

ValaTryStatement* _tmp68_;

1993

gboolean _tmp69_;

1994

gboolean _tmp70_;

1995

self = (ValaGErrorModule*) base;

1996

g_return_if_fail (stmt != NULL);

1997

_tmp0_ = self->priv->next_try_id;

1998

self->priv->next_try_id = _tmp0_ + 1;

1999

this_try_id = _tmp0_;

2000

_tmp1_ = vala_ccode_base_module_get_current_try ((ValaCCodeBaseModule*) self);

2001

_tmp2_ = _tmp1_;

2002

_tmp3_ = _vala_code_node_ref0 (_tmp2_);

2003

old_try = _tmp3_;

2004

_tmp4_ = self->priv->current_try_id;

2005

old_try_id = _tmp4_;

2006

_tmp5_ = self->priv->is_in_catch;

2007

old_is_in_catch = _tmp5_;

2008

_tmp6_ = vala_ccode_base_module_get_current_catch ((ValaCCodeBaseModule*) self);

2009

_tmp7_ = _tmp6_;

2010

_tmp8_ = _vala_code_node_ref0 (_tmp7_);

2011

old_catch = _tmp8_;

2012

_tmp9_ = stmt;

2013

vala_ccode_base_module_set_current_try ((ValaCCodeBaseModule*) self, _tmp9_);

2014

_tmp10_ = this_try_id;

2015

self->priv->current_try_id = _tmp10_;

2016

self->priv->is_in_catch = TRUE;

2017

{

2018

ValaTryStatement* _tmp11_;

2019

ValaList* _tmp12_ = NULL;

2020

ValaList* _clause_list;

2021

ValaList* _tmp13_;

2022

gint _tmp14_;

2023

gint _tmp15_;

2024

gint _clause_size;

2025

gint _clause_index;

2026

_tmp11_ = stmt;

2027

_tmp12_ = vala_try_statement_get_catch_clauses (_tmp11_);

2028

_clause_list = _tmp12_;

2029

_tmp13_ = _clause_list;

2030

_tmp14_ = vala_collection_get_size ((ValaCollection*) _tmp13_);

2031

_tmp15_ = _tmp14_;

2032

_clause_size = _tmp15_;

2033

_clause_index = -1;

2034

while (TRUE) {

2035

gint _tmp16_;

2036

gint _tmp17_;

2037

gint _tmp18_;

2038

ValaList* _tmp19_;

2039

gint _tmp20_;

2040

gpointer _tmp21_ = NULL;

2041

ValaCatchClause* clause;

2042

ValaCatchClause* _tmp22_;

2043

gint _tmp23_;

2044

ValaCatchClause* _tmp24_;

2045

ValaDataType* _tmp25_;

2046

ValaDataType* _tmp26_;

2047

gchar* _tmp27_ = NULL;

2048

gchar* _tmp28_;

2049

gchar* _tmp29_ = NULL;

2050

gchar* _tmp30_;

2051

_tmp16_ = _clause_index;

2052

_clause_index = _tmp16_ + 1;

2053

_tmp17_ = _clause_index;

2054

_tmp18_ = _clause_size;

2055

if (!(_tmp17_ < _tmp18_)) {

2056

break;

2057

}

2058

_tmp19_ = _clause_list;

2059

_tmp20_ = _clause_index;

2060

_tmp21_ = vala_list_get (_tmp19_, _tmp20_);

2061

clause = (ValaCatchClause*) _tmp21_;

2062

_tmp22_ = clause;

2063

_tmp23_ = this_try_id;

2064

_tmp24_ = clause;

2065

_tmp25_ = vala_catch_clause_get_error_type (_tmp24_);

2066

_tmp26_ = _tmp25_;

2067

_tmp27_ = vala_ccode_base_module_get_ccode_lower_case_name ((ValaCodeNode*) _tmp26_, NULL);

2068

_tmp28_ = _tmp27_;

2069

_tmp29_ = g_strdup_printf ("__catch%d_%s", _tmp23_, _tmp28_);

2070

_tmp30_ = _tmp29_;

2071

vala_catch_clause_set_clabel_name (_tmp22_, _tmp30_);

2072

_g_free0 (_tmp30_);

2073

_g_free0 (_tmp28_);

2074

_vala_code_node_unref0 (clause);

2075

}

2076

_vala_iterable_unref0 (_clause_list);

2077

}

2078

self->priv->is_in_catch = FALSE;

2079

_tmp31_ = stmt;

2080

_tmp32_ = vala_try_statement_get_body (_tmp31_);

2081

_tmp33_ = _tmp32_;

2082

vala_code_node_emit ((ValaCodeNode*) _tmp33_, (ValaCodeGenerator*) self);

2083

self->priv->is_in_catch = TRUE;

2084

{

2085

ValaTryStatement* _tmp34_;

2086

ValaList* _tmp35_ = NULL;

2087

ValaList* _clause_list;

2088

ValaList* _tmp36_;

2089

gint _tmp37_;

2090

gint _tmp38_;

2091

gint _clause_size;

2092

gint _clause_index;

2093

_tmp34_ = stmt;

2094

_tmp35_ = vala_try_statement_get_catch_clauses (_tmp34_);

2095

_clause_list = _tmp35_;

2096

_tmp36_ = _clause_list;

2097

_tmp37_ = vala_collection_get_size ((ValaCollection*) _tmp36_);

2098

_tmp38_ = _tmp37_;

2099

_clause_size = _tmp38_;

2100

_clause_index = -1;

2101

while (TRUE) {

2102

gint _tmp39_;

2103

gint _tmp40_;

2104

gint _tmp41_;

2105

ValaList* _tmp42_;

2106

gint _tmp43_;

2107

gpointer _tmp44_ = NULL;

2108

ValaCatchClause* clause;

2109

ValaCatchClause* _tmp45_;

2110

ValaCCodeFunction* _tmp46_;

2111

ValaCCodeFunction* _tmp47_;

2112

gint _tmp48_;

2113

gchar* _tmp49_ = NULL;

2114

gchar* _tmp50_;

2115

ValaCatchClause* _tmp51_;

2116

_tmp39_ = _clause_index;

2117

_clause_index = _tmp39_ + 1;

2118

_tmp40_ = _clause_index;

2119

_tmp41_ = _clause_size;

2120

if (!(_tmp40_ < _tmp41_)) {

2121

break;

2122

}

2123

_tmp42_ = _clause_list;

2124

_tmp43_ = _clause_index;

2125

_tmp44_ = vala_list_get (_tmp42_, _tmp43_);

2126

clause = (ValaCatchClause*) _tmp44_;

2127

_tmp45_ = clause;

2128

vala_ccode_base_module_set_current_catch ((ValaCCodeBaseModule*) self, _tmp45_);

2129

_tmp46_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

2130

_tmp47_ = _tmp46_;

2131

_tmp48_ = this_try_id;

2132

_tmp49_ = g_strdup_printf ("__finally%d", _tmp48_);

2133

_tmp50_ = _tmp49_;

2134

vala_ccode_function_add_goto (_tmp47_, _tmp50_);

2135

_g_free0 (_tmp50_);

2136

_tmp51_ = clause;

2137

vala_code_node_emit ((ValaCodeNode*) _tmp51_, (ValaCodeGenerator*) self);

2138

_vala_code_node_unref0 (clause);

2139

}

2140

_vala_iterable_unref0 (_clause_list);

2141

}

2142

_tmp52_ = old_try;

2143

vala_ccode_base_module_set_current_try ((ValaCCodeBaseModule*) self, _tmp52_);

2144

_tmp53_ = old_try_id;

2145

self->priv->current_try_id = _tmp53_;

2146

_tmp54_ = old_is_in_catch;

2147

self->priv->is_in_catch = _tmp54_;

2148

_tmp55_ = old_catch;

2149

vala_ccode_base_module_set_current_catch ((ValaCCodeBaseModule*) self, _tmp55_);

2150

_tmp56_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

2151

_tmp57_ = _tmp56_;

2152

_tmp58_ = this_try_id;

2153

_tmp59_ = g_strdup_printf ("__finally%d", _tmp58_);

2154

_tmp60_ = _tmp59_;

2155

vala_ccode_function_add_label (_tmp57_, _tmp60_);

2156

_g_free0 (_tmp60_);

2157

_tmp61_ = stmt;

2158

_tmp62_ = vala_try_statement_get_finally_body (_tmp61_);

2159

_tmp63_ = _tmp62_;

2160

if (_tmp63_ != NULL) {

2161

ValaTryStatement* _tmp64_;

2162

ValaBlock* _tmp65_;

2163

ValaBlock* _tmp66_;

2164

_tmp64_ = stmt;

2165

_tmp65_ = vala_try_statement_get_finally_body (_tmp64_);

2166

_tmp66_ = _tmp65_;

2167

vala_code_node_emit ((ValaCodeNode*) _tmp66_, (ValaCodeGenerator*) self);

2168

}

2169

_tmp67_ = stmt;

2170

_tmp68_ = stmt;

2171

_tmp69_ = vala_try_statement_get_after_try_block_reachable (_tmp68_);

2172

_tmp70_ = _tmp69_;

2173

vala_ccode_base_module_add_simple_check ((ValaCCodeBaseModule*) self, (ValaCodeNode*) _tmp67_, !_tmp70_);

2174

_vala_code_node_unref0 (old_catch);

2175

_vala_code_node_unref0 (old_try);

2176

}

2177

2178

2179

static void vala_gerror_module_real_visit_catch_clause (ValaCodeVisitor* base, ValaCatchClause* clause) {

2180

ValaGErrorModule * self;

2181

ValaCatchClause* _tmp0_;

2182

ValaDataType* _tmp1_;

2183

ValaDataType* _tmp2_;

2184

ValaErrorType* _tmp3_;

2185

ValaErrorType* error_type;

2186

ValaErrorType* _tmp4_;

2187

ValaErrorDomain* _tmp5_;

2188

ValaErrorDomain* _tmp6_;

2189

ValaCCodeFunction* _tmp11_;

2190

ValaCCodeFunction* _tmp12_;

2191

ValaCatchClause* _tmp13_;

2192

const gchar* _tmp14_;

2193

const gchar* _tmp15_;

2194

ValaCCodeFunction* _tmp16_;

2195

ValaCCodeFunction* _tmp17_;

2196

ValaCatchClause* _tmp18_;

2197

ValaLocalVariable* _tmp19_;

2198

ValaLocalVariable* _tmp20_;

2199

ValaCCodeFunction* _tmp47_;

2200

ValaCCodeFunction* _tmp48_;

2201

ValaCCodeExpression* _tmp49_ = NULL;

2202

ValaCCodeExpression* _tmp50_;

2203

ValaCCodeConstant* _tmp51_;

2204

ValaCCodeConstant* _tmp52_;

2205

ValaCatchClause* _tmp53_;

2206

ValaBlock* _tmp54_;

2207

ValaBlock* _tmp55_;

2208

ValaCCodeFunction* _tmp56_;

2209

ValaCCodeFunction* _tmp57_;

2210

self = (ValaGErrorModule*) base;

2211

g_return_if_fail (clause != NULL);

2212

vala_ccode_base_module_set_current_method_inner_error ((ValaCCodeBaseModule*) self, TRUE);

2213

_tmp0_ = clause;

2214

_tmp1_ = vala_catch_clause_get_error_type (_tmp0_);

2215

_tmp2_ = _tmp1_;

2216

_tmp3_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp2_, VALA_TYPE_ERROR_TYPE, ValaErrorType));

2217

error_type = _tmp3_;

2218

_tmp4_ = error_type;

2219

_tmp5_ = vala_error_type_get_error_domain (_tmp4_);

2220

_tmp6_ = _tmp5_;

2221

if (_tmp6_ != NULL) {

2222

ValaErrorType* _tmp7_;

2223

ValaErrorDomain* _tmp8_;

2224

ValaErrorDomain* _tmp9_;

2225

ValaCCodeFile* _tmp10_;

2226

_tmp7_ = error_type;

2227

_tmp8_ = vala_error_type_get_error_domain (_tmp7_);

2228

_tmp9_ = _tmp8_;

2229

_tmp10_ = ((ValaCCodeBaseModule*) self)->cfile;

2230

vala_ccode_base_module_generate_error_domain_declaration ((ValaCCodeBaseModule*) self, _tmp9_, _tmp10_);

2231

}

2232

_tmp11_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

2233

_tmp12_ = _tmp11_;

2234

_tmp13_ = clause;

2235

_tmp14_ = vala_catch_clause_get_clabel_name (_tmp13_);

2236

_tmp15_ = _tmp14_;

2237

vala_ccode_function_add_label (_tmp12_, _tmp15_);

2238

_tmp16_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

2239

_tmp17_ = _tmp16_;

2240

vala_ccode_function_open_block (_tmp17_);

2241

_tmp18_ = clause;

2242

_tmp19_ = vala_catch_clause_get_error_variable (_tmp18_);

2243

_tmp20_ = _tmp19_;

2244

if (_tmp20_ != NULL) {

2245

ValaCatchClause* _tmp21_;

2246

ValaLocalVariable* _tmp22_;

2247

ValaLocalVariable* _tmp23_;

2248

ValaCCodeFunction* _tmp24_;

2249

ValaCCodeFunction* _tmp25_;

2250

ValaCatchClause* _tmp26_;

2251

ValaLocalVariable* _tmp27_;

2252

ValaLocalVariable* _tmp28_;

2253

gchar* _tmp29_ = NULL;

2254

gchar* _tmp30_;

2255

ValaCCodeExpression* _tmp31_ = NULL;

2256

ValaCCodeExpression* _tmp32_;

2257

ValaCCodeExpression* _tmp33_ = NULL;

2258

ValaCCodeExpression* _tmp34_;

2259

_tmp21_ = clause;

2260

_tmp22_ = vala_catch_clause_get_error_variable (_tmp21_);

2261

_tmp23_ = _tmp22_;

2262

vala_code_visitor_visit_local_variable ((ValaCodeVisitor*) self, _tmp23_);

2263

_tmp24_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

2264

_tmp25_ = _tmp24_;

2265

_tmp26_ = clause;

2266

_tmp27_ = vala_catch_clause_get_error_variable (_tmp26_);

2267

_tmp28_ = _tmp27_;

2268

_tmp29_ = vala_ccode_base_module_get_local_cname ((ValaCCodeBaseModule*) self, _tmp28_);

2269

_tmp30_ = _tmp29_;

2270

_tmp31_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, _tmp30_);

2271

_tmp32_ = _tmp31_;

2272

_tmp33_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, "_inner_error_");

2273

_tmp34_ = _tmp33_;

2274

vala_ccode_function_add_assignment (_tmp25_, _tmp32_, _tmp34_);

2275

_vala_ccode_node_unref0 (_tmp34_);

2276

_vala_ccode_node_unref0 (_tmp32_);

2277

_g_free0 (_tmp30_);

2278

} else {

2279

ValaCCodeIdentifier* _tmp35_;

2280

ValaCCodeIdentifier* _tmp36_;

2281

ValaCCodeFunctionCall* _tmp37_;

2282

ValaCCodeFunctionCall* _tmp38_;

2283

ValaCCodeFunctionCall* cclear;

2284

ValaCCodeFunctionCall* _tmp39_;

2285

ValaCCodeExpression* _tmp40_ = NULL;

2286

ValaCCodeExpression* _tmp41_;

2287

ValaCCodeUnaryExpression* _tmp42_;

2288

ValaCCodeUnaryExpression* _tmp43_;

2289

ValaCCodeFunction* _tmp44_;

2290

ValaCCodeFunction* _tmp45_;

2291

ValaCCodeFunctionCall* _tmp46_;

2292

_tmp35_ = vala_ccode_identifier_new ("g_clear_error");

2293

_tmp36_ = _tmp35_;

2294

_tmp37_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp36_);

2295

_tmp38_ = _tmp37_;

2296

_vala_ccode_node_unref0 (_tmp36_);

2297

cclear = _tmp38_;

2298

_tmp39_ = cclear;

2299

_tmp40_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, "_inner_error_");

2300

_tmp41_ = _tmp40_;

2301

_tmp42_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, _tmp41_);

2302

_tmp43_ = _tmp42_;

2303

vala_ccode_function_call_add_argument (_tmp39_, (ValaCCodeExpression*) _tmp43_);

2304

_vala_ccode_node_unref0 (_tmp43_);

2305

_vala_ccode_node_unref0 (_tmp41_);

2306

_tmp44_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

2307

_tmp45_ = _tmp44_;

2308

_tmp46_ = cclear;

2309

vala_ccode_function_add_expression (_tmp45_, (ValaCCodeExpression*) _tmp46_);

2310

_vala_ccode_node_unref0 (cclear);

2311

}

2312

_tmp47_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

2313

_tmp48_ = _tmp47_;

2314

_tmp49_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, "_inner_error_");

2315

_tmp50_ = _tmp49_;

2316

_tmp51_ = vala_ccode_constant_new ("NULL");

2317

_tmp52_ = _tmp51_;

2318

vala_ccode_function_add_assignment (_tmp48_, _tmp50_, (ValaCCodeExpression*) _tmp52_);

2319

_vala_ccode_node_unref0 (_tmp52_);

2320

_vala_ccode_node_unref0 (_tmp50_);

2321

_tmp53_ = clause;

2322

_tmp54_ = vala_catch_clause_get_body (_tmp53_);

2323

_tmp55_ = _tmp54_;

2324

vala_code_node_emit ((ValaCodeNode*) _tmp55_, (ValaCodeGenerator*) self);

2325

_tmp56_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

2326

_tmp57_ = _tmp56_;

2327

vala_ccode_function_close (_tmp57_);

2328

_vala_code_node_unref0 (error_type);

2329

}

2330

2331

2332

static void vala_gerror_module_real_append_scope_free (ValaCCodeBaseModule* base, ValaSymbol* sym, ValaCodeNode* stop_at) {

2333

ValaGErrorModule * self;

2334

ValaSymbol* _tmp0_;

2335

ValaCodeNode* _tmp1_;

2336

gboolean _tmp2_ = FALSE;

2337

ValaCodeNode* _tmp3_;

2338

gboolean _tmp5_;

2339

self = (ValaGErrorModule*) base;

2340

g_return_if_fail (sym != NULL);

2341

_tmp0_ = sym;

2342

_tmp1_ = stop_at;

2343

VALA_CCODE_BASE_MODULE_CLASS (vala_gerror_module_parent_class)->append_scope_free ((ValaCCodeBaseModule*) G_TYPE_CHECK_INSTANCE_CAST (self, VALA_TYPE_CCODE_DELEGATE_MODULE, ValaCCodeDelegateModule), _tmp0_, _tmp1_);

2344

_tmp3_ = stop_at;

2345

if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp3_, VALA_TYPE_TRY_STATEMENT)) {

2346

_tmp2_ = TRUE;

2347

} else {

2348

ValaCodeNode* _tmp4_;

2349

_tmp4_ = stop_at;

2350

_tmp2_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp4_, VALA_TYPE_CATCH_CLAUSE);

2351

}

2352

_tmp5_ = _tmp2_;

2353

if (!_tmp5_) {

2354

ValaBlock* _tmp6_;

2355

ValaBlock* finally_block;

2356

ValaSymbol* _tmp7_;

2357

ValaCodeNode* _tmp8_;

2358

ValaCodeNode* _tmp9_;

2359

gboolean _tmp27_ = FALSE;

2360

ValaBlock* _tmp28_;

2361

gboolean _tmp31_;

2362

_tmp6_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (NULL, VALA_TYPE_BLOCK, ValaBlock));

2363

finally_block = _tmp6_;

2364

_tmp7_ = sym;

2365

_tmp8_ = vala_code_node_get_parent_node ((ValaCodeNode*) _tmp7_);

2366

_tmp9_ = _tmp8_;

2367

if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp9_, VALA_TYPE_TRY_STATEMENT)) {

2368

ValaSymbol* _tmp10_;

2369

ValaCodeNode* _tmp11_;

2370

ValaCodeNode* _tmp12_;

2371

ValaBlock* _tmp13_;

2372

ValaBlock* _tmp14_;

2373

ValaBlock* _tmp15_;

2374

_tmp10_ = sym;

2375

_tmp11_ = vala_code_node_get_parent_node ((ValaCodeNode*) _tmp10_);

2376

_tmp12_ = _tmp11_;

2377

_tmp13_ = vala_try_statement_get_finally_body (G_TYPE_CHECK_INSTANCE_TYPE (_tmp12_, VALA_TYPE_TRY_STATEMENT) ? ((ValaTryStatement*) _tmp12_) : NULL);

2378

_tmp14_ = _tmp13_;

2379

_tmp15_ = _vala_code_node_ref0 (_tmp14_);

2380

_vala_code_node_unref0 (finally_block);

2381

finally_block = _tmp15_;

2382

} else {

2383

ValaSymbol* _tmp16_;

2384

ValaCodeNode* _tmp17_;

2385

ValaCodeNode* _tmp18_;

2386

_tmp16_ = sym;

2387

_tmp17_ = vala_code_node_get_parent_node ((ValaCodeNode*) _tmp16_);

2388

_tmp18_ = _tmp17_;

2389

if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp18_, VALA_TYPE_CATCH_CLAUSE)) {

2390

ValaSymbol* _tmp19_;

2391

ValaCodeNode* _tmp20_;

2392

ValaCodeNode* _tmp21_;

2393

ValaCodeNode* _tmp22_;

2394

ValaCodeNode* _tmp23_;

2395

ValaBlock* _tmp24_;

2396

ValaBlock* _tmp25_;

2397

ValaBlock* _tmp26_;

2398

_tmp19_ = sym;

2399

_tmp20_ = vala_code_node_get_parent_node ((ValaCodeNode*) _tmp19_);

2400

_tmp21_ = _tmp20_;

2401

_tmp22_ = vala_code_node_get_parent_node (_tmp21_);

2402

_tmp23_ = _tmp22_;

2403

_tmp24_ = vala_try_statement_get_finally_body (G_TYPE_CHECK_INSTANCE_TYPE (_tmp23_, VALA_TYPE_TRY_STATEMENT) ? ((ValaTryStatement*) _tmp23_) : NULL);

2404

_tmp25_ = _tmp24_;

2405

_tmp26_ = _vala_code_node_ref0 (_tmp25_);

2406

_vala_code_node_unref0 (finally_block);

2407

finally_block = _tmp26_;

2408

}

2409

}

2410

_tmp28_ = finally_block;

2411

if (_tmp28_ != NULL) {

2412

ValaBlock* _tmp29_;

2413

ValaSymbol* _tmp30_;

2414

_tmp29_ = finally_block;

2415

_tmp30_ = sym;

2416

_tmp27_ = G_TYPE_CHECK_INSTANCE_CAST (_tmp29_, VALA_TYPE_SYMBOL, ValaSymbol) != _tmp30_;

2417

} else {

2418

_tmp27_ = FALSE;

2419

}

2420

_tmp31_ = _tmp27_;

2421

if (_tmp31_) {

2422

ValaBlock* _tmp32_;

2423

_tmp32_ = finally_block;

2424

vala_code_node_emit ((ValaCodeNode*) _tmp32_, (ValaCodeGenerator*) self);

2425

}

2426

_vala_code_node_unref0 (finally_block);

2427

}

2428

}

2429

2430

2431

ValaGErrorModule* vala_gerror_module_construct (GType object_type) {

2432

ValaGErrorModule* self = NULL;

2433

self = (ValaGErrorModule*) vala_ccode_delegate_module_construct (object_type);

2434

return self;

2435

}

2436

2437

2438

ValaGErrorModule* vala_gerror_module_new (void) {

2439

return vala_gerror_module_construct (VALA_TYPE_GERROR_MODULE);

2440

}

2441

2442

2443

static void vala_gerror_module_class_init (ValaGErrorModuleClass * klass) {

2444

vala_gerror_module_parent_class = g_type_class_peek_parent (klass);

2445

VALA_CODE_VISITOR_CLASS (klass)->finalize = vala_gerror_module_finalize;

2446

g_type_class_add_private (klass, sizeof (ValaGErrorModulePrivate));

2447

VALA_CCODE_BASE_MODULE_CLASS (klass)->generate_error_domain_declaration = vala_gerror_module_real_generate_error_domain_declaration;

2448

VALA_CODE_VISITOR_CLASS (klass)->visit_error_domain = vala_gerror_module_real_visit_error_domain;

2449

VALA_CODE_VISITOR_CLASS (klass)->visit_throw_statement = vala_gerror_module_real_visit_throw_statement;

2450

VALA_GERROR_MODULE_CLASS (klass)->return_with_exception = vala_gerror_module_real_return_with_exception;

2451

VALA_CCODE_BASE_MODULE_CLASS (klass)->add_simple_check = vala_gerror_module_real_add_simple_check;

2452

VALA_CODE_VISITOR_CLASS (klass)->visit_try_statement = vala_gerror_module_real_visit_try_statement;

2453

VALA_CODE_VISITOR_CLASS (klass)->visit_catch_clause = vala_gerror_module_real_visit_catch_clause;

2454

VALA_CCODE_BASE_MODULE_CLASS (klass)->append_scope_free = vala_gerror_module_real_append_scope_free;

2455

}

2456

2457

2458

static void vala_gerror_module_instance_init (ValaGErrorModule * self) {

2459

self->priv = VALA_GERROR_MODULE_GET_PRIVATE (self);

2460

self->priv->current_try_id = 0;

2461

self->priv->next_try_id = 0;

2462

self->priv->is_in_catch = FALSE;

2463

}

2464

2465

2466

static void vala_gerror_module_finalize (ValaCodeVisitor* obj) {

2467

ValaGErrorModule * self;

2468

self = G_TYPE_CHECK_INSTANCE_CAST (obj, VALA_TYPE_GERROR_MODULE, ValaGErrorModule);

2469

VALA_CODE_VISITOR_CLASS (vala_gerror_module_parent_class)->finalize (obj);

2470

}

2471

2472

2473

GType vala_gerror_module_get_type (void) {

2474

static volatile gsize vala_gerror_module_type_id__volatile = 0;

2475

if (g_once_init_enter (&vala_gerror_module_type_id__volatile)) {

2476

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

2477

GType vala_gerror_module_type_id;

2478

vala_gerror_module_type_id = g_type_register_static (VALA_TYPE_CCODE_DELEGATE_MODULE, "ValaGErrorModule", &g_define_type_info, 0);

2479

g_once_init_leave (&vala_gerror_module_type_id__volatile, vala_gerror_module_type_id);

2480

}

2481

return vala_gerror_module_type_id__volatile;

2482

}

2483

2484

2485

Older »