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

100

typedef struct _ValaCCodeMemberAccessModulePrivate ValaCCodeMemberAccessModulePrivate;

101

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

102

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

103

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

104

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

105

106

#define VALA_TYPE_GLIB_VALUE (vala_glib_value_get_type ())

107

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

108

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

109

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

110

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

111

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

112

113

typedef struct _ValaGLibValue ValaGLibValue;

114

typedef struct _ValaGLibValueClass ValaGLibValueClass;

115

typedef struct _ValaGLibValuePrivate ValaGLibValuePrivate;

116

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

117

118

struct _ValaCCodeBaseModule {

119

ValaCodeGenerator parent_instance;

120

ValaCCodeBaseModulePrivate * priv;

121

ValaSymbol* root_symbol;

122

ValaCCodeBaseModuleEmitContext* emit_context;

123

ValaCCodeLineDirective* current_line;

124

ValaCCodeFile* header_file;

125

ValaCCodeFile* internal_header_file;

126

ValaCCodeFile* cfile;

127

ValaCCodeBaseModuleEmitContext* class_init_context;

128

ValaCCodeBaseModuleEmitContext* base_init_context;

129

ValaCCodeBaseModuleEmitContext* class_finalize_context;

130

ValaCCodeBaseModuleEmitContext* base_finalize_context;

131

ValaCCodeBaseModuleEmitContext* instance_init_context;

132

ValaCCodeBaseModuleEmitContext* instance_finalize_context;

133

ValaCCodeStruct* param_spec_struct;

134

ValaCCodeStruct* closure_struct;

135

ValaCCodeEnum* prop_enum;

136

ValaSet* user_marshal_set;

137

ValaSet* predefined_marshal_set;

138

gint next_regex_id;

139

gint next_coroutine_state;

140

ValaDataType* void_type;

141

ValaDataType* bool_type;

142

ValaDataType* char_type;

143

ValaDataType* uchar_type;

144

ValaDataType* unichar_type;

145

ValaDataType* short_type;

146

ValaDataType* ushort_type;

147

ValaDataType* int_type;

148

ValaDataType* uint_type;

149

ValaDataType* long_type;

150

ValaDataType* ulong_type;

151

ValaDataType* int8_type;

152

ValaDataType* uint8_type;

153

ValaDataType* int16_type;

154

ValaDataType* uint16_type;

155

ValaDataType* int32_type;

156

ValaDataType* uint32_type;

157

ValaDataType* int64_type;

158

ValaDataType* uint64_type;

159

ValaDataType* string_type;

160

ValaDataType* regex_type;

161

ValaDataType* float_type;

162

ValaDataType* double_type;

163

ValaTypeSymbol* gtype_type;

164

ValaTypeSymbol* gobject_type;

165

ValaErrorType* gerror_type;

166

ValaClass* glist_type;

167

ValaClass* gslist_type;

168

ValaClass* gnode_type;

169

ValaClass* gqueue_type;

170

ValaClass* gvaluearray_type;

171

ValaTypeSymbol* gstringbuilder_type;

172

ValaTypeSymbol* garray_type;

173

ValaTypeSymbol* gbytearray_type;

174

ValaTypeSymbol* gptrarray_type;

175

ValaTypeSymbol* gthreadpool_type;

176

ValaDataType* gdestroynotify_type;

177

ValaDataType* gquark_type;

178

ValaStruct* gvalue_type;

179

ValaClass* gvariant_type;

180

ValaStruct* mutex_type;

181

ValaStruct* gmutex_type;

182

ValaStruct* grecmutex_type;

183

ValaStruct* grwlock_type;

184

ValaStruct* gcond_type;

185

ValaClass* gsource_type;

186

ValaTypeSymbol* type_module_type;

187

ValaTypeSymbol* dbus_proxy_type;

188

gboolean in_plugin;

189

gchar* module_init_param_name;

190

gboolean gvaluecollector_h_needed;

191

gboolean requires_assert;

192

gboolean requires_array_free;

193

gboolean requires_array_move;

194

gboolean requires_array_length;

195

gboolean requires_clear_mutex;

196

ValaSet* wrappers;

197

};

198

199

struct _ValaCCodeBaseModuleClass {

200

ValaCodeGeneratorClass parent_class;

201

void (*append_vala_array_free) (ValaCCodeBaseModule* self);

202

void (*append_vala_array_move) (ValaCCodeBaseModule* self);

203

void (*append_vala_array_length) (ValaCCodeBaseModule* self);

204

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

205

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

206

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

207

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

208

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

209

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

210

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

211

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

212

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

213

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

214

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

215

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

216

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

217

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

218

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

219

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

220

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

221

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

222

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

223

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

224

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

225

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

226

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

227

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

228

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

229

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

230

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

231

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

232

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

233

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

234

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

235

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

236

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

237

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

238

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

239

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

240

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

241

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

242

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

243

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

244

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

245

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

246

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

247

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

248

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

249

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

250

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

251

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

252

};

253

254

struct _ValaCCodeStructModule {

255

ValaCCodeBaseModule parent_instance;

256

ValaCCodeStructModulePrivate * priv;

257

};

258

259

struct _ValaCCodeStructModuleClass {

260

ValaCCodeBaseModuleClass parent_class;

261

};

262

263

struct _ValaCCodeMethodModule {

264

ValaCCodeStructModule parent_instance;

265

ValaCCodeMethodModulePrivate * priv;

266

};

267

268

struct _ValaCCodeMethodModuleClass {

269

ValaCCodeStructModuleClass parent_class;

270

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

271

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

272

};

273

274

struct _ValaCCodeControlFlowModule {

275

ValaCCodeMethodModule parent_instance;

276

ValaCCodeControlFlowModulePrivate * priv;

277

};

278

279

struct _ValaCCodeControlFlowModuleClass {

280

ValaCCodeMethodModuleClass parent_class;

281

};

282

283

struct _ValaCCodeMemberAccessModule {

284

ValaCCodeControlFlowModule parent_instance;

285

ValaCCodeMemberAccessModulePrivate * priv;

286

};

287

288

struct _ValaCCodeMemberAccessModuleClass {

289

ValaCCodeControlFlowModuleClass parent_class;

290

};

291

292

struct _ValaGLibValue {

293

ValaTargetValue parent_instance;

294

ValaGLibValuePrivate * priv;

295

ValaCCodeExpression* cvalue;

296

gboolean lvalue;

297

gboolean non_null;

298

gchar* ctype;

299

ValaList* array_length_cvalues;

300

ValaCCodeExpression* array_size_cvalue;

301

gboolean array_null_terminated;

302

ValaCCodeExpression* array_length_cexpr;

303

ValaCCodeExpression* delegate_target_cvalue;

304

ValaCCodeExpression* delegate_target_destroy_notify_cvalue;

305

};

306

307

struct _ValaGLibValueClass {

308

ValaTargetValueClass parent_class;

309

};

310

311

312

static gpointer vala_ccode_member_access_module_parent_class = NULL;

313

314

GType vala_ccode_base_module_get_type (void) G_GNUC_CONST;

315

gpointer vala_ccode_base_module_emit_context_ref (gpointer instance);

316

void vala_ccode_base_module_emit_context_unref (gpointer instance);

317

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

318

void vala_ccode_base_module_value_set_emit_context (GValue* value, gpointer v_object);

319

void vala_ccode_base_module_value_take_emit_context (GValue* value, gpointer v_object);

320

gpointer vala_ccode_base_module_value_get_emit_context (const GValue* value);

321

GType vala_ccode_base_module_emit_context_get_type (void) G_GNUC_CONST;

322

GType vala_ccode_struct_module_get_type (void) G_GNUC_CONST;

323

GType vala_ccode_method_module_get_type (void) G_GNUC_CONST;

324

GType vala_ccode_control_flow_module_get_type (void) G_GNUC_CONST;

325

GType vala_ccode_member_access_module_get_type (void) G_GNUC_CONST;

326

enum {

327

VALA_CCODE_MEMBER_ACCESS_MODULE_DUMMY_PROPERTY

328

};

329

static void vala_ccode_member_access_module_real_visit_member_access (ValaCodeVisitor* base, ValaMemberAccess* expr);

330

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

331

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

332

gboolean vala_ccode_base_module_add_generated_external_symbol (ValaCCodeBaseModule* self, ValaSymbol* external_symbol);

333

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

334

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

335

ValaClass* vala_ccode_base_module_get_current_class (ValaCCodeBaseModule* self);

336

void vala_ccode_base_module_set_cvalue (ValaCCodeBaseModule* self, ValaExpression* expr, ValaCCodeExpression* cvalue);

337

gchar* vala_ccode_base_module_get_ccode_vfunc_name (ValaMethod* m);

338

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

339

gchar* vala_ccode_base_module_get_ccode_name (ValaCodeNode* node);

340

gchar* vala_ccode_base_module_get_ccode_real_name (ValaSymbol* sym);

341

void vala_ccode_base_module_set_delegate_target_destroy_notify (ValaCCodeBaseModule* self, ValaExpression* expr, ValaCCodeExpression* destroy_notify);

342

void vala_ccode_base_module_set_delegate_target (ValaCCodeBaseModule* self, ValaExpression* expr, ValaCCodeExpression* delegate_target);

343

ValaMethod* vala_ccode_base_module_get_current_method (ValaCCodeBaseModule* self);

344

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

345

gint vala_ccode_base_module_get_block_id (ValaCCodeBaseModule* self, ValaBlock* b);

346

ValaCCodeExpression* vala_ccode_base_module_get_ccodenode (ValaCCodeBaseModule* self, ValaExpression* node);

347

gboolean vala_ccode_base_module_is_reference_counting (ValaTypeSymbol* sym);

348

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

349

ValaCCodeExpression* vala_ccode_base_module_get_destroy_func_expression (ValaCCodeBaseModule* self, ValaDataType* type, gboolean is_chainup);

350

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

351

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

352

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

353

void vala_ccode_base_module_generate_constant_declaration (ValaCCodeBaseModule* self, ValaConstant* c, ValaCCodeFile* decl_space, gboolean definition);

354

void vala_ccode_base_module_append_array_length (ValaCCodeBaseModule* self, ValaExpression* expr, ValaCCodeExpression* size);

355

void vala_ccode_base_module_generate_property_accessor_declaration (ValaCCodeBaseModule* self, ValaPropertyAccessor* acc, ValaCCodeFile* decl_space);

356

ValaTypeSymbol* vala_ccode_base_module_get_current_type_symbol (ValaCCodeBaseModule* self);

357

gboolean vala_ccode_base_module_get_ccode_no_accessor_method (ValaProperty* p);

358

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

359

gboolean vala_ccode_base_module_get_lvalue (ValaCCodeBaseModule* self, ValaTargetValue* value);

360

ValaTargetValue* vala_ccode_base_module_store_temp_value (ValaCCodeBaseModule* self, ValaTargetValue* initializer, ValaCodeNode* node_reference, gboolean* value_owned);

361

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

362

ValaTargetValue* vala_ccode_base_module_create_temp_value (ValaCCodeBaseModule* self, ValaDataType* type, gboolean init, ValaCodeNode* node_reference, gboolean* value_owned);

363

GType vala_glib_value_get_type (void) G_GNUC_CONST;

364

ValaTargetValue* vala_ccode_base_module_load_temp_value (ValaCCodeBaseModule* self, ValaTargetValue* lvalue);

365

ValaCCodeFunction* vala_ccode_base_module_get_ccode (ValaCCodeBaseModule* self);

366

gboolean vala_ccode_base_module_get_ccode_array_null_terminated (ValaCodeNode* node);

367

gboolean vala_ccode_base_module_get_ccode_array_length (ValaCodeNode* node);

368

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

369

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

370

ValaCCodeConstant* vala_ccode_base_module_get_property_canonical_cconstant (ValaCCodeBaseModule* self, ValaProperty* prop);

371

gboolean vala_ccode_base_module_requires_copy (ValaCCodeBaseModule* self, ValaDataType* type);

372

ValaLocalVariable* vala_ccode_base_module_get_temp_variable (ValaCCodeBaseModule* self, ValaDataType* type, gboolean value_owned, ValaCodeNode* node_reference, gboolean init);

373

void vala_ccode_base_module_emit_temp_var (ValaCCodeBaseModule* self, ValaLocalVariable* local);

374

ValaDataType* vala_ccode_base_module_get_current_return_type (ValaCCodeBaseModule* self);

375

gboolean vala_ccode_base_module_variable_accessible_in_finally (ValaCCodeBaseModule* self, ValaLocalVariable* local);

376

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

377

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

378

static ValaTargetValue* vala_ccode_member_access_module_real_get_local_cvalue (ValaCCodeBaseModule* base, ValaLocalVariable* local);

379

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

380

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

381

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

382

void vala_glib_value_append_array_length_cvalue (ValaGLibValue* self, ValaCCodeExpression* length_cvalue);

383

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

384

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

385

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

386

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

387

ValaCCodeExpression* vala_ccode_base_module_get_local_cexpression (ValaCCodeBaseModule* self, ValaLocalVariable* local);

388

gboolean vala_ccode_base_module_is_in_coroutine (ValaCCodeBaseModule* self);

389

static ValaTargetValue* vala_ccode_member_access_module_real_get_parameter_cvalue (ValaCCodeBaseModule* base, ValaParameter* param);

390

gchar* vala_ccode_base_module_get_ccode_array_length_expr (ValaCodeNode* node);

391

gchar* vala_ccode_base_module_get_ccode_type (ValaCodeNode* node);

392

gchar* vala_ccode_base_module_get_variable_cname (ValaCCodeBaseModule* self, const gchar* name);

393

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

394

gchar* vala_ccode_base_module_get_ccode_delegate_target_name (ValaVariable* variable);

395

ValaPropertyAccessor* vala_ccode_base_module_get_current_property_accessor (ValaCCodeBaseModule* self);

396

static ValaTargetValue* vala_ccode_member_access_module_real_get_field_cvalue (ValaCCodeBaseModule* base, ValaField* field, ValaTargetValue* instance);

397

ValaDataType* vala_ccode_base_module_get_data_type_for_symbol (ValaTypeSymbol* sym);

398

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

399

gchar* vala_ccode_base_module_get_ccode_array_length_name (ValaCodeNode* node);

400

void vala_ccode_base_module_set_array_size_cvalue (ValaCCodeBaseModule* self, ValaTargetValue* value, ValaCCodeExpression* cvalue);

401

gboolean vala_ccode_base_module_get_ccode_delegate_target (ValaCodeNode* node);

402

ValaDataType* vala_ccode_base_module_get_this_type (ValaCCodeBaseModule* self);

403

void vala_ccode_base_module_generate_field_declaration (ValaCCodeBaseModule* self, ValaField* f, ValaCCodeFile* decl_space);

404

static ValaTargetValue* vala_ccode_member_access_module_real_load_variable (ValaCCodeBaseModule* base, ValaVariable* variable, ValaTargetValue* value);

405

gchar* vala_ccode_base_module_get_ccode_array_length_type (ValaCodeNode* node);

406

gboolean vala_ccode_base_module_is_lvalue_access_allowed (ValaCCodeBaseModule* self, ValaDataType* type);

407

static ValaTargetValue* vala_ccode_member_access_module_real_load_local (ValaCodeGenerator* base, ValaLocalVariable* local);

408

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

409

static ValaTargetValue* vala_ccode_member_access_module_real_load_parameter (ValaCodeGenerator* base, ValaParameter* param);

410

static ValaTargetValue* vala_ccode_member_access_module_real_load_this_parameter (ValaCCodeBaseModule* base, ValaTypeSymbol* sym);

411

static ValaTargetValue* vala_ccode_member_access_module_real_load_field (ValaCodeGenerator* base, ValaField* field, ValaTargetValue* instance);

412

ValaCCodeMemberAccessModule* vala_ccode_member_access_module_construct (GType object_type);

413

ValaCCodeControlFlowModule* vala_ccode_control_flow_module_construct (GType object_type);

414

415

416

static gpointer _vala_code_node_ref0 (gpointer self) {

417

return self ? vala_code_node_ref (self) : NULL;

418

}

419

420

421

static gpointer _vala_ccode_node_ref0 (gpointer self) {

422

return self ? vala_ccode_node_ref (self) : NULL;

423

}

424

425

426

static gpointer _vala_target_value_ref0 (gpointer self) {

427

return self ? vala_target_value_ref (self) : NULL;

428

}

429

430

431

static void vala_ccode_member_access_module_real_visit_member_access (ValaCodeVisitor* base, ValaMemberAccess* expr) {

432

ValaCCodeMemberAccessModule * self;

433

ValaCCodeExpression* pub_inst;

434

ValaMemberAccess* _tmp0_;

435

ValaExpression* _tmp1_;

436

ValaExpression* _tmp2_;

437

ValaMemberAccess* _tmp7_;

438

ValaDataType* _tmp8_;

439

ValaDataType* _tmp9_;

440

ValaArrayType* _tmp10_;

441

ValaArrayType* array_type;

442

ValaMemberAccess* _tmp11_;

443

ValaDataType* _tmp12_;

444

ValaDataType* _tmp13_;

445

ValaDelegateType* _tmp14_;

446

ValaDelegateType* delegate_type;

447

ValaMemberAccess* _tmp15_;

448

ValaSymbol* _tmp16_;

449

ValaSymbol* _tmp17_;

450

self = (ValaCCodeMemberAccessModule*) base;

451

g_return_if_fail (expr != NULL);

452

pub_inst = NULL;

453

_tmp0_ = expr;

454

_tmp1_ = vala_member_access_get_inner (_tmp0_);

455

_tmp2_ = _tmp1_;

456

if (_tmp2_ != NULL) {

457

ValaMemberAccess* _tmp3_;

458

ValaExpression* _tmp4_;

459

ValaExpression* _tmp5_;

460

ValaCCodeExpression* _tmp6_ = NULL;

461

_tmp3_ = expr;

462

_tmp4_ = vala_member_access_get_inner (_tmp3_);

463

_tmp5_ = _tmp4_;

464

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

465

_vala_ccode_node_unref0 (pub_inst);

466

pub_inst = _tmp6_;

467

}

468

_tmp7_ = expr;

469

_tmp8_ = vala_expression_get_value_type ((ValaExpression*) _tmp7_);

470

_tmp9_ = _tmp8_;

471

_tmp10_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp9_, VALA_TYPE_ARRAY_TYPE) ? ((ValaArrayType*) _tmp9_) : NULL);

472

array_type = _tmp10_;

473

_tmp11_ = expr;

474

_tmp12_ = vala_expression_get_value_type ((ValaExpression*) _tmp11_);

475

_tmp13_ = _tmp12_;

476

_tmp14_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp13_, VALA_TYPE_DELEGATE_TYPE) ? ((ValaDelegateType*) _tmp13_) : NULL);

477

delegate_type = _tmp14_;

478

_tmp15_ = expr;

479

_tmp16_ = vala_expression_get_symbol_reference ((ValaExpression*) _tmp15_);

480

_tmp17_ = _tmp16_;

481

if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp17_, VALA_TYPE_METHOD)) {

482

ValaMemberAccess* _tmp18_;

483

ValaSymbol* _tmp19_;

484

ValaSymbol* _tmp20_;

485

ValaMethod* _tmp21_;

486

ValaMethod* m;

487

gboolean _tmp22_ = FALSE;

488

gboolean _tmp23_ = FALSE;

489

ValaMethod* _tmp24_;

490

gboolean _tmp26_;

491

gboolean _tmp28_;

492

ValaMemberAccess* _tmp42_;

493

ValaExpression* _tmp43_;

494

ValaExpression* _tmp44_;

495

ValaMethod* _tmp106_;

496

ValaMethod* _tmp107_;

497

ValaMethod* _tmp108_;

498

ValaMemberAccess* _tmp169_;

499

ValaCCodeConstant* _tmp170_;

500

ValaCCodeConstant* _tmp171_;

501

ValaMethod* _tmp172_;

502

ValaMemberBinding _tmp173_;

503

ValaMemberBinding _tmp174_;

504

_tmp18_ = expr;

505

_tmp19_ = vala_expression_get_symbol_reference ((ValaExpression*) _tmp18_);

506

_tmp20_ = _tmp19_;

507

_tmp21_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp20_, VALA_TYPE_METHOD, ValaMethod));

508

m = _tmp21_;

509

_tmp24_ = m;

510

if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp24_, VALA_TYPE_DYNAMIC_METHOD)) {

511

_tmp23_ = TRUE;

512

} else {

513

ValaMethod* _tmp25_;

514

_tmp25_ = m;

515

_tmp23_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp25_, VALA_TYPE_ARRAY_MOVE_METHOD);

516

}

517

_tmp26_ = _tmp23_;

518

if (_tmp26_) {

519

_tmp22_ = TRUE;

520

} else {

521

ValaMethod* _tmp27_;

522

_tmp27_ = m;

523

_tmp22_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp27_, VALA_TYPE_ARRAY_RESIZE_METHOD);

524

}

525

_tmp28_ = _tmp22_;

526

if (!_tmp28_) {

527

ValaMethod* _tmp29_;

528

ValaCCodeFile* _tmp30_;

529

gboolean _tmp31_ = FALSE;

530

ValaMethod* _tmp32_;

531

gboolean _tmp33_;

532

gboolean _tmp34_;

533

gboolean _tmp38_;

534

_tmp29_ = m;

535

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

536

vala_ccode_base_module_generate_method_declaration ((ValaCCodeBaseModule*) self, _tmp29_, _tmp30_);

537

_tmp32_ = m;

538

_tmp33_ = vala_symbol_get_external ((ValaSymbol*) _tmp32_);

539

_tmp34_ = _tmp33_;

540

if (!_tmp34_) {

541

ValaMethod* _tmp35_;

542

gboolean _tmp36_;

543

gboolean _tmp37_;

544

_tmp35_ = m;

545

_tmp36_ = vala_symbol_get_external_package ((ValaSymbol*) _tmp35_);

546

_tmp37_ = _tmp36_;

547

_tmp31_ = _tmp37_;

548

} else {

549

_tmp31_ = FALSE;

550

}

551

_tmp38_ = _tmp31_;

552

if (_tmp38_) {

553

ValaMethod* _tmp39_;

554

gboolean _tmp40_ = FALSE;

555

_tmp39_ = m;

556

_tmp40_ = vala_ccode_base_module_add_generated_external_symbol ((ValaCCodeBaseModule*) self, (ValaSymbol*) _tmp39_);

557

if (_tmp40_) {

558

ValaMethod* _tmp41_;

559

_tmp41_ = m;

560

vala_code_visitor_visit_method ((ValaCodeVisitor*) self, _tmp41_);

561

}

562

}

563

}

564

_tmp42_ = expr;

565

_tmp43_ = vala_member_access_get_inner (_tmp42_);

566

_tmp44_ = _tmp43_;

567

if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp44_, VALA_TYPE_BASE_ACCESS)) {

568

ValaMethod* _tmp45_;

569

ValaMethod* _tmp46_;

570

ValaMethod* _tmp47_;

571

_tmp45_ = m;

572

_tmp46_ = vala_method_get_base_method (_tmp45_);

573

_tmp47_ = _tmp46_;

574

if (_tmp47_ != NULL) {

575

ValaMethod* _tmp48_;

576

ValaMethod* _tmp49_;

577

ValaMethod* _tmp50_;

578

ValaSymbol* _tmp51_;

579

ValaSymbol* _tmp52_;

580

ValaClass* _tmp53_;

581

ValaClass* base_class;

582

ValaClass* _tmp54_;

583

gchar* _tmp55_ = NULL;

584

gchar* _tmp56_;

585

gchar* _tmp57_ = NULL;

586

gchar* _tmp58_;

587

ValaCCodeIdentifier* _tmp59_;

588

ValaCCodeIdentifier* _tmp60_;

589

ValaCCodeFunctionCall* _tmp61_;

590

ValaCCodeFunctionCall* _tmp62_;

591

ValaCCodeFunctionCall* vcast;

592

ValaCCodeFunctionCall* _tmp63_;

593

ValaClass* _tmp64_;

594

ValaClass* _tmp65_;

595

gchar* _tmp66_ = NULL;

596

gchar* _tmp67_;

597

gchar* _tmp68_ = NULL;

598

gchar* _tmp69_;

599

ValaCCodeIdentifier* _tmp70_;

600

ValaCCodeIdentifier* _tmp71_;

601

ValaMemberAccess* _tmp72_;

602

ValaCCodeFunctionCall* _tmp73_;

603

ValaMethod* _tmp74_;

604

gchar* _tmp75_ = NULL;

605

gchar* _tmp76_;

606

ValaCCodeMemberAccess* _tmp77_;

607

ValaCCodeMemberAccess* _tmp78_;

608

_tmp48_ = m;

609

_tmp49_ = vala_method_get_base_method (_tmp48_);

610

_tmp50_ = _tmp49_;

611

_tmp51_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp50_);

612

_tmp52_ = _tmp51_;

613

_tmp53_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp52_, VALA_TYPE_CLASS, ValaClass));

614

base_class = _tmp53_;

615

_tmp54_ = base_class;

616

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

617

_tmp56_ = _tmp55_;

618

_tmp57_ = g_strdup_printf ("%s_CLASS", _tmp56_);

619

_tmp58_ = _tmp57_;

620

_tmp59_ = vala_ccode_identifier_new (_tmp58_);

621

_tmp60_ = _tmp59_;

622

_tmp61_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp60_);

623

_tmp62_ = _tmp61_;

624

_vala_ccode_node_unref0 (_tmp60_);

625

_g_free0 (_tmp58_);

626

_g_free0 (_tmp56_);

627

vcast = _tmp62_;

628

_tmp63_ = vcast;

629

_tmp64_ = vala_ccode_base_module_get_current_class ((ValaCCodeBaseModule*) self);

630

_tmp65_ = _tmp64_;

631

_tmp66_ = vala_ccode_base_module_get_ccode_lower_case_name ((ValaCodeNode*) _tmp65_, NULL);

632

_tmp67_ = _tmp66_;

633

_tmp68_ = g_strdup_printf ("%s_parent_class", _tmp67_);

634

_tmp69_ = _tmp68_;

635

_tmp70_ = vala_ccode_identifier_new (_tmp69_);

636

_tmp71_ = _tmp70_;

637

vala_ccode_function_call_add_argument (_tmp63_, (ValaCCodeExpression*) _tmp71_);

638

_vala_ccode_node_unref0 (_tmp71_);

639

_g_free0 (_tmp69_);

640

_g_free0 (_tmp67_);

641

_tmp72_ = expr;

642

_tmp73_ = vcast;

643

_tmp74_ = m;

644

_tmp75_ = vala_ccode_base_module_get_ccode_vfunc_name (_tmp74_);

645

_tmp76_ = _tmp75_;

646

_tmp77_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp73_, _tmp76_);

647

_tmp78_ = _tmp77_;

648

vala_ccode_base_module_set_cvalue ((ValaCCodeBaseModule*) self, (ValaExpression*) _tmp72_, (ValaCCodeExpression*) _tmp78_);

649

_vala_ccode_node_unref0 (_tmp78_);

650

_g_free0 (_tmp76_);

651

_vala_ccode_node_unref0 (vcast);

652

_vala_code_node_unref0 (base_class);

653

_vala_code_node_unref0 (m);

654

_vala_code_node_unref0 (delegate_type);

655

_vala_code_node_unref0 (array_type);

656

_vala_ccode_node_unref0 (pub_inst);

657

return;

658

} else {

659

ValaMethod* _tmp79_;

660

ValaMethod* _tmp80_;

661

ValaMethod* _tmp81_;

662

_tmp79_ = m;

663

_tmp80_ = vala_method_get_base_interface_method (_tmp79_);

664

_tmp81_ = _tmp80_;

665

if (_tmp81_ != NULL) {

666

ValaMethod* _tmp82_;

667

ValaMethod* _tmp83_;

668

ValaMethod* _tmp84_;

669

ValaSymbol* _tmp85_;

670

ValaSymbol* _tmp86_;

671

ValaInterface* _tmp87_;

672

ValaInterface* base_iface;

673

ValaClass* _tmp88_;

674

ValaClass* _tmp89_;

675

gchar* _tmp90_ = NULL;

676

gchar* _tmp91_;

677

ValaInterface* _tmp92_;

678

gchar* _tmp93_ = NULL;

679

gchar* _tmp94_;

680

gchar* _tmp95_ = NULL;

681

gchar* _tmp96_;

682

gchar* parent_iface_var;

683

ValaMemberAccess* _tmp97_;

684

const gchar* _tmp98_;

685

ValaCCodeIdentifier* _tmp99_;

686

ValaCCodeIdentifier* _tmp100_;

687

ValaMethod* _tmp101_;

688

gchar* _tmp102_ = NULL;

689

gchar* _tmp103_;

690

ValaCCodeMemberAccess* _tmp104_;

691

ValaCCodeMemberAccess* _tmp105_;

692

_tmp82_ = m;

693

_tmp83_ = vala_method_get_base_interface_method (_tmp82_);

694

_tmp84_ = _tmp83_;

695

_tmp85_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp84_);

696

_tmp86_ = _tmp85_;

697

_tmp87_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp86_, VALA_TYPE_INTERFACE, ValaInterface));

698

base_iface = _tmp87_;

699

_tmp88_ = vala_ccode_base_module_get_current_class ((ValaCCodeBaseModule*) self);

700

_tmp89_ = _tmp88_;

701

_tmp90_ = vala_ccode_base_module_get_ccode_lower_case_name ((ValaCodeNode*) _tmp89_, NULL);

702

_tmp91_ = _tmp90_;

703

_tmp92_ = base_iface;

704

_tmp93_ = vala_ccode_base_module_get_ccode_lower_case_name ((ValaCodeNode*) _tmp92_, NULL);

705

_tmp94_ = _tmp93_;

706

_tmp95_ = g_strdup_printf ("%s_%s_parent_iface", _tmp91_, _tmp94_);

707

_tmp96_ = _tmp95_;

708

_g_free0 (_tmp94_);

709

_g_free0 (_tmp91_);

710

parent_iface_var = _tmp96_;

711

_tmp97_ = expr;

712

_tmp98_ = parent_iface_var;

713

_tmp99_ = vala_ccode_identifier_new (_tmp98_);

714

_tmp100_ = _tmp99_;

715

_tmp101_ = m;

716

_tmp102_ = vala_ccode_base_module_get_ccode_vfunc_name (_tmp101_);

717

_tmp103_ = _tmp102_;

718

_tmp104_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp100_, _tmp103_);

719

_tmp105_ = _tmp104_;

720

vala_ccode_base_module_set_cvalue ((ValaCCodeBaseModule*) self, (ValaExpression*) _tmp97_, (ValaCCodeExpression*) _tmp105_);

721

_vala_ccode_node_unref0 (_tmp105_);

722

_g_free0 (_tmp103_);

723

_vala_ccode_node_unref0 (_tmp100_);

724

_g_free0 (parent_iface_var);

725

_vala_code_node_unref0 (base_iface);

726

_vala_code_node_unref0 (m);

727

_vala_code_node_unref0 (delegate_type);

728

_vala_code_node_unref0 (array_type);

729

_vala_ccode_node_unref0 (pub_inst);

730

return;

731

}

732

}

733

}

734

_tmp106_ = m;

735

_tmp107_ = vala_method_get_base_method (_tmp106_);

736

_tmp108_ = _tmp107_;

737

if (_tmp108_ != NULL) {

738

ValaMethod* _tmp109_;

739

ValaMethod* _tmp110_;

740

ValaMethod* _tmp111_;

741

gboolean _tmp112_ = FALSE;

742

_tmp109_ = m;

743

_tmp110_ = vala_method_get_base_method (_tmp109_);

744

_tmp111_ = _tmp110_;

745

_tmp112_ = vala_ccode_base_module_method_has_wrapper ((ValaCCodeBaseModule*) self, _tmp111_);

746

if (!_tmp112_) {

747

ValaMethod* _tmp113_;

748

ValaMethod* _tmp114_;

749

ValaMethod* _tmp115_;

750

ValaSymbol* _tmp116_;

751

ValaSymbol* _tmp117_;

752

ValaClass* _tmp118_;

753

ValaClass* base_class;

754

ValaClass* _tmp119_;

755

gchar* _tmp120_ = NULL;

756

gchar* _tmp121_;

757

gchar* _tmp122_ = NULL;

758

gchar* _tmp123_;

759

ValaCCodeIdentifier* _tmp124_;

760

ValaCCodeIdentifier* _tmp125_;

761

ValaCCodeFunctionCall* _tmp126_;

762

ValaCCodeFunctionCall* _tmp127_;

763

ValaCCodeFunctionCall* vclass;

764

ValaCCodeFunctionCall* _tmp128_;

765

ValaCCodeExpression* _tmp129_;

766

ValaMemberAccess* _tmp130_;

767

ValaCCodeFunctionCall* _tmp131_;

768

ValaMethod* _tmp132_;

769

gchar* _tmp133_ = NULL;

770

gchar* _tmp134_;

771

ValaCCodeMemberAccess* _tmp135_;

772

ValaCCodeMemberAccess* _tmp136_;

773

_tmp113_ = m;

774

_tmp114_ = vala_method_get_base_method (_tmp113_);

775

_tmp115_ = _tmp114_;

776

_tmp116_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp115_);

777

_tmp117_ = _tmp116_;

778

_tmp118_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp117_, VALA_TYPE_CLASS, ValaClass));

779

base_class = _tmp118_;

780

_tmp119_ = base_class;

781

_tmp120_ = vala_ccode_base_module_get_ccode_upper_case_name ((ValaSymbol*) _tmp119_, NULL);

782

_tmp121_ = _tmp120_;

783

_tmp122_ = g_strdup_printf ("%s_GET_CLASS", _tmp121_);

784

_tmp123_ = _tmp122_;

785

_tmp124_ = vala_ccode_identifier_new (_tmp123_);

786

_tmp125_ = _tmp124_;

787

_tmp126_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp125_);

788

_tmp127_ = _tmp126_;

789

_vala_ccode_node_unref0 (_tmp125_);

790

_g_free0 (_tmp123_);

791

_g_free0 (_tmp121_);

792

vclass = _tmp127_;

793

_tmp128_ = vclass;

794

_tmp129_ = pub_inst;

795

vala_ccode_function_call_add_argument (_tmp128_, _tmp129_);

796

_tmp130_ = expr;

797

_tmp131_ = vclass;

798

_tmp132_ = m;

799

_tmp133_ = vala_ccode_base_module_get_ccode_vfunc_name (_tmp132_);

800

_tmp134_ = _tmp133_;

801

_tmp135_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp131_, _tmp134_);

802

_tmp136_ = _tmp135_;

803

vala_ccode_base_module_set_cvalue ((ValaCCodeBaseModule*) self, (ValaExpression*) _tmp130_, (ValaCCodeExpression*) _tmp136_);

804

_vala_ccode_node_unref0 (_tmp136_);

805

_g_free0 (_tmp134_);

806

_vala_ccode_node_unref0 (vclass);

807

_vala_code_node_unref0 (base_class);

808

} else {

809

ValaMemberAccess* _tmp137_;

810

ValaMethod* _tmp138_;

811

ValaMethod* _tmp139_;

812

ValaMethod* _tmp140_;

813

gchar* _tmp141_ = NULL;

814

gchar* _tmp142_;

815

ValaCCodeIdentifier* _tmp143_;

816

ValaCCodeIdentifier* _tmp144_;

817

_tmp137_ = expr;

818

_tmp138_ = m;

819

_tmp139_ = vala_method_get_base_method (_tmp138_);

820

_tmp140_ = _tmp139_;

821

_tmp141_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp140_);

822

_tmp142_ = _tmp141_;

823

_tmp143_ = vala_ccode_identifier_new (_tmp142_);

824

_tmp144_ = _tmp143_;

825

vala_ccode_base_module_set_cvalue ((ValaCCodeBaseModule*) self, (ValaExpression*) _tmp137_, (ValaCCodeExpression*) _tmp144_);

826

_vala_ccode_node_unref0 (_tmp144_);

827

_g_free0 (_tmp142_);

828

}

829

} else {

830

ValaMethod* _tmp145_;

831

ValaMethod* _tmp146_;

832

ValaMethod* _tmp147_;

833

_tmp145_ = m;

834

_tmp146_ = vala_method_get_base_interface_method (_tmp145_);

835

_tmp147_ = _tmp146_;

836

if (_tmp147_ != NULL) {

837

ValaMemberAccess* _tmp148_;

838

ValaMethod* _tmp149_;

839

ValaMethod* _tmp150_;

840

ValaMethod* _tmp151_;

841

gchar* _tmp152_ = NULL;

842

gchar* _tmp153_;

843

ValaCCodeIdentifier* _tmp154_;

844

ValaCCodeIdentifier* _tmp155_;

845

_tmp148_ = expr;

846

_tmp149_ = m;

847

_tmp150_ = vala_method_get_base_interface_method (_tmp149_);

848

_tmp151_ = _tmp150_;

849

_tmp152_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp151_);

850

_tmp153_ = _tmp152_;

851

_tmp154_ = vala_ccode_identifier_new (_tmp153_);

852

_tmp155_ = _tmp154_;

853

vala_ccode_base_module_set_cvalue ((ValaCCodeBaseModule*) self, (ValaExpression*) _tmp148_, (ValaCCodeExpression*) _tmp155_);

854

_vala_ccode_node_unref0 (_tmp155_);

855

_g_free0 (_tmp153_);

856

} else {

857

ValaMethod* _tmp156_;

858

_tmp156_ = m;

859

if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp156_, VALA_TYPE_CREATION_METHOD)) {

860

ValaMemberAccess* _tmp157_;

861

ValaMethod* _tmp158_;

862

gchar* _tmp159_ = NULL;

863

gchar* _tmp160_;

864

ValaCCodeIdentifier* _tmp161_;

865

ValaCCodeIdentifier* _tmp162_;

866

_tmp157_ = expr;

867

_tmp158_ = m;

868

_tmp159_ = vala_ccode_base_module_get_ccode_real_name ((ValaSymbol*) _tmp158_);

869

_tmp160_ = _tmp159_;

870

_tmp161_ = vala_ccode_identifier_new (_tmp160_);

871

_tmp162_ = _tmp161_;

872

vala_ccode_base_module_set_cvalue ((ValaCCodeBaseModule*) self, (ValaExpression*) _tmp157_, (ValaCCodeExpression*) _tmp162_);

873

_vala_ccode_node_unref0 (_tmp162_);

874

_g_free0 (_tmp160_);

875

} else {

876

ValaMemberAccess* _tmp163_;

877

ValaMethod* _tmp164_;

878

gchar* _tmp165_ = NULL;

879

gchar* _tmp166_;

880

ValaCCodeIdentifier* _tmp167_;

881

ValaCCodeIdentifier* _tmp168_;

882

_tmp163_ = expr;

883

_tmp164_ = m;

884

_tmp165_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp164_);

885

_tmp166_ = _tmp165_;

886

_tmp167_ = vala_ccode_identifier_new (_tmp166_);

887

_tmp168_ = _tmp167_;

888

vala_ccode_base_module_set_cvalue ((ValaCCodeBaseModule*) self, (ValaExpression*) _tmp163_, (ValaCCodeExpression*) _tmp168_);

889

_vala_ccode_node_unref0 (_tmp168_);

890

_g_free0 (_tmp166_);

891

}

892

}

893

}

894

_tmp169_ = expr;

895

_tmp170_ = vala_ccode_constant_new ("NULL");

896

_tmp171_ = _tmp170_;

897

vala_ccode_base_module_set_delegate_target_destroy_notify ((ValaCCodeBaseModule*) self, (ValaExpression*) _tmp169_, (ValaCCodeExpression*) _tmp171_);

898

_vala_ccode_node_unref0 (_tmp171_);

899

_tmp172_ = m;

900

_tmp173_ = vala_method_get_binding (_tmp172_);

901

_tmp174_ = _tmp173_;

902

if (_tmp174_ == VALA_MEMBER_BINDING_STATIC) {

903

ValaMemberAccess* _tmp175_;

904

ValaCCodeConstant* _tmp176_;

905

ValaCCodeConstant* _tmp177_;

906

_tmp175_ = expr;

907

_tmp176_ = vala_ccode_constant_new ("NULL");

908

_tmp177_ = _tmp176_;

909

vala_ccode_base_module_set_delegate_target ((ValaCCodeBaseModule*) self, (ValaExpression*) _tmp175_, (ValaCCodeExpression*) _tmp177_);

910

_vala_ccode_node_unref0 (_tmp177_);

911

} else {

912

ValaMethod* _tmp178_;

913

gboolean _tmp179_;

914

gboolean _tmp180_;

915

_tmp178_ = m;

916

_tmp179_ = vala_method_get_is_async_callback (_tmp178_);

917

_tmp180_ = _tmp179_;

918

if (_tmp180_) {

919

ValaMethod* _tmp181_;

920

ValaMethod* _tmp182_;

921

gboolean _tmp183_;

922

gboolean _tmp184_;

923

_tmp181_ = vala_ccode_base_module_get_current_method ((ValaCCodeBaseModule*) self);

924

_tmp182_ = _tmp181_;

925

_tmp183_ = vala_method_get_closure (_tmp182_);

926

_tmp184_ = _tmp183_;

927

if (_tmp184_) {

928

ValaMethod* _tmp185_;

929

ValaSymbol* _tmp186_;

930

ValaSymbol* _tmp187_;

931

ValaBlock* _tmp188_;

932

ValaBlock* _tmp189_;

933

ValaBlock* _tmp190_;

934

ValaBlock* block;

935

ValaMemberAccess* _tmp191_;

936

ValaBlock* _tmp192_;

937

gint _tmp193_ = 0;

938

gchar* _tmp194_ = NULL;

939

gchar* _tmp195_;

940

ValaCCodeExpression* _tmp196_ = NULL;

941

ValaCCodeExpression* _tmp197_;

942

ValaCCodeMemberAccess* _tmp198_;

943

ValaCCodeMemberAccess* _tmp199_;

944

_tmp185_ = m;

945

_tmp186_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp185_);

946

_tmp187_ = _tmp186_;

947

_tmp188_ = vala_subroutine_get_body ((ValaSubroutine*) G_TYPE_CHECK_INSTANCE_CAST (_tmp187_, VALA_TYPE_METHOD, ValaMethod));

948

_tmp189_ = _tmp188_;

949

_tmp190_ = _vala_code_node_ref0 (_tmp189_);

950

block = _tmp190_;

951

_tmp191_ = expr;

952

_tmp192_ = block;

953

_tmp193_ = vala_ccode_base_module_get_block_id ((ValaCCodeBaseModule*) self, _tmp192_);

954

_tmp194_ = g_strdup_printf ("_data%d_", _tmp193_);

955

_tmp195_ = _tmp194_;

956

_tmp196_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, _tmp195_);

957

_tmp197_ = _tmp196_;

958

_tmp198_ = vala_ccode_member_access_new_pointer (_tmp197_, "_async_data_");

959

_tmp199_ = _tmp198_;

960

vala_ccode_base_module_set_delegate_target ((ValaCCodeBaseModule*) self, (ValaExpression*) _tmp191_, (ValaCCodeExpression*) _tmp199_);

961

_vala_ccode_node_unref0 (_tmp199_);

962

_vala_ccode_node_unref0 (_tmp197_);

963

_g_free0 (_tmp195_);

964

_vala_code_node_unref0 (block);

965

} else {

966

ValaMemberAccess* _tmp200_;

967

ValaCCodeIdentifier* _tmp201_;

968

ValaCCodeIdentifier* _tmp202_;

969

_tmp200_ = expr;

970

_tmp201_ = vala_ccode_identifier_new ("_data_");

971

_tmp202_ = _tmp201_;

972

vala_ccode_base_module_set_delegate_target ((ValaCCodeBaseModule*) self, (ValaExpression*) _tmp200_, (ValaCCodeExpression*) _tmp202_);

973

_vala_ccode_node_unref0 (_tmp202_);

974

}

975

} else {

976

gboolean _tmp203_ = FALSE;

977

ValaMemberAccess* _tmp204_;

978

ValaExpression* _tmp205_;

979

ValaExpression* _tmp206_;

980

gboolean _tmp210_;

981

_tmp204_ = expr;

982

_tmp205_ = vala_member_access_get_inner (_tmp204_);

983

_tmp206_ = _tmp205_;

984

if (_tmp206_ != NULL) {

985

ValaMemberAccess* _tmp207_;

986

gboolean _tmp208_;

987

gboolean _tmp209_;

988

_tmp207_ = expr;

989

_tmp208_ = vala_member_access_get_prototype_access (_tmp207_);

990

_tmp209_ = _tmp208_;

991

_tmp203_ = !_tmp209_;

992

} else {

993

_tmp203_ = FALSE;

994

}

995

_tmp210_ = _tmp203_;

996

if (_tmp210_) {

997

ValaMemberAccess* _tmp211_;

998

ValaExpression* _tmp212_;

999

ValaExpression* _tmp213_;

1000

ValaCCodeExpression* _tmp214_ = NULL;

1001

ValaCCodeExpression* delegate_target;

1002

ValaMemberAccess* _tmp215_;

1003

ValaDataType* _tmp216_;

1004

ValaDataType* _tmp217_;

1005

ValaDelegateType* _tmp218_;

1006

gboolean _tmp219_ = FALSE;

1007

gboolean _tmp220_ = FALSE;

1008

gboolean _tmp221_ = FALSE;

1009

ValaMemberAccess* _tmp222_;

1010

ValaDataType* _tmp223_;

1011

ValaDataType* _tmp224_;

1012

gboolean _tmp225_;

1013

gboolean _tmp226_;

1014

gboolean _tmp233_;

1015

gboolean _tmp241_;

1016

gboolean _tmp250_;

1017

ValaMemberAccess* _tmp275_;

1018

ValaCCodeExpression* _tmp276_;

1019

_tmp211_ = expr;

1020

_tmp212_ = vala_member_access_get_inner (_tmp211_);

1021

_tmp213_ = _tmp212_;

1022

_tmp214_ = vala_ccode_base_module_get_ccodenode ((ValaCCodeBaseModule*) self, _tmp213_);

1023

delegate_target = G_TYPE_CHECK_INSTANCE_CAST (_tmp214_, VALA_TYPE_CCODE_EXPRESSION, ValaCCodeExpression);

1024

_tmp215_ = expr;

1025

_tmp216_ = vala_expression_get_target_type ((ValaExpression*) _tmp215_);

1026

_tmp217_ = _tmp216_;

1027

_tmp218_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp217_, VALA_TYPE_DELEGATE_TYPE) ? ((ValaDelegateType*) _tmp217_) : NULL);

1028

_vala_code_node_unref0 (delegate_type);

1029

delegate_type = _tmp218_;

1030

_tmp222_ = expr;

1031

_tmp223_ = vala_expression_get_value_type ((ValaExpression*) _tmp222_);

1032

_tmp224_ = _tmp223_;

1033

_tmp225_ = vala_data_type_get_value_owned (_tmp224_);

1034

_tmp226_ = _tmp225_;

1035

if (_tmp226_) {

1036

_tmp221_ = TRUE;

1037

} else {

1038

gboolean _tmp227_ = FALSE;

1039

ValaDelegateType* _tmp228_;

1040

gboolean _tmp232_;

1041

_tmp228_ = delegate_type;

1042

if (_tmp228_ != NULL) {

1043

ValaDelegateType* _tmp229_;

1044

gboolean _tmp230_;

1045

gboolean _tmp231_;

1046

_tmp229_ = delegate_type;

1047

_tmp230_ = vala_delegate_type_get_is_called_once (_tmp229_);

1048

_tmp231_ = _tmp230_;

1049

_tmp227_ = _tmp231_;

1050

} else {

1051

_tmp227_ = FALSE;

1052

}

1053

_tmp232_ = _tmp227_;

1054

_tmp221_ = _tmp232_;

1055

}

1056

_tmp233_ = _tmp221_;

1057

if (_tmp233_) {

1058

ValaMemberAccess* _tmp234_;

1059

ValaExpression* _tmp235_;

1060

ValaExpression* _tmp236_;

1061

ValaDataType* _tmp237_;

1062

ValaDataType* _tmp238_;

1063

ValaTypeSymbol* _tmp239_;

1064

ValaTypeSymbol* _tmp240_;

1065

_tmp234_ = expr;

1066

_tmp235_ = vala_member_access_get_inner (_tmp234_);

1067

_tmp236_ = _tmp235_;

1068

_tmp237_ = vala_expression_get_value_type (_tmp236_);

1069

_tmp238_ = _tmp237_;

1070

_tmp239_ = vala_data_type_get_data_type (_tmp238_);

1071

_tmp240_ = _tmp239_;

1072

_tmp220_ = _tmp240_ != NULL;

1073

} else {

1074

_tmp220_ = FALSE;

1075

}

1076

_tmp241_ = _tmp220_;

1077

if (_tmp241_) {

1078

ValaMemberAccess* _tmp242_;

1079

ValaExpression* _tmp243_;

1080

ValaExpression* _tmp244_;

1081

ValaDataType* _tmp245_;

1082

ValaDataType* _tmp246_;

1083

ValaTypeSymbol* _tmp247_;

1084

ValaTypeSymbol* _tmp248_;

1085

gboolean _tmp249_ = FALSE;

1086

_tmp242_ = expr;

1087

_tmp243_ = vala_member_access_get_inner (_tmp242_);

1088

_tmp244_ = _tmp243_;

1089

_tmp245_ = vala_expression_get_value_type (_tmp244_);

1090

_tmp246_ = _tmp245_;

1091

_tmp247_ = vala_data_type_get_data_type (_tmp246_);

1092

_tmp248_ = _tmp247_;

1093

_tmp249_ = vala_ccode_base_module_is_reference_counting (_tmp248_);

1094

_tmp219_ = _tmp249_;

1095

} else {

1096

_tmp219_ = FALSE;

1097

}

1098

_tmp250_ = _tmp219_;

1099

if (_tmp250_) {

1100

ValaMemberAccess* _tmp251_;

1101

ValaExpression* _tmp252_;

1102

ValaExpression* _tmp253_;

1103

ValaDataType* _tmp254_;

1104

ValaDataType* _tmp255_;

1105

ValaMemberAccess* _tmp256_;

1106

ValaSourceReference* _tmp257_;

1107

ValaSourceReference* _tmp258_;

1108

ValaCCodeExpression* _tmp259_ = NULL;

1109

ValaCCodeExpression* _tmp260_;

1110

ValaCCodeFunctionCall* _tmp261_;

1111

ValaCCodeFunctionCall* _tmp262_;

1112

ValaCCodeFunctionCall* ref_call;

1113

ValaCCodeFunctionCall* _tmp263_;

1114

ValaCCodeExpression* _tmp264_;

1115

ValaCCodeFunctionCall* _tmp265_;

1116

ValaCCodeExpression* _tmp266_;

1117

ValaMemberAccess* _tmp267_;

1118

ValaMemberAccess* _tmp268_;

1119

ValaExpression* _tmp269_;

1120

ValaExpression* _tmp270_;

1121

ValaDataType* _tmp271_;

1122

ValaDataType* _tmp272_;

1123

ValaCCodeExpression* _tmp273_ = NULL;

1124

ValaCCodeExpression* _tmp274_;

1125

_tmp251_ = expr;

1126

_tmp252_ = vala_member_access_get_inner (_tmp251_);

1127

_tmp253_ = _tmp252_;

1128

_tmp254_ = vala_expression_get_value_type (_tmp253_);

1129

_tmp255_ = _tmp254_;

1130

_tmp256_ = expr;

1131

_tmp257_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp256_);

1132

_tmp258_ = _tmp257_;

1133

_tmp259_ = vala_ccode_base_module_get_dup_func_expression ((ValaCCodeBaseModule*) self, _tmp255_, _tmp258_, FALSE);

1134

_tmp260_ = _tmp259_;

1135

_tmp261_ = vala_ccode_function_call_new (_tmp260_);

1136

_tmp262_ = _tmp261_;

1137

_vala_ccode_node_unref0 (_tmp260_);

1138

ref_call = _tmp262_;

1139

_tmp263_ = ref_call;

1140

_tmp264_ = delegate_target;

1141

vala_ccode_function_call_add_argument (_tmp263_, _tmp264_);

1142

_tmp265_ = ref_call;

1143

_tmp266_ = _vala_ccode_node_ref0 ((ValaCCodeExpression*) _tmp265_);

1144

_vala_ccode_node_unref0 (delegate_target);

1145

delegate_target = _tmp266_;

1146

_tmp267_ = expr;

1147

_tmp268_ = expr;

1148

_tmp269_ = vala_member_access_get_inner (_tmp268_);

1149

_tmp270_ = _tmp269_;

1150

_tmp271_ = vala_expression_get_value_type (_tmp270_);

1151

_tmp272_ = _tmp271_;

1152

_tmp273_ = vala_ccode_base_module_get_destroy_func_expression ((ValaCCodeBaseModule*) self, _tmp272_, FALSE);

1153

_tmp274_ = _tmp273_;

1154

vala_ccode_base_module_set_delegate_target_destroy_notify ((ValaCCodeBaseModule*) self, (ValaExpression*) _tmp267_, _tmp274_);

1155

_vala_ccode_node_unref0 (_tmp274_);

1156

_vala_ccode_node_unref0 (ref_call);

1157

}

1158

_tmp275_ = expr;

1159

_tmp276_ = delegate_target;

1160

vala_ccode_base_module_set_delegate_target ((ValaCCodeBaseModule*) self, (ValaExpression*) _tmp275_, _tmp276_);

1161

_vala_ccode_node_unref0 (delegate_target);

1162

}

1163

}

1164

}

1165

_vala_code_node_unref0 (m);

1166

} else {

1167

ValaMemberAccess* _tmp277_;

1168

ValaSymbol* _tmp278_;

1169

ValaSymbol* _tmp279_;

1170

_tmp277_ = expr;

1171

_tmp278_ = vala_expression_get_symbol_reference ((ValaExpression*) _tmp277_);

1172

_tmp279_ = _tmp278_;

1173

if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp279_, VALA_TYPE_ARRAY_LENGTH_FIELD)) {

1174

gboolean _tmp280_ = FALSE;

1175

ValaMemberAccess* _tmp281_;

1176

ValaDataType* _tmp282_;

1177

ValaDataType* _tmp283_;

1178

gboolean _tmp287_;

1179

ValaMemberAccess* _tmp291_;

1180

ValaMemberAccess* _tmp292_;

1181

ValaExpression* _tmp293_;

1182

ValaExpression* _tmp294_;

1183

ValaCCodeExpression* _tmp295_ = NULL;

1184

ValaCCodeExpression* _tmp296_;

1185

_tmp281_ = expr;

1186

_tmp282_ = vala_expression_get_value_type ((ValaExpression*) _tmp281_);

1187

_tmp283_ = _tmp282_;

1188

if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp283_, VALA_TYPE_ARRAY_TYPE)) {

1189

ValaMemberAccess* _tmp284_;

1190

ValaCodeNode* _tmp285_;

1191

ValaCodeNode* _tmp286_;

1192

_tmp284_ = expr;

1193

_tmp285_ = vala_code_node_get_parent_node ((ValaCodeNode*) _tmp284_);

1194

_tmp286_ = _tmp285_;

1195

_tmp280_ = !G_TYPE_CHECK_INSTANCE_TYPE (_tmp286_, VALA_TYPE_ELEMENT_ACCESS);

1196

} else {

1197

_tmp280_ = FALSE;

1198

}

1199

_tmp287_ = _tmp280_;

1200

if (_tmp287_) {

1201

ValaMemberAccess* _tmp288_;

1202

ValaSourceReference* _tmp289_;

1203

ValaSourceReference* _tmp290_;

1204

_tmp288_ = expr;

1205

_tmp289_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp288_);

1206

_tmp290_ = _tmp289_;

1207

vala_report_error (_tmp290_, "unsupported use of length field of multi-dimensional array");

1208

}

1209

_tmp291_ = expr;

1210

_tmp292_ = expr;

1211

_tmp293_ = vala_member_access_get_inner (_tmp292_);

1212

_tmp294_ = _tmp293_;

1213

_tmp295_ = vala_ccode_base_module_get_array_length_cexpression ((ValaCCodeBaseModule*) self, _tmp294_, 1);

1214

_tmp296_ = _tmp295_;

1215

vala_ccode_base_module_set_cvalue ((ValaCCodeBaseModule*) self, (ValaExpression*) _tmp291_, _tmp296_);

1216

_vala_ccode_node_unref0 (_tmp296_);

1217

} else {

1218

ValaMemberAccess* _tmp297_;

1219

ValaSymbol* _tmp298_;

1220

ValaSymbol* _tmp299_;

1221

_tmp297_ = expr;

1222

_tmp298_ = vala_expression_get_symbol_reference ((ValaExpression*) _tmp297_);

1223

_tmp299_ = _tmp298_;

1224

if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp299_, VALA_TYPE_FIELD)) {

1225

ValaMemberAccess* _tmp300_;

1226

ValaSymbol* _tmp301_;

1227

ValaSymbol* _tmp302_;

1228

ValaField* _tmp303_;

1229

ValaField* field;

1230

ValaMemberAccess* _tmp304_;

1231

gboolean _tmp305_;

1232

gboolean _tmp306_;

1233

_tmp300_ = expr;

1234

_tmp301_ = vala_expression_get_symbol_reference ((ValaExpression*) _tmp300_);

1235

_tmp302_ = _tmp301_;

1236

_tmp303_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp302_, VALA_TYPE_FIELD, ValaField));

1237

field = _tmp303_;

1238

_tmp304_ = expr;

1239

_tmp305_ = vala_expression_get_lvalue ((ValaExpression*) _tmp304_);

1240

_tmp306_ = _tmp305_;

1241

if (_tmp306_) {

1242

ValaTargetValue* _tmp307_ = NULL;

1243

ValaMemberAccess* _tmp308_;

1244

ValaExpression* _tmp309_;

1245

ValaExpression* _tmp310_;

1246

ValaMemberAccess* _tmp316_;

1247

ValaField* _tmp317_;

1248

ValaTargetValue* _tmp318_;

1249

ValaTargetValue* _tmp319_ = NULL;

1250

ValaTargetValue* _tmp320_;

1251

_tmp308_ = expr;

1252

_tmp309_ = vala_member_access_get_inner (_tmp308_);

1253

_tmp310_ = _tmp309_;

1254

if (_tmp310_ != NULL) {

1255

ValaMemberAccess* _tmp311_;

1256

ValaExpression* _tmp312_;

1257

ValaExpression* _tmp313_;

1258

ValaTargetValue* _tmp314_;

1259

ValaTargetValue* _tmp315_;

1260

_tmp311_ = expr;

1261

_tmp312_ = vala_member_access_get_inner (_tmp311_);

1262

_tmp313_ = _tmp312_;

1263

_tmp314_ = vala_expression_get_target_value (_tmp313_);

1264

_tmp315_ = _tmp314_;

1265

_tmp307_ = _tmp315_;

1266

} else {

1267

_tmp307_ = NULL;

1268

}

1269

_tmp316_ = expr;

1270

_tmp317_ = field;

1271

_tmp318_ = _tmp307_;

1272

_tmp319_ = vala_ccode_base_module_get_field_cvalue ((ValaCCodeBaseModule*) self, _tmp317_, _tmp318_);

1273

_tmp320_ = _tmp319_;

1274

vala_expression_set_target_value ((ValaExpression*) _tmp316_, _tmp320_);

1275

_vala_target_value_unref0 (_tmp320_);

1276

} else {

1277

ValaTargetValue* _tmp321_ = NULL;

1278

ValaMemberAccess* _tmp322_;

1279

ValaExpression* _tmp323_;

1280

ValaExpression* _tmp324_;

1281

ValaMemberAccess* _tmp330_;

1282

ValaField* _tmp331_;

1283

ValaTargetValue* _tmp332_;

1284

ValaTargetValue* _tmp333_ = NULL;

1285

ValaTargetValue* _tmp334_;

1286

_tmp322_ = expr;

1287

_tmp323_ = vala_member_access_get_inner (_tmp322_);

1288

_tmp324_ = _tmp323_;

1289

if (_tmp324_ != NULL) {

1290

ValaMemberAccess* _tmp325_;

1291

ValaExpression* _tmp326_;

1292

ValaExpression* _tmp327_;

1293

ValaTargetValue* _tmp328_;

1294

ValaTargetValue* _tmp329_;

1295

_tmp325_ = expr;

1296

_tmp326_ = vala_member_access_get_inner (_tmp325_);

1297

_tmp327_ = _tmp326_;

1298

_tmp328_ = vala_expression_get_target_value (_tmp327_);

1299

_tmp329_ = _tmp328_;

1300

_tmp321_ = _tmp329_;

1301

} else {

1302

_tmp321_ = NULL;

1303

}

1304

_tmp330_ = expr;

1305

_tmp331_ = field;

1306

_tmp332_ = _tmp321_;

1307

_tmp333_ = vala_code_generator_load_field ((ValaCodeGenerator*) self, _tmp331_, _tmp332_);

1308

_tmp334_ = _tmp333_;

1309

vala_expression_set_target_value ((ValaExpression*) _tmp330_, _tmp334_);

1310

_vala_target_value_unref0 (_tmp334_);

1311

}

1312

_vala_code_node_unref0 (field);

1313

} else {

1314

ValaMemberAccess* _tmp335_;

1315

ValaSymbol* _tmp336_;

1316

ValaSymbol* _tmp337_;

1317

_tmp335_ = expr;

1318

_tmp336_ = vala_expression_get_symbol_reference ((ValaExpression*) _tmp335_);

1319

_tmp337_ = _tmp336_;

1320

if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp337_, VALA_TYPE_ENUM_VALUE)) {

1321

ValaMemberAccess* _tmp338_;

1322

ValaSymbol* _tmp339_;

1323

ValaSymbol* _tmp340_;

1324

ValaEnumValue* _tmp341_;

1325

ValaEnumValue* ev;

1326

ValaEnumValue* _tmp342_;

1327

ValaSymbol* _tmp343_;

1328

ValaSymbol* _tmp344_;

1329

ValaCCodeFile* _tmp345_;

1330

ValaMemberAccess* _tmp346_;

1331

ValaEnumValue* _tmp347_;

1332

gchar* _tmp348_ = NULL;

1333

gchar* _tmp349_;

1334

ValaCCodeConstant* _tmp350_;

1335

ValaCCodeConstant* _tmp351_;

1336

_tmp338_ = expr;

1337

_tmp339_ = vala_expression_get_symbol_reference ((ValaExpression*) _tmp338_);

1338

_tmp340_ = _tmp339_;

1339

_tmp341_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp340_, VALA_TYPE_ENUM_VALUE, ValaEnumValue));

1340

ev = _tmp341_;

1341

_tmp342_ = ev;

1342

_tmp343_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp342_);

1343

_tmp344_ = _tmp343_;

1344

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

1345

vala_ccode_base_module_generate_enum_declaration ((ValaCCodeBaseModule*) self, G_TYPE_CHECK_INSTANCE_CAST (_tmp344_, VALA_TYPE_ENUM, ValaEnum), _tmp345_);

1346

_tmp346_ = expr;

1347

_tmp347_ = ev;

1348

_tmp348_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp347_);

1349

_tmp349_ = _tmp348_;

1350

_tmp350_ = vala_ccode_constant_new (_tmp349_);

1351

_tmp351_ = _tmp350_;

1352

vala_ccode_base_module_set_cvalue ((ValaCCodeBaseModule*) self, (ValaExpression*) _tmp346_, (ValaCCodeExpression*) _tmp351_);

1353

_vala_ccode_node_unref0 (_tmp351_);

1354

_g_free0 (_tmp349_);

1355

_vala_code_node_unref0 (ev);

1356

} else {

1357

ValaMemberAccess* _tmp352_;

1358

ValaSymbol* _tmp353_;

1359

ValaSymbol* _tmp354_;

1360

_tmp352_ = expr;

1361

_tmp353_ = vala_expression_get_symbol_reference ((ValaExpression*) _tmp352_);

1362

_tmp354_ = _tmp353_;

1363

if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp354_, VALA_TYPE_CONSTANT)) {

1364

ValaMemberAccess* _tmp355_;

1365

ValaSymbol* _tmp356_;

1366

ValaSymbol* _tmp357_;

1367

ValaConstant* _tmp358_;

1368

ValaConstant* c;

1369

gboolean _tmp359_ = FALSE;

1370

gboolean _tmp360_ = FALSE;

1371

ValaConstant* _tmp361_;

1372

ValaSourceReference* _tmp362_;

1373

ValaSourceReference* _tmp363_;

1374

gboolean _tmp367_;

1375

ValaConstant* _tmp378_;

1376

ValaCCodeFile* _tmp379_;

1377

gboolean _tmp380_;

1378

ValaConstant* _tmp381_;

1379

gchar* _tmp382_ = NULL;

1380

gchar* fn;

1381

const gchar* _tmp383_;

1382

ValaArrayType* _tmp430_;

1383

_tmp355_ = expr;

1384

_tmp356_ = vala_expression_get_symbol_reference ((ValaExpression*) _tmp355_);

1385

_tmp357_ = _tmp356_;

1386

_tmp358_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp357_, VALA_TYPE_CONSTANT, ValaConstant));

1387

c = _tmp358_;

1388

_tmp361_ = c;

1389

_tmp362_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp361_);

1390

_tmp363_ = _tmp362_;

1391

if (_tmp363_ != NULL) {

1392

ValaMemberAccess* _tmp364_;

1393

ValaSourceReference* _tmp365_;

1394

ValaSourceReference* _tmp366_;

1395

_tmp364_ = expr;

1396

_tmp365_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp364_);

1397

_tmp366_ = _tmp365_;

1398

_tmp360_ = _tmp366_ != NULL;

1399

} else {

1400

_tmp360_ = FALSE;

1401

}

1402

_tmp367_ = _tmp360_;

1403

if (_tmp367_) {

1404

ValaConstant* _tmp368_;

1405

ValaSourceReference* _tmp369_;

1406

ValaSourceReference* _tmp370_;

1407

ValaSourceFile* _tmp371_;

1408

ValaSourceFile* _tmp372_;

1409

ValaMemberAccess* _tmp373_;

1410

ValaSourceReference* _tmp374_;

1411

ValaSourceReference* _tmp375_;

1412

ValaSourceFile* _tmp376_;

1413

ValaSourceFile* _tmp377_;

1414

_tmp368_ = c;

1415

_tmp369_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp368_);

1416

_tmp370_ = _tmp369_;

1417

_tmp371_ = vala_source_reference_get_file (_tmp370_);

1418

_tmp372_ = _tmp371_;

1419

_tmp373_ = expr;

1420

_tmp374_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp373_);

1421

_tmp375_ = _tmp374_;

1422

_tmp376_ = vala_source_reference_get_file (_tmp375_);

1423

_tmp377_ = _tmp376_;

1424

_tmp359_ = _tmp372_ == _tmp377_;

1425

} else {

1426

_tmp359_ = FALSE;

1427

}

1428

_tmp378_ = c;

1429

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

1430

_tmp380_ = _tmp359_;

1431

vala_ccode_base_module_generate_constant_declaration ((ValaCCodeBaseModule*) self, _tmp378_, _tmp379_, _tmp380_);

1432

_tmp381_ = c;

1433

_tmp382_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp381_);

1434

fn = _tmp382_;

1435

_tmp383_ = fn;

1436

if (g_strcmp0 (_tmp383_, "GLib.Log.FILE") == 0) {

1437

ValaMemberAccess* _tmp384_;

1438

ValaSourceReference* _tmp385_;

1439

ValaSourceReference* _tmp386_;

1440

ValaSourceFile* _tmp387_;

1441

ValaSourceFile* _tmp388_;

1442

const gchar* _tmp389_;

1443

const gchar* _tmp390_;

1444

gchar* _tmp391_ = NULL;

1445

gchar* s;

1446

ValaMemberAccess* _tmp392_;

1447

const gchar* _tmp393_;

1448

gchar* _tmp394_ = NULL;

1449

gchar* _tmp395_;

1450

ValaCCodeConstant* _tmp396_;

1451

ValaCCodeConstant* _tmp397_;

1452

_tmp384_ = expr;

1453

_tmp385_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp384_);

1454

_tmp386_ = _tmp385_;

1455

_tmp387_ = vala_source_reference_get_file (_tmp386_);

1456

_tmp388_ = _tmp387_;

1457

_tmp389_ = vala_source_file_get_filename (_tmp388_);

1458

_tmp390_ = _tmp389_;

1459

_tmp391_ = g_path_get_basename (_tmp390_);

1460

s = _tmp391_;

1461

_tmp392_ = expr;

1462

_tmp393_ = s;

1463

_tmp394_ = g_strdup_printf ("\"%s\"", _tmp393_);

1464

_tmp395_ = _tmp394_;

1465

_tmp396_ = vala_ccode_constant_new (_tmp395_);

1466

_tmp397_ = _tmp396_;

1467

vala_ccode_base_module_set_cvalue ((ValaCCodeBaseModule*) self, (ValaExpression*) _tmp392_, (ValaCCodeExpression*) _tmp397_);

1468

_vala_ccode_node_unref0 (_tmp397_);

1469

_g_free0 (_tmp395_);

1470

_g_free0 (s);

1471

} else {

1472

const gchar* _tmp398_;

1473

_tmp398_ = fn;

1474

if (g_strcmp0 (_tmp398_, "GLib.Log.LINE") == 0) {

1475

ValaMemberAccess* _tmp399_;

1476

ValaSourceReference* _tmp400_;

1477

ValaSourceReference* _tmp401_;

1478

ValaSourceLocation _tmp402_;

1479

ValaSourceLocation _tmp403_;

1480

gint _tmp404_;

1481

gint i;

1482

ValaMemberAccess* _tmp405_;

1483

gint _tmp406_;

1484

gchar* _tmp407_ = NULL;

1485

gchar* _tmp408_;

1486

ValaCCodeConstant* _tmp409_;

1487

ValaCCodeConstant* _tmp410_;

1488

_tmp399_ = expr;

1489

_tmp400_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp399_);

1490

_tmp401_ = _tmp400_;

1491

vala_source_reference_get_begin (_tmp401_, &_tmp402_);

1492

_tmp403_ = _tmp402_;

1493

_tmp404_ = _tmp403_.line;

1494

i = _tmp404_;

1495

_tmp405_ = expr;

1496

_tmp406_ = i;

1497

_tmp407_ = g_strdup_printf ("%d", _tmp406_);

1498

_tmp408_ = _tmp407_;

1499

_tmp409_ = vala_ccode_constant_new (_tmp408_);

1500

_tmp410_ = _tmp409_;

1501

vala_ccode_base_module_set_cvalue ((ValaCCodeBaseModule*) self, (ValaExpression*) _tmp405_, (ValaCCodeExpression*) _tmp410_);

1502

_vala_ccode_node_unref0 (_tmp410_);

1503

_g_free0 (_tmp408_);

1504

} else {

1505

const gchar* _tmp411_;

1506

_tmp411_ = fn;

1507

if (g_strcmp0 (_tmp411_, "GLib.Log.METHOD") == 0) {

1508

gchar* _tmp412_;

1509

gchar* s;

1510

ValaMethod* _tmp413_;

1511

ValaMethod* _tmp414_;

1512

ValaMemberAccess* _tmp418_;

1513

const gchar* _tmp419_;

1514

gchar* _tmp420_ = NULL;

1515

gchar* _tmp421_;

1516

ValaCCodeConstant* _tmp422_;

1517

ValaCCodeConstant* _tmp423_;

1518

_tmp412_ = g_strdup ("");

1519

s = _tmp412_;

1520

_tmp413_ = vala_ccode_base_module_get_current_method ((ValaCCodeBaseModule*) self);

1521

_tmp414_ = _tmp413_;

1522

if (_tmp414_ != NULL) {

1523

ValaMethod* _tmp415_;

1524

ValaMethod* _tmp416_;

1525

gchar* _tmp417_ = NULL;

1526

_tmp415_ = vala_ccode_base_module_get_current_method ((ValaCCodeBaseModule*) self);

1527

_tmp416_ = _tmp415_;

1528

_tmp417_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp416_);

1529

_g_free0 (s);

1530

s = _tmp417_;

1531

}

1532

_tmp418_ = expr;

1533

_tmp419_ = s;

1534

_tmp420_ = g_strdup_printf ("\"%s\"", _tmp419_);

1535

_tmp421_ = _tmp420_;

1536

_tmp422_ = vala_ccode_constant_new (_tmp421_);

1537

_tmp423_ = _tmp422_;

1538

vala_ccode_base_module_set_cvalue ((ValaCCodeBaseModule*) self, (ValaExpression*) _tmp418_, (ValaCCodeExpression*) _tmp423_);

1539

_vala_ccode_node_unref0 (_tmp423_);

1540

_g_free0 (_tmp421_);

1541

_g_free0 (s);

1542

} else {

1543

ValaMemberAccess* _tmp424_;

1544

ValaConstant* _tmp425_;

1545

gchar* _tmp426_ = NULL;

1546

gchar* _tmp427_;

1547

ValaCCodeIdentifier* _tmp428_;

1548

ValaCCodeIdentifier* _tmp429_;

1549

_tmp424_ = expr;

1550

_tmp425_ = c;

1551

_tmp426_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp425_);

1552

_tmp427_ = _tmp426_;

1553

_tmp428_ = vala_ccode_identifier_new (_tmp427_);

1554

_tmp429_ = _tmp428_;

1555

vala_ccode_base_module_set_cvalue ((ValaCCodeBaseModule*) self, (ValaExpression*) _tmp424_, (ValaCCodeExpression*) _tmp429_);

1556

_vala_ccode_node_unref0 (_tmp429_);

1557

_g_free0 (_tmp427_);

1558

}

1559

}

1560

}

1561

_tmp430_ = array_type;

1562

if (_tmp430_ != NULL) {

1563

ValaCCodeIdentifier* _tmp431_;

1564

ValaCCodeIdentifier* _tmp432_;

1565

ValaCCodeFunctionCall* _tmp433_;

1566

ValaCCodeFunctionCall* _tmp434_;

1567

ValaCCodeFunctionCall* ccall;

1568

ValaCCodeFunctionCall* _tmp435_;

1569

ValaConstant* _tmp436_;

1570

gchar* _tmp437_ = NULL;

1571

gchar* _tmp438_;

1572

ValaCCodeIdentifier* _tmp439_;

1573

ValaCCodeIdentifier* _tmp440_;

1574

ValaMemberAccess* _tmp441_;

1575

ValaCCodeFunctionCall* _tmp442_;

1576

_tmp431_ = vala_ccode_identifier_new ("G_N_ELEMENTS");

1577

_tmp432_ = _tmp431_;

1578

_tmp433_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp432_);

1579

_tmp434_ = _tmp433_;

1580

_vala_ccode_node_unref0 (_tmp432_);

1581

ccall = _tmp434_;

1582

_tmp435_ = ccall;

1583

_tmp436_ = c;

1584

_tmp437_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp436_);

1585

_tmp438_ = _tmp437_;

1586

_tmp439_ = vala_ccode_identifier_new (_tmp438_);

1587

_tmp440_ = _tmp439_;

1588

vala_ccode_function_call_add_argument (_tmp435_, (ValaCCodeExpression*) _tmp440_);

1589

_vala_ccode_node_unref0 (_tmp440_);

1590

_g_free0 (_tmp438_);

1591

_tmp441_ = expr;

1592

_tmp442_ = ccall;

1593

vala_ccode_base_module_append_array_length ((ValaCCodeBaseModule*) self, (ValaExpression*) _tmp441_, (ValaCCodeExpression*) _tmp442_);

1594

_vala_ccode_node_unref0 (ccall);

1595

}

1596

_g_free0 (fn);

1597

_vala_code_node_unref0 (c);

1598

} else {

1599

ValaMemberAccess* _tmp443_;

1600

ValaSymbol* _tmp444_;

1601

ValaSymbol* _tmp445_;

1602

_tmp443_ = expr;

1603

_tmp444_ = vala_expression_get_symbol_reference ((ValaExpression*) _tmp443_);

1604

_tmp445_ = _tmp444_;

1605

if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp445_, VALA_TYPE_PROPERTY)) {

1606

ValaMemberAccess* _tmp446_;

1607

ValaSymbol* _tmp447_;

1608

ValaSymbol* _tmp448_;

1609

ValaProperty* _tmp449_;

1610

ValaProperty* prop;

1611

ValaProperty* _tmp450_;

1612

ValaMemberAccess* _tmp466_;

1613

ValaExpression* _tmp467_;

1614

ValaExpression* _tmp468_;

1615

ValaMemberAccess* _tmp802_;

1616

ValaTargetValue* _tmp803_;

1617

ValaTargetValue* _tmp804_;

1618

ValaMemberAccess* _tmp805_;

1619

ValaDataType* _tmp806_;

1620

ValaDataType* _tmp807_;

1621

ValaMemberAccess* _tmp808_;

1622

ValaMemberAccess* _tmp809_;

1623

ValaTargetValue* _tmp810_;

1624

ValaTargetValue* _tmp811_;

1625

ValaMemberAccess* _tmp812_;

1626

ValaTargetValue* _tmp813_ = NULL;

1627

ValaTargetValue* _tmp814_;

1628

_tmp446_ = expr;

1629

_tmp447_ = vala_expression_get_symbol_reference ((ValaExpression*) _tmp446_);

1630

_tmp448_ = _tmp447_;

1631

_tmp449_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp448_, VALA_TYPE_PROPERTY, ValaProperty));

1632

prop = _tmp449_;

1633

_tmp450_ = prop;

1634

if (!G_TYPE_CHECK_INSTANCE_TYPE (_tmp450_, VALA_TYPE_DYNAMIC_PROPERTY)) {

1635

ValaProperty* _tmp451_;

1636

ValaPropertyAccessor* _tmp452_;

1637

ValaPropertyAccessor* _tmp453_;

1638

ValaCCodeFile* _tmp454_;

1639

gboolean _tmp455_ = FALSE;

1640

ValaProperty* _tmp456_;

1641

gboolean _tmp457_;

1642

gboolean _tmp458_;

1643

gboolean _tmp462_;

1644

_tmp451_ = prop;

1645

_tmp452_ = vala_property_get_get_accessor (_tmp451_);

1646

_tmp453_ = _tmp452_;

1647

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

1648

vala_ccode_base_module_generate_property_accessor_declaration ((ValaCCodeBaseModule*) self, _tmp453_, _tmp454_);

1649

_tmp456_ = prop;

1650

_tmp457_ = vala_symbol_get_external ((ValaSymbol*) _tmp456_);

1651

_tmp458_ = _tmp457_;

1652

if (!_tmp458_) {

1653

ValaProperty* _tmp459_;

1654

gboolean _tmp460_;

1655

gboolean _tmp461_;

1656

_tmp459_ = prop;

1657

_tmp460_ = vala_symbol_get_external_package ((ValaSymbol*) _tmp459_);

1658

_tmp461_ = _tmp460_;

1659

_tmp455_ = _tmp461_;

1660

} else {

1661

_tmp455_ = FALSE;

1662

}

1663

_tmp462_ = _tmp455_;

1664

if (_tmp462_) {

1665

ValaProperty* _tmp463_;

1666

gboolean _tmp464_ = FALSE;

1667

_tmp463_ = prop;

1668

_tmp464_ = vala_ccode_base_module_add_generated_external_symbol ((ValaCCodeBaseModule*) self, (ValaSymbol*) _tmp463_);

1669

if (_tmp464_) {

1670

ValaProperty* _tmp465_;

1671

_tmp465_ = prop;

1672

vala_code_visitor_visit_property ((ValaCodeVisitor*) self, _tmp465_);

1673

}

1674

}

1675

}

1676

_tmp466_ = expr;

1677

_tmp467_ = vala_member_access_get_inner (_tmp466_);

1678

_tmp468_ = _tmp467_;

1679

if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp468_, VALA_TYPE_BASE_ACCESS)) {

1680

ValaProperty* _tmp469_;

1681

ValaProperty* _tmp470_;

1682

ValaProperty* _tmp471_;

1683

_tmp469_ = prop;

1684

_tmp470_ = vala_property_get_base_property (_tmp469_);

1685

_tmp471_ = _tmp470_;

1686

if (_tmp471_ != NULL) {

1687

ValaProperty* _tmp472_;

1688

ValaProperty* _tmp473_;

1689

ValaProperty* _tmp474_;

1690

ValaSymbol* _tmp475_;

1691

ValaSymbol* _tmp476_;

1692

ValaClass* _tmp477_;

1693

ValaClass* base_class;

1694

ValaClass* _tmp478_;

1695

gchar* _tmp479_ = NULL;

1696

gchar* _tmp480_;

1697

gchar* _tmp481_ = NULL;

1698

gchar* _tmp482_;

1699

ValaCCodeIdentifier* _tmp483_;

1700

ValaCCodeIdentifier* _tmp484_;

1701

ValaCCodeFunctionCall* _tmp485_;

1702

ValaCCodeFunctionCall* _tmp486_;

1703

ValaCCodeFunctionCall* vcast;

1704

ValaCCodeFunctionCall* _tmp487_;

1705

ValaClass* _tmp488_;

1706

ValaClass* _tmp489_;

1707

gchar* _tmp490_ = NULL;

1708

gchar* _tmp491_;

1709

gchar* _tmp492_ = NULL;

1710

gchar* _tmp493_;

1711

ValaCCodeIdentifier* _tmp494_;

1712

ValaCCodeIdentifier* _tmp495_;

1713

ValaCCodeFunctionCall* _tmp496_;

1714

ValaProperty* _tmp497_;

1715

const gchar* _tmp498_;

1716

const gchar* _tmp499_;

1717

gchar* _tmp500_ = NULL;

1718

gchar* _tmp501_;

1719

ValaCCodeMemberAccess* _tmp502_;

1720

ValaCCodeMemberAccess* _tmp503_;

1721

ValaCCodeFunctionCall* _tmp504_;

1722

ValaCCodeFunctionCall* _tmp505_;

1723

ValaCCodeFunctionCall* ccall;

1724

ValaCCodeFunctionCall* _tmp506_;

1725

ValaMemberAccess* _tmp507_;

1726

ValaExpression* _tmp508_;

1727

ValaExpression* _tmp509_;

1728

ValaCCodeExpression* _tmp510_ = NULL;

1729

ValaCCodeExpression* _tmp511_;

1730

ValaMemberAccess* _tmp512_;

1731

ValaCCodeFunctionCall* _tmp513_;

1732

_tmp472_ = prop;

1733

_tmp473_ = vala_property_get_base_property (_tmp472_);

1734

_tmp474_ = _tmp473_;

1735

_tmp475_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp474_);

1736

_tmp476_ = _tmp475_;

1737

_tmp477_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp476_, VALA_TYPE_CLASS, ValaClass));

1738

base_class = _tmp477_;

1739

_tmp478_ = base_class;

1740

_tmp479_ = vala_ccode_base_module_get_ccode_upper_case_name ((ValaSymbol*) _tmp478_, NULL);

1741

_tmp480_ = _tmp479_;

1742

_tmp481_ = g_strdup_printf ("%s_CLASS", _tmp480_);

1743

_tmp482_ = _tmp481_;

1744

_tmp483_ = vala_ccode_identifier_new (_tmp482_);

1745

_tmp484_ = _tmp483_;

1746

_tmp485_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp484_);

1747

_tmp486_ = _tmp485_;

1748

_vala_ccode_node_unref0 (_tmp484_);

1749

_g_free0 (_tmp482_);

1750

_g_free0 (_tmp480_);

1751

vcast = _tmp486_;

1752

_tmp487_ = vcast;

1753

_tmp488_ = vala_ccode_base_module_get_current_class ((ValaCCodeBaseModule*) self);

1754

_tmp489_ = _tmp488_;

1755

_tmp490_ = vala_ccode_base_module_get_ccode_lower_case_name ((ValaCodeNode*) _tmp489_, NULL);

1756

_tmp491_ = _tmp490_;

1757

_tmp492_ = g_strdup_printf ("%s_parent_class", _tmp491_);

1758

_tmp493_ = _tmp492_;

1759

_tmp494_ = vala_ccode_identifier_new (_tmp493_);

1760

_tmp495_ = _tmp494_;

1761

vala_ccode_function_call_add_argument (_tmp487_, (ValaCCodeExpression*) _tmp495_);

1762

_vala_ccode_node_unref0 (_tmp495_);

1763

_g_free0 (_tmp493_);

1764

_g_free0 (_tmp491_);

1765

_tmp496_ = vcast;

1766

_tmp497_ = prop;

1767

_tmp498_ = vala_symbol_get_name ((ValaSymbol*) _tmp497_);

1768

_tmp499_ = _tmp498_;

1769

_tmp500_ = g_strdup_printf ("get_%s", _tmp499_);

1770

_tmp501_ = _tmp500_;

1771

_tmp502_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp496_, _tmp501_);

1772

_tmp503_ = _tmp502_;

1773

_tmp504_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp503_);

1774

_tmp505_ = _tmp504_;

1775

_vala_ccode_node_unref0 (_tmp503_);

1776

_g_free0 (_tmp501_);

1777

ccall = _tmp505_;

1778

_tmp506_ = ccall;

1779

_tmp507_ = expr;

1780

_tmp508_ = vala_member_access_get_inner (_tmp507_);

1781

_tmp509_ = _tmp508_;

1782

_tmp510_ = vala_ccode_base_module_get_cvalue ((ValaCCodeBaseModule*) self, _tmp509_);

1783

_tmp511_ = _tmp510_;

1784

vala_ccode_function_call_add_argument (_tmp506_, _tmp511_);

1785

_vala_ccode_node_unref0 (_tmp511_);

1786

_tmp512_ = expr;

1787

_tmp513_ = ccall;

1788

vala_ccode_base_module_set_cvalue ((ValaCCodeBaseModule*) self, (ValaExpression*) _tmp512_, (ValaCCodeExpression*) _tmp513_);

1789

_vala_ccode_node_unref0 (ccall);

1790

_vala_ccode_node_unref0 (vcast);

1791

_vala_code_node_unref0 (base_class);

1792

} else {

1793

ValaProperty* _tmp514_;

1794

ValaProperty* _tmp515_;

1795

ValaProperty* _tmp516_;

1796

_tmp514_ = prop;

1797

_tmp515_ = vala_property_get_base_interface_property (_tmp514_);

1798

_tmp516_ = _tmp515_;

1799

if (_tmp516_ != NULL) {

1800

ValaProperty* _tmp517_;

1801

ValaProperty* _tmp518_;

1802

ValaProperty* _tmp519_;

1803

ValaSymbol* _tmp520_;

1804

ValaSymbol* _tmp521_;

1805

ValaInterface* _tmp522_;

1806

ValaInterface* base_iface;

1807

ValaClass* _tmp523_;

1808

ValaClass* _tmp524_;

1809

gchar* _tmp525_ = NULL;

1810

gchar* _tmp526_;

1811

ValaInterface* _tmp527_;

1812

gchar* _tmp528_ = NULL;

1813

gchar* _tmp529_;

1814

gchar* _tmp530_ = NULL;

1815

gchar* _tmp531_;

1816

gchar* parent_iface_var;

1817

const gchar* _tmp532_;

1818

ValaCCodeIdentifier* _tmp533_;

1819

ValaCCodeIdentifier* _tmp534_;

1820

ValaProperty* _tmp535_;

1821

const gchar* _tmp536_;

1822

const gchar* _tmp537_;

1823

gchar* _tmp538_ = NULL;

1824

gchar* _tmp539_;

1825

ValaCCodeMemberAccess* _tmp540_;

1826

ValaCCodeMemberAccess* _tmp541_;

1827

ValaCCodeFunctionCall* _tmp542_;

1828

ValaCCodeFunctionCall* _tmp543_;

1829

ValaCCodeFunctionCall* ccall;

1830

ValaCCodeFunctionCall* _tmp544_;

1831

ValaMemberAccess* _tmp545_;

1832

ValaExpression* _tmp546_;

1833

ValaExpression* _tmp547_;

1834

ValaCCodeExpression* _tmp548_ = NULL;

1835

ValaCCodeExpression* _tmp549_;

1836

ValaMemberAccess* _tmp550_;

1837

ValaCCodeFunctionCall* _tmp551_;

1838

_tmp517_ = prop;

1839

_tmp518_ = vala_property_get_base_interface_property (_tmp517_);

1840

_tmp519_ = _tmp518_;

1841

_tmp520_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp519_);

1842

_tmp521_ = _tmp520_;

1843

_tmp522_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp521_, VALA_TYPE_INTERFACE, ValaInterface));

1844

base_iface = _tmp522_;

1845

_tmp523_ = vala_ccode_base_module_get_current_class ((ValaCCodeBaseModule*) self);

1846

_tmp524_ = _tmp523_;

1847

_tmp525_ = vala_ccode_base_module_get_ccode_lower_case_name ((ValaCodeNode*) _tmp524_, NULL);

1848

_tmp526_ = _tmp525_;

1849

_tmp527_ = base_iface;

1850

_tmp528_ = vala_ccode_base_module_get_ccode_lower_case_name ((ValaCodeNode*) _tmp527_, NULL);

1851

_tmp529_ = _tmp528_;

1852

_tmp530_ = g_strdup_printf ("%s_%s_parent_iface", _tmp526_, _tmp529_);

1853

_tmp531_ = _tmp530_;

1854

_g_free0 (_tmp529_);

1855

_g_free0 (_tmp526_);

1856

parent_iface_var = _tmp531_;

1857

_tmp532_ = parent_iface_var;

1858

_tmp533_ = vala_ccode_identifier_new (_tmp532_);

1859

_tmp534_ = _tmp533_;

1860

_tmp535_ = prop;

1861

_tmp536_ = vala_symbol_get_name ((ValaSymbol*) _tmp535_);

1862

_tmp537_ = _tmp536_;

1863

_tmp538_ = g_strdup_printf ("get_%s", _tmp537_);

1864

_tmp539_ = _tmp538_;

1865

_tmp540_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp534_, _tmp539_);

1866

_tmp541_ = _tmp540_;

1867

_tmp542_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp541_);

1868

_tmp543_ = _tmp542_;

1869

_vala_ccode_node_unref0 (_tmp541_);

1870

_g_free0 (_tmp539_);

1871

_vala_ccode_node_unref0 (_tmp534_);

1872

ccall = _tmp543_;

1873

_tmp544_ = ccall;

1874

_tmp545_ = expr;

1875

_tmp546_ = vala_member_access_get_inner (_tmp545_);

1876

_tmp547_ = _tmp546_;

1877

_tmp548_ = vala_ccode_base_module_get_cvalue ((ValaCCodeBaseModule*) self, _tmp547_);

1878

_tmp549_ = _tmp548_;

1879

vala_ccode_function_call_add_argument (_tmp544_, _tmp549_);

1880

_vala_ccode_node_unref0 (_tmp549_);

1881

_tmp550_ = expr;

1882

_tmp551_ = ccall;

1883

vala_ccode_base_module_set_cvalue ((ValaCCodeBaseModule*) self, (ValaExpression*) _tmp550_, (ValaCCodeExpression*) _tmp551_);

1884

_vala_ccode_node_unref0 (ccall);

1885

_g_free0 (parent_iface_var);

1886

_vala_code_node_unref0 (base_iface);

1887

}

1888

}

1889

} else {

1890

gboolean _tmp552_ = FALSE;

1891

gboolean _tmp553_ = FALSE;

1892

gboolean _tmp554_ = FALSE;

1893

gboolean _tmp555_ = FALSE;

1894

gboolean _tmp556_ = FALSE;

1895

gboolean _tmp557_ = FALSE;

1896

gboolean _tmp558_ = FALSE;

1897

ValaProperty* _tmp559_;

1898

ValaMemberBinding _tmp560_;

1899

ValaMemberBinding _tmp561_;

1900

gboolean _tmp567_;

1901

gboolean _tmp575_;

1902

gboolean _tmp581_;

1903

gboolean _tmp584_;

1904

gboolean _tmp588_;

1905

gboolean _tmp592_;

1906

gboolean _tmp601_;

1907

_tmp559_ = prop;

1908

_tmp560_ = vala_property_get_binding (_tmp559_);

1909

_tmp561_ = _tmp560_;

1910

if (_tmp561_ == VALA_MEMBER_BINDING_INSTANCE) {

1911

ValaProperty* _tmp562_;

1912

ValaPropertyAccessor* _tmp563_;

1913

ValaPropertyAccessor* _tmp564_;

1914

gboolean _tmp565_;

1915

gboolean _tmp566_;

1916

_tmp562_ = prop;

1917

_tmp563_ = vala_property_get_get_accessor (_tmp562_);

1918

_tmp564_ = _tmp563_;

1919

_tmp565_ = vala_property_accessor_get_automatic_body (_tmp564_);

1920

_tmp566_ = _tmp565_;

1921

_tmp558_ = _tmp566_;

1922

} else {

1923

_tmp558_ = FALSE;

1924

}

1925

_tmp567_ = _tmp558_;

1926

if (_tmp567_) {

1927

ValaProperty* _tmp568_;

1928

ValaPropertyAccessor* _tmp569_;

1929

ValaPropertyAccessor* _tmp570_;

1930

ValaDataType* _tmp571_;

1931

ValaDataType* _tmp572_;

1932

gboolean _tmp573_;

1933

gboolean _tmp574_;

1934

_tmp568_ = prop;

1935

_tmp569_ = vala_property_get_get_accessor (_tmp568_);

1936

_tmp570_ = _tmp569_;

1937

_tmp571_ = vala_property_accessor_get_value_type (_tmp570_);

1938

_tmp572_ = _tmp571_;

1939

_tmp573_ = vala_data_type_get_value_owned (_tmp572_);

1940

_tmp574_ = _tmp573_;

1941

_tmp557_ = !_tmp574_;

1942

} else {

1943

_tmp557_ = FALSE;

1944

}

1945

_tmp575_ = _tmp557_;

1946

if (_tmp575_) {

1947

ValaTypeSymbol* _tmp576_;

1948

ValaTypeSymbol* _tmp577_;

1949

ValaProperty* _tmp578_;

1950

ValaSymbol* _tmp579_;

1951

ValaSymbol* _tmp580_;

1952

_tmp576_ = vala_ccode_base_module_get_current_type_symbol ((ValaCCodeBaseModule*) self);

1953

_tmp577_ = _tmp576_;

1954

_tmp578_ = prop;

1955

_tmp579_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp578_);

1956

_tmp580_ = _tmp579_;

1957

_tmp556_ = G_TYPE_CHECK_INSTANCE_CAST (_tmp577_, VALA_TYPE_SYMBOL, ValaSymbol) == _tmp580_;

1958

} else {

1959

_tmp556_ = FALSE;

1960

}

1961

_tmp581_ = _tmp556_;

1962

if (_tmp581_) {

1963

ValaTypeSymbol* _tmp582_;

1964

ValaTypeSymbol* _tmp583_;

1965

_tmp582_ = vala_ccode_base_module_get_current_type_symbol ((ValaCCodeBaseModule*) self);

1966

_tmp583_ = _tmp582_;

1967

_tmp555_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp583_, VALA_TYPE_CLASS);

1968

} else {

1969

_tmp555_ = FALSE;

1970

}

1971

_tmp584_ = _tmp555_;

1972

if (_tmp584_) {

1973

ValaProperty* _tmp585_;

1974

ValaProperty* _tmp586_;

1975

ValaProperty* _tmp587_;

1976

_tmp585_ = prop;

1977

_tmp586_ = vala_property_get_base_property (_tmp585_);

1978

_tmp587_ = _tmp586_;

1979

_tmp554_ = _tmp587_ == NULL;

1980

} else {

1981

_tmp554_ = FALSE;

1982

}

1983

_tmp588_ = _tmp554_;

1984

if (_tmp588_) {

1985

ValaProperty* _tmp589_;

1986

ValaProperty* _tmp590_;

1987

ValaProperty* _tmp591_;

1988

_tmp589_ = prop;

1989

_tmp590_ = vala_property_get_base_interface_property (_tmp589_);

1990

_tmp591_ = _tmp590_;

1991

_tmp553_ = _tmp591_ == NULL;

1992

} else {

1993

_tmp553_ = FALSE;

1994

}

1995

_tmp592_ = _tmp553_;

1996

if (_tmp592_) {

1997

gboolean _tmp593_ = FALSE;

1998

ValaProperty* _tmp594_;

1999

ValaDataType* _tmp595_;

2000

ValaDataType* _tmp596_;

2001

gboolean _tmp600_;

2002

_tmp594_ = prop;

2003

_tmp595_ = vala_property_get_property_type (_tmp594_);

2004

_tmp596_ = _tmp595_;

2005

if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp596_, VALA_TYPE_ARRAY_TYPE)) {

2006

_tmp593_ = TRUE;

2007

} else {

2008

ValaProperty* _tmp597_;

2009

ValaDataType* _tmp598_;

2010

ValaDataType* _tmp599_;

2011

_tmp597_ = prop;

2012

_tmp598_ = vala_property_get_property_type (_tmp597_);

2013

_tmp599_ = _tmp598_;

2014

_tmp593_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp599_, VALA_TYPE_DELEGATE_TYPE);

2015

}

2016

_tmp600_ = _tmp593_;

2017

_tmp552_ = !_tmp600_;

2018

} else {

2019

_tmp552_ = FALSE;

2020

}

2021

_tmp601_ = _tmp552_;

2022

if (_tmp601_) {

2023

ValaCCodeExpression* inst = NULL;

2024

ValaCCodeExpression* _tmp602_;

2025

ValaCCodeMemberAccess* _tmp603_;

2026

ValaMemberAccess* _tmp604_;

2027

ValaCCodeExpression* _tmp605_;

2028

ValaProperty* _tmp606_;

2029

ValaField* _tmp607_;

2030

ValaField* _tmp608_;

2031

gchar* _tmp609_ = NULL;

2032

gchar* _tmp610_;

2033

ValaCCodeMemberAccess* _tmp611_;

2034

ValaCCodeMemberAccess* _tmp612_;

2035

_tmp602_ = pub_inst;

2036

_tmp603_ = vala_ccode_member_access_new_pointer (_tmp602_, "priv");

2037

_vala_ccode_node_unref0 (inst);

2038

inst = (ValaCCodeExpression*) _tmp603_;

2039

_tmp604_ = expr;

2040

_tmp605_ = inst;

2041

_tmp606_ = prop;

2042

_tmp607_ = vala_property_get_field (_tmp606_);

2043

_tmp608_ = _tmp607_;

2044

_tmp609_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp608_);

2045

_tmp610_ = _tmp609_;

2046

_tmp611_ = vala_ccode_member_access_new_pointer (_tmp605_, _tmp610_);

2047

_tmp612_ = _tmp611_;

2048

vala_ccode_base_module_set_cvalue ((ValaCCodeBaseModule*) self, (ValaExpression*) _tmp604_, (ValaCCodeExpression*) _tmp612_);

2049

_vala_ccode_node_unref0 (_tmp612_);

2050

_g_free0 (_tmp610_);

2051

_vala_ccode_node_unref0 (inst);

2052

} else {

2053

ValaProperty* _tmp613_;

2054

gboolean _tmp614_ = FALSE;

2055

_tmp613_ = prop;

2056

_tmp614_ = vala_ccode_base_module_get_ccode_no_accessor_method (_tmp613_);

2057

if (!_tmp614_) {

2058

gchar* getter_cname = NULL;

2059

ValaProperty* _tmp615_;

2060

const gchar* _tmp622_;

2061

ValaCCodeIdentifier* _tmp623_;

2062

ValaCCodeIdentifier* _tmp624_;

2063

ValaCCodeFunctionCall* _tmp625_;

2064

ValaCCodeFunctionCall* _tmp626_;

2065

ValaCCodeFunctionCall* ccall;

2066

ValaProperty* _tmp627_;

2067

ValaMemberBinding _tmp628_;

2068

ValaMemberBinding _tmp629_;

2069

ValaProperty* _tmp656_;

2070

ValaPropertyAccessor* _tmp657_;

2071

ValaPropertyAccessor* _tmp658_;

2072

ValaDataType* _tmp659_;

2073

ValaDataType* _tmp660_;

2074

ValaMemberAccess* _tmp661_;

2075

ValaTargetValue* _tmp662_ = NULL;

2076

ValaGLibValue* temp_value;

2077

ValaMemberAccess* _tmp663_;

2078

ValaGLibValue* _tmp664_;

2079

ValaTargetValue* _tmp665_ = NULL;

2080

ValaTargetValue* _tmp666_;

2081

ValaGLibValue* _tmp667_;

2082

ValaCCodeExpression* _tmp668_ = NULL;

2083

ValaCCodeExpression* ctemp;

2084

ValaProperty* _tmp669_;

2085

ValaDataType* _tmp670_;

2086

ValaDataType* _tmp671_;

2087

gboolean _tmp672_ = FALSE;

2088

_tmp615_ = prop;

2089

if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp615_, VALA_TYPE_DYNAMIC_PROPERTY)) {

2090

ValaProperty* _tmp616_;

2091

gchar* _tmp617_ = NULL;

2092

_tmp616_ = prop;

2093

_tmp617_ = vala_ccode_base_module_get_dynamic_property_getter_cname ((ValaCCodeBaseModule*) self, G_TYPE_CHECK_INSTANCE_CAST (_tmp616_, VALA_TYPE_DYNAMIC_PROPERTY, ValaDynamicProperty));

2094

_g_free0 (getter_cname);

2095

getter_cname = _tmp617_;

2096

} else {

2097

ValaProperty* _tmp618_;

2098

ValaPropertyAccessor* _tmp619_;

2099

ValaPropertyAccessor* _tmp620_;

2100

gchar* _tmp621_ = NULL;

2101

_tmp618_ = prop;

2102

_tmp619_ = vala_property_get_get_accessor (_tmp618_);

2103

_tmp620_ = _tmp619_;

2104

_tmp621_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp620_);

2105

_g_free0 (getter_cname);

2106

getter_cname = _tmp621_;

2107

}

2108

_tmp622_ = getter_cname;

2109

_tmp623_ = vala_ccode_identifier_new (_tmp622_);

2110

_tmp624_ = _tmp623_;

2111

_tmp625_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp624_);

2112

_tmp626_ = _tmp625_;

2113

_vala_ccode_node_unref0 (_tmp624_);

2114

ccall = _tmp626_;

2115

_tmp627_ = prop;

2116

_tmp628_ = vala_property_get_binding (_tmp627_);

2117

_tmp629_ = _tmp628_;

2118

if (_tmp629_ == VALA_MEMBER_BINDING_INSTANCE) {

2119

gboolean _tmp630_ = FALSE;

2120

ValaProperty* _tmp631_;

2121

ValaSymbol* _tmp632_;

2122

ValaSymbol* _tmp633_;

2123

gboolean _tmp638_;

2124

ValaCCodeFunctionCall* _tmp654_;

2125

ValaCCodeExpression* _tmp655_;

2126

_tmp631_ = prop;

2127

_tmp632_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp631_);

2128

_tmp633_ = _tmp632_;

2129

if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp633_, VALA_TYPE_STRUCT)) {

2130

ValaProperty* _tmp634_;

2131

ValaSymbol* _tmp635_;

2132

ValaSymbol* _tmp636_;

2133

gboolean _tmp637_ = FALSE;

2134

_tmp634_ = prop;

2135

_tmp635_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp634_);

2136

_tmp636_ = _tmp635_;

2137

_tmp637_ = vala_struct_is_simple_type (G_TYPE_CHECK_INSTANCE_CAST (_tmp636_, VALA_TYPE_STRUCT, ValaStruct));

2138

_tmp630_ = !_tmp637_;

2139

} else {

2140

_tmp630_ = FALSE;

2141

}

2142

_tmp638_ = _tmp630_;

2143

if (_tmp638_) {

2144

ValaMemberAccess* _tmp639_;

2145

ValaExpression* _tmp640_;

2146

ValaExpression* _tmp641_;

2147

ValaTargetValue* _tmp642_;

2148

ValaTargetValue* _tmp643_;

2149

ValaTargetValue* _tmp644_;

2150

ValaTargetValue* instance;

2151

ValaTargetValue* _tmp645_;

2152

gboolean _tmp646_ = FALSE;

2153

ValaTargetValue* _tmp650_;

2154

ValaCCodeExpression* _tmp651_ = NULL;

2155

ValaCCodeExpression* _tmp652_;

2156

ValaCCodeUnaryExpression* _tmp653_;

2157

_tmp639_ = expr;

2158

_tmp640_ = vala_member_access_get_inner (_tmp639_);

2159

_tmp641_ = _tmp640_;

2160

_tmp642_ = vala_expression_get_target_value (_tmp641_);

2161

_tmp643_ = _tmp642_;

2162

_tmp644_ = _vala_target_value_ref0 (_tmp643_);

2163

instance = _tmp644_;

2164

_tmp645_ = instance;

2165

_tmp646_ = vala_ccode_base_module_get_lvalue ((ValaCCodeBaseModule*) self, _tmp645_);

2166

if (!_tmp646_) {

2167

ValaTargetValue* _tmp647_;

2168

ValaMemberAccess* _tmp648_;

2169

ValaTargetValue* _tmp649_ = NULL;

2170

_tmp647_ = instance;

2171

_tmp648_ = expr;

2172

_tmp649_ = vala_ccode_base_module_store_temp_value ((ValaCCodeBaseModule*) self, _tmp647_, (ValaCodeNode*) _tmp648_, NULL);

2173

_vala_target_value_unref0 (instance);

2174

instance = _tmp649_;

2175

}

2176

_tmp650_ = instance;

2177

_tmp651_ = vala_ccode_base_module_get_cvalue_ ((ValaCCodeBaseModule*) self, _tmp650_);

2178

_tmp652_ = _tmp651_;

2179

_tmp653_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, _tmp652_);

2180

_vala_ccode_node_unref0 (pub_inst);

2181

pub_inst = (ValaCCodeExpression*) _tmp653_;

2182

_vala_ccode_node_unref0 (_tmp652_);

2183

_vala_target_value_unref0 (instance);

2184

}

2185

_tmp654_ = ccall;

2186

_tmp655_ = pub_inst;

2187

vala_ccode_function_call_add_argument (_tmp654_, _tmp655_);

2188

}

2189

_tmp656_ = prop;

2190

_tmp657_ = vala_property_get_get_accessor (_tmp656_);

2191

_tmp658_ = _tmp657_;

2192

_tmp659_ = vala_property_accessor_get_value_type (_tmp658_);

2193

_tmp660_ = _tmp659_;

2194

_tmp661_ = expr;

2195

_tmp662_ = vala_ccode_base_module_create_temp_value ((ValaCCodeBaseModule*) self, _tmp660_, FALSE, (ValaCodeNode*) _tmp661_, NULL);

2196

temp_value = G_TYPE_CHECK_INSTANCE_CAST (_tmp662_, VALA_TYPE_GLIB_VALUE, ValaGLibValue);

2197

_tmp663_ = expr;

2198

_tmp664_ = temp_value;

2199

_tmp665_ = vala_ccode_base_module_load_temp_value ((ValaCCodeBaseModule*) self, (ValaTargetValue*) _tmp664_);

2200

_tmp666_ = _tmp665_;

2201

vala_expression_set_target_value ((ValaExpression*) _tmp663_, _tmp666_);

2202

_vala_target_value_unref0 (_tmp666_);

2203

_tmp667_ = temp_value;

2204

_tmp668_ = vala_ccode_base_module_get_cvalue_ ((ValaCCodeBaseModule*) self, (ValaTargetValue*) _tmp667_);

2205

ctemp = _tmp668_;

2206

_tmp669_ = prop;

2207

_tmp670_ = vala_property_get_property_type (_tmp669_);

2208

_tmp671_ = _tmp670_;

2209

_tmp672_ = vala_data_type_is_real_non_null_struct_type (_tmp671_);

2210

if (_tmp672_) {

2211

ValaCCodeFunctionCall* _tmp673_;

2212

ValaCCodeExpression* _tmp674_;

2213

ValaCCodeUnaryExpression* _tmp675_;

2214

ValaCCodeUnaryExpression* _tmp676_;

2215

ValaCCodeFunction* _tmp677_;

2216

ValaCCodeFunction* _tmp678_;

2217

ValaCCodeFunctionCall* _tmp679_;

2218

_tmp673_ = ccall;

2219

_tmp674_ = ctemp;

2220

_tmp675_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, _tmp674_);

2221

_tmp676_ = _tmp675_;

2222

vala_ccode_function_call_add_argument (_tmp673_, (ValaCCodeExpression*) _tmp676_);

2223

_vala_ccode_node_unref0 (_tmp676_);

2224

_tmp677_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

2225

_tmp678_ = _tmp677_;

2226

_tmp679_ = ccall;

2227

vala_ccode_function_add_expression (_tmp678_, (ValaCCodeExpression*) _tmp679_);

2228

} else {

2229

ValaCCodeFunction* _tmp680_;

2230

ValaCCodeFunction* _tmp681_;

2231

ValaCCodeExpression* _tmp682_;

2232

ValaCCodeFunctionCall* _tmp683_;

2233

ValaProperty* _tmp684_;

2234

ValaDataType* _tmp685_;

2235

ValaDataType* _tmp686_;

2236

ValaArrayType* _tmp687_;

2237

ValaArrayType* _tmp688_;

2238

_tmp680_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

2239

_tmp681_ = _tmp680_;

2240

_tmp682_ = ctemp;

2241

_tmp683_ = ccall;

2242

vala_ccode_function_add_assignment (_tmp681_, _tmp682_, (ValaCCodeExpression*) _tmp683_);

2243

_tmp684_ = prop;

2244

_tmp685_ = vala_property_get_property_type (_tmp684_);

2245

_tmp686_ = _tmp685_;

2246

_tmp687_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp686_, VALA_TYPE_ARRAY_TYPE) ? ((ValaArrayType*) _tmp686_) : NULL);

2247

_vala_code_node_unref0 (array_type);

2248

array_type = _tmp687_;

2249

_tmp688_ = array_type;

2250

if (_tmp688_ != NULL) {

2251

ValaProperty* _tmp689_;

2252

gboolean _tmp690_ = FALSE;

2253

_tmp689_ = prop;

2254

_tmp690_ = vala_ccode_base_module_get_ccode_array_null_terminated ((ValaCodeNode*) _tmp689_);

2255

if (_tmp690_) {

2256

ValaCCodeIdentifier* _tmp691_;

2257

ValaCCodeIdentifier* _tmp692_;

2258

ValaCCodeFunctionCall* _tmp693_;

2259

ValaCCodeFunctionCall* _tmp694_;

2260

ValaCCodeFunctionCall* len_call;

2261

ValaCCodeFunctionCall* _tmp695_;

2262

ValaCCodeExpression* _tmp696_;

2263

ValaCCodeFunction* _tmp697_;

2264

ValaCCodeFunction* _tmp698_;

2265

ValaGLibValue* _tmp699_;

2266

ValaList* _tmp700_;

2267

gpointer _tmp701_ = NULL;

2268

ValaCCodeExpression* _tmp702_;

2269

ValaCCodeFunctionCall* _tmp703_;

2270

((ValaCCodeBaseModule*) self)->requires_array_length = TRUE;

2271

_tmp691_ = vala_ccode_identifier_new ("_vala_array_length");

2272

_tmp692_ = _tmp691_;

2273

_tmp693_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp692_);

2274

_tmp694_ = _tmp693_;

2275

_vala_ccode_node_unref0 (_tmp692_);

2276

len_call = _tmp694_;

2277

_tmp695_ = len_call;

2278

_tmp696_ = ctemp;

2279

vala_ccode_function_call_add_argument (_tmp695_, _tmp696_);

2280

_tmp697_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

2281

_tmp698_ = _tmp697_;

2282

_tmp699_ = temp_value;

2283

_tmp700_ = _tmp699_->array_length_cvalues;

2284

_tmp701_ = vala_list_get (_tmp700_, 0);

2285

_tmp702_ = (ValaCCodeExpression*) _tmp701_;

2286

_tmp703_ = len_call;

2287

vala_ccode_function_add_assignment (_tmp698_, _tmp702_, (ValaCCodeExpression*) _tmp703_);

2288

_vala_ccode_node_unref0 (_tmp702_);

2289

_vala_ccode_node_unref0 (len_call);

2290

} else {

2291

ValaProperty* _tmp704_;

2292

gboolean _tmp705_ = FALSE;

2293

_tmp704_ = prop;

2294

_tmp705_ = vala_ccode_base_module_get_ccode_array_length ((ValaCodeNode*) _tmp704_);

2295

if (_tmp705_) {

2296

{

2297

gint dim;

2298

dim = 1;

2299

{

2300

gboolean _tmp706_;

2301

_tmp706_ = TRUE;

2302

while (TRUE) {

2303

gboolean _tmp707_;

2304

gint _tmp709_;

2305

ValaArrayType* _tmp710_;

2306

gint _tmp711_;

2307

gint _tmp712_;

2308

ValaCCodeFunctionCall* _tmp713_;

2309

ValaGLibValue* _tmp714_;

2310

gint _tmp715_;

2311

ValaCCodeExpression* _tmp716_ = NULL;

2312

ValaCCodeExpression* _tmp717_;

2313

ValaCCodeUnaryExpression* _tmp718_;

2314

ValaCCodeUnaryExpression* _tmp719_;

2315

_tmp707_ = _tmp706_;

2316

if (!_tmp707_) {

2317

gint _tmp708_;

2318

_tmp708_ = dim;

2319

dim = _tmp708_ + 1;

2320

}

2321

_tmp706_ = FALSE;

2322

_tmp709_ = dim;

2323

_tmp710_ = array_type;

2324

_tmp711_ = vala_array_type_get_rank (_tmp710_);

2325

_tmp712_ = _tmp711_;

2326

if (!(_tmp709_ <= _tmp712_)) {

2327

break;

2328

}

2329

_tmp713_ = ccall;

2330

_tmp714_ = temp_value;

2331

_tmp715_ = dim;

2332

_tmp716_ = vala_ccode_base_module_get_array_length_cvalue ((ValaCCodeBaseModule*) self, (ValaTargetValue*) _tmp714_, _tmp715_);

2333

_tmp717_ = _tmp716_;

2334

_tmp718_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, _tmp717_);

2335

_tmp719_ = _tmp718_;

2336

vala_ccode_function_call_add_argument (_tmp713_, (ValaCCodeExpression*) _tmp719_);

2337

_vala_ccode_node_unref0 (_tmp719_);

2338

_vala_ccode_node_unref0 (_tmp717_);

2339

}

2340

}

2341

}

2342

}

2343

}

2344

} else {

2345

ValaProperty* _tmp720_;

2346

ValaDataType* _tmp721_;

2347

ValaDataType* _tmp722_;

2348

ValaDelegateType* _tmp723_;

2349

gboolean _tmp724_ = FALSE;

2350

ValaDelegateType* _tmp725_;

2351

gboolean _tmp731_;

2352

_tmp720_ = prop;

2353

_tmp721_ = vala_property_get_property_type (_tmp720_);

2354

_tmp722_ = _tmp721_;

2355

_tmp723_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp722_, VALA_TYPE_DELEGATE_TYPE) ? ((ValaDelegateType*) _tmp722_) : NULL);

2356

_vala_code_node_unref0 (delegate_type);

2357

delegate_type = _tmp723_;

2358

_tmp725_ = delegate_type;

2359

if (_tmp725_ != NULL) {

2360

ValaDelegateType* _tmp726_;

2361

ValaDelegate* _tmp727_;

2362

ValaDelegate* _tmp728_;

2363

gboolean _tmp729_;

2364

gboolean _tmp730_;

2365

_tmp726_ = delegate_type;

2366

_tmp727_ = vala_delegate_type_get_delegate_symbol (_tmp726_);

2367

_tmp728_ = _tmp727_;

2368

_tmp729_ = vala_delegate_get_has_target (_tmp728_);

2369

_tmp730_ = _tmp729_;

2370

_tmp724_ = _tmp730_;

2371

} else {

2372

_tmp724_ = FALSE;

2373

}

2374

_tmp731_ = _tmp724_;

2375

if (_tmp731_) {

2376

ValaCCodeFunctionCall* _tmp732_;

2377

ValaGLibValue* _tmp733_;

2378

ValaCCodeExpression* _tmp734_ = NULL;

2379

ValaCCodeExpression* _tmp735_;

2380

ValaCCodeUnaryExpression* _tmp736_;

2381

ValaCCodeUnaryExpression* _tmp737_;

2382

_tmp732_ = ccall;

2383

_tmp733_ = temp_value;

2384

_tmp734_ = vala_ccode_base_module_get_delegate_target_cvalue ((ValaCCodeBaseModule*) self, (ValaTargetValue*) _tmp733_);

2385

_tmp735_ = _tmp734_;

2386

_tmp736_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, _tmp735_);

2387

_tmp737_ = _tmp736_;

2388

vala_ccode_function_call_add_argument (_tmp732_, (ValaCCodeExpression*) _tmp737_);

2389

_vala_ccode_node_unref0 (_tmp737_);

2390

_vala_ccode_node_unref0 (_tmp735_);

2391

}

2392

}

2393

}

2394

_vala_ccode_node_unref0 (ctemp);

2395

_vala_target_value_unref0 (temp_value);

2396

_vala_ccode_node_unref0 (ccall);

2397

_g_free0 (getter_cname);

2398

} else {

2399

ValaCCodeIdentifier* _tmp738_;

2400

ValaCCodeIdentifier* _tmp739_;

2401

ValaCCodeFunctionCall* _tmp740_;

2402

ValaCCodeFunctionCall* _tmp741_;

2403

ValaCCodeFunctionCall* ccall;

2404

ValaCCodeFunctionCall* _tmp742_;

2405

ValaCCodeExpression* _tmp743_;

2406

ValaCCodeFunctionCall* _tmp744_;

2407

ValaProperty* _tmp745_;

2408

ValaCCodeConstant* _tmp746_ = NULL;

2409

ValaCCodeConstant* _tmp747_;

2410

ValaProperty* _tmp748_;

2411

ValaPropertyAccessor* _tmp749_;

2412

ValaPropertyAccessor* _tmp750_;

2413

ValaDataType* _tmp751_;

2414

ValaDataType* _tmp752_;

2415

gboolean _tmp753_;

2416

gboolean _tmp754_;

2417

ValaMemberAccess* _tmp774_;

2418

ValaDataType* _tmp775_;

2419

ValaDataType* _tmp776_;

2420

gboolean _tmp777_ = FALSE;

2421

ValaMemberAccess* _tmp781_;

2422

ValaDataType* _tmp782_;

2423

ValaDataType* _tmp783_;

2424

ValaLocalVariable* _tmp784_ = NULL;

2425

ValaLocalVariable* temp_var;

2426

ValaLocalVariable* _tmp785_;

2427

const gchar* _tmp786_;

2428

const gchar* _tmp787_;

2429

ValaCCodeExpression* _tmp788_ = NULL;

2430

ValaCCodeExpression* ctemp;

2431

ValaLocalVariable* _tmp789_;

2432

ValaCCodeFunctionCall* _tmp790_;

2433

ValaCCodeExpression* _tmp791_;

2434

ValaCCodeUnaryExpression* _tmp792_;

2435

ValaCCodeUnaryExpression* _tmp793_;

2436

ValaCCodeFunctionCall* _tmp794_;

2437

ValaCCodeConstant* _tmp795_;

2438

ValaCCodeConstant* _tmp796_;

2439

ValaCCodeFunction* _tmp797_;

2440

ValaCCodeFunction* _tmp798_;

2441

ValaCCodeFunctionCall* _tmp799_;

2442

ValaMemberAccess* _tmp800_;

2443

ValaCCodeExpression* _tmp801_;

2444

_tmp738_ = vala_ccode_identifier_new ("g_object_get");

2445

_tmp739_ = _tmp738_;

2446

_tmp740_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp739_);

2447

_tmp741_ = _tmp740_;

2448

_vala_ccode_node_unref0 (_tmp739_);

2449

ccall = _tmp741_;

2450

_tmp742_ = ccall;

2451

_tmp743_ = pub_inst;

2452

vala_ccode_function_call_add_argument (_tmp742_, _tmp743_);

2453

_tmp744_ = ccall;

2454

_tmp745_ = prop;

2455

_tmp746_ = vala_ccode_base_module_get_property_canonical_cconstant ((ValaCCodeBaseModule*) self, _tmp745_);

2456

_tmp747_ = _tmp746_;

2457

vala_ccode_function_call_add_argument (_tmp744_, (ValaCCodeExpression*) _tmp747_);

2458

_vala_ccode_node_unref0 (_tmp747_);

2459

_tmp748_ = prop;

2460

_tmp749_ = vala_property_get_get_accessor (_tmp748_);

2461

_tmp750_ = _tmp749_;

2462

_tmp751_ = vala_property_accessor_get_value_type (_tmp750_);

2463

_tmp752_ = _tmp751_;

2464

_tmp753_ = vala_data_type_get_value_owned (_tmp752_);

2465

_tmp754_ = _tmp753_;

2466

if (!_tmp754_) {

2467

ValaProperty* _tmp755_;

2468

ValaPropertyAccessor* _tmp756_;

2469

ValaPropertyAccessor* _tmp757_;

2470

ValaDataType* _tmp758_;

2471

ValaDataType* _tmp759_;

2472

ValaDataType* _tmp760_ = NULL;

2473

ValaDataType* owned_value_type;

2474

ValaDataType* _tmp761_;

2475

ValaDataType* _tmp762_;

2476

gboolean _tmp763_ = FALSE;

2477

_tmp755_ = prop;

2478

_tmp756_ = vala_property_get_get_accessor (_tmp755_);

2479

_tmp757_ = _tmp756_;

2480

_tmp758_ = vala_property_accessor_get_value_type (_tmp757_);

2481

_tmp759_ = _tmp758_;

2482

_tmp760_ = vala_data_type_copy (_tmp759_);

2483

owned_value_type = _tmp760_;

2484

_tmp761_ = owned_value_type;

2485

vala_data_type_set_value_owned (_tmp761_, TRUE);

2486

_tmp762_ = owned_value_type;

2487

_tmp763_ = vala_ccode_base_module_requires_copy ((ValaCCodeBaseModule*) self, _tmp762_);

2488

if (_tmp763_) {

2489

ValaProperty* _tmp764_;

2490

ValaPropertyAccessor* _tmp765_;

2491

ValaPropertyAccessor* _tmp766_;

2492

ValaSourceReference* _tmp767_;

2493

ValaSourceReference* _tmp768_;

2494

ValaProperty* _tmp769_;

2495

gchar* _tmp770_ = NULL;

2496

gchar* _tmp771_;

2497

gchar* _tmp772_ = NULL;

2498

gchar* _tmp773_;

2499

_tmp764_ = prop;

2500

_tmp765_ = vala_property_get_get_accessor (_tmp764_);

2501

_tmp766_ = _tmp765_;

2502

_tmp767_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp766_);

2503

_tmp768_ = _tmp767_;

2504

_tmp769_ = prop;

2505

_tmp770_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp769_);

2506

_tmp771_ = _tmp770_;

2507

_tmp772_ = g_strdup_printf ("unowned return value for getter of property `%s' not supported without" \

2508

" accessor", _tmp771_);

2509

_tmp773_ = _tmp772_;

2510

vala_report_error (_tmp768_, _tmp773_);

2511

_g_free0 (_tmp773_);

2512

_g_free0 (_tmp771_);

2513

}

2514

_vala_code_node_unref0 (owned_value_type);

2515

}

2516

_tmp774_ = expr;

2517

_tmp775_ = vala_expression_get_value_type ((ValaExpression*) _tmp774_);

2518

_tmp776_ = _tmp775_;

2519

_tmp777_ = vala_data_type_is_real_struct_type (_tmp776_);

2520

if (_tmp777_) {

2521

ValaMemberAccess* _tmp778_;

2522

ValaDataType* _tmp779_;

2523

ValaDataType* _tmp780_;

2524

_tmp778_ = expr;

2525

_tmp779_ = vala_expression_get_value_type ((ValaExpression*) _tmp778_);

2526

_tmp780_ = _tmp779_;

2527

vala_data_type_set_nullable (_tmp780_, TRUE);

2528

}

2529

_tmp781_ = expr;

2530

_tmp782_ = vala_expression_get_value_type ((ValaExpression*) _tmp781_);

2531

_tmp783_ = _tmp782_;

2532

_tmp784_ = vala_ccode_base_module_get_temp_variable ((ValaCCodeBaseModule*) self, _tmp783_, TRUE, NULL, TRUE);

2533

temp_var = _tmp784_;

2534

_tmp785_ = temp_var;

2535

_tmp786_ = vala_symbol_get_name ((ValaSymbol*) _tmp785_);

2536

_tmp787_ = _tmp786_;

2537

_tmp788_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, _tmp787_);

2538

ctemp = _tmp788_;

2539

_tmp789_ = temp_var;

2540

vala_ccode_base_module_emit_temp_var ((ValaCCodeBaseModule*) self, _tmp789_);

2541

_tmp790_ = ccall;

2542

_tmp791_ = ctemp;

2543

_tmp792_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, _tmp791_);

2544

_tmp793_ = _tmp792_;

2545

vala_ccode_function_call_add_argument (_tmp790_, (ValaCCodeExpression*) _tmp793_);

2546

_vala_ccode_node_unref0 (_tmp793_);

2547

_tmp794_ = ccall;

2548

_tmp795_ = vala_ccode_constant_new ("NULL");

2549

_tmp796_ = _tmp795_;

2550

vala_ccode_function_call_add_argument (_tmp794_, (ValaCCodeExpression*) _tmp796_);

2551

_vala_ccode_node_unref0 (_tmp796_);

2552

_tmp797_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

2553

_tmp798_ = _tmp797_;

2554

_tmp799_ = ccall;

2555

vala_ccode_function_add_expression (_tmp798_, (ValaCCodeExpression*) _tmp799_);

2556

_tmp800_ = expr;

2557

_tmp801_ = ctemp;

2558

vala_ccode_base_module_set_cvalue ((ValaCCodeBaseModule*) self, (ValaExpression*) _tmp800_, _tmp801_);

2559

_vala_ccode_node_unref0 (ctemp);

2560

_vala_code_node_unref0 (temp_var);

2561

_vala_ccode_node_unref0 (ccall);

2562

}

2563

}

2564

}

2565

_tmp802_ = expr;

2566

_tmp803_ = vala_expression_get_target_value ((ValaExpression*) _tmp802_);

2567

_tmp804_ = _tmp803_;

2568

_tmp805_ = expr;

2569

_tmp806_ = vala_expression_get_value_type ((ValaExpression*) _tmp805_);

2570

_tmp807_ = _tmp806_;

2571

vala_target_value_set_value_type (_tmp804_, _tmp807_);

2572

_tmp808_ = expr;

2573

_tmp809_ = expr;

2574

_tmp810_ = vala_expression_get_target_value ((ValaExpression*) _tmp809_);

2575

_tmp811_ = _tmp810_;

2576

_tmp812_ = expr;

2577

_tmp813_ = vala_ccode_base_module_store_temp_value ((ValaCCodeBaseModule*) self, _tmp811_, (ValaCodeNode*) _tmp812_, NULL);

2578

_tmp814_ = _tmp813_;

2579

vala_expression_set_target_value ((ValaExpression*) _tmp808_, _tmp814_);

2580

_vala_target_value_unref0 (_tmp814_);

2581

_vala_code_node_unref0 (prop);

2582

} else {

2583

ValaMemberAccess* _tmp815_;

2584

ValaSymbol* _tmp816_;

2585

ValaSymbol* _tmp817_;

2586

_tmp815_ = expr;

2587

_tmp816_ = vala_expression_get_symbol_reference ((ValaExpression*) _tmp815_);

2588

_tmp817_ = _tmp816_;

2589

if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp817_, VALA_TYPE_LOCAL_VARIABLE)) {

2590

ValaMemberAccess* _tmp818_;

2591

ValaSymbol* _tmp819_;

2592

ValaSymbol* _tmp820_;

2593

ValaLocalVariable* _tmp821_;

2594

ValaLocalVariable* local;

2595

gboolean _tmp822_ = FALSE;

2596

gboolean _tmp823_ = FALSE;

2597

gboolean _tmp824_ = FALSE;

2598

gboolean _tmp825_ = FALSE;

2599

gboolean _tmp826_ = FALSE;

2600

ValaMemberAccess* _tmp827_;

2601

ValaCodeNode* _tmp828_;

2602

ValaCodeNode* _tmp829_;

2603

gboolean _tmp834_;

2604

gboolean _tmp840_;

2605

gboolean _tmp844_;

2606

gboolean _tmp847_;

2607

gboolean _tmp858_;

2608

_tmp818_ = expr;

2609

_tmp819_ = vala_expression_get_symbol_reference ((ValaExpression*) _tmp818_);

2610

_tmp820_ = _tmp819_;

2611

_tmp821_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp820_, VALA_TYPE_LOCAL_VARIABLE, ValaLocalVariable));

2612

local = _tmp821_;

2613

_tmp827_ = expr;

2614

_tmp828_ = vala_code_node_get_parent_node ((ValaCodeNode*) _tmp827_);

2615

_tmp829_ = _tmp828_;

2616

if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp829_, VALA_TYPE_RETURN_STATEMENT)) {

2617

ValaDataType* _tmp830_;

2618

ValaDataType* _tmp831_;

2619

gboolean _tmp832_;

2620

gboolean _tmp833_;

2621

_tmp830_ = vala_ccode_base_module_get_current_return_type ((ValaCCodeBaseModule*) self);

2622

_tmp831_ = _tmp830_;

2623

_tmp832_ = vala_data_type_get_value_owned (_tmp831_);

2624

_tmp833_ = _tmp832_;

2625

_tmp826_ = _tmp833_;

2626

} else {

2627

_tmp826_ = FALSE;

2628

}

2629

_tmp834_ = _tmp826_;

2630

if (_tmp834_) {

2631

ValaLocalVariable* _tmp835_;

2632

ValaDataType* _tmp836_;

2633

ValaDataType* _tmp837_;

2634

gboolean _tmp838_;

2635

gboolean _tmp839_;

2636

_tmp835_ = local;

2637

_tmp836_ = vala_variable_get_variable_type ((ValaVariable*) _tmp835_);

2638

_tmp837_ = _tmp836_;

2639

_tmp838_ = vala_data_type_get_value_owned (_tmp837_);

2640

_tmp839_ = _tmp838_;

2641

_tmp825_ = _tmp839_;

2642

} else {

2643

_tmp825_ = FALSE;

2644

}

2645

_tmp840_ = _tmp825_;

2646

if (_tmp840_) {

2647

ValaLocalVariable* _tmp841_;

2648

gboolean _tmp842_;

2649

gboolean _tmp843_;

2650

_tmp841_ = local;

2651

_tmp842_ = vala_local_variable_get_captured (_tmp841_);

2652

_tmp843_ = _tmp842_;

2653

_tmp824_ = !_tmp843_;

2654

} else {

2655

_tmp824_ = FALSE;

2656

}

2657

_tmp844_ = _tmp824_;

2658

if (_tmp844_) {

2659

ValaLocalVariable* _tmp845_;

2660

gboolean _tmp846_ = FALSE;

2661

_tmp845_ = local;

2662

_tmp846_ = vala_ccode_base_module_variable_accessible_in_finally ((ValaCCodeBaseModule*) self, _tmp845_);

2663

_tmp823_ = !_tmp846_;

2664

} else {

2665

_tmp823_ = FALSE;

2666

}

2667

_tmp847_ = _tmp823_;

2668

if (_tmp847_) {

2669

gboolean _tmp848_ = FALSE;

2670

ValaLocalVariable* _tmp849_;

2671

ValaDataType* _tmp850_;

2672

ValaDataType* _tmp851_;

2673

gboolean _tmp857_;

2674

_tmp849_ = local;

2675

_tmp850_ = vala_variable_get_variable_type ((ValaVariable*) _tmp849_);

2676

_tmp851_ = _tmp850_;

2677

if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp851_, VALA_TYPE_ARRAY_TYPE)) {

2678

ValaLocalVariable* _tmp852_;

2679

ValaDataType* _tmp853_;

2680

ValaDataType* _tmp854_;

2681

gboolean _tmp855_;

2682

gboolean _tmp856_;

2683

_tmp852_ = local;

2684

_tmp853_ = vala_variable_get_variable_type ((ValaVariable*) _tmp852_);

2685

_tmp854_ = _tmp853_;

2686

_tmp855_ = vala_array_type_get_inline_allocated (G_TYPE_CHECK_INSTANCE_CAST (_tmp854_, VALA_TYPE_ARRAY_TYPE, ValaArrayType));

2687

_tmp856_ = _tmp855_;

2688

_tmp848_ = _tmp856_;

2689

} else {

2690

_tmp848_ = FALSE;

2691

}

2692

_tmp857_ = _tmp848_;

2693

_tmp822_ = !_tmp857_;

2694

} else {

2695

_tmp822_ = FALSE;

2696

}

2697

_tmp858_ = _tmp822_;

2698

if (_tmp858_) {

2699

ValaMemberAccess* _tmp859_;

2700

ValaDataType* _tmp860_;

2701

ValaDataType* _tmp861_;

2702

ValaLocalVariable* _tmp862_;

2703

ValaLocalVariable* _tmp863_;

2704

ValaTargetValue* _tmp864_ = NULL;

2705

ValaGLibValue* glib_value;

2706

ValaMemberAccess* _tmp865_;

2707

ValaGLibValue* _tmp866_;

2708

ValaGLibValue* _tmp867_;

2709

ValaCCodeExpression* _tmp868_;

2710

ValaGLibValue* _tmp871_;

2711

ValaCCodeExpression* _tmp872_;

2712

_tmp859_ = expr;

2713

_tmp860_ = vala_expression_get_value_type ((ValaExpression*) _tmp859_);

2714

_tmp861_ = _tmp860_;

2715

vala_data_type_set_value_owned (_tmp861_, TRUE);

2716

_tmp862_ = local;

2717

vala_symbol_set_active ((ValaSymbol*) _tmp862_, FALSE);

2718

_tmp863_ = local;

2719

_tmp864_ = vala_ccode_base_module_get_local_cvalue ((ValaCCodeBaseModule*) self, _tmp863_);

2720

glib_value = G_TYPE_CHECK_INSTANCE_CAST (_tmp864_, VALA_TYPE_GLIB_VALUE, ValaGLibValue);

2721

_tmp865_ = expr;

2722

_tmp866_ = glib_value;

2723

vala_expression_set_target_value ((ValaExpression*) _tmp865_, (ValaTargetValue*) _tmp866_);

2724

_tmp867_ = glib_value;

2725

_tmp868_ = _tmp867_->delegate_target_cvalue;

2726

if (_tmp868_ == NULL) {

2727

ValaGLibValue* _tmp869_;

2728

ValaCCodeConstant* _tmp870_;

2729

_tmp869_ = glib_value;

2730

_tmp870_ = vala_ccode_constant_new ("NULL");

2731

_vala_ccode_node_unref0 (_tmp869_->delegate_target_cvalue);

2732

_tmp869_->delegate_target_cvalue = (ValaCCodeExpression*) _tmp870_;

2733

}

2734

_tmp871_ = glib_value;

2735

_tmp872_ = _tmp871_->delegate_target_destroy_notify_cvalue;

2736

if (_tmp872_ == NULL) {

2737

ValaGLibValue* _tmp873_;

2738

ValaCCodeConstant* _tmp874_;

2739

_tmp873_ = glib_value;

2740

_tmp874_ = vala_ccode_constant_new ("NULL");

2741

_vala_ccode_node_unref0 (_tmp873_->delegate_target_destroy_notify_cvalue);

2742

_tmp873_->delegate_target_destroy_notify_cvalue = (ValaCCodeExpression*) _tmp874_;

2743

}

2744

_vala_target_value_unref0 (glib_value);

2745

} else {

2746

ValaMemberAccess* _tmp875_;

2747

gboolean _tmp876_;

2748

gboolean _tmp877_;

2749

_tmp875_ = expr;

2750

_tmp876_ = vala_expression_get_lvalue ((ValaExpression*) _tmp875_);

2751

_tmp877_ = _tmp876_;

2752

if (_tmp877_) {

2753

ValaMemberAccess* _tmp878_;

2754

ValaLocalVariable* _tmp879_;

2755

ValaTargetValue* _tmp880_ = NULL;

2756

ValaTargetValue* _tmp881_;

2757

_tmp878_ = expr;

2758

_tmp879_ = local;

2759

_tmp880_ = vala_ccode_base_module_get_local_cvalue ((ValaCCodeBaseModule*) self, _tmp879_);

2760

_tmp881_ = _tmp880_;

2761

vala_expression_set_target_value ((ValaExpression*) _tmp878_, _tmp881_);

2762

_vala_target_value_unref0 (_tmp881_);

2763

} else {

2764

ValaMemberAccess* _tmp882_;

2765

ValaLocalVariable* _tmp883_;

2766

ValaTargetValue* _tmp884_ = NULL;

2767

ValaTargetValue* _tmp885_;

2768

_tmp882_ = expr;

2769

_tmp883_ = local;

2770

_tmp884_ = vala_code_generator_load_local ((ValaCodeGenerator*) self, _tmp883_);

2771

_tmp885_ = _tmp884_;

2772

vala_expression_set_target_value ((ValaExpression*) _tmp882_, _tmp885_);

2773

_vala_target_value_unref0 (_tmp885_);

2774

}

2775

}

2776

_vala_code_node_unref0 (local);

2777

} else {

2778

ValaMemberAccess* _tmp886_;

2779

ValaSymbol* _tmp887_;

2780

ValaSymbol* _tmp888_;

2781

_tmp886_ = expr;

2782

_tmp887_ = vala_expression_get_symbol_reference ((ValaExpression*) _tmp886_);

2783

_tmp888_ = _tmp887_;

2784

if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp888_, VALA_TYPE_PARAMETER)) {

2785

ValaMemberAccess* _tmp889_;

2786

ValaSymbol* _tmp890_;

2787

ValaSymbol* _tmp891_;

2788

ValaParameter* _tmp892_;

2789

ValaParameter* param;

2790

ValaMemberAccess* _tmp893_;

2791

gboolean _tmp894_;

2792

gboolean _tmp895_;

2793

_tmp889_ = expr;

2794

_tmp890_ = vala_expression_get_symbol_reference ((ValaExpression*) _tmp889_);

2795

_tmp891_ = _tmp890_;

2796

_tmp892_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp891_, VALA_TYPE_PARAMETER, ValaParameter));

2797

param = _tmp892_;

2798

_tmp893_ = expr;

2799

_tmp894_ = vala_expression_get_lvalue ((ValaExpression*) _tmp893_);

2800

_tmp895_ = _tmp894_;

2801

if (_tmp895_) {

2802

ValaMemberAccess* _tmp896_;

2803

ValaParameter* _tmp897_;

2804

ValaTargetValue* _tmp898_ = NULL;

2805

ValaTargetValue* _tmp899_;

2806

_tmp896_ = expr;

2807

_tmp897_ = param;

2808

_tmp898_ = vala_ccode_base_module_get_parameter_cvalue ((ValaCCodeBaseModule*) self, _tmp897_);

2809

_tmp899_ = _tmp898_;

2810

vala_expression_set_target_value ((ValaExpression*) _tmp896_, _tmp899_);

2811

_vala_target_value_unref0 (_tmp899_);

2812

} else {

2813

ValaMemberAccess* _tmp900_;

2814

ValaParameter* _tmp901_;

2815

ValaTargetValue* _tmp902_ = NULL;

2816

ValaTargetValue* _tmp903_;

2817

_tmp900_ = expr;

2818

_tmp901_ = param;

2819

_tmp902_ = vala_code_generator_load_parameter ((ValaCodeGenerator*) self, _tmp901_);

2820

_tmp903_ = _tmp902_;

2821

vala_expression_set_target_value ((ValaExpression*) _tmp900_, _tmp903_);

2822

_vala_target_value_unref0 (_tmp903_);

2823

}

2824

_vala_code_node_unref0 (param);

2825

}

2826

}

2827

}

2828

}

2829

}

2830

}

2831

}

2832

}

2833

_vala_code_node_unref0 (delegate_type);

2834

_vala_code_node_unref0 (array_type);

2835

_vala_ccode_node_unref0 (pub_inst);

2836

}

2837

2838

2839

static ValaTargetValue* vala_ccode_member_access_module_real_get_local_cvalue (ValaCCodeBaseModule* base, ValaLocalVariable* local) {

2840

ValaCCodeMemberAccessModule * self;

2841

ValaTargetValue* result = NULL;

2842

ValaLocalVariable* _tmp0_;

2843

ValaDataType* _tmp1_;

2844

ValaDataType* _tmp2_;

2845

ValaDataType* _tmp3_ = NULL;

2846

ValaDataType* _tmp4_;

2847

ValaGLibValue* _tmp5_;

2848

ValaGLibValue* _tmp6_;

2849

ValaGLibValue* _result_;

2850

ValaGLibValue* _tmp7_;

2851

ValaLocalVariable* _tmp8_;

2852

ValaDataType* _tmp9_;

2853

ValaDataType* _tmp10_;

2854

ValaArrayType* _tmp11_;

2855

ValaArrayType* array_type;

2856

ValaLocalVariable* _tmp12_;

2857

ValaDataType* _tmp13_;

2858

ValaDataType* _tmp14_;

2859

ValaDelegateType* _tmp15_;

2860

ValaDelegateType* delegate_type;

2861

ValaLocalVariable* _tmp16_;

2862

gboolean _tmp17_;

2863

gboolean _tmp18_;

2864

self = (ValaCCodeMemberAccessModule*) base;

2865

g_return_val_if_fail (local != NULL, NULL);

2866

_tmp0_ = local;

2867

_tmp1_ = vala_variable_get_variable_type ((ValaVariable*) _tmp0_);

2868

_tmp2_ = _tmp1_;

2869

_tmp3_ = vala_data_type_copy (_tmp2_);

2870

_tmp4_ = _tmp3_;

2871

_tmp5_ = vala_glib_value_new (_tmp4_, NULL, FALSE);

2872

_tmp6_ = _tmp5_;

2873

_vala_code_node_unref0 (_tmp4_);

2874

_result_ = _tmp6_;

2875

_tmp7_ = _result_;

2876

_tmp7_->lvalue = TRUE;

2877

_tmp8_ = local;

2878

_tmp9_ = vala_variable_get_variable_type ((ValaVariable*) _tmp8_);

2879

_tmp10_ = _tmp9_;

2880

_tmp11_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp10_, VALA_TYPE_ARRAY_TYPE) ? ((ValaArrayType*) _tmp10_) : NULL);

2881

array_type = _tmp11_;

2882

_tmp12_ = local;

2883

_tmp13_ = vala_variable_get_variable_type ((ValaVariable*) _tmp12_);

2884

_tmp14_ = _tmp13_;

2885

_tmp15_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp14_, VALA_TYPE_DELEGATE_TYPE) ? ((ValaDelegateType*) _tmp14_) : NULL);

2886

delegate_type = _tmp15_;

2887

_tmp16_ = local;

2888

_tmp17_ = vala_local_variable_get_is_result (_tmp16_);

2889

_tmp18_ = _tmp17_;

2890

if (_tmp18_) {

2891

gboolean _tmp19_ = FALSE;

2892

ValaLocalVariable* _tmp20_;

2893

ValaDataType* _tmp21_;

2894

ValaDataType* _tmp22_;

2895

gboolean _tmp27_;

2896

_tmp20_ = local;

2897

_tmp21_ = vala_variable_get_variable_type ((ValaVariable*) _tmp20_);

2898

_tmp22_ = _tmp21_;

2899

if (_tmp22_ != NULL) {

2900

ValaLocalVariable* _tmp23_;

2901

ValaDataType* _tmp24_;

2902

ValaDataType* _tmp25_;

2903

gboolean _tmp26_ = FALSE;

2904

_tmp23_ = local;

2905

_tmp24_ = vala_variable_get_variable_type ((ValaVariable*) _tmp23_);

2906

_tmp25_ = _tmp24_;

2907

_tmp26_ = vala_data_type_is_real_non_null_struct_type (_tmp25_);

2908

_tmp19_ = _tmp26_;

2909

} else {

2910

_tmp19_ = FALSE;

2911

}

2912

_tmp27_ = _tmp19_;

2913

if (_tmp27_) {

2914

ValaGLibValue* _tmp28_;

2915

ValaCCodeIdentifier* _tmp29_;

2916

ValaCCodeIdentifier* _tmp30_;

2917

ValaCCodeUnaryExpression* _tmp31_;

2918

_tmp28_ = _result_;

2919

_tmp29_ = vala_ccode_identifier_new ("result");

2920

_tmp30_ = _tmp29_;

2921

_tmp31_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_POINTER_INDIRECTION, (ValaCCodeExpression*) _tmp30_);

2922

_vala_ccode_node_unref0 (_tmp28_->cvalue);

2923

_tmp28_->cvalue = (ValaCCodeExpression*) _tmp31_;

2924

_vala_ccode_node_unref0 (_tmp30_);

2925

} else {

2926

ValaGLibValue* _tmp32_;

2927

ValaCCodeIdentifier* _tmp33_;

2928

_tmp32_ = _result_;

2929

_tmp33_ = vala_ccode_identifier_new ("result");

2930

_vala_ccode_node_unref0 (_tmp32_->cvalue);

2931

_tmp32_->cvalue = (ValaCCodeExpression*) _tmp33_;

2932

}

2933

} else {

2934

ValaLocalVariable* _tmp34_;

2935

gboolean _tmp35_;

2936

gboolean _tmp36_;

2937

_tmp34_ = local;

2938

_tmp35_ = vala_local_variable_get_captured (_tmp34_);

2939

_tmp36_ = _tmp35_;

2940

if (_tmp36_) {

2941

ValaLocalVariable* _tmp37_;

2942

ValaSymbol* _tmp38_;

2943

ValaSymbol* _tmp39_;

2944

ValaBlock* _tmp40_;

2945

ValaBlock* block;

2946

ValaGLibValue* _tmp41_;

2947

ValaBlock* _tmp42_;

2948

gint _tmp43_ = 0;

2949

gchar* _tmp44_ = NULL;

2950

gchar* _tmp45_;

2951

ValaCCodeExpression* _tmp46_ = NULL;

2952

ValaCCodeExpression* _tmp47_;

2953

ValaLocalVariable* _tmp48_;

2954

gchar* _tmp49_ = NULL;

2955

gchar* _tmp50_;

2956

ValaCCodeMemberAccess* _tmp51_;

2957

gboolean _tmp52_ = FALSE;

2958

ValaArrayType* _tmp53_;

2959

gboolean _tmp57_;

2960

_tmp37_ = local;

2961

_tmp38_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp37_);

2962

_tmp39_ = _tmp38_;

2963

_tmp40_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp39_, VALA_TYPE_BLOCK, ValaBlock));

2964

block = _tmp40_;

2965

_tmp41_ = _result_;

2966

_tmp42_ = block;

2967

_tmp43_ = vala_ccode_base_module_get_block_id ((ValaCCodeBaseModule*) self, _tmp42_);

2968

_tmp44_ = g_strdup_printf ("_data%d_", _tmp43_);

2969

_tmp45_ = _tmp44_;

2970

_tmp46_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, _tmp45_);

2971

_tmp47_ = _tmp46_;

2972

_tmp48_ = local;

2973

_tmp49_ = vala_ccode_base_module_get_local_cname ((ValaCCodeBaseModule*) self, _tmp48_);

2974

_tmp50_ = _tmp49_;

2975

_tmp51_ = vala_ccode_member_access_new_pointer (_tmp47_, _tmp50_);

2976

_vala_ccode_node_unref0 (_tmp41_->cvalue);

2977

_tmp41_->cvalue = (ValaCCodeExpression*) _tmp51_;

2978

_g_free0 (_tmp50_);

2979

_vala_ccode_node_unref0 (_tmp47_);

2980

_g_free0 (_tmp45_);

2981

_tmp53_ = array_type;

2982

if (_tmp53_ != NULL) {

2983

ValaArrayType* _tmp54_;

2984

gboolean _tmp55_;

2985

gboolean _tmp56_;

2986

_tmp54_ = array_type;

2987

_tmp55_ = vala_array_type_get_fixed_length (_tmp54_);

2988

_tmp56_ = _tmp55_;

2989

_tmp52_ = !_tmp56_;

2990

} else {

2991

_tmp52_ = FALSE;

2992

}

2993

_tmp57_ = _tmp52_;

2994

if (_tmp57_) {

2995

ValaArrayType* _tmp80_;

2996

gint _tmp81_;

2997

gint _tmp82_;

2998

{

2999

gint dim;

3000

dim = 1;

3001

{

3002

gboolean _tmp58_;

3003

_tmp58_ = TRUE;

3004

while (TRUE) {

3005

gboolean _tmp59_;

3006

gint _tmp61_;

3007

ValaArrayType* _tmp62_;

3008

gint _tmp63_;

3009

gint _tmp64_;

3010

ValaGLibValue* _tmp65_;

3011

ValaBlock* _tmp66_;

3012

gint _tmp67_ = 0;

3013

gchar* _tmp68_ = NULL;

3014

gchar* _tmp69_;

3015

ValaCCodeExpression* _tmp70_ = NULL;

3016

ValaCCodeExpression* _tmp71_;

3017

ValaLocalVariable* _tmp72_;

3018

gchar* _tmp73_ = NULL;

3019

gchar* _tmp74_;

3020

gint _tmp75_;

3021

gchar* _tmp76_ = NULL;

3022

gchar* _tmp77_;

3023

ValaCCodeMemberAccess* _tmp78_;

3024

ValaCCodeMemberAccess* _tmp79_;

3025

_tmp59_ = _tmp58_;

3026

if (!_tmp59_) {

3027

gint _tmp60_;

3028

_tmp60_ = dim;

3029

dim = _tmp60_ + 1;

3030

}

3031

_tmp58_ = FALSE;

3032

_tmp61_ = dim;

3033

_tmp62_ = array_type;

3034

_tmp63_ = vala_array_type_get_rank (_tmp62_);

3035

_tmp64_ = _tmp63_;

3036

if (!(_tmp61_ <= _tmp64_)) {

3037

break;

3038

}

3039

_tmp65_ = _result_;

3040

_tmp66_ = block;

3041

_tmp67_ = vala_ccode_base_module_get_block_id ((ValaCCodeBaseModule*) self, _tmp66_);

3042

_tmp68_ = g_strdup_printf ("_data%d_", _tmp67_);

3043

_tmp69_ = _tmp68_;

3044

_tmp70_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, _tmp69_);

3045

_tmp71_ = _tmp70_;

3046

_tmp72_ = local;

3047

_tmp73_ = vala_ccode_base_module_get_local_cname ((ValaCCodeBaseModule*) self, _tmp72_);

3048

_tmp74_ = _tmp73_;

3049

_tmp75_ = dim;

3050

_tmp76_ = vala_ccode_base_module_get_array_length_cname ((ValaCCodeBaseModule*) self, _tmp74_, _tmp75_);

3051

_tmp77_ = _tmp76_;

3052

_tmp78_ = vala_ccode_member_access_new_pointer (_tmp71_, _tmp77_);

3053

_tmp79_ = _tmp78_;

3054

vala_glib_value_append_array_length_cvalue (_tmp65_, (ValaCCodeExpression*) _tmp79_);

3055

_vala_ccode_node_unref0 (_tmp79_);

3056

_g_free0 (_tmp77_);

3057

_g_free0 (_tmp74_);

3058

_vala_ccode_node_unref0 (_tmp71_);

3059

_g_free0 (_tmp69_);

3060

}

3061

}

3062

}

3063

_tmp80_ = array_type;

3064

_tmp81_ = vala_array_type_get_rank (_tmp80_);

3065

_tmp82_ = _tmp81_;

3066

if (_tmp82_ == 1) {

3067

ValaGLibValue* _tmp83_;

3068

ValaBlock* _tmp84_;

3069

gint _tmp85_ = 0;

3070

gchar* _tmp86_ = NULL;

3071

gchar* _tmp87_;

3072

ValaCCodeExpression* _tmp88_ = NULL;

3073

ValaCCodeExpression* _tmp89_;

3074

ValaLocalVariable* _tmp90_;

3075

gchar* _tmp91_ = NULL;

3076

gchar* _tmp92_;

3077

gchar* _tmp93_ = NULL;

3078

gchar* _tmp94_;

3079

ValaCCodeMemberAccess* _tmp95_;

3080

_tmp83_ = _result_;

3081

_tmp84_ = block;

3082

_tmp85_ = vala_ccode_base_module_get_block_id ((ValaCCodeBaseModule*) self, _tmp84_);

3083

_tmp86_ = g_strdup_printf ("_data%d_", _tmp85_);

3084

_tmp87_ = _tmp86_;

3085

_tmp88_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, _tmp87_);

3086

_tmp89_ = _tmp88_;

3087

_tmp90_ = local;

3088

_tmp91_ = vala_ccode_base_module_get_local_cname ((ValaCCodeBaseModule*) self, _tmp90_);

3089

_tmp92_ = _tmp91_;

3090

_tmp93_ = vala_ccode_base_module_get_array_size_cname ((ValaCCodeBaseModule*) self, _tmp92_);

3091

_tmp94_ = _tmp93_;

3092

_tmp95_ = vala_ccode_member_access_new_pointer (_tmp89_, _tmp94_);

3093

_vala_ccode_node_unref0 (_tmp83_->array_size_cvalue);

3094

_tmp83_->array_size_cvalue = (ValaCCodeExpression*) _tmp95_;

3095

_g_free0 (_tmp94_);

3096

_g_free0 (_tmp92_);

3097

_vala_ccode_node_unref0 (_tmp89_);

3098

_g_free0 (_tmp87_);

3099

}

3100

} else {

3101

gboolean _tmp96_ = FALSE;

3102

ValaDelegateType* _tmp97_;

3103

gboolean _tmp103_;

3104

_tmp97_ = delegate_type;

3105

if (_tmp97_ != NULL) {

3106

ValaDelegateType* _tmp98_;

3107

ValaDelegate* _tmp99_;

3108

ValaDelegate* _tmp100_;

3109

gboolean _tmp101_;

3110

gboolean _tmp102_;

3111

_tmp98_ = delegate_type;

3112

_tmp99_ = vala_delegate_type_get_delegate_symbol (_tmp98_);

3113

_tmp100_ = _tmp99_;

3114

_tmp101_ = vala_delegate_get_has_target (_tmp100_);

3115

_tmp102_ = _tmp101_;

3116

_tmp96_ = _tmp102_;

3117

} else {

3118

_tmp96_ = FALSE;

3119

}

3120

_tmp103_ = _tmp96_;

3121

if (_tmp103_) {

3122

ValaGLibValue* _tmp104_;

3123

ValaBlock* _tmp105_;

3124

gint _tmp106_ = 0;

3125

gchar* _tmp107_ = NULL;

3126

gchar* _tmp108_;

3127

ValaCCodeExpression* _tmp109_ = NULL;

3128

ValaCCodeExpression* _tmp110_;

3129

ValaLocalVariable* _tmp111_;

3130

gchar* _tmp112_ = NULL;

3131

gchar* _tmp113_;

3132

gchar* _tmp114_ = NULL;

3133

gchar* _tmp115_;

3134

ValaCCodeMemberAccess* _tmp116_;

3135

ValaDelegateType* _tmp117_;

3136

gboolean _tmp118_;

3137

gboolean _tmp119_;

3138

_tmp104_ = _result_;

3139

_tmp105_ = block;

3140

_tmp106_ = vala_ccode_base_module_get_block_id ((ValaCCodeBaseModule*) self, _tmp105_);

3141

_tmp107_ = g_strdup_printf ("_data%d_", _tmp106_);

3142

_tmp108_ = _tmp107_;

3143

_tmp109_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, _tmp108_);

3144

_tmp110_ = _tmp109_;

3145

_tmp111_ = local;

3146

_tmp112_ = vala_ccode_base_module_get_local_cname ((ValaCCodeBaseModule*) self, _tmp111_);

3147

_tmp113_ = _tmp112_;

3148

_tmp114_ = vala_ccode_base_module_get_delegate_target_cname ((ValaCCodeBaseModule*) self, _tmp113_);

3149

_tmp115_ = _tmp114_;

3150

_tmp116_ = vala_ccode_member_access_new_pointer (_tmp110_, _tmp115_);

3151

_vala_ccode_node_unref0 (_tmp104_->delegate_target_cvalue);

3152

_tmp104_->delegate_target_cvalue = (ValaCCodeExpression*) _tmp116_;

3153

_g_free0 (_tmp115_);

3154

_g_free0 (_tmp113_);

3155

_vala_ccode_node_unref0 (_tmp110_);

3156

_g_free0 (_tmp108_);

3157

_tmp117_ = delegate_type;

3158

_tmp118_ = vala_data_type_get_value_owned ((ValaDataType*) _tmp117_);

3159

_tmp119_ = _tmp118_;

3160

if (_tmp119_) {

3161

ValaGLibValue* _tmp120_;

3162

ValaBlock* _tmp121_;

3163

gint _tmp122_ = 0;

3164

gchar* _tmp123_ = NULL;

3165

gchar* _tmp124_;

3166

ValaCCodeExpression* _tmp125_ = NULL;

3167

ValaCCodeExpression* _tmp126_;

3168

ValaLocalVariable* _tmp127_;

3169

gchar* _tmp128_ = NULL;

3170

gchar* _tmp129_;

3171

gchar* _tmp130_ = NULL;

3172

gchar* _tmp131_;

3173

ValaCCodeMemberAccess* _tmp132_;

3174

_tmp120_ = _result_;

3175

_tmp121_ = block;

3176

_tmp122_ = vala_ccode_base_module_get_block_id ((ValaCCodeBaseModule*) self, _tmp121_);

3177

_tmp123_ = g_strdup_printf ("_data%d_", _tmp122_);

3178

_tmp124_ = _tmp123_;

3179

_tmp125_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, _tmp124_);

3180

_tmp126_ = _tmp125_;

3181

_tmp127_ = local;

3182

_tmp128_ = vala_ccode_base_module_get_local_cname ((ValaCCodeBaseModule*) self, _tmp127_);

3183

_tmp129_ = _tmp128_;

3184

_tmp130_ = vala_ccode_base_module_get_delegate_target_destroy_notify_cname ((ValaCCodeBaseModule*) self, _tmp129_);

3185

_tmp131_ = _tmp130_;

3186

_tmp132_ = vala_ccode_member_access_new_pointer (_tmp126_, _tmp131_);

3187

_vala_ccode_node_unref0 (_tmp120_->delegate_target_destroy_notify_cvalue);

3188

_tmp120_->delegate_target_destroy_notify_cvalue = (ValaCCodeExpression*) _tmp132_;

3189

_g_free0 (_tmp131_);

3190

_g_free0 (_tmp129_);

3191

_vala_ccode_node_unref0 (_tmp126_);

3192

_g_free0 (_tmp124_);

3193

}

3194

}

3195

}

3196

_vala_code_node_unref0 (block);

3197

} else {

3198

ValaGLibValue* _tmp133_;

3199

ValaLocalVariable* _tmp134_;

3200

ValaCCodeExpression* _tmp135_ = NULL;

3201

gboolean _tmp136_ = FALSE;

3202

ValaArrayType* _tmp137_;

3203

gboolean _tmp141_;

3204

_tmp133_ = _result_;

3205

_tmp134_ = local;

3206

_tmp135_ = vala_ccode_base_module_get_local_cexpression ((ValaCCodeBaseModule*) self, _tmp134_);

3207

_vala_ccode_node_unref0 (_tmp133_->cvalue);

3208

_tmp133_->cvalue = _tmp135_;

3209

_tmp137_ = array_type;

3210

if (_tmp137_ != NULL) {

3211

ValaArrayType* _tmp138_;

3212

gboolean _tmp139_;

3213

gboolean _tmp140_;

3214

_tmp138_ = array_type;

3215

_tmp139_ = vala_array_type_get_fixed_length (_tmp138_);

3216

_tmp140_ = _tmp139_;

3217

_tmp136_ = !_tmp140_;

3218

} else {

3219

_tmp136_ = FALSE;

3220

}

3221

_tmp141_ = _tmp136_;

3222

if (_tmp141_) {

3223

ValaArrayType* _tmp158_;

3224

gint _tmp159_;

3225

gint _tmp160_;

3226

{

3227

gint dim;

3228

dim = 1;

3229

{

3230

gboolean _tmp142_;

3231

_tmp142_ = TRUE;

3232

while (TRUE) {

3233

gboolean _tmp143_;

3234

gint _tmp145_;

3235

ValaArrayType* _tmp146_;

3236

gint _tmp147_;

3237

gint _tmp148_;

3238

ValaGLibValue* _tmp149_;

3239

ValaLocalVariable* _tmp150_;

3240

gchar* _tmp151_ = NULL;

3241

gchar* _tmp152_;

3242

gint _tmp153_;

3243

gchar* _tmp154_ = NULL;

3244

gchar* _tmp155_;

3245

ValaCCodeExpression* _tmp156_ = NULL;

3246

ValaCCodeExpression* _tmp157_;

3247

_tmp143_ = _tmp142_;

3248

if (!_tmp143_) {

3249

gint _tmp144_;

3250

_tmp144_ = dim;

3251

dim = _tmp144_ + 1;

3252

}

3253

_tmp142_ = FALSE;

3254

_tmp145_ = dim;

3255

_tmp146_ = array_type;

3256

_tmp147_ = vala_array_type_get_rank (_tmp146_);

3257

_tmp148_ = _tmp147_;

3258

if (!(_tmp145_ <= _tmp148_)) {

3259

break;

3260

}

3261

_tmp149_ = _result_;

3262

_tmp150_ = local;

3263

_tmp151_ = vala_ccode_base_module_get_local_cname ((ValaCCodeBaseModule*) self, _tmp150_);

3264

_tmp152_ = _tmp151_;

3265

_tmp153_ = dim;

3266

_tmp154_ = vala_ccode_base_module_get_array_length_cname ((ValaCCodeBaseModule*) self, _tmp152_, _tmp153_);

3267

_tmp155_ = _tmp154_;

3268

_tmp156_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, _tmp155_);

3269

_tmp157_ = _tmp156_;

3270

vala_glib_value_append_array_length_cvalue (_tmp149_, _tmp157_);

3271

_vala_ccode_node_unref0 (_tmp157_);

3272

_g_free0 (_tmp155_);

3273

_g_free0 (_tmp152_);

3274

}

3275

}

3276

}

3277

_tmp158_ = array_type;

3278

_tmp159_ = vala_array_type_get_rank (_tmp158_);

3279

_tmp160_ = _tmp159_;

3280

if (_tmp160_ == 1) {

3281

ValaGLibValue* _tmp161_;

3282

ValaLocalVariable* _tmp162_;

3283

gchar* _tmp163_ = NULL;

3284

gchar* _tmp164_;

3285

gchar* _tmp165_ = NULL;

3286

gchar* _tmp166_;

3287

ValaCCodeExpression* _tmp167_ = NULL;

3288

_tmp161_ = _result_;

3289

_tmp162_ = local;

3290

_tmp163_ = vala_ccode_base_module_get_local_cname ((ValaCCodeBaseModule*) self, _tmp162_);

3291

_tmp164_ = _tmp163_;

3292

_tmp165_ = vala_ccode_base_module_get_array_size_cname ((ValaCCodeBaseModule*) self, _tmp164_);

3293

_tmp166_ = _tmp165_;

3294

_tmp167_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, _tmp166_);

3295

_vala_ccode_node_unref0 (_tmp161_->array_size_cvalue);

3296

_tmp161_->array_size_cvalue = _tmp167_;

3297

_g_free0 (_tmp166_);

3298

_g_free0 (_tmp164_);

3299

}

3300

} else {

3301

gboolean _tmp168_ = FALSE;

3302

ValaDelegateType* _tmp169_;

3303

gboolean _tmp175_;

3304

_tmp169_ = delegate_type;

3305

if (_tmp169_ != NULL) {

3306

ValaDelegateType* _tmp170_;

3307

ValaDelegate* _tmp171_;

3308

ValaDelegate* _tmp172_;

3309

gboolean _tmp173_;

3310

gboolean _tmp174_;

3311

_tmp170_ = delegate_type;

3312

_tmp171_ = vala_delegate_type_get_delegate_symbol (_tmp170_);

3313

_tmp172_ = _tmp171_;

3314

_tmp173_ = vala_delegate_get_has_target (_tmp172_);

3315

_tmp174_ = _tmp173_;

3316

_tmp168_ = _tmp174_;

3317

} else {

3318

_tmp168_ = FALSE;

3319

}

3320

_tmp175_ = _tmp168_;

3321

if (_tmp175_) {

3322

gboolean _tmp176_ = FALSE;

3323

_tmp176_ = vala_ccode_base_module_is_in_coroutine ((ValaCCodeBaseModule*) self);

3324

if (_tmp176_) {

3325

ValaGLibValue* _tmp177_;

3326

ValaCCodeIdentifier* _tmp178_;

3327

ValaCCodeIdentifier* _tmp179_;

3328

ValaLocalVariable* _tmp180_;

3329

gchar* _tmp181_ = NULL;

3330

gchar* _tmp182_;

3331

gchar* _tmp183_ = NULL;

3332

gchar* _tmp184_;

3333

ValaCCodeMemberAccess* _tmp185_;

3334

ValaLocalVariable* _tmp186_;

3335

ValaDataType* _tmp187_;

3336

ValaDataType* _tmp188_;

3337

gboolean _tmp189_;

3338

gboolean _tmp190_;

3339

_tmp177_ = _result_;

3340

_tmp178_ = vala_ccode_identifier_new ("_data_");

3341

_tmp179_ = _tmp178_;

3342

_tmp180_ = local;

3343

_tmp181_ = vala_ccode_base_module_get_local_cname ((ValaCCodeBaseModule*) self, _tmp180_);

3344

_tmp182_ = _tmp181_;

3345

_tmp183_ = vala_ccode_base_module_get_delegate_target_cname ((ValaCCodeBaseModule*) self, _tmp182_);

3346

_tmp184_ = _tmp183_;

3347

_tmp185_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp179_, _tmp184_);

3348

_vala_ccode_node_unref0 (_tmp177_->delegate_target_cvalue);

3349

_tmp177_->delegate_target_cvalue = (ValaCCodeExpression*) _tmp185_;

3350

_g_free0 (_tmp184_);

3351

_g_free0 (_tmp182_);

3352

_vala_ccode_node_unref0 (_tmp179_);

3353

_tmp186_ = local;

3354

_tmp187_ = vala_variable_get_variable_type ((ValaVariable*) _tmp186_);

3355

_tmp188_ = _tmp187_;

3356

_tmp189_ = vala_data_type_get_value_owned (_tmp188_);

3357

_tmp190_ = _tmp189_;

3358

if (_tmp190_) {

3359

ValaGLibValue* _tmp191_;

3360

ValaCCodeIdentifier* _tmp192_;

3361

ValaCCodeIdentifier* _tmp193_;

3362

ValaLocalVariable* _tmp194_;

3363

gchar* _tmp195_ = NULL;

3364

gchar* _tmp196_;

3365

gchar* _tmp197_ = NULL;

3366

gchar* _tmp198_;

3367

ValaCCodeMemberAccess* _tmp199_;

3368

_tmp191_ = _result_;

3369

_tmp192_ = vala_ccode_identifier_new ("_data_");

3370

_tmp193_ = _tmp192_;

3371

_tmp194_ = local;

3372

_tmp195_ = vala_ccode_base_module_get_local_cname ((ValaCCodeBaseModule*) self, _tmp194_);

3373

_tmp196_ = _tmp195_;

3374

_tmp197_ = vala_ccode_base_module_get_delegate_target_destroy_notify_cname ((ValaCCodeBaseModule*) self, _tmp196_);

3375

_tmp198_ = _tmp197_;

3376

_tmp199_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp193_, _tmp198_);

3377

_vala_ccode_node_unref0 (_tmp191_->delegate_target_destroy_notify_cvalue);

3378

_tmp191_->delegate_target_destroy_notify_cvalue = (ValaCCodeExpression*) _tmp199_;

3379

_g_free0 (_tmp198_);

3380

_g_free0 (_tmp196_);

3381

_vala_ccode_node_unref0 (_tmp193_);

3382

}

3383

} else {

3384

ValaGLibValue* _tmp200_;

3385

ValaLocalVariable* _tmp201_;

3386

gchar* _tmp202_ = NULL;

3387

gchar* _tmp203_;

3388

gchar* _tmp204_ = NULL;

3389

gchar* _tmp205_;

3390

ValaCCodeIdentifier* _tmp206_;

3391

ValaLocalVariable* _tmp207_;

3392

ValaDataType* _tmp208_;

3393

ValaDataType* _tmp209_;

3394

gboolean _tmp210_;

3395

gboolean _tmp211_;

3396

_tmp200_ = _result_;

3397

_tmp201_ = local;

3398

_tmp202_ = vala_ccode_base_module_get_local_cname ((ValaCCodeBaseModule*) self, _tmp201_);

3399

_tmp203_ = _tmp202_;

3400

_tmp204_ = vala_ccode_base_module_get_delegate_target_cname ((ValaCCodeBaseModule*) self, _tmp203_);

3401

_tmp205_ = _tmp204_;

3402

_tmp206_ = vala_ccode_identifier_new (_tmp205_);

3403

_vala_ccode_node_unref0 (_tmp200_->delegate_target_cvalue);

3404

_tmp200_->delegate_target_cvalue = (ValaCCodeExpression*) _tmp206_;

3405

_g_free0 (_tmp205_);

3406

_g_free0 (_tmp203_);

3407

_tmp207_ = local;

3408

_tmp208_ = vala_variable_get_variable_type ((ValaVariable*) _tmp207_);

3409

_tmp209_ = _tmp208_;

3410

_tmp210_ = vala_data_type_get_value_owned (_tmp209_);

3411

_tmp211_ = _tmp210_;

3412

if (_tmp211_) {

3413

ValaGLibValue* _tmp212_;

3414

ValaLocalVariable* _tmp213_;

3415

gchar* _tmp214_ = NULL;

3416

gchar* _tmp215_;

3417

gchar* _tmp216_ = NULL;

3418

gchar* _tmp217_;

3419

ValaCCodeIdentifier* _tmp218_;

3420

_tmp212_ = _result_;

3421

_tmp213_ = local;

3422

_tmp214_ = vala_ccode_base_module_get_local_cname ((ValaCCodeBaseModule*) self, _tmp213_);

3423

_tmp215_ = _tmp214_;

3424

_tmp216_ = vala_ccode_base_module_get_delegate_target_destroy_notify_cname ((ValaCCodeBaseModule*) self, _tmp215_);

3425

_tmp217_ = _tmp216_;

3426

_tmp218_ = vala_ccode_identifier_new (_tmp217_);

3427

_vala_ccode_node_unref0 (_tmp212_->delegate_target_destroy_notify_cvalue);

3428

_tmp212_->delegate_target_destroy_notify_cvalue = (ValaCCodeExpression*) _tmp218_;

3429

_g_free0 (_tmp217_);

3430

_g_free0 (_tmp215_);

3431

}

3432

}

3433

}

3434

}

3435

}

3436

}

3437

result = (ValaTargetValue*) _result_;

3438

_vala_code_node_unref0 (delegate_type);

3439

_vala_code_node_unref0 (array_type);

3440

return result;

3441

}

3442

3443

3444

static ValaTargetValue* vala_ccode_member_access_module_real_get_parameter_cvalue (ValaCCodeBaseModule* base, ValaParameter* param) {

3445

ValaCCodeMemberAccessModule * self;

3446

ValaTargetValue* result = NULL;

3447

ValaParameter* _tmp0_;

3448

ValaDataType* _tmp1_;

3449

ValaDataType* _tmp2_;

3450

ValaDataType* _tmp3_ = NULL;

3451

ValaDataType* _tmp4_;

3452

ValaGLibValue* _tmp5_;

3453

ValaGLibValue* _tmp6_;

3454

ValaGLibValue* _result_;

3455

ValaGLibValue* _tmp7_;

3456

ValaGLibValue* _tmp8_;

3457

ValaParameter* _tmp9_;

3458

gboolean _tmp10_ = FALSE;

3459

ValaParameter* _tmp11_;

3460

gchar* _tmp12_ = NULL;

3461

gchar* _tmp13_;

3462

gboolean _tmp14_;

3463

ValaGLibValue* _tmp20_;

3464

ValaParameter* _tmp21_;

3465

gchar* _tmp22_ = NULL;

3466

ValaGLibValue* _tmp23_;

3467

ValaDataType* _tmp24_;

3468

ValaDataType* _tmp25_;

3469

ValaArrayType* _tmp26_;

3470

ValaArrayType* array_type;

3471

ValaGLibValue* _tmp27_;

3472

ValaDataType* _tmp28_;

3473

ValaDataType* _tmp29_;

3474

ValaDelegateType* _tmp30_;

3475

ValaDelegateType* delegate_type;

3476

gboolean _tmp31_ = FALSE;

3477

ValaDelegateType* _tmp32_;

3478

gboolean _tmp38_;

3479

gboolean is_unowned_delegate;

3480

gboolean _tmp39_ = FALSE;

3481

gboolean _tmp40_ = FALSE;

3482

ValaParameter* _tmp41_;

3483

gboolean _tmp42_;

3484

gboolean _tmp43_;

3485

gboolean _tmp45_;

3486

gboolean _tmp47_;

3487

ValaParameter* _tmp51_;

3488

const gchar* _tmp52_;

3489

const gchar* _tmp53_;

3490

self = (ValaCCodeMemberAccessModule*) base;

3491

g_return_val_if_fail (param != NULL, NULL);

3492

_tmp0_ = param;

3493

_tmp1_ = vala_variable_get_variable_type ((ValaVariable*) _tmp0_);

3494

_tmp2_ = _tmp1_;

3495

_tmp3_ = vala_data_type_copy (_tmp2_);

3496

_tmp4_ = _tmp3_;

3497

_tmp5_ = vala_glib_value_new (_tmp4_, NULL, FALSE);

3498

_tmp6_ = _tmp5_;

3499

_vala_code_node_unref0 (_tmp4_);

3500

_result_ = _tmp6_;

3501

_tmp7_ = _result_;

3502

_tmp7_->lvalue = TRUE;

3503

_tmp8_ = _result_;

3504

_tmp9_ = param;

3505

_tmp10_ = vala_ccode_base_module_get_ccode_array_null_terminated ((ValaCodeNode*) _tmp9_);

3506

_tmp8_->array_null_terminated = _tmp10_;

3507

_tmp11_ = param;

3508

_tmp12_ = vala_ccode_base_module_get_ccode_array_length_expr ((ValaCodeNode*) _tmp11_);

3509

_tmp13_ = _tmp12_;

3510

_tmp14_ = _tmp13_ != NULL;

3511

_g_free0 (_tmp13_);

3512

if (_tmp14_) {

3513

ValaGLibValue* _tmp15_;

3514

ValaParameter* _tmp16_;

3515

gchar* _tmp17_ = NULL;

3516

gchar* _tmp18_;

3517

ValaCCodeConstant* _tmp19_;

3518

_tmp15_ = _result_;

3519

_tmp16_ = param;

3520

_tmp17_ = vala_ccode_base_module_get_ccode_array_length_expr ((ValaCodeNode*) _tmp16_);

3521

_tmp18_ = _tmp17_;

3522

_tmp19_ = vala_ccode_constant_new (_tmp18_);

3523

_vala_ccode_node_unref0 (_tmp15_->array_length_cexpr);

3524

_tmp15_->array_length_cexpr = (ValaCCodeExpression*) _tmp19_;

3525

_g_free0 (_tmp18_);

3526

}

3527

_tmp20_ = _result_;

3528

_tmp21_ = param;

3529

_tmp22_ = vala_ccode_base_module_get_ccode_type ((ValaCodeNode*) _tmp21_);

3530

_g_free0 (_tmp20_->ctype);

3531

_tmp20_->ctype = _tmp22_;

3532

_tmp23_ = _result_;

3533

_tmp24_ = vala_target_value_get_value_type ((ValaTargetValue*) _tmp23_);

3534

_tmp25_ = _tmp24_;

3535

_tmp26_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp25_, VALA_TYPE_ARRAY_TYPE) ? ((ValaArrayType*) _tmp25_) : NULL);

3536

array_type = _tmp26_;

3537

_tmp27_ = _result_;

3538

_tmp28_ = vala_target_value_get_value_type ((ValaTargetValue*) _tmp27_);

3539

_tmp29_ = _tmp28_;

3540

_tmp30_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp29_, VALA_TYPE_DELEGATE_TYPE) ? ((ValaDelegateType*) _tmp29_) : NULL);

3541

delegate_type = _tmp30_;

3542

_tmp32_ = delegate_type;

3543

if (_tmp32_ != NULL) {

3544

ValaParameter* _tmp33_;

3545

ValaDataType* _tmp34_;

3546

ValaDataType* _tmp35_;

3547

gboolean _tmp36_;

3548

gboolean _tmp37_;

3549

_tmp33_ = param;

3550

_tmp34_ = vala_variable_get_variable_type ((ValaVariable*) _tmp33_);

3551

_tmp35_ = _tmp34_;

3552

_tmp36_ = vala_data_type_get_value_owned (_tmp35_);

3553

_tmp37_ = _tmp36_;

3554

_tmp31_ = !_tmp37_;

3555

} else {

3556

_tmp31_ = FALSE;

3557

}

3558

_tmp38_ = _tmp31_;

3559

is_unowned_delegate = _tmp38_;

3560

_tmp41_ = param;

3561

_tmp42_ = vala_parameter_get_captured (_tmp41_);

3562

_tmp43_ = _tmp42_;

3563

if (_tmp43_) {

3564

_tmp40_ = TRUE;

3565

} else {

3566

gboolean _tmp44_ = FALSE;

3567

_tmp44_ = vala_ccode_base_module_is_in_coroutine ((ValaCCodeBaseModule*) self);

3568

_tmp40_ = _tmp44_;

3569

}

3570

_tmp45_ = _tmp40_;

3571

if (_tmp45_) {

3572

gboolean _tmp46_;

3573

_tmp46_ = is_unowned_delegate;

3574

_tmp39_ = !_tmp46_;

3575

} else {

3576

_tmp39_ = FALSE;

3577

}

3578

_tmp47_ = _tmp39_;

3579

if (_tmp47_) {

3580

ValaGLibValue* _tmp48_;

3581

ValaDataType* _tmp49_;

3582

ValaDataType* _tmp50_;

3583

_tmp48_ = _result_;

3584

_tmp49_ = vala_target_value_get_value_type ((ValaTargetValue*) _tmp48_);

3585

_tmp50_ = _tmp49_;

3586

vala_data_type_set_value_owned (_tmp50_, TRUE);

3587

}

3588

_tmp51_ = param;

3589

_tmp52_ = vala_symbol_get_name ((ValaSymbol*) _tmp51_);

3590

_tmp53_ = _tmp52_;

3591

if (g_strcmp0 (_tmp53_, "this") == 0) {

3592

gboolean _tmp54_ = FALSE;

3593

_tmp54_ = vala_ccode_base_module_is_in_coroutine ((ValaCCodeBaseModule*) self);

3594

if (_tmp54_) {

3595

ValaGLibValue* _tmp55_;

3596

ValaCCodeIdentifier* _tmp56_;

3597

ValaCCodeIdentifier* _tmp57_;

3598

ValaCCodeMemberAccess* _tmp58_;

3599

_tmp55_ = _result_;

3600

_tmp56_ = vala_ccode_identifier_new ("_data_");

3601

_tmp57_ = _tmp56_;

3602

_tmp58_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp57_, "self");

3603

_vala_ccode_node_unref0 (_tmp55_->cvalue);

3604

_tmp55_->cvalue = (ValaCCodeExpression*) _tmp58_;

3605

_vala_ccode_node_unref0 (_tmp57_);

3606

} else {

3607

ValaGLibValue* _tmp59_;

3608

ValaDataType* _tmp60_;

3609

ValaDataType* _tmp61_;

3610

ValaTypeSymbol* _tmp62_;

3611

ValaTypeSymbol* _tmp63_;

3612

ValaStruct* _tmp64_;

3613

ValaStruct* st;

3614

gboolean _tmp65_ = FALSE;

3615

ValaStruct* _tmp66_;

3616

gboolean _tmp69_;

3617

_tmp59_ = _result_;

3618

_tmp60_ = vala_target_value_get_value_type ((ValaTargetValue*) _tmp59_);

3619

_tmp61_ = _tmp60_;

3620

_tmp62_ = vala_data_type_get_data_type (_tmp61_);

3621

_tmp63_ = _tmp62_;

3622

_tmp64_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp63_, VALA_TYPE_STRUCT) ? ((ValaStruct*) _tmp63_) : NULL);

3623

st = _tmp64_;

3624

_tmp66_ = st;

3625

if (_tmp66_ != NULL) {

3626

ValaStruct* _tmp67_;

3627

gboolean _tmp68_ = FALSE;

3628

_tmp67_ = st;

3629

_tmp68_ = vala_struct_is_simple_type (_tmp67_);

3630

_tmp65_ = !_tmp68_;

3631

} else {

3632

_tmp65_ = FALSE;

3633

}

3634

_tmp69_ = _tmp65_;

3635

if (_tmp69_) {

3636

ValaGLibValue* _tmp70_;

3637

ValaCCodeIdentifier* _tmp71_;

3638

_tmp70_ = _result_;

3639

_tmp71_ = vala_ccode_identifier_new ("(*self)");

3640

_vala_ccode_node_unref0 (_tmp70_->cvalue);

3641

_tmp70_->cvalue = (ValaCCodeExpression*) _tmp71_;

3642

} else {

3643

ValaGLibValue* _tmp72_;

3644

ValaCCodeIdentifier* _tmp73_;

3645

_tmp72_ = _result_;

3646

_tmp73_ = vala_ccode_identifier_new ("self");

3647

_vala_ccode_node_unref0 (_tmp72_->cvalue);

3648

_tmp72_->cvalue = (ValaCCodeExpression*) _tmp73_;

3649

}

3650

_vala_code_node_unref0 (st);

3651

}

3652

} else {

3653

ValaParameter* _tmp74_;

3654

const gchar* _tmp75_;

3655

const gchar* _tmp76_;

3656

gchar* _tmp77_;

3657

gchar* name;

3658

ValaParameter* _tmp78_;

3659

gboolean _tmp79_;

3660

gboolean _tmp80_;

3661

gboolean _tmp327_ = FALSE;

3662

ValaParameter* _tmp328_;

3663

gboolean _tmp329_;

3664

gboolean _tmp330_;

3665

gboolean _tmp332_;

3666

_tmp74_ = param;

3667

_tmp75_ = vala_symbol_get_name ((ValaSymbol*) _tmp74_);

3668

_tmp76_ = _tmp75_;

3669

_tmp77_ = g_strdup (_tmp76_);

3670

name = _tmp77_;

3671

_tmp78_ = param;

3672

_tmp79_ = vala_parameter_get_captured (_tmp78_);

3673

_tmp80_ = _tmp79_;

3674

if (_tmp80_) {

3675

ValaParameter* _tmp81_;

3676

ValaSymbol* _tmp82_;

3677

ValaSymbol* _tmp83_;

3678

ValaBlock* _tmp84_;

3679

ValaBlock* block;

3680

ValaBlock* _tmp85_;

3681

ValaGLibValue* _tmp92_;

3682

ValaBlock* _tmp93_;

3683

gint _tmp94_ = 0;

3684

gchar* _tmp95_ = NULL;

3685

gchar* _tmp96_;

3686

ValaCCodeExpression* _tmp97_ = NULL;

3687

ValaCCodeExpression* _tmp98_;

3688

ValaParameter* _tmp99_;

3689

const gchar* _tmp100_;

3690

const gchar* _tmp101_;

3691

gchar* _tmp102_ = NULL;

3692

gchar* _tmp103_;

3693

ValaCCodeMemberAccess* _tmp104_;

3694

gboolean _tmp105_ = FALSE;

3695

ValaArrayType* _tmp106_;

3696

gboolean _tmp109_;

3697

_tmp81_ = param;

3698

_tmp82_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp81_);

3699

_tmp83_ = _tmp82_;

3700

_tmp84_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp83_, VALA_TYPE_BLOCK) ? ((ValaBlock*) _tmp83_) : NULL);

3701

block = _tmp84_;

3702

_tmp85_ = block;

3703

if (_tmp85_ == NULL) {

3704

ValaParameter* _tmp86_;

3705

ValaSymbol* _tmp87_;

3706

ValaSymbol* _tmp88_;

3707

ValaBlock* _tmp89_;

3708

ValaBlock* _tmp90_;

3709

ValaBlock* _tmp91_;

3710

_tmp86_ = param;

3711

_tmp87_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp86_);

3712

_tmp88_ = _tmp87_;

3713

_tmp89_ = vala_subroutine_get_body ((ValaSubroutine*) G_TYPE_CHECK_INSTANCE_CAST (_tmp88_, VALA_TYPE_METHOD, ValaMethod));

3714

_tmp90_ = _tmp89_;

3715

_tmp91_ = _vala_code_node_ref0 (_tmp90_);

3716

_vala_code_node_unref0 (block);

3717

block = _tmp91_;

3718

}

3719

_tmp92_ = _result_;

3720

_tmp93_ = block;

3721

_tmp94_ = vala_ccode_base_module_get_block_id ((ValaCCodeBaseModule*) self, _tmp93_);

3722

_tmp95_ = g_strdup_printf ("_data%d_", _tmp94_);

3723

_tmp96_ = _tmp95_;

3724

_tmp97_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, _tmp96_);

3725

_tmp98_ = _tmp97_;

3726

_tmp99_ = param;

3727

_tmp100_ = vala_symbol_get_name ((ValaSymbol*) _tmp99_);

3728

_tmp101_ = _tmp100_;

3729

_tmp102_ = vala_ccode_base_module_get_variable_cname ((ValaCCodeBaseModule*) self, _tmp101_);

3730

_tmp103_ = _tmp102_;

3731

_tmp104_ = vala_ccode_member_access_new_pointer (_tmp98_, _tmp103_);

3732

_vala_ccode_node_unref0 (_tmp92_->cvalue);

3733

_tmp92_->cvalue = (ValaCCodeExpression*) _tmp104_;

3734

_g_free0 (_tmp103_);

3735

_vala_ccode_node_unref0 (_tmp98_);

3736

_g_free0 (_tmp96_);

3737

_tmp106_ = array_type;

3738

if (_tmp106_ != NULL) {

3739

ValaParameter* _tmp107_;

3740

gboolean _tmp108_ = FALSE;

3741

_tmp107_ = param;

3742

_tmp108_ = vala_ccode_base_module_get_ccode_array_length ((ValaCodeNode*) _tmp107_);

3743

_tmp105_ = _tmp108_;

3744

} else {

3745

_tmp105_ = FALSE;

3746

}

3747

_tmp109_ = _tmp105_;

3748

if (_tmp109_) {

3749

{

3750

gint dim;

3751

dim = 1;

3752

{

3753

gboolean _tmp110_;

3754

_tmp110_ = TRUE;

3755

while (TRUE) {

3756

gboolean _tmp111_;

3757

gint _tmp113_;

3758

ValaArrayType* _tmp114_;

3759

gint _tmp115_;

3760

gint _tmp116_;

3761

ValaGLibValue* _tmp117_;

3762

ValaBlock* _tmp118_;

3763

gint _tmp119_ = 0;

3764

gchar* _tmp120_ = NULL;

3765

gchar* _tmp121_;

3766

ValaCCodeExpression* _tmp122_ = NULL;

3767

ValaCCodeExpression* _tmp123_;

3768

ValaParameter* _tmp124_;

3769

gint _tmp125_;

3770

gchar* _tmp126_ = NULL;

3771

gchar* _tmp127_;

3772

ValaCCodeMemberAccess* _tmp128_;

3773

ValaCCodeMemberAccess* _tmp129_;

3774

_tmp111_ = _tmp110_;

3775

if (!_tmp111_) {

3776

gint _tmp112_;

3777

_tmp112_ = dim;

3778

dim = _tmp112_ + 1;

3779

}

3780

_tmp110_ = FALSE;

3781

_tmp113_ = dim;

3782

_tmp114_ = array_type;

3783

_tmp115_ = vala_array_type_get_rank (_tmp114_);

3784

_tmp116_ = _tmp115_;

3785

if (!(_tmp113_ <= _tmp116_)) {

3786

break;

3787

}

3788

_tmp117_ = _result_;

3789

_tmp118_ = block;

3790

_tmp119_ = vala_ccode_base_module_get_block_id ((ValaCCodeBaseModule*) self, _tmp118_);

3791

_tmp120_ = g_strdup_printf ("_data%d_", _tmp119_);

3792

_tmp121_ = _tmp120_;

3793

_tmp122_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, _tmp121_);

3794

_tmp123_ = _tmp122_;

3795

_tmp124_ = param;

3796

_tmp125_ = dim;

3797

_tmp126_ = vala_ccode_base_module_get_parameter_array_length_cname ((ValaCCodeBaseModule*) self, _tmp124_, _tmp125_);

3798

_tmp127_ = _tmp126_;

3799

_tmp128_ = vala_ccode_member_access_new_pointer (_tmp123_, _tmp127_);

3800

_tmp129_ = _tmp128_;

3801

vala_glib_value_append_array_length_cvalue (_tmp117_, (ValaCCodeExpression*) _tmp129_);

3802

_vala_ccode_node_unref0 (_tmp129_);

3803

_g_free0 (_tmp127_);

3804

_vala_ccode_node_unref0 (_tmp123_);

3805

_g_free0 (_tmp121_);

3806

}

3807

}

3808

}

3809

} else {

3810

gboolean _tmp130_ = FALSE;

3811

ValaDelegateType* _tmp131_;

3812

gboolean _tmp137_;

3813

_tmp131_ = delegate_type;

3814

if (_tmp131_ != NULL) {

3815

ValaDelegateType* _tmp132_;

3816

ValaDelegate* _tmp133_;

3817

ValaDelegate* _tmp134_;

3818

gboolean _tmp135_;

3819

gboolean _tmp136_;

3820

_tmp132_ = delegate_type;

3821

_tmp133_ = vala_delegate_type_get_delegate_symbol (_tmp132_);

3822

_tmp134_ = _tmp133_;

3823

_tmp135_ = vala_delegate_get_has_target (_tmp134_);

3824

_tmp136_ = _tmp135_;

3825

_tmp130_ = _tmp136_;

3826

} else {

3827

_tmp130_ = FALSE;

3828

}

3829

_tmp137_ = _tmp130_;

3830

if (_tmp137_) {

3831

ValaGLibValue* _tmp138_;

3832

ValaBlock* _tmp139_;

3833

gint _tmp140_ = 0;

3834

gchar* _tmp141_ = NULL;

3835

gchar* _tmp142_;

3836

ValaCCodeExpression* _tmp143_ = NULL;

3837

ValaCCodeExpression* _tmp144_;

3838

ValaParameter* _tmp145_;

3839

gchar* _tmp146_ = NULL;

3840

gchar* _tmp147_;

3841

ValaCCodeMemberAccess* _tmp148_;

3842

ValaGLibValue* _tmp149_;

3843

ValaDataType* _tmp150_;

3844

ValaDataType* _tmp151_;

3845

gboolean _tmp152_;

3846

gboolean _tmp153_;

3847

_tmp138_ = _result_;

3848

_tmp139_ = block;

3849

_tmp140_ = vala_ccode_base_module_get_block_id ((ValaCCodeBaseModule*) self, _tmp139_);

3850

_tmp141_ = g_strdup_printf ("_data%d_", _tmp140_);

3851

_tmp142_ = _tmp141_;

3852

_tmp143_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, _tmp142_);

3853

_tmp144_ = _tmp143_;

3854

_tmp145_ = param;

3855

_tmp146_ = vala_ccode_base_module_get_ccode_delegate_target_name ((ValaVariable*) _tmp145_);

3856

_tmp147_ = _tmp146_;

3857

_tmp148_ = vala_ccode_member_access_new_pointer (_tmp144_, _tmp147_);

3858

_vala_ccode_node_unref0 (_tmp138_->delegate_target_cvalue);

3859

_tmp138_->delegate_target_cvalue = (ValaCCodeExpression*) _tmp148_;

3860

_g_free0 (_tmp147_);

3861

_vala_ccode_node_unref0 (_tmp144_);

3862

_g_free0 (_tmp142_);

3863

_tmp149_ = _result_;

3864

_tmp150_ = vala_target_value_get_value_type ((ValaTargetValue*) _tmp149_);

3865

_tmp151_ = _tmp150_;

3866

_tmp152_ = vala_data_type_get_value_owned (_tmp151_);

3867

_tmp153_ = _tmp152_;

3868

if (_tmp153_) {

3869

ValaGLibValue* _tmp154_;

3870

ValaBlock* _tmp155_;

3871

gint _tmp156_ = 0;

3872

gchar* _tmp157_ = NULL;

3873

gchar* _tmp158_;

3874

ValaCCodeExpression* _tmp159_ = NULL;

3875

ValaCCodeExpression* _tmp160_;

3876

ValaParameter* _tmp161_;

3877

const gchar* _tmp162_;

3878

const gchar* _tmp163_;

3879

gchar* _tmp164_ = NULL;

3880

gchar* _tmp165_;

3881

gchar* _tmp166_ = NULL;

3882

gchar* _tmp167_;

3883

ValaCCodeMemberAccess* _tmp168_;

3884

_tmp154_ = _result_;

3885

_tmp155_ = block;

3886

_tmp156_ = vala_ccode_base_module_get_block_id ((ValaCCodeBaseModule*) self, _tmp155_);

3887

_tmp157_ = g_strdup_printf ("_data%d_", _tmp156_);

3888

_tmp158_ = _tmp157_;

3889

_tmp159_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, _tmp158_);

3890

_tmp160_ = _tmp159_;

3891

_tmp161_ = param;

3892

_tmp162_ = vala_symbol_get_name ((ValaSymbol*) _tmp161_);

3893

_tmp163_ = _tmp162_;

3894

_tmp164_ = vala_ccode_base_module_get_variable_cname ((ValaCCodeBaseModule*) self, _tmp163_);

3895

_tmp165_ = _tmp164_;

3896

_tmp166_ = vala_ccode_base_module_get_delegate_target_destroy_notify_cname ((ValaCCodeBaseModule*) self, _tmp165_);

3897

_tmp167_ = _tmp166_;

3898

_tmp168_ = vala_ccode_member_access_new_pointer (_tmp160_, _tmp167_);

3899

_vala_ccode_node_unref0 (_tmp154_->delegate_target_destroy_notify_cvalue);

3900

_tmp154_->delegate_target_destroy_notify_cvalue = (ValaCCodeExpression*) _tmp168_;

3901

_g_free0 (_tmp167_);

3902

_g_free0 (_tmp165_);

3903

_vala_ccode_node_unref0 (_tmp160_);

3904

_g_free0 (_tmp158_);

3905

}

3906

}

3907

}

3908

_vala_code_node_unref0 (block);

3909

} else {

3910

gboolean _tmp169_ = FALSE;

3911

_tmp169_ = vala_ccode_base_module_is_in_coroutine ((ValaCCodeBaseModule*) self);

3912

if (_tmp169_) {

3913

ValaGLibValue* _tmp170_;

3914

ValaParameter* _tmp171_;

3915

const gchar* _tmp172_;

3916

const gchar* _tmp173_;

3917

ValaCCodeExpression* _tmp174_ = NULL;

3918

gboolean _tmp175_ = FALSE;

3919

ValaDelegateType* _tmp176_;

3920

gboolean _tmp182_;

3921

_tmp170_ = _result_;

3922

_tmp171_ = param;

3923

_tmp172_ = vala_symbol_get_name ((ValaSymbol*) _tmp171_);

3924

_tmp173_ = _tmp172_;

3925

_tmp174_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, _tmp173_);

3926

_vala_ccode_node_unref0 (_tmp170_->cvalue);

3927

_tmp170_->cvalue = _tmp174_;

3928

_tmp176_ = delegate_type;

3929

if (_tmp176_ != NULL) {

3930

ValaDelegateType* _tmp177_;

3931

ValaDelegate* _tmp178_;

3932

ValaDelegate* _tmp179_;

3933

gboolean _tmp180_;

3934

gboolean _tmp181_;

3935

_tmp177_ = delegate_type;

3936

_tmp178_ = vala_delegate_type_get_delegate_symbol (_tmp177_);

3937

_tmp179_ = _tmp178_;

3938

_tmp180_ = vala_delegate_get_has_target (_tmp179_);

3939

_tmp181_ = _tmp180_;

3940

_tmp175_ = _tmp181_;

3941

} else {

3942

_tmp175_ = FALSE;

3943

}

3944

_tmp182_ = _tmp175_;

3945

if (_tmp182_) {

3946

ValaGLibValue* _tmp183_;

3947

ValaCCodeIdentifier* _tmp184_;

3948

ValaCCodeIdentifier* _tmp185_;

3949

ValaParameter* _tmp186_;

3950

gchar* _tmp187_ = NULL;

3951

gchar* _tmp188_;

3952

ValaCCodeMemberAccess* _tmp189_;

3953

ValaDelegateType* _tmp190_;

3954

gboolean _tmp191_;

3955

gboolean _tmp192_;

3956

_tmp183_ = _result_;

3957

_tmp184_ = vala_ccode_identifier_new ("_data_");

3958

_tmp185_ = _tmp184_;

3959

_tmp186_ = param;

3960

_tmp187_ = vala_ccode_base_module_get_ccode_delegate_target_name ((ValaVariable*) _tmp186_);

3961

_tmp188_ = _tmp187_;

3962

_tmp189_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp185_, _tmp188_);

3963

_vala_ccode_node_unref0 (_tmp183_->delegate_target_cvalue);

3964

_tmp183_->delegate_target_cvalue = (ValaCCodeExpression*) _tmp189_;

3965

_g_free0 (_tmp188_);

3966

_vala_ccode_node_unref0 (_tmp185_);

3967

_tmp190_ = delegate_type;

3968

_tmp191_ = vala_data_type_get_value_owned ((ValaDataType*) _tmp190_);

3969

_tmp192_ = _tmp191_;

3970

if (_tmp192_) {

3971

ValaGLibValue* _tmp193_;

3972

ValaCCodeIdentifier* _tmp194_;

3973

ValaCCodeIdentifier* _tmp195_;

3974

ValaParameter* _tmp196_;

3975

const gchar* _tmp197_;

3976

const gchar* _tmp198_;

3977

gchar* _tmp199_ = NULL;

3978

gchar* _tmp200_;

3979

gchar* _tmp201_ = NULL;

3980

gchar* _tmp202_;

3981

ValaCCodeMemberAccess* _tmp203_;

3982

_tmp193_ = _result_;

3983

_tmp194_ = vala_ccode_identifier_new ("_data_");

3984

_tmp195_ = _tmp194_;

3985

_tmp196_ = param;

3986

_tmp197_ = vala_symbol_get_name ((ValaSymbol*) _tmp196_);

3987

_tmp198_ = _tmp197_;

3988

_tmp199_ = vala_ccode_base_module_get_variable_cname ((ValaCCodeBaseModule*) self, _tmp198_);

3989

_tmp200_ = _tmp199_;

3990

_tmp201_ = vala_ccode_base_module_get_delegate_target_destroy_notify_cname ((ValaCCodeBaseModule*) self, _tmp200_);

3991

_tmp202_ = _tmp201_;

3992

_tmp203_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp195_, _tmp202_);

3993

_vala_ccode_node_unref0 (_tmp193_->delegate_target_destroy_notify_cvalue);

3994

_tmp193_->delegate_target_destroy_notify_cvalue = (ValaCCodeExpression*) _tmp203_;

3995

_g_free0 (_tmp202_);

3996

_g_free0 (_tmp200_);

3997

_vala_ccode_node_unref0 (_tmp195_);

3998

}

3999

}

4000

} else {

4001

ValaGLibValue* _tmp204_;

4002

ValaDataType* _tmp205_;

4003

ValaDataType* _tmp206_;

4004

ValaTypeSymbol* _tmp207_;

4005

ValaTypeSymbol* _tmp208_;

4006

ValaStruct* _tmp209_;

4007

ValaStruct* type_as_struct;

4008

ValaParameter* _tmp210_;

4009

ValaParameterDirection _tmp211_;

4010

ValaParameterDirection _tmp212_;

4011

gboolean _tmp215_ = FALSE;

4012

ValaParameter* _tmp216_;

4013

ValaParameterDirection _tmp217_;

4014

ValaParameterDirection _tmp218_;

4015

gboolean _tmp236_;

4016

gboolean _tmp285_ = FALSE;

4017

ValaDelegateType* _tmp286_;

4018

gboolean _tmp292_;

4019

_tmp204_ = _result_;

4020

_tmp205_ = vala_target_value_get_value_type ((ValaTargetValue*) _tmp204_);

4021

_tmp206_ = _tmp205_;

4022

_tmp207_ = vala_data_type_get_data_type (_tmp206_);

4023

_tmp208_ = _tmp207_;

4024

_tmp209_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp208_, VALA_TYPE_STRUCT) ? ((ValaStruct*) _tmp208_) : NULL);

4025

type_as_struct = _tmp209_;

4026

_tmp210_ = param;

4027

_tmp211_ = vala_parameter_get_direction (_tmp210_);

4028

_tmp212_ = _tmp211_;

4029

if (_tmp212_ == VALA_PARAMETER_DIRECTION_OUT) {

4030

const gchar* _tmp213_;

4031

gchar* _tmp214_;

4032

_tmp213_ = name;

4033

_tmp214_ = g_strconcat ("_vala_", _tmp213_, NULL);

4034

_g_free0 (name);

4035

name = _tmp214_;

4036

}

4037

_tmp216_ = param;

4038

_tmp217_ = vala_parameter_get_direction (_tmp216_);

4039

_tmp218_ = _tmp217_;

4040

if (_tmp218_ == VALA_PARAMETER_DIRECTION_REF) {

4041

_tmp215_ = TRUE;

4042

} else {

4043

gboolean _tmp219_ = FALSE;

4044

gboolean _tmp220_ = FALSE;

4045

gboolean _tmp221_ = FALSE;

4046

ValaParameter* _tmp222_;

4047

ValaParameterDirection _tmp223_;

4048

ValaParameterDirection _tmp224_;

4049

gboolean _tmp226_;

4050

gboolean _tmp229_;

4051

gboolean _tmp235_;

4052

_tmp222_ = param;

4053

_tmp223_ = vala_parameter_get_direction (_tmp222_);

4054

_tmp224_ = _tmp223_;

4055

if (_tmp224_ == VALA_PARAMETER_DIRECTION_IN) {

4056

ValaStruct* _tmp225_;

4057

_tmp225_ = type_as_struct;

4058

_tmp221_ = _tmp225_ != NULL;

4059

} else {

4060

_tmp221_ = FALSE;

4061

}

4062

_tmp226_ = _tmp221_;

4063

if (_tmp226_) {

4064

ValaStruct* _tmp227_;

4065

gboolean _tmp228_ = FALSE;

4066

_tmp227_ = type_as_struct;

4067

_tmp228_ = vala_struct_is_simple_type (_tmp227_);

4068

_tmp220_ = !_tmp228_;

4069

} else {

4070

_tmp220_ = FALSE;

4071

}

4072

_tmp229_ = _tmp220_;

4073

if (_tmp229_) {

4074

ValaGLibValue* _tmp230_;

4075

ValaDataType* _tmp231_;

4076

ValaDataType* _tmp232_;

4077

gboolean _tmp233_;

4078

gboolean _tmp234_;

4079

_tmp230_ = _result_;

4080

_tmp231_ = vala_target_value_get_value_type ((ValaTargetValue*) _tmp230_);

4081

_tmp232_ = _tmp231_;

4082

_tmp233_ = vala_data_type_get_nullable (_tmp232_);

4083

_tmp234_ = _tmp233_;

4084

_tmp219_ = !_tmp234_;

4085

} else {

4086

_tmp219_ = FALSE;

4087

}

4088

_tmp235_ = _tmp219_;

4089

_tmp215_ = _tmp235_;

4090

}

4091

_tmp236_ = _tmp215_;

4092

if (_tmp236_) {

4093

ValaGLibValue* _tmp237_;

4094

const gchar* _tmp238_;

4095

gchar* _tmp239_ = NULL;

4096

gchar* _tmp240_;

4097

ValaCCodeIdentifier* _tmp241_;

4098

ValaCCodeIdentifier* _tmp242_;

4099

ValaCCodeUnaryExpression* _tmp243_;

4100

_tmp237_ = _result_;

4101

_tmp238_ = name;

4102

_tmp239_ = vala_ccode_base_module_get_variable_cname ((ValaCCodeBaseModule*) self, _tmp238_);

4103

_tmp240_ = _tmp239_;

4104

_tmp241_ = vala_ccode_identifier_new (_tmp240_);

4105

_tmp242_ = _tmp241_;

4106

_tmp243_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_POINTER_INDIRECTION, (ValaCCodeExpression*) _tmp242_);

4107

_vala_ccode_node_unref0 (_tmp237_->cvalue);

4108

_tmp237_->cvalue = (ValaCCodeExpression*) _tmp243_;

4109

_vala_ccode_node_unref0 (_tmp242_);

4110

_g_free0 (_tmp240_);

4111

} else {

4112

gboolean _tmp244_ = FALSE;

4113

gboolean _tmp245_ = FALSE;

4114

gboolean _tmp246_ = FALSE;

4115

gboolean _tmp247_ = FALSE;

4116

ValaPropertyAccessor* _tmp248_;

4117

ValaPropertyAccessor* _tmp249_;

4118

gboolean _tmp254_;

4119

gboolean _tmp260_;

4120

gboolean _tmp268_;

4121

gboolean _tmp277_;

4122

_tmp248_ = vala_ccode_base_module_get_current_property_accessor ((ValaCCodeBaseModule*) self);

4123

_tmp249_ = _tmp248_;

4124

if (_tmp249_ != NULL) {

4125

ValaPropertyAccessor* _tmp250_;

4126

ValaPropertyAccessor* _tmp251_;

4127

gboolean _tmp252_;

4128

gboolean _tmp253_;

4129

_tmp250_ = vala_ccode_base_module_get_current_property_accessor ((ValaCCodeBaseModule*) self);

4130

_tmp251_ = _tmp250_;

4131

_tmp252_ = vala_property_accessor_get_writable (_tmp251_);

4132

_tmp253_ = _tmp252_;

4133

_tmp247_ = _tmp253_;

4134

} else {

4135

_tmp247_ = FALSE;

4136

}

4137

_tmp254_ = _tmp247_;

4138

if (_tmp254_) {

4139

ValaPropertyAccessor* _tmp255_;

4140

ValaPropertyAccessor* _tmp256_;

4141

ValaParameter* _tmp257_;

4142

ValaParameter* _tmp258_;

4143

ValaParameter* _tmp259_;

4144

_tmp255_ = vala_ccode_base_module_get_current_property_accessor ((ValaCCodeBaseModule*) self);

4145

_tmp256_ = _tmp255_;

4146

_tmp257_ = vala_property_accessor_get_value_parameter (_tmp256_);

4147

_tmp258_ = _tmp257_;

4148

_tmp259_ = param;

4149

_tmp246_ = _tmp258_ == _tmp259_;

4150

} else {

4151

_tmp246_ = FALSE;

4152

}

4153

_tmp260_ = _tmp246_;

4154

if (_tmp260_) {

4155

ValaPropertyAccessor* _tmp261_;

4156

ValaPropertyAccessor* _tmp262_;

4157

ValaProperty* _tmp263_;

4158

ValaProperty* _tmp264_;

4159

ValaDataType* _tmp265_;

4160

ValaDataType* _tmp266_;

4161

gboolean _tmp267_ = FALSE;

4162

_tmp261_ = vala_ccode_base_module_get_current_property_accessor ((ValaCCodeBaseModule*) self);

4163

_tmp262_ = _tmp261_;

4164

_tmp263_ = vala_property_accessor_get_prop (_tmp262_);

4165

_tmp264_ = _tmp263_;

4166

_tmp265_ = vala_property_get_property_type (_tmp264_);

4167

_tmp266_ = _tmp265_;

4168

_tmp267_ = vala_data_type_is_real_struct_type (_tmp266_);

4169

_tmp245_ = _tmp267_;

4170

} else {

4171

_tmp245_ = FALSE;

4172

}

4173

_tmp268_ = _tmp245_;

4174

if (_tmp268_) {

4175

ValaPropertyAccessor* _tmp269_;

4176

ValaPropertyAccessor* _tmp270_;

4177

ValaProperty* _tmp271_;

4178

ValaProperty* _tmp272_;

4179

ValaDataType* _tmp273_;

4180

ValaDataType* _tmp274_;

4181

gboolean _tmp275_;

4182

gboolean _tmp276_;

4183

_tmp269_ = vala_ccode_base_module_get_current_property_accessor ((ValaCCodeBaseModule*) self);

4184

_tmp270_ = _tmp269_;

4185

_tmp271_ = vala_property_accessor_get_prop (_tmp270_);

4186

_tmp272_ = _tmp271_;

4187

_tmp273_ = vala_property_get_property_type (_tmp272_);

4188

_tmp274_ = _tmp273_;

4189

_tmp275_ = vala_data_type_get_nullable (_tmp274_);

4190

_tmp276_ = _tmp275_;

4191

_tmp244_ = !_tmp276_;

4192

} else {

4193

_tmp244_ = FALSE;

4194

}

4195

_tmp277_ = _tmp244_;

4196

if (_tmp277_) {

4197

ValaGLibValue* _tmp278_;

4198

ValaCCodeIdentifier* _tmp279_;

4199

ValaCCodeIdentifier* _tmp280_;

4200

ValaCCodeUnaryExpression* _tmp281_;

4201

_tmp278_ = _result_;

4202

_tmp279_ = vala_ccode_identifier_new ("value");

4203

_tmp280_ = _tmp279_;

4204

_tmp281_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_POINTER_INDIRECTION, (ValaCCodeExpression*) _tmp280_);

4205

_vala_ccode_node_unref0 (_tmp278_->cvalue);

4206

_tmp278_->cvalue = (ValaCCodeExpression*) _tmp281_;

4207

_vala_ccode_node_unref0 (_tmp280_);

4208

} else {

4209

ValaGLibValue* _tmp282_;

4210

const gchar* _tmp283_;

4211

ValaCCodeExpression* _tmp284_ = NULL;

4212

_tmp282_ = _result_;

4213

_tmp283_ = name;

4214

_tmp284_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, _tmp283_);

4215

_vala_ccode_node_unref0 (_tmp282_->cvalue);

4216

_tmp282_->cvalue = _tmp284_;

4217

}

4218

}

4219

_tmp286_ = delegate_type;

4220

if (_tmp286_ != NULL) {

4221

ValaDelegateType* _tmp287_;

4222

ValaDelegate* _tmp288_;

4223

ValaDelegate* _tmp289_;

4224

gboolean _tmp290_;

4225

gboolean _tmp291_;

4226

_tmp287_ = delegate_type;

4227

_tmp288_ = vala_delegate_type_get_delegate_symbol (_tmp287_);

4228

_tmp289_ = _tmp288_;

4229

_tmp290_ = vala_delegate_get_has_target (_tmp289_);

4230

_tmp291_ = _tmp290_;

4231

_tmp285_ = _tmp291_;

4232

} else {

4233

_tmp285_ = FALSE;

4234

}

4235

_tmp292_ = _tmp285_;

4236

if (_tmp292_) {

4237

ValaParameter* _tmp293_;

4238

gchar* _tmp294_ = NULL;

4239

gchar* target_cname;

4240

ValaParameter* _tmp295_;

4241

ValaParameterDirection _tmp296_;

4242

ValaParameterDirection _tmp297_;

4243

const gchar* _tmp300_;

4244

ValaCCodeIdentifier* _tmp301_;

4245

ValaCCodeExpression* target_expr;

4246

const gchar* _tmp302_;

4247

gchar* _tmp303_ = NULL;

4248

gchar* _tmp304_;

4249

gchar* _tmp305_ = NULL;

4250

gchar* _tmp306_;

4251

ValaCCodeIdentifier* _tmp307_;

4252

ValaCCodeExpression* _tmp308_;

4253

ValaCCodeExpression* delegate_target_destroy_notify;

4254

ValaParameter* _tmp309_;

4255

ValaParameterDirection _tmp310_;

4256

ValaParameterDirection _tmp311_;

4257

ValaGLibValue* _tmp316_;

4258

ValaCCodeExpression* _tmp317_;

4259

ValaCCodeExpression* _tmp318_;

4260

ValaGLibValue* _tmp319_;

4261

ValaDataType* _tmp320_;

4262

ValaDataType* _tmp321_;

4263

gboolean _tmp322_;

4264

gboolean _tmp323_;

4265

_tmp293_ = param;

4266

_tmp294_ = vala_ccode_base_module_get_ccode_delegate_target_name ((ValaVariable*) _tmp293_);

4267

target_cname = _tmp294_;

4268

_tmp295_ = param;

4269

_tmp296_ = vala_parameter_get_direction (_tmp295_);

4270

_tmp297_ = _tmp296_;

4271

if (_tmp297_ == VALA_PARAMETER_DIRECTION_OUT) {

4272

const gchar* _tmp298_;

4273

gchar* _tmp299_;

4274

_tmp298_ = target_cname;

4275

_tmp299_ = g_strconcat ("_vala_", _tmp298_, NULL);

4276

_g_free0 (target_cname);

4277

target_cname = _tmp299_;

4278

}

4279

_tmp300_ = target_cname;

4280

_tmp301_ = vala_ccode_identifier_new (_tmp300_);

4281

target_expr = (ValaCCodeExpression*) _tmp301_;

4282

_tmp302_ = name;

4283

_tmp303_ = vala_ccode_base_module_get_variable_cname ((ValaCCodeBaseModule*) self, _tmp302_);

4284

_tmp304_ = _tmp303_;

4285

_tmp305_ = vala_ccode_base_module_get_delegate_target_destroy_notify_cname ((ValaCCodeBaseModule*) self, _tmp304_);

4286

_tmp306_ = _tmp305_;

4287

_tmp307_ = vala_ccode_identifier_new (_tmp306_);

4288

_tmp308_ = (ValaCCodeExpression*) _tmp307_;

4289

_g_free0 (_tmp306_);

4290

_g_free0 (_tmp304_);

4291

delegate_target_destroy_notify = _tmp308_;

4292

_tmp309_ = param;

4293

_tmp310_ = vala_parameter_get_direction (_tmp309_);

4294

_tmp311_ = _tmp310_;

4295

if (_tmp311_ == VALA_PARAMETER_DIRECTION_REF) {

4296

ValaCCodeExpression* _tmp312_;

4297

ValaCCodeUnaryExpression* _tmp313_;

4298

ValaCCodeExpression* _tmp314_;

4299

ValaCCodeUnaryExpression* _tmp315_;

4300

_tmp312_ = target_expr;

4301

_tmp313_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_POINTER_INDIRECTION, _tmp312_);

4302

_vala_ccode_node_unref0 (target_expr);

4303

target_expr = (ValaCCodeExpression*) _tmp313_;

4304

_tmp314_ = delegate_target_destroy_notify;

4305

_tmp315_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_POINTER_INDIRECTION, _tmp314_);

4306

_vala_ccode_node_unref0 (delegate_target_destroy_notify);

4307

delegate_target_destroy_notify = (ValaCCodeExpression*) _tmp315_;

4308

}

4309

_tmp316_ = _result_;

4310

_tmp317_ = target_expr;

4311

_tmp318_ = _vala_ccode_node_ref0 (_tmp317_);

4312

_vala_ccode_node_unref0 (_tmp316_->delegate_target_cvalue);

4313

_tmp316_->delegate_target_cvalue = _tmp318_;

4314

_tmp319_ = _result_;

4315

_tmp320_ = vala_target_value_get_value_type ((ValaTargetValue*) _tmp319_);

4316

_tmp321_ = _tmp320_;

4317

_tmp322_ = vala_data_type_get_value_owned (_tmp321_);

4318

_tmp323_ = _tmp322_;

4319

if (_tmp323_) {

4320

ValaGLibValue* _tmp324_;

4321

ValaCCodeExpression* _tmp325_;

4322

ValaCCodeExpression* _tmp326_;

4323

_tmp324_ = _result_;

4324

_tmp325_ = delegate_target_destroy_notify;

4325

_tmp326_ = _vala_ccode_node_ref0 (_tmp325_);

4326

_vala_ccode_node_unref0 (_tmp324_->delegate_target_destroy_notify_cvalue);

4327

_tmp324_->delegate_target_destroy_notify_cvalue = _tmp326_;

4328

}

4329

_vala_ccode_node_unref0 (delegate_target_destroy_notify);

4330

_vala_ccode_node_unref0 (target_expr);

4331

_g_free0 (target_cname);

4332

}

4333

_vala_code_node_unref0 (type_as_struct);

4334

}

4335

}

4336

_tmp328_ = param;

4337

_tmp329_ = vala_parameter_get_captured (_tmp328_);

4338

_tmp330_ = _tmp329_;

4339

if (!_tmp330_) {

4340

ValaArrayType* _tmp331_;

4341

_tmp331_ = array_type;

4342

_tmp327_ = _tmp331_ != NULL;

4343

} else {

4344

_tmp327_ = FALSE;

4345

}

4346

_tmp332_ = _tmp327_;

4347

if (_tmp332_) {

4348

gboolean _tmp333_ = FALSE;

4349

ValaParameter* _tmp334_;

4350

gboolean _tmp335_ = FALSE;

4351

gboolean _tmp338_;

4352

_tmp334_ = param;

4353

_tmp335_ = vala_ccode_base_module_get_ccode_array_length ((ValaCodeNode*) _tmp334_);

4354

if (_tmp335_) {

4355

ValaParameter* _tmp336_;

4356

gboolean _tmp337_ = FALSE;

4357

_tmp336_ = param;

4358

_tmp337_ = vala_ccode_base_module_get_ccode_array_null_terminated ((ValaCodeNode*) _tmp336_);

4359

_tmp333_ = !_tmp337_;

4360

} else {

4361

_tmp333_ = FALSE;

4362

}

4363

_tmp338_ = _tmp333_;

4364

if (_tmp338_) {

4365

{

4366

gint dim;

4367

dim = 1;

4368

{

4369

gboolean _tmp339_;

4370

_tmp339_ = TRUE;

4371

while (TRUE) {

4372

gboolean _tmp340_;

4373

gint _tmp342_;

4374

ValaArrayType* _tmp343_;

4375

gint _tmp344_;

4376

gint _tmp345_;

4377

ValaParameter* _tmp346_;

4378

gint _tmp347_;

4379

gchar* _tmp348_ = NULL;

4380

gchar* _tmp349_;

4381

ValaCCodeExpression* _tmp350_ = NULL;

4382

ValaCCodeExpression* _tmp351_;

4383

ValaCCodeExpression* length_expr;

4384

ValaParameter* _tmp352_;

4385

ValaParameterDirection _tmp353_;

4386

ValaParameterDirection _tmp354_;

4387

ValaGLibValue* _tmp367_;

4388

ValaCCodeExpression* _tmp368_;

4389

_tmp340_ = _tmp339_;

4390

if (!_tmp340_) {

4391

gint _tmp341_;

4392

_tmp341_ = dim;

4393

dim = _tmp341_ + 1;

4394

}

4395

_tmp339_ = FALSE;

4396

_tmp342_ = dim;

4397

_tmp343_ = array_type;

4398

_tmp344_ = vala_array_type_get_rank (_tmp343_);

4399

_tmp345_ = _tmp344_;

4400

if (!(_tmp342_ <= _tmp345_)) {

4401

break;

4402

}

4403

_tmp346_ = param;

4404

_tmp347_ = dim;

4405

_tmp348_ = vala_ccode_base_module_get_parameter_array_length_cname ((ValaCCodeBaseModule*) self, _tmp346_, _tmp347_);

4406

_tmp349_ = _tmp348_;

4407

_tmp350_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, _tmp349_);

4408

_tmp351_ = _tmp350_;

4409

_g_free0 (_tmp349_);

4410

length_expr = _tmp351_;

4411

_tmp352_ = param;

4412

_tmp353_ = vala_parameter_get_direction (_tmp352_);

4413

_tmp354_ = _tmp353_;

4414

if (_tmp354_ == VALA_PARAMETER_DIRECTION_OUT) {

4415

const gchar* _tmp355_;

4416

gchar* _tmp356_ = NULL;

4417

gchar* _tmp357_;

4418

gint _tmp358_;

4419

gchar* _tmp359_ = NULL;

4420

gchar* _tmp360_;

4421

ValaCCodeExpression* _tmp361_ = NULL;

4422

_tmp355_ = name;

4423

_tmp356_ = vala_ccode_base_module_get_variable_cname ((ValaCCodeBaseModule*) self, _tmp355_);

4424

_tmp357_ = _tmp356_;

4425

_tmp358_ = dim;

4426

_tmp359_ = vala_ccode_base_module_get_array_length_cname ((ValaCCodeBaseModule*) self, _tmp357_, _tmp358_);

4427

_tmp360_ = _tmp359_;

4428

_tmp361_ = vala_ccode_base_module_get_variable_cexpression ((ValaCCodeBaseModule*) self, _tmp360_);

4429

_vala_ccode_node_unref0 (length_expr);

4430

length_expr = _tmp361_;

4431

_g_free0 (_tmp360_);

4432

_g_free0 (_tmp357_);

4433

} else {

4434

ValaParameter* _tmp362_;

4435

ValaParameterDirection _tmp363_;

4436

ValaParameterDirection _tmp364_;

4437

_tmp362_ = param;

4438

_tmp363_ = vala_parameter_get_direction (_tmp362_);

4439

_tmp364_ = _tmp363_;

4440

if (_tmp364_ == VALA_PARAMETER_DIRECTION_REF) {

4441

ValaCCodeExpression* _tmp365_;

4442

ValaCCodeUnaryExpression* _tmp366_;

4443

_tmp365_ = length_expr;

4444

_tmp366_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_POINTER_INDIRECTION, _tmp365_);

4445

_vala_ccode_node_unref0 (length_expr);

4446

length_expr = (ValaCCodeExpression*) _tmp366_;

4447

}

4448

}

4449

_tmp367_ = _result_;

4450

_tmp368_ = length_expr;

4451

vala_glib_value_append_array_length_cvalue (_tmp367_, _tmp368_);

4452

_vala_ccode_node_unref0 (length_expr);

4453

}

4454

}

4455

}

4456

}

4457

}

4458

_g_free0 (name);

4459

}

4460

result = (ValaTargetValue*) _result_;

4461

_vala_code_node_unref0 (delegate_type);

4462

_vala_code_node_unref0 (array_type);

4463

return result;

4464

}

4465

4466

4467

static ValaTargetValue* vala_ccode_member_access_module_real_get_field_cvalue (ValaCCodeBaseModule* base, ValaField* field, ValaTargetValue* instance) {

4468

ValaCCodeMemberAccessModule * self;

4469

ValaTargetValue* result = NULL;

4470

ValaField* _tmp0_;

4471

ValaDataType* _tmp1_;

4472

ValaDataType* _tmp2_;

4473

ValaDataType* _tmp3_ = NULL;

4474

ValaDataType* value_type;

4475

ValaDataType* _tmp4_;

4476

ValaGLibValue* _tmp5_;

4477

ValaGLibValue* _result_;

4478

ValaTargetValue* _tmp6_;

4479

ValaGLibValue* _tmp17_;

4480

ValaGLibValue* _tmp18_;

4481

ValaField* _tmp19_;

4482

gboolean _tmp20_ = FALSE;

4483

ValaField* _tmp21_;

4484

gchar* _tmp22_ = NULL;

4485

gchar* _tmp23_;

4486

gboolean _tmp24_;

4487

ValaGLibValue* _tmp30_;

4488

ValaField* _tmp31_;

4489

gchar* _tmp32_ = NULL;

4490

ValaGLibValue* _tmp33_;

4491

ValaDataType* _tmp34_;

4492

ValaDataType* _tmp35_;

4493

ValaArrayType* _tmp36_;

4494

ValaArrayType* array_type;

4495

ValaGLibValue* _tmp37_;

4496

ValaDataType* _tmp38_;

4497

ValaDataType* _tmp39_;

4498

ValaDelegateType* _tmp40_;

4499

ValaDelegateType* delegate_type;

4500

ValaField* _tmp41_;

4501

ValaMemberBinding _tmp42_;

4502

ValaMemberBinding _tmp43_;

4503

self = (ValaCCodeMemberAccessModule*) base;

4504

g_return_val_if_fail (field != NULL, NULL);

4505

_tmp0_ = field;

4506

_tmp1_ = vala_variable_get_variable_type ((ValaVariable*) _tmp0_);

4507

_tmp2_ = _tmp1_;

4508

_tmp3_ = vala_data_type_copy (_tmp2_);

4509

value_type = _tmp3_;

4510

_tmp4_ = value_type;

4511

_tmp5_ = vala_glib_value_new (_tmp4_, NULL, FALSE);

4512

_result_ = _tmp5_;

4513

_tmp6_ = instance;

4514

if (_tmp6_ != NULL) {

4515

ValaGLibValue* _tmp7_;

4516

ValaField* _tmp8_;

4517

ValaDataType* _tmp9_;

4518

ValaDataType* _tmp10_;

4519

ValaTargetValue* _tmp11_;

4520

ValaDataType* _tmp12_;

4521

ValaDataType* _tmp13_;

4522

ValaField* _tmp14_;

4523

ValaDataType* _tmp15_ = NULL;

4524

ValaDataType* _tmp16_;

4525

_tmp7_ = _result_;

4526

_tmp8_ = field;

4527

_tmp9_ = vala_variable_get_variable_type ((ValaVariable*) _tmp8_);

4528

_tmp10_ = _tmp9_;

4529

_tmp11_ = instance;

4530

_tmp12_ = vala_target_value_get_value_type (_tmp11_);

4531

_tmp13_ = _tmp12_;

4532

_tmp14_ = field;

4533

_tmp15_ = vala_data_type_get_actual_type (_tmp10_, _tmp13_, NULL, (ValaCodeNode*) _tmp14_);

4534

_tmp16_ = _tmp15_;

4535

vala_target_value_set_actual_value_type ((ValaTargetValue*) _tmp7_, _tmp16_);

4536

_vala_code_node_unref0 (_tmp16_);

4537

}

4538

_tmp17_ = _result_;

4539

_tmp17_->lvalue = TRUE;

4540

_tmp18_ = _result_;

4541

_tmp19_ = field;

4542

_tmp20_ = vala_ccode_base_module_get_ccode_array_null_terminated ((ValaCodeNode*) _tmp19_);

4543

_tmp18_->array_null_terminated = _tmp20_;

4544

_tmp21_ = field;

4545

_tmp22_ = vala_ccode_base_module_get_ccode_array_length_expr ((ValaCodeNode*) _tmp21_);

4546

_tmp23_ = _tmp22_;

4547

_tmp24_ = _tmp23_ != NULL;

4548

_g_free0 (_tmp23_);

4549

if (_tmp24_) {

4550

ValaGLibValue* _tmp25_;

4551

ValaField* _tmp26_;

4552

gchar* _tmp27_ = NULL;

4553

gchar* _tmp28_;

4554

ValaCCodeConstant* _tmp29_;

4555

_tmp25_ = _result_;

4556

_tmp26_ = field;

4557

_tmp27_ = vala_ccode_base_module_get_ccode_array_length_expr ((ValaCodeNode*) _tmp26_);

4558

_tmp28_ = _tmp27_;

4559

_tmp29_ = vala_ccode_constant_new (_tmp28_);

4560

_vala_ccode_node_unref0 (_tmp25_->array_length_cexpr);

4561

_tmp25_->array_length_cexpr = (ValaCCodeExpression*) _tmp29_;

4562

_g_free0 (_tmp28_);

4563

}

4564

_tmp30_ = _result_;

4565

_tmp31_ = field;

4566

_tmp32_ = vala_ccode_base_module_get_ccode_type ((ValaCodeNode*) _tmp31_);

4567

_g_free0 (_tmp30_->ctype);

4568

_tmp30_->ctype = _tmp32_;

4569

_tmp33_ = _result_;

4570

_tmp34_ = vala_target_value_get_value_type ((ValaTargetValue*) _tmp33_);

4571

_tmp35_ = _tmp34_;

4572

_tmp36_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp35_, VALA_TYPE_ARRAY_TYPE) ? ((ValaArrayType*) _tmp35_) : NULL);

4573

array_type = _tmp36_;

4574

_tmp37_ = _result_;

4575

_tmp38_ = vala_target_value_get_value_type ((ValaTargetValue*) _tmp37_);

4576

_tmp39_ = _tmp38_;

4577

_tmp40_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp39_, VALA_TYPE_DELEGATE_TYPE) ? ((ValaDelegateType*) _tmp39_) : NULL);

4578

delegate_type = _tmp40_;

4579

_tmp41_ = field;

4580

_tmp42_ = vala_field_get_binding (_tmp41_);

4581

_tmp43_ = _tmp42_;

4582

if (_tmp43_ == VALA_MEMBER_BINDING_INSTANCE) {

4583

ValaCCodeExpression* pub_inst;

4584

ValaTargetValue* _tmp44_;

4585

ValaField* _tmp47_;

4586

ValaSymbol* _tmp48_;

4587

ValaSymbol* _tmp49_;

4588

ValaDataType* _tmp50_ = NULL;

4589

ValaDataType* instance_target_type;

4590

ValaDataType* _tmp51_;

4591

ValaTypeSymbol* _tmp52_;

4592

ValaTypeSymbol* _tmp53_;

4593

ValaClass* _tmp54_;

4594

ValaClass* cl;

4595

gboolean _tmp55_ = FALSE;

4596

ValaDataType* _tmp56_;

4597

ValaTypeSymbol* _tmp57_;

4598

ValaTypeSymbol* _tmp58_;

4599

ValaClass* _tmp59_;

4600

gboolean _tmp66_;

4601

gboolean is_gtypeinstance;

4602

ValaCCodeExpression* inst = NULL;

4603

gboolean _tmp67_ = FALSE;

4604

gboolean _tmp68_;

4605

gboolean _tmp72_;

4606

gboolean _tmp80_ = FALSE;

4607

ValaDataType* _tmp81_;

4608

ValaTypeSymbol* _tmp82_;

4609

ValaTypeSymbol* _tmp83_;

4610

gboolean _tmp84_ = FALSE;

4611

gboolean _tmp91_;

4612

gboolean _tmp104_ = FALSE;

4613

ValaArrayType* _tmp105_;

4614

gboolean _tmp108_;

4615

pub_inst = NULL;

4616

_tmp44_ = instance;

4617

if (_tmp44_ != NULL) {

4618

ValaTargetValue* _tmp45_;

4619

ValaCCodeExpression* _tmp46_ = NULL;

4620

_tmp45_ = instance;

4621

_tmp46_ = vala_ccode_base_module_get_cvalue_ ((ValaCCodeBaseModule*) self, _tmp45_);

4622

_vala_ccode_node_unref0 (pub_inst);

4623

pub_inst = _tmp46_;

4624

}

4625

_tmp47_ = field;

4626

_tmp48_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp47_);

4627

_tmp49_ = _tmp48_;

4628

_tmp50_ = vala_ccode_base_module_get_data_type_for_symbol (G_TYPE_CHECK_INSTANCE_CAST (_tmp49_, VALA_TYPE_TYPESYMBOL, ValaTypeSymbol));

4629

instance_target_type = _tmp50_;

4630

_tmp51_ = instance_target_type;

4631

_tmp52_ = vala_data_type_get_data_type (_tmp51_);

4632

_tmp53_ = _tmp52_;

4633

_tmp54_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp53_, VALA_TYPE_CLASS) ? ((ValaClass*) _tmp53_) : NULL);

4634

cl = _tmp54_;

4635

_tmp56_ = instance_target_type;

4636

_tmp57_ = vala_data_type_get_data_type (_tmp56_);

4637

_tmp58_ = _tmp57_;

4638

_tmp59_ = cl;

4639

if (_tmp58_ == G_TYPE_CHECK_INSTANCE_CAST (_tmp59_, VALA_TYPE_TYPESYMBOL, ValaTypeSymbol)) {

4640

gboolean _tmp60_ = FALSE;

4641

ValaClass* _tmp61_;

4642

gboolean _tmp65_;

4643

_tmp61_ = cl;

4644

if (_tmp61_ == NULL) {

4645

_tmp60_ = TRUE;

4646

} else {

4647

ValaClass* _tmp62_;

4648

gboolean _tmp63_;

4649

gboolean _tmp64_;

4650

_tmp62_ = cl;

4651

_tmp63_ = vala_class_get_is_compact (_tmp62_);

4652

_tmp64_ = _tmp63_;

4653

_tmp60_ = !_tmp64_;

4654

}

4655

_tmp65_ = _tmp60_;

4656

_tmp55_ = _tmp65_;

4657

} else {

4658

_tmp55_ = FALSE;

4659

}

4660

_tmp66_ = _tmp55_;

4661

is_gtypeinstance = _tmp66_;

4662

_tmp68_ = is_gtypeinstance;

4663

if (_tmp68_) {

4664

ValaField* _tmp69_;

4665

ValaSymbolAccessibility _tmp70_;

4666

ValaSymbolAccessibility _tmp71_;

4667

_tmp69_ = field;

4668

_tmp70_ = vala_symbol_get_access ((ValaSymbol*) _tmp69_);

4669

_tmp71_ = _tmp70_;

4670

_tmp67_ = _tmp71_ == VALA_SYMBOL_ACCESSIBILITY_PRIVATE;

4671

} else {

4672

_tmp67_ = FALSE;

4673

}

4674

_tmp72_ = _tmp67_;

4675

if (_tmp72_) {

4676

ValaCCodeExpression* _tmp73_;

4677

ValaCCodeMemberAccess* _tmp74_;

4678

_tmp73_ = pub_inst;

4679

_tmp74_ = vala_ccode_member_access_new_pointer (_tmp73_, "priv");

4680

_vala_ccode_node_unref0 (inst);

4681

inst = (ValaCCodeExpression*) _tmp74_;

4682

} else {

4683

ValaClass* _tmp75_;

4684

ValaCCodeExpression* _tmp78_;

4685

ValaCCodeExpression* _tmp79_;

4686

_tmp75_ = cl;

4687

if (_tmp75_ != NULL) {

4688

ValaClass* _tmp76_;

4689

ValaCCodeFile* _tmp77_;

4690

_tmp76_ = cl;

4691

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

4692

vala_ccode_base_module_generate_class_struct_declaration ((ValaCCodeBaseModule*) self, _tmp76_, _tmp77_);

4693

}

4694

_tmp78_ = pub_inst;

4695

_tmp79_ = _vala_ccode_node_ref0 (_tmp78_);

4696

_vala_ccode_node_unref0 (inst);

4697

inst = _tmp79_;

4698

}

4699

_tmp81_ = instance_target_type;

4700

_tmp82_ = vala_data_type_get_data_type (_tmp81_);

4701

_tmp83_ = _tmp82_;

4702

_tmp84_ = vala_typesymbol_is_reference_type (_tmp83_);

4703

if (_tmp84_) {

4704

_tmp80_ = TRUE;

4705

} else {

4706

gboolean _tmp85_ = FALSE;

4707

ValaTargetValue* _tmp86_;

4708

gboolean _tmp90_;

4709

_tmp86_ = instance;

4710

if (_tmp86_ != NULL) {

4711

ValaTargetValue* _tmp87_;

4712

ValaDataType* _tmp88_;

4713

ValaDataType* _tmp89_;

4714

_tmp87_ = instance;

4715

_tmp88_ = vala_target_value_get_value_type (_tmp87_);

4716

_tmp89_ = _tmp88_;

4717

_tmp85_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp89_, VALA_TYPE_POINTER_TYPE);

4718

} else {

4719

_tmp85_ = FALSE;

4720

}

4721

_tmp90_ = _tmp85_;

4722

_tmp80_ = _tmp90_;

4723

}

4724

_tmp91_ = _tmp80_;

4725

if (_tmp91_) {

4726

ValaGLibValue* _tmp92_;

4727

ValaCCodeExpression* _tmp93_;

4728

ValaField* _tmp94_;

4729

gchar* _tmp95_ = NULL;

4730

gchar* _tmp96_;

4731

ValaCCodeMemberAccess* _tmp97_;

4732

_tmp92_ = _result_;

4733

_tmp93_ = inst;

4734

_tmp94_ = field;

4735

_tmp95_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp94_);

4736

_tmp96_ = _tmp95_;

4737

_tmp97_ = vala_ccode_member_access_new_pointer (_tmp93_, _tmp96_);

4738

_vala_ccode_node_unref0 (_tmp92_->cvalue);

4739

_tmp92_->cvalue = (ValaCCodeExpression*) _tmp97_;

4740

_g_free0 (_tmp96_);

4741

} else {

4742

ValaGLibValue* _tmp98_;

4743

ValaCCodeExpression* _tmp99_;

4744

ValaField* _tmp100_;

4745

gchar* _tmp101_ = NULL;

4746

gchar* _tmp102_;

4747

ValaCCodeMemberAccess* _tmp103_;

4748

_tmp98_ = _result_;

4749

_tmp99_ = inst;

4750

_tmp100_ = field;

4751

_tmp101_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp100_);

4752

_tmp102_ = _tmp101_;

4753

_tmp103_ = vala_ccode_member_access_new (_tmp99_, _tmp102_, FALSE);

4754

_vala_ccode_node_unref0 (_tmp98_->cvalue);

4755

_tmp98_->cvalue = (ValaCCodeExpression*) _tmp103_;

4756

_g_free0 (_tmp102_);

4757

}

4758

_tmp105_ = array_type;

4759

if (_tmp105_ != NULL) {

4760

ValaField* _tmp106_;

4761

gboolean _tmp107_ = FALSE;

4762

_tmp106_ = field;

4763

_tmp107_ = vala_ccode_base_module_get_ccode_array_length ((ValaCodeNode*) _tmp106_);

4764

_tmp104_ = _tmp107_;

4765

} else {

4766

_tmp104_ = FALSE;

4767

}

4768

_tmp108_ = _tmp104_;

4769

if (_tmp108_) {

4770

gboolean _tmp139_ = FALSE;

4771

ValaArrayType* _tmp140_;

4772

gint _tmp141_;

4773

gint _tmp142_;

4774

gboolean _tmp145_;

4775

{

4776

gint dim;

4777

dim = 1;

4778

{

4779

gboolean _tmp109_;

4780

_tmp109_ = TRUE;

4781

while (TRUE) {

4782

gboolean _tmp110_;

4783

gint _tmp112_;

4784

ValaArrayType* _tmp113_;

4785

gint _tmp114_;

4786

gint _tmp115_;

4787

ValaCCodeExpression* length_expr;

4788

gchar* length_cname = NULL;

4789

ValaField* _tmp116_;

4790

gchar* _tmp117_ = NULL;

4791

gchar* _tmp118_;

4792

gboolean _tmp119_;

4793

ValaField* _tmp127_;

4794

ValaSymbol* _tmp128_;

4795

ValaSymbol* _tmp129_;

4796

gboolean _tmp130_ = FALSE;

4797

ValaGLibValue* _tmp137_;

4798

ValaCCodeExpression* _tmp138_;

4799

_tmp110_ = _tmp109_;

4800

if (!_tmp110_) {

4801

gint _tmp111_;

4802

_tmp111_ = dim;

4803

dim = _tmp111_ + 1;

4804

}

4805

_tmp109_ = FALSE;

4806

_tmp112_ = dim;

4807

_tmp113_ = array_type;

4808

_tmp114_ = vala_array_type_get_rank (_tmp113_);

4809

_tmp115_ = _tmp114_;

4810

if (!(_tmp112_ <= _tmp115_)) {

4811

break;

4812

}

4813

length_expr = NULL;

4814

_tmp116_ = field;

4815

_tmp117_ = vala_ccode_base_module_get_ccode_array_length_name ((ValaCodeNode*) _tmp116_);

4816

_tmp118_ = _tmp117_;

4817

_tmp119_ = _tmp118_ != NULL;

4818

_g_free0 (_tmp118_);

4819

if (_tmp119_) {

4820

ValaField* _tmp120_;

4821

gchar* _tmp121_ = NULL;

4822

_tmp120_ = field;

4823

_tmp121_ = vala_ccode_base_module_get_ccode_array_length_name ((ValaCodeNode*) _tmp120_);

4824

_g_free0 (length_cname);

4825

length_cname = _tmp121_;

4826

} else {

4827

ValaField* _tmp122_;

4828

const gchar* _tmp123_;

4829

const gchar* _tmp124_;

4830

gint _tmp125_;

4831

gchar* _tmp126_ = NULL;

4832

_tmp122_ = field;

4833

_tmp123_ = vala_symbol_get_name ((ValaSymbol*) _tmp122_);

4834

_tmp124_ = _tmp123_;

4835

_tmp125_ = dim;

4836

_tmp126_ = vala_ccode_base_module_get_array_length_cname ((ValaCCodeBaseModule*) self, _tmp124_, _tmp125_);

4837

_g_free0 (length_cname);

4838

length_cname = _tmp126_;

4839

}

4840

_tmp127_ = field;

4841

_tmp128_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp127_);

4842

_tmp129_ = _tmp128_;

4843

_tmp130_ = vala_typesymbol_is_reference_type (G_TYPE_CHECK_INSTANCE_CAST (_tmp129_, VALA_TYPE_TYPESYMBOL, ValaTypeSymbol));

4844

if (_tmp130_) {

4845

ValaCCodeExpression* _tmp131_;

4846

const gchar* _tmp132_;

4847

ValaCCodeMemberAccess* _tmp133_;

4848

_tmp131_ = inst;

4849

_tmp132_ = length_cname;

4850

_tmp133_ = vala_ccode_member_access_new_pointer (_tmp131_, _tmp132_);

4851

_vala_ccode_node_unref0 (length_expr);

4852

length_expr = (ValaCCodeExpression*) _tmp133_;

4853

} else {

4854

ValaCCodeExpression* _tmp134_;

4855

const gchar* _tmp135_;

4856

ValaCCodeMemberAccess* _tmp136_;

4857

_tmp134_ = inst;

4858

_tmp135_ = length_cname;

4859

_tmp136_ = vala_ccode_member_access_new (_tmp134_, _tmp135_, FALSE);

4860

_vala_ccode_node_unref0 (length_expr);

4861

length_expr = (ValaCCodeExpression*) _tmp136_;

4862

}

4863

_tmp137_ = _result_;

4864

_tmp138_ = length_expr;

4865

vala_glib_value_append_array_length_cvalue (_tmp137_, _tmp138_);

4866

_g_free0 (length_cname);

4867

_vala_ccode_node_unref0 (length_expr);

4868

}

4869

}

4870

}

4871

_tmp140_ = array_type;

4872

_tmp141_ = vala_array_type_get_rank (_tmp140_);

4873

_tmp142_ = _tmp141_;

4874

if (_tmp142_ == 1) {

4875

ValaField* _tmp143_;

4876

gboolean _tmp144_ = FALSE;

4877

_tmp143_ = field;

4878

_tmp144_ = vala_symbol_is_internal_symbol ((ValaSymbol*) _tmp143_);

4879

_tmp139_ = _tmp144_;

4880

} else {

4881

_tmp139_ = FALSE;

4882

}

4883

_tmp145_ = _tmp139_;

4884

if (_tmp145_) {

4885

ValaField* _tmp146_;

4886

const gchar* _tmp147_;

4887

const gchar* _tmp148_;

4888

gchar* _tmp149_ = NULL;

4889

gchar* size_cname;

4890

ValaField* _tmp150_;

4891

ValaSymbol* _tmp151_;

4892

ValaSymbol* _tmp152_;

4893

gboolean _tmp153_ = FALSE;

4894

_tmp146_ = field;

4895

_tmp147_ = vala_symbol_get_name ((ValaSymbol*) _tmp146_);

4896

_tmp148_ = _tmp147_;

4897

_tmp149_ = vala_ccode_base_module_get_array_size_cname ((ValaCCodeBaseModule*) self, _tmp148_);

4898

size_cname = _tmp149_;

4899

_tmp150_ = field;

4900

_tmp151_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp150_);

4901

_tmp152_ = _tmp151_;

4902

_tmp153_ = vala_typesymbol_is_reference_type (G_TYPE_CHECK_INSTANCE_CAST (_tmp152_, VALA_TYPE_TYPESYMBOL, ValaTypeSymbol));

4903

if (_tmp153_) {

4904

ValaGLibValue* _tmp154_;

4905

ValaCCodeExpression* _tmp155_;

4906

const gchar* _tmp156_;

4907

ValaCCodeMemberAccess* _tmp157_;

4908

ValaCCodeMemberAccess* _tmp158_;

4909

_tmp154_ = _result_;

4910

_tmp155_ = inst;

4911

_tmp156_ = size_cname;

4912

_tmp157_ = vala_ccode_member_access_new_pointer (_tmp155_, _tmp156_);

4913

_tmp158_ = _tmp157_;

4914

vala_ccode_base_module_set_array_size_cvalue ((ValaCCodeBaseModule*) self, (ValaTargetValue*) _tmp154_, (ValaCCodeExpression*) _tmp158_);

4915

_vala_ccode_node_unref0 (_tmp158_);

4916

} else {

4917

ValaGLibValue* _tmp159_;

4918

ValaCCodeExpression* _tmp160_;

4919

const gchar* _tmp161_;

4920

ValaCCodeMemberAccess* _tmp162_;

4921

ValaCCodeMemberAccess* _tmp163_;

4922

_tmp159_ = _result_;

4923

_tmp160_ = inst;

4924

_tmp161_ = size_cname;

4925

_tmp162_ = vala_ccode_member_access_new (_tmp160_, _tmp161_, FALSE);

4926

_tmp163_ = _tmp162_;

4927

vala_ccode_base_module_set_array_size_cvalue ((ValaCCodeBaseModule*) self, (ValaTargetValue*) _tmp159_, (ValaCCodeExpression*) _tmp163_);

4928

_vala_ccode_node_unref0 (_tmp163_);

4929

}

4930

_g_free0 (size_cname);

4931

}

4932

} else {

4933

gboolean _tmp164_ = FALSE;

4934

gboolean _tmp165_ = FALSE;

4935

ValaDelegateType* _tmp166_;

4936

gboolean _tmp172_;

4937

gboolean _tmp175_;

4938

_tmp166_ = delegate_type;

4939

if (_tmp166_ != NULL) {

4940

ValaDelegateType* _tmp167_;

4941

ValaDelegate* _tmp168_;

4942

ValaDelegate* _tmp169_;

4943

gboolean _tmp170_;

4944

gboolean _tmp171_;

4945

_tmp167_ = delegate_type;

4946

_tmp168_ = vala_delegate_type_get_delegate_symbol (_tmp167_);

4947

_tmp169_ = _tmp168_;

4948

_tmp170_ = vala_delegate_get_has_target (_tmp169_);

4949

_tmp171_ = _tmp170_;

4950

_tmp165_ = _tmp171_;

4951

} else {

4952

_tmp165_ = FALSE;

4953

}

4954

_tmp172_ = _tmp165_;

4955

if (_tmp172_) {

4956

ValaField* _tmp173_;

4957

gboolean _tmp174_ = FALSE;

4958

_tmp173_ = field;

4959

_tmp174_ = vala_ccode_base_module_get_ccode_delegate_target ((ValaCodeNode*) _tmp173_);

4960

_tmp164_ = _tmp174_;

4961

} else {

4962

_tmp164_ = FALSE;

4963

}

4964

_tmp175_ = _tmp164_;

4965

if (_tmp175_) {

4966

ValaField* _tmp176_;

4967

gchar* _tmp177_ = NULL;

4968

gchar* target_cname;

4969

ValaField* _tmp178_;

4970

gchar* _tmp179_ = NULL;

4971

gchar* _tmp180_;

4972

gchar* _tmp181_ = NULL;

4973

gchar* _tmp182_;

4974

gchar* target_destroy_notify_cname;

4975

ValaField* _tmp183_;

4976

ValaSymbol* _tmp184_;

4977

ValaSymbol* _tmp185_;

4978

gboolean _tmp186_ = FALSE;

4979

_tmp176_ = field;

4980

_tmp177_ = vala_ccode_base_module_get_ccode_delegate_target_name ((ValaVariable*) _tmp176_);

4981

target_cname = _tmp177_;

4982

_tmp178_ = field;

4983

_tmp179_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp178_);

4984

_tmp180_ = _tmp179_;

4985

_tmp181_ = vala_ccode_base_module_get_delegate_target_destroy_notify_cname ((ValaCCodeBaseModule*) self, _tmp180_);

4986

_tmp182_ = _tmp181_;

4987

_g_free0 (_tmp180_);

4988

target_destroy_notify_cname = _tmp182_;

4989

_tmp183_ = field;

4990

_tmp184_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp183_);

4991

_tmp185_ = _tmp184_;

4992

_tmp186_ = vala_typesymbol_is_reference_type (G_TYPE_CHECK_INSTANCE_CAST (_tmp185_, VALA_TYPE_TYPESYMBOL, ValaTypeSymbol));

4993

if (_tmp186_) {

4994

ValaGLibValue* _tmp187_;

4995

ValaCCodeExpression* _tmp188_;

4996

const gchar* _tmp189_;

4997

ValaCCodeMemberAccess* _tmp190_;

4998

ValaGLibValue* _tmp191_;

4999

ValaDataType* _tmp192_;

5000

ValaDataType* _tmp193_;

5001

gboolean _tmp194_;

5002

gboolean _tmp195_;

5003

_tmp187_ = _result_;

5004

_tmp188_ = inst;

5005

_tmp189_ = target_cname;

5006

_tmp190_ = vala_ccode_member_access_new_pointer (_tmp188_, _tmp189_);

5007

_vala_ccode_node_unref0 (_tmp187_->delegate_target_cvalue);

5008

_tmp187_->delegate_target_cvalue = (ValaCCodeExpression*) _tmp190_;

5009

_tmp191_ = _result_;

5010

_tmp192_ = vala_target_value_get_value_type ((ValaTargetValue*) _tmp191_);

5011

_tmp193_ = _tmp192_;

5012

_tmp194_ = vala_data_type_get_value_owned (_tmp193_);

5013

_tmp195_ = _tmp194_;

5014

if (_tmp195_) {

5015

ValaGLibValue* _tmp196_;

5016

ValaCCodeExpression* _tmp197_;

5017

const gchar* _tmp198_;

5018

ValaCCodeMemberAccess* _tmp199_;

5019

_tmp196_ = _result_;

5020

_tmp197_ = inst;

5021

_tmp198_ = target_destroy_notify_cname;

5022

_tmp199_ = vala_ccode_member_access_new_pointer (_tmp197_, _tmp198_);

5023

_vala_ccode_node_unref0 (_tmp196_->delegate_target_destroy_notify_cvalue);

5024

_tmp196_->delegate_target_destroy_notify_cvalue = (ValaCCodeExpression*) _tmp199_;

5025

}

5026

} else {

5027

ValaGLibValue* _tmp200_;

5028

ValaCCodeExpression* _tmp201_;

5029

const gchar* _tmp202_;

5030

ValaCCodeMemberAccess* _tmp203_;

5031

ValaGLibValue* _tmp204_;

5032

ValaDataType* _tmp205_;

5033

ValaDataType* _tmp206_;

5034

gboolean _tmp207_;

5035

gboolean _tmp208_;

5036

_tmp200_ = _result_;

5037

_tmp201_ = inst;

5038

_tmp202_ = target_cname;

5039

_tmp203_ = vala_ccode_member_access_new (_tmp201_, _tmp202_, FALSE);

5040

_vala_ccode_node_unref0 (_tmp200_->delegate_target_cvalue);

5041

_tmp200_->delegate_target_cvalue = (ValaCCodeExpression*) _tmp203_;

5042

_tmp204_ = _result_;

5043

_tmp205_ = vala_target_value_get_value_type ((ValaTargetValue*) _tmp204_);

5044

_tmp206_ = _tmp205_;

5045

_tmp207_ = vala_data_type_get_value_owned (_tmp206_);

5046

_tmp208_ = _tmp207_;

5047

if (_tmp208_) {

5048

ValaGLibValue* _tmp209_;

5049

ValaCCodeExpression* _tmp210_;

5050

const gchar* _tmp211_;

5051

ValaCCodeMemberAccess* _tmp212_;

5052

_tmp209_ = _result_;

5053

_tmp210_ = inst;

5054

_tmp211_ = target_destroy_notify_cname;

5055

_tmp212_ = vala_ccode_member_access_new (_tmp210_, _tmp211_, FALSE);

5056

_vala_ccode_node_unref0 (_tmp209_->delegate_target_destroy_notify_cvalue);

5057

_tmp209_->delegate_target_destroy_notify_cvalue = (ValaCCodeExpression*) _tmp212_;

5058

}

5059

}

5060

_g_free0 (target_destroy_notify_cname);

5061

_g_free0 (target_cname);

5062

}

5063

}

5064

_vala_ccode_node_unref0 (inst);

5065

_vala_code_node_unref0 (cl);

5066

_vala_code_node_unref0 (instance_target_type);

5067

_vala_ccode_node_unref0 (pub_inst);

5068

} else {

5069

ValaField* _tmp213_;

5070

ValaMemberBinding _tmp214_;

5071

ValaMemberBinding _tmp215_;

5072

_tmp213_ = field;

5073

_tmp214_ = vala_field_get_binding (_tmp213_);

5074

_tmp215_ = _tmp214_;

5075

if (_tmp215_ == VALA_MEMBER_BINDING_CLASS) {

5076

ValaField* _tmp216_;

5077

ValaSymbol* _tmp217_;

5078

ValaSymbol* _tmp218_;

5079

ValaClass* _tmp219_;

5080

ValaClass* cl;

5081

ValaClass* _tmp220_;

5082

gchar* _tmp221_ = NULL;

5083

gchar* _tmp222_;

5084

gchar* _tmp223_;

5085

gchar* _tmp224_;

5086

ValaCCodeIdentifier* _tmp225_;

5087

ValaCCodeIdentifier* _tmp226_;

5088

ValaCCodeFunctionCall* _tmp227_;

5089

ValaCCodeFunctionCall* _tmp228_;

5090

ValaCCodeFunctionCall* cast;

5091

ValaCCodeExpression* klass = NULL;

5092

ValaTargetValue* _tmp229_;

5093

ValaCCodeFunctionCall* _tmp253_;

5094

ValaCCodeExpression* _tmp254_;

5095

ValaField* _tmp255_;

5096

ValaSymbolAccessibility _tmp256_;

5097

ValaSymbolAccessibility _tmp257_;

5098

_tmp216_ = field;

5099

_tmp217_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp216_);

5100

_tmp218_ = _tmp217_;

5101

_tmp219_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp218_, VALA_TYPE_CLASS, ValaClass));

5102

cl = _tmp219_;

5103

_tmp220_ = cl;

5104

_tmp221_ = vala_ccode_base_module_get_ccode_upper_case_name ((ValaSymbol*) _tmp220_, NULL);

5105

_tmp222_ = _tmp221_;

5106

_tmp223_ = g_strconcat (_tmp222_, "_CLASS", NULL);

5107

_tmp224_ = _tmp223_;

5108

_tmp225_ = vala_ccode_identifier_new (_tmp224_);

5109

_tmp226_ = _tmp225_;

5110

_tmp227_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp226_);

5111

_tmp228_ = _tmp227_;

5112

_vala_ccode_node_unref0 (_tmp226_);

5113

_g_free0 (_tmp224_);

5114

_g_free0 (_tmp222_);

5115

cast = _tmp228_;

5116

_tmp229_ = instance;

5117

if (_tmp229_ == NULL) {

5118

ValaDataType* _tmp230_ = NULL;

5119

ValaDataType* _tmp231_;

5120

gboolean _tmp232_;

5121

_tmp230_ = vala_ccode_base_module_get_this_type ((ValaCCodeBaseModule*) self);

5122

_tmp231_ = _tmp230_;

5123

_tmp232_ = _tmp231_ == NULL;

5124

_vala_code_node_unref0 (_tmp231_);

5125

if (_tmp232_) {

5126

ValaCCodeIdentifier* _tmp233_;

5127

_tmp233_ = vala_ccode_identifier_new ("klass");

5128

_vala_ccode_node_unref0 (klass);

5129

klass = (ValaCCodeExpression*) _tmp233_;

5130

} else {

5131

ValaCCodeIdentifier* _tmp234_;

5132

ValaCCodeIdentifier* _tmp235_;

5133

ValaCCodeFunctionCall* _tmp236_;

5134

ValaCCodeFunctionCall* _tmp237_;

5135

ValaCCodeFunctionCall* k;

5136

ValaCCodeFunctionCall* _tmp238_;

5137

ValaCCodeIdentifier* _tmp239_;

5138

ValaCCodeIdentifier* _tmp240_;

5139

ValaCCodeFunctionCall* _tmp241_;

5140

ValaCCodeExpression* _tmp242_;

5141

_tmp234_ = vala_ccode_identifier_new ("G_OBJECT_GET_CLASS");

5142

_tmp235_ = _tmp234_;

5143

_tmp236_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp235_);

5144

_tmp237_ = _tmp236_;

5145

_vala_ccode_node_unref0 (_tmp235_);

5146

k = _tmp237_;

5147

_tmp238_ = k;

5148

_tmp239_ = vala_ccode_identifier_new ("self");

5149

_tmp240_ = _tmp239_;

5150

vala_ccode_function_call_add_argument (_tmp238_, (ValaCCodeExpression*) _tmp240_);

5151

_vala_ccode_node_unref0 (_tmp240_);

5152

_tmp241_ = k;

5153

_tmp242_ = _vala_ccode_node_ref0 ((ValaCCodeExpression*) _tmp241_);

5154

_vala_ccode_node_unref0 (klass);

5155

klass = _tmp242_;

5156

_vala_ccode_node_unref0 (k);

5157

}

5158

} else {

5159

ValaCCodeIdentifier* _tmp243_;

5160

ValaCCodeIdentifier* _tmp244_;

5161

ValaCCodeFunctionCall* _tmp245_;

5162

ValaCCodeFunctionCall* _tmp246_;

5163

ValaCCodeFunctionCall* k;

5164

ValaCCodeFunctionCall* _tmp247_;

5165

ValaTargetValue* _tmp248_;

5166

ValaCCodeExpression* _tmp249_ = NULL;

5167

ValaCCodeExpression* _tmp250_;

5168

ValaCCodeFunctionCall* _tmp251_;

5169

ValaCCodeExpression* _tmp252_;

5170

_tmp243_ = vala_ccode_identifier_new ("G_OBJECT_GET_CLASS");

5171

_tmp244_ = _tmp243_;

5172

_tmp245_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp244_);

5173

_tmp246_ = _tmp245_;

5174

_vala_ccode_node_unref0 (_tmp244_);

5175

k = _tmp246_;

5176

_tmp247_ = k;

5177

_tmp248_ = instance;

5178

_tmp249_ = vala_ccode_base_module_get_cvalue_ ((ValaCCodeBaseModule*) self, _tmp248_);

5179

_tmp250_ = _tmp249_;

5180

vala_ccode_function_call_add_argument (_tmp247_, _tmp250_);

5181

_vala_ccode_node_unref0 (_tmp250_);

5182

_tmp251_ = k;

5183

_tmp252_ = _vala_ccode_node_ref0 ((ValaCCodeExpression*) _tmp251_);

5184

_vala_ccode_node_unref0 (klass);

5185

klass = _tmp252_;

5186

_vala_ccode_node_unref0 (k);

5187

}

5188

_tmp253_ = cast;

5189

_tmp254_ = klass;

5190

vala_ccode_function_call_add_argument (_tmp253_, _tmp254_);

5191

_tmp255_ = field;

5192

_tmp256_ = vala_symbol_get_access ((ValaSymbol*) _tmp255_);

5193

_tmp257_ = _tmp256_;

5194

if (_tmp257_ == VALA_SYMBOL_ACCESSIBILITY_PRIVATE) {

5195

ValaClass* _tmp258_;

5196

gchar* _tmp259_ = NULL;

5197

gchar* _tmp260_;

5198

gchar* _tmp261_ = NULL;

5199

gchar* _tmp262_;

5200

ValaCCodeIdentifier* _tmp263_;

5201

ValaCCodeIdentifier* _tmp264_;

5202

ValaCCodeFunctionCall* _tmp265_;

5203

ValaCCodeFunctionCall* _tmp266_;

5204

ValaCCodeFunctionCall* ccall;

5205

ValaCCodeFunctionCall* _tmp267_;

5206

ValaCCodeExpression* _tmp268_;

5207

ValaGLibValue* _tmp269_;

5208

ValaCCodeFunctionCall* _tmp270_;

5209

ValaField* _tmp271_;

5210

gchar* _tmp272_ = NULL;

5211

gchar* _tmp273_;

5212

ValaCCodeMemberAccess* _tmp274_;

5213

_tmp258_ = cl;

5214

_tmp259_ = vala_ccode_base_module_get_ccode_upper_case_name ((ValaSymbol*) _tmp258_, NULL);

5215

_tmp260_ = _tmp259_;

5216

_tmp261_ = g_strdup_printf ("%s_GET_CLASS_PRIVATE", _tmp260_);

5217

_tmp262_ = _tmp261_;

5218

_tmp263_ = vala_ccode_identifier_new (_tmp262_);

5219

_tmp264_ = _tmp263_;

5220

_tmp265_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp264_);

5221

_tmp266_ = _tmp265_;

5222

_vala_ccode_node_unref0 (_tmp264_);

5223

_g_free0 (_tmp262_);

5224

_g_free0 (_tmp260_);

5225

ccall = _tmp266_;

5226

_tmp267_ = ccall;

5227

_tmp268_ = klass;

5228

vala_ccode_function_call_add_argument (_tmp267_, _tmp268_);

5229

_tmp269_ = _result_;

5230

_tmp270_ = ccall;

5231

_tmp271_ = field;

5232

_tmp272_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp271_);

5233

_tmp273_ = _tmp272_;

5234

_tmp274_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp270_, _tmp273_);

5235

_vala_ccode_node_unref0 (_tmp269_->cvalue);

5236

_tmp269_->cvalue = (ValaCCodeExpression*) _tmp274_;

5237

_g_free0 (_tmp273_);

5238

_vala_ccode_node_unref0 (ccall);

5239

} else {

5240

ValaGLibValue* _tmp275_;

5241

ValaCCodeFunctionCall* _tmp276_;

5242

ValaField* _tmp277_;

5243

gchar* _tmp278_ = NULL;

5244

gchar* _tmp279_;

5245

ValaCCodeMemberAccess* _tmp280_;

5246

_tmp275_ = _result_;

5247

_tmp276_ = cast;

5248

_tmp277_ = field;

5249

_tmp278_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp277_);

5250

_tmp279_ = _tmp278_;

5251

_tmp280_ = vala_ccode_member_access_new_pointer ((ValaCCodeExpression*) _tmp276_, _tmp279_);

5252

_vala_ccode_node_unref0 (_tmp275_->cvalue);

5253

_tmp275_->cvalue = (ValaCCodeExpression*) _tmp280_;

5254

_g_free0 (_tmp279_);

5255

}

5256

_vala_ccode_node_unref0 (klass);

5257

_vala_ccode_node_unref0 (cast);

5258

_vala_code_node_unref0 (cl);

5259

} else {

5260

ValaField* _tmp281_;

5261

ValaCCodeFile* _tmp282_;

5262

ValaGLibValue* _tmp283_;

5263

ValaField* _tmp284_;

5264

gchar* _tmp285_ = NULL;

5265

gchar* _tmp286_;

5266

ValaCCodeIdentifier* _tmp287_;

5267

gboolean _tmp288_ = FALSE;

5268

ValaArrayType* _tmp289_;

5269

gboolean _tmp292_;

5270

_tmp281_ = field;

5271

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

5272

vala_ccode_base_module_generate_field_declaration ((ValaCCodeBaseModule*) self, _tmp281_, _tmp282_);

5273

_tmp283_ = _result_;

5274

_tmp284_ = field;

5275

_tmp285_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp284_);

5276

_tmp286_ = _tmp285_;

5277

_tmp287_ = vala_ccode_identifier_new (_tmp286_);

5278

_vala_ccode_node_unref0 (_tmp283_->cvalue);

5279

_tmp283_->cvalue = (ValaCCodeExpression*) _tmp287_;

5280

_g_free0 (_tmp286_);

5281

_tmp289_ = array_type;

5282

if (_tmp289_ != NULL) {

5283

ValaField* _tmp290_;

5284

gboolean _tmp291_ = FALSE;

5285

_tmp290_ = field;

5286

_tmp291_ = vala_ccode_base_module_get_ccode_array_length ((ValaCodeNode*) _tmp290_);

5287

_tmp288_ = _tmp291_;

5288

} else {

5289

_tmp288_ = FALSE;

5290

}

5291

_tmp292_ = _tmp288_;

5292

if (_tmp292_) {

5293

gboolean _tmp315_ = FALSE;

5294

ValaArrayType* _tmp316_;

5295

gint _tmp317_;

5296

gint _tmp318_;

5297

gboolean _tmp321_;

5298

{

5299

gint dim;

5300

dim = 1;

5301

{

5302

gboolean _tmp293_;

5303

_tmp293_ = TRUE;

5304

while (TRUE) {

5305

gboolean _tmp294_;

5306

gint _tmp296_;

5307

ValaArrayType* _tmp297_;

5308

gint _tmp298_;

5309

gint _tmp299_;

5310

gchar* length_cname = NULL;

5311

ValaField* _tmp300_;

5312

gchar* _tmp301_ = NULL;

5313

gchar* _tmp302_;

5314

gboolean _tmp303_;

5315

ValaGLibValue* _tmp311_;

5316

const gchar* _tmp312_;

5317

ValaCCodeIdentifier* _tmp313_;

5318

ValaCCodeIdentifier* _tmp314_;

5319

_tmp294_ = _tmp293_;

5320

if (!_tmp294_) {

5321

gint _tmp295_;

5322

_tmp295_ = dim;

5323

dim = _tmp295_ + 1;

5324

}

5325

_tmp293_ = FALSE;

5326

_tmp296_ = dim;

5327

_tmp297_ = array_type;

5328

_tmp298_ = vala_array_type_get_rank (_tmp297_);

5329

_tmp299_ = _tmp298_;

5330

if (!(_tmp296_ <= _tmp299_)) {

5331

break;

5332

}

5333

_tmp300_ = field;

5334

_tmp301_ = vala_ccode_base_module_get_ccode_array_length_name ((ValaCodeNode*) _tmp300_);

5335

_tmp302_ = _tmp301_;

5336

_tmp303_ = _tmp302_ != NULL;

5337

_g_free0 (_tmp302_);

5338

if (_tmp303_) {

5339

ValaField* _tmp304_;

5340

gchar* _tmp305_ = NULL;

5341

_tmp304_ = field;

5342

_tmp305_ = vala_ccode_base_module_get_ccode_array_length_name ((ValaCodeNode*) _tmp304_);

5343

_g_free0 (length_cname);

5344

length_cname = _tmp305_;

5345

} else {

5346

ValaField* _tmp306_;

5347

gchar* _tmp307_ = NULL;

5348

gchar* _tmp308_;

5349

gint _tmp309_;

5350

gchar* _tmp310_ = NULL;

5351

_tmp306_ = field;

5352

_tmp307_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp306_);

5353

_tmp308_ = _tmp307_;

5354

_tmp309_ = dim;

5355

_tmp310_ = vala_ccode_base_module_get_array_length_cname ((ValaCCodeBaseModule*) self, _tmp308_, _tmp309_);

5356

_g_free0 (length_cname);

5357

length_cname = _tmp310_;

5358

_g_free0 (_tmp308_);

5359

}

5360

_tmp311_ = _result_;

5361

_tmp312_ = length_cname;

5362

_tmp313_ = vala_ccode_identifier_new (_tmp312_);

5363

_tmp314_ = _tmp313_;

5364

vala_glib_value_append_array_length_cvalue (_tmp311_, (ValaCCodeExpression*) _tmp314_);

5365

_vala_ccode_node_unref0 (_tmp314_);

5366

_g_free0 (length_cname);

5367

}

5368

}

5369

}

5370

_tmp316_ = array_type;

5371

_tmp317_ = vala_array_type_get_rank (_tmp316_);

5372

_tmp318_ = _tmp317_;

5373

if (_tmp318_ == 1) {

5374

ValaField* _tmp319_;

5375

gboolean _tmp320_ = FALSE;

5376

_tmp319_ = field;

5377

_tmp320_ = vala_symbol_is_internal_symbol ((ValaSymbol*) _tmp319_);

5378

_tmp315_ = _tmp320_;

5379

} else {

5380

_tmp315_ = FALSE;

5381

}

5382

_tmp321_ = _tmp315_;

5383

if (_tmp321_) {

5384

ValaGLibValue* _tmp322_;

5385

ValaField* _tmp323_;

5386

gchar* _tmp324_ = NULL;

5387

gchar* _tmp325_;

5388

gchar* _tmp326_ = NULL;

5389

gchar* _tmp327_;

5390

ValaCCodeIdentifier* _tmp328_;

5391

ValaCCodeIdentifier* _tmp329_;

5392

_tmp322_ = _result_;

5393

_tmp323_ = field;

5394

_tmp324_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp323_);

5395

_tmp325_ = _tmp324_;

5396

_tmp326_ = vala_ccode_base_module_get_array_size_cname ((ValaCCodeBaseModule*) self, _tmp325_);

5397

_tmp327_ = _tmp326_;

5398

_tmp328_ = vala_ccode_identifier_new (_tmp327_);

5399

_tmp329_ = _tmp328_;

5400

vala_ccode_base_module_set_array_size_cvalue ((ValaCCodeBaseModule*) self, (ValaTargetValue*) _tmp322_, (ValaCCodeExpression*) _tmp329_);

5401

_vala_ccode_node_unref0 (_tmp329_);

5402

_g_free0 (_tmp327_);

5403

_g_free0 (_tmp325_);

5404

}

5405

} else {

5406

gboolean _tmp330_ = FALSE;

5407

gboolean _tmp331_ = FALSE;

5408

ValaDelegateType* _tmp332_;

5409

gboolean _tmp338_;

5410

gboolean _tmp341_;

5411

_tmp332_ = delegate_type;

5412

if (_tmp332_ != NULL) {

5413

ValaDelegateType* _tmp333_;

5414

ValaDelegate* _tmp334_;

5415

ValaDelegate* _tmp335_;

5416

gboolean _tmp336_;

5417

gboolean _tmp337_;

5418

_tmp333_ = delegate_type;

5419

_tmp334_ = vala_delegate_type_get_delegate_symbol (_tmp333_);

5420

_tmp335_ = _tmp334_;

5421

_tmp336_ = vala_delegate_get_has_target (_tmp335_);

5422

_tmp337_ = _tmp336_;

5423

_tmp331_ = _tmp337_;

5424

} else {

5425

_tmp331_ = FALSE;

5426

}

5427

_tmp338_ = _tmp331_;

5428

if (_tmp338_) {

5429

ValaField* _tmp339_;

5430

gboolean _tmp340_ = FALSE;

5431

_tmp339_ = field;

5432

_tmp340_ = vala_ccode_base_module_get_ccode_delegate_target ((ValaCodeNode*) _tmp339_);

5433

_tmp330_ = _tmp340_;

5434

} else {

5435

_tmp330_ = FALSE;

5436

}

5437

_tmp341_ = _tmp330_;

5438

if (_tmp341_) {

5439

ValaGLibValue* _tmp342_;

5440

ValaField* _tmp343_;

5441

gchar* _tmp344_ = NULL;

5442

gchar* _tmp345_;

5443

ValaCCodeIdentifier* _tmp346_;

5444

ValaGLibValue* _tmp347_;

5445

ValaDataType* _tmp348_;

5446

ValaDataType* _tmp349_;

5447

gboolean _tmp350_;

5448

gboolean _tmp351_;

5449

_tmp342_ = _result_;

5450

_tmp343_ = field;

5451

_tmp344_ = vala_ccode_base_module_get_ccode_delegate_target_name ((ValaVariable*) _tmp343_);

5452

_tmp345_ = _tmp344_;

5453

_tmp346_ = vala_ccode_identifier_new (_tmp345_);

5454

_vala_ccode_node_unref0 (_tmp342_->delegate_target_cvalue);

5455

_tmp342_->delegate_target_cvalue = (ValaCCodeExpression*) _tmp346_;

5456

_g_free0 (_tmp345_);

5457

_tmp347_ = _result_;

5458

_tmp348_ = vala_target_value_get_value_type ((ValaTargetValue*) _tmp347_);

5459

_tmp349_ = _tmp348_;

5460

_tmp350_ = vala_data_type_get_value_owned (_tmp349_);

5461

_tmp351_ = _tmp350_;

5462

if (_tmp351_) {

5463

ValaGLibValue* _tmp352_;

5464

ValaField* _tmp353_;

5465

gchar* _tmp354_ = NULL;

5466

gchar* _tmp355_;

5467

gchar* _tmp356_ = NULL;

5468

gchar* _tmp357_;

5469

ValaCCodeIdentifier* _tmp358_;

5470

_tmp352_ = _result_;

5471

_tmp353_ = field;

5472

_tmp354_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp353_);

5473

_tmp355_ = _tmp354_;

5474

_tmp356_ = vala_ccode_base_module_get_delegate_target_destroy_notify_cname ((ValaCCodeBaseModule*) self, _tmp355_);

5475

_tmp357_ = _tmp356_;

5476

_tmp358_ = vala_ccode_identifier_new (_tmp357_);

5477

_vala_ccode_node_unref0 (_tmp352_->delegate_target_destroy_notify_cvalue);

5478

_tmp352_->delegate_target_destroy_notify_cvalue = (ValaCCodeExpression*) _tmp358_;

5479

_g_free0 (_tmp357_);

5480

_g_free0 (_tmp355_);

5481

}

5482

}

5483

}

5484

}

5485

}

5486

result = (ValaTargetValue*) _result_;

5487

_vala_code_node_unref0 (delegate_type);

5488

_vala_code_node_unref0 (array_type);

5489

_vala_code_node_unref0 (value_type);

5490

return result;

5491

}

5492

5493

5494

static ValaTargetValue* vala_ccode_member_access_module_real_load_variable (ValaCCodeBaseModule* base, ValaVariable* variable, ValaTargetValue* value) {

5495

ValaCCodeMemberAccessModule * self;

5496

ValaTargetValue* result = NULL;

5497

ValaTargetValue* _tmp0_;

5498

ValaGLibValue* _tmp1_;

5499

ValaGLibValue* _result_;

5500

ValaGLibValue* _tmp2_;

5501

ValaDataType* _tmp3_;

5502

ValaDataType* _tmp4_;

5503

ValaArrayType* _tmp5_;

5504

ValaArrayType* array_type;

5505

ValaGLibValue* _tmp6_;

5506

ValaDataType* _tmp7_;

5507

ValaDataType* _tmp8_;

5508

ValaDelegateType* _tmp9_;

5509

ValaDelegateType* delegate_type;

5510

ValaArrayType* _tmp10_;

5511

ValaGLibValue* _tmp102_;

5512

ValaDataType* _tmp103_;

5513

ValaDataType* _tmp104_;

5514

gboolean use_temp;

5515

ValaGLibValue* _tmp105_;

5516

ValaDataType* _tmp106_;

5517

ValaDataType* _tmp107_;

5518

gboolean _tmp108_ = FALSE;

5519

gboolean _tmp109_ = FALSE;

5520

ValaVariable* _tmp110_;

5521

gboolean _tmp114_;

5522

gboolean _tmp115_ = FALSE;

5523

ValaVariable* _tmp116_;

5524

gboolean _tmp117_;

5525

gboolean _tmp118_;

5526

gboolean _tmp123_;

5527

ValaVariable* _tmp124_;

5528

ValaLocalVariable* _tmp125_;

5529

ValaLocalVariable* local;

5530

gboolean _tmp126_ = FALSE;

5531

ValaLocalVariable* _tmp127_;

5532

gboolean _tmp131_;

5533

gboolean _tmp132_;

5534

self = (ValaCCodeMemberAccessModule*) base;

5535

g_return_val_if_fail (variable != NULL, NULL);

5536

g_return_val_if_fail (value != NULL, NULL);

5537

_tmp0_ = value;

5538

_tmp1_ = _vala_target_value_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp0_, VALA_TYPE_GLIB_VALUE, ValaGLibValue));

5539

_result_ = _tmp1_;

5540

_tmp2_ = _result_;

5541

_tmp3_ = vala_target_value_get_value_type ((ValaTargetValue*) _tmp2_);

5542

_tmp4_ = _tmp3_;

5543

_tmp5_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp4_, VALA_TYPE_ARRAY_TYPE) ? ((ValaArrayType*) _tmp4_) : NULL);

5544

array_type = _tmp5_;

5545

_tmp6_ = _result_;

5546

_tmp7_ = vala_target_value_get_value_type ((ValaTargetValue*) _tmp6_);

5547

_tmp8_ = _tmp7_;

5548

_tmp9_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp8_, VALA_TYPE_DELEGATE_TYPE) ? ((ValaDelegateType*) _tmp8_) : NULL);

5549

delegate_type = _tmp9_;

5550

_tmp10_ = array_type;

5551

if (_tmp10_ != NULL) {

5552

ValaArrayType* _tmp11_;

5553

gboolean _tmp12_;

5554

gboolean _tmp13_;

5555

ValaGLibValue* _tmp86_;

5556

_tmp11_ = array_type;

5557

_tmp12_ = vala_array_type_get_fixed_length (_tmp11_);

5558

_tmp13_ = _tmp12_;

5559

if (_tmp13_) {

5560

ValaGLibValue* _tmp14_;

5561

ValaGLibValue* _tmp15_;

5562

ValaArrayType* _tmp16_;

5563

gint _tmp17_;

5564

gint _tmp18_;

5565

gchar* _tmp19_ = NULL;

5566

gchar* _tmp20_;

5567

ValaCCodeConstant* _tmp21_;

5568

ValaCCodeConstant* _tmp22_;

5569

ValaGLibValue* _tmp23_;

5570

_tmp14_ = _result_;

5571

_vala_iterable_unref0 (_tmp14_->array_length_cvalues);

5572

_tmp14_->array_length_cvalues = NULL;

5573

_tmp15_ = _result_;

5574

_tmp16_ = array_type;

5575

_tmp17_ = vala_array_type_get_length (_tmp16_);

5576

_tmp18_ = _tmp17_;

5577

_tmp19_ = g_strdup_printf ("%i", _tmp18_);

5578

_tmp20_ = _tmp19_;

5579

_tmp21_ = vala_ccode_constant_new (_tmp20_);

5580

_tmp22_ = _tmp21_;

5581

vala_glib_value_append_array_length_cvalue (_tmp15_, (ValaCCodeExpression*) _tmp22_);

5582

_vala_ccode_node_unref0 (_tmp22_);

5583

_g_free0 (_tmp20_);

5584

_tmp23_ = _result_;

5585

_tmp23_->lvalue = FALSE;

5586

} else {

5587

ValaVariable* _tmp24_;

5588

gboolean _tmp25_ = FALSE;

5589

_tmp24_ = variable;

5590

_tmp25_ = vala_ccode_base_module_get_ccode_array_null_terminated ((ValaCodeNode*) _tmp24_);

5591

if (_tmp25_) {

5592

ValaCCodeIdentifier* _tmp26_;

5593

ValaCCodeIdentifier* _tmp27_;

5594

ValaCCodeFunctionCall* _tmp28_;

5595

ValaCCodeFunctionCall* _tmp29_;

5596

ValaCCodeFunctionCall* len_call;

5597

ValaCCodeFunctionCall* _tmp30_;

5598

ValaGLibValue* _tmp31_;

5599

ValaCCodeExpression* _tmp32_;

5600

ValaGLibValue* _tmp33_;

5601

ValaGLibValue* _tmp34_;

5602

ValaCCodeFunctionCall* _tmp35_;

5603

ValaGLibValue* _tmp36_;

5604

((ValaCCodeBaseModule*) self)->requires_array_length = TRUE;

5605

_tmp26_ = vala_ccode_identifier_new ("_vala_array_length");

5606

_tmp27_ = _tmp26_;

5607

_tmp28_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp27_);

5608

_tmp29_ = _tmp28_;

5609

_vala_ccode_node_unref0 (_tmp27_);

5610

len_call = _tmp29_;

5611

_tmp30_ = len_call;

5612

_tmp31_ = _result_;

5613

_tmp32_ = _tmp31_->cvalue;

5614

vala_ccode_function_call_add_argument (_tmp30_, _tmp32_);

5615

_tmp33_ = _result_;

5616

_vala_iterable_unref0 (_tmp33_->array_length_cvalues);

5617

_tmp33_->array_length_cvalues = NULL;

5618

_tmp34_ = _result_;

5619

_tmp35_ = len_call;

5620

vala_glib_value_append_array_length_cvalue (_tmp34_, (ValaCCodeExpression*) _tmp35_);

5621

_tmp36_ = _result_;

5622

_tmp36_->lvalue = FALSE;

5623

_vala_ccode_node_unref0 (len_call);

5624

} else {

5625

ValaVariable* _tmp37_;

5626

gchar* _tmp38_ = NULL;

5627

gchar* _tmp39_;

5628

gboolean _tmp40_;

5629

_tmp37_ = variable;

5630

_tmp38_ = vala_ccode_base_module_get_ccode_array_length_expr ((ValaCodeNode*) _tmp37_);

5631

_tmp39_ = _tmp38_;

5632

_tmp40_ = _tmp39_ != NULL;

5633

_g_free0 (_tmp39_);

5634

if (_tmp40_) {

5635

ValaVariable* _tmp41_;

5636

gchar* _tmp42_ = NULL;

5637

gchar* _tmp43_;

5638

ValaCCodeConstant* _tmp44_;

5639

ValaCCodeConstant* _tmp45_;

5640

ValaCCodeConstant* length_expr;

5641

ValaGLibValue* _tmp46_;

5642

ValaGLibValue* _tmp47_;

5643

ValaCCodeConstant* _tmp48_;

5644

ValaGLibValue* _tmp49_;

5645

_tmp41_ = variable;

5646

_tmp42_ = vala_ccode_base_module_get_ccode_array_length_expr ((ValaCodeNode*) _tmp41_);

5647

_tmp43_ = _tmp42_;

5648

_tmp44_ = vala_ccode_constant_new (_tmp43_);

5649

_tmp45_ = _tmp44_;

5650

_g_free0 (_tmp43_);

5651

length_expr = _tmp45_;

5652

_tmp46_ = _result_;

5653

_vala_iterable_unref0 (_tmp46_->array_length_cvalues);

5654

_tmp46_->array_length_cvalues = NULL;

5655

_tmp47_ = _result_;

5656

_tmp48_ = length_expr;

5657

vala_glib_value_append_array_length_cvalue (_tmp47_, (ValaCCodeExpression*) _tmp48_);

5658

_tmp49_ = _result_;

5659

_tmp49_->lvalue = FALSE;

5660

_vala_ccode_node_unref0 (length_expr);

5661

} else {

5662

ValaVariable* _tmp50_;

5663

gboolean _tmp51_ = FALSE;

5664

_tmp50_ = variable;

5665

_tmp51_ = vala_ccode_base_module_get_ccode_array_length ((ValaCodeNode*) _tmp50_);

5666

if (!_tmp51_) {

5667

ValaGLibValue* _tmp52_;

5668

ValaGLibValue* _tmp63_;

5669

_tmp52_ = _result_;

5670

_vala_iterable_unref0 (_tmp52_->array_length_cvalues);

5671

_tmp52_->array_length_cvalues = NULL;

5672

{

5673

gint dim;

5674

dim = 1;

5675

{

5676

gboolean _tmp53_;

5677

_tmp53_ = TRUE;

5678

while (TRUE) {

5679

gboolean _tmp54_;

5680

gint _tmp56_;

5681

ValaArrayType* _tmp57_;

5682

gint _tmp58_;

5683

gint _tmp59_;

5684

ValaGLibValue* _tmp60_;

5685

ValaCCodeConstant* _tmp61_;

5686

ValaCCodeConstant* _tmp62_;

5687

_tmp54_ = _tmp53_;

5688

if (!_tmp54_) {

5689

gint _tmp55_;

5690

_tmp55_ = dim;

5691

dim = _tmp55_ + 1;

5692

}

5693

_tmp53_ = FALSE;

5694

_tmp56_ = dim;

5695

_tmp57_ = array_type;

5696

_tmp58_ = vala_array_type_get_rank (_tmp57_);

5697

_tmp59_ = _tmp58_;

5698

if (!(_tmp56_ <= _tmp59_)) {

5699

break;

5700

}

5701

_tmp60_ = _result_;

5702

_tmp61_ = vala_ccode_constant_new ("-1");

5703

_tmp62_ = _tmp61_;

5704

vala_glib_value_append_array_length_cvalue (_tmp60_, (ValaCCodeExpression*) _tmp62_);

5705

_vala_ccode_node_unref0 (_tmp62_);

5706

}

5707

}

5708

}

5709

_tmp63_ = _result_;

5710

_tmp63_->lvalue = FALSE;

5711

} else {

5712

ValaVariable* _tmp64_;

5713

gchar* _tmp65_ = NULL;

5714

gchar* _tmp66_;

5715

gboolean _tmp67_;

5716

_tmp64_ = variable;

5717

_tmp65_ = vala_ccode_base_module_get_ccode_array_length_type ((ValaCodeNode*) _tmp64_);

5718

_tmp66_ = _tmp65_;

5719

_tmp67_ = _tmp66_ != NULL;

5720

_g_free0 (_tmp66_);

5721

if (_tmp67_) {

5722

ValaGLibValue* _tmp85_;

5723

{

5724

gint dim;

5725

dim = 1;

5726

{

5727

gboolean _tmp68_;

5728

_tmp68_ = TRUE;

5729

while (TRUE) {

5730

gboolean _tmp69_;

5731

gint _tmp71_;

5732

ValaArrayType* _tmp72_;

5733

gint _tmp73_;

5734

gint _tmp74_;

5735

ValaGLibValue* _tmp75_;

5736

ValaList* _tmp76_;

5737

gint _tmp77_;

5738

ValaGLibValue* _tmp78_;

5739

ValaList* _tmp79_;

5740

gint _tmp80_;

5741

gpointer _tmp81_ = NULL;

5742

ValaCCodeExpression* _tmp82_;

5743

ValaCCodeCastExpression* _tmp83_;

5744

ValaCCodeCastExpression* _tmp84_;

5745

_tmp69_ = _tmp68_;

5746

if (!_tmp69_) {

5747

gint _tmp70_;

5748

_tmp70_ = dim;

5749

dim = _tmp70_ + 1;

5750

}

5751

_tmp68_ = FALSE;

5752

_tmp71_ = dim;

5753

_tmp72_ = array_type;

5754

_tmp73_ = vala_array_type_get_rank (_tmp72_);

5755

_tmp74_ = _tmp73_;

5756

if (!(_tmp71_ <= _tmp74_)) {

5757

break;

5758

}

5759

_tmp75_ = _result_;

5760

_tmp76_ = _tmp75_->array_length_cvalues;

5761

_tmp77_ = dim;

5762

_tmp78_ = _result_;

5763

_tmp79_ = _tmp78_->array_length_cvalues;

5764

_tmp80_ = dim;

5765

_tmp81_ = vala_list_get (_tmp79_, _tmp80_ - 1);

5766

_tmp82_ = (ValaCCodeExpression*) _tmp81_;

5767

_tmp83_ = vala_ccode_cast_expression_new (_tmp82_, "gint");

5768

_tmp84_ = _tmp83_;

5769

vala_list_set (_tmp76_, _tmp77_ - 1, (ValaCCodeExpression*) _tmp84_);

5770

_vala_ccode_node_unref0 (_tmp84_);

5771

_vala_ccode_node_unref0 (_tmp82_);

5772

}

5773

}

5774

}

5775

_tmp85_ = _result_;

5776

_tmp85_->lvalue = FALSE;

5777

}

5778

}

5779

}

5780

}

5781

}

5782

_tmp86_ = _result_;

5783

_vala_ccode_node_unref0 (_tmp86_->array_size_cvalue);

5784

_tmp86_->array_size_cvalue = NULL;

5785

} else {

5786

ValaDelegateType* _tmp87_;

5787

_tmp87_ = delegate_type;

5788

if (_tmp87_ != NULL) {

5789

gboolean _tmp88_ = FALSE;

5790

ValaDelegateType* _tmp89_;

5791

ValaDelegate* _tmp90_;

5792

ValaDelegate* _tmp91_;

5793

gboolean _tmp92_;

5794

gboolean _tmp93_;

5795

gboolean _tmp96_;

5796

ValaGLibValue* _tmp99_;

5797

ValaCCodeConstant* _tmp100_;

5798

ValaGLibValue* _tmp101_;

5799

_tmp89_ = delegate_type;

5800

_tmp90_ = vala_delegate_type_get_delegate_symbol (_tmp89_);

5801

_tmp91_ = _tmp90_;

5802

_tmp92_ = vala_delegate_get_has_target (_tmp91_);

5803

_tmp93_ = _tmp92_;

5804

if (!_tmp93_) {

5805

_tmp88_ = TRUE;

5806

} else {

5807

ValaVariable* _tmp94_;

5808

gboolean _tmp95_ = FALSE;

5809

_tmp94_ = variable;

5810

_tmp95_ = vala_ccode_base_module_get_ccode_delegate_target ((ValaCodeNode*) _tmp94_);

5811

_tmp88_ = !_tmp95_;

5812

}

5813

_tmp96_ = _tmp88_;

5814

if (_tmp96_) {

5815

ValaGLibValue* _tmp97_;

5816

ValaCCodeConstant* _tmp98_;

5817

_tmp97_ = _result_;

5818

_tmp98_ = vala_ccode_constant_new ("NULL");

5819

_vala_ccode_node_unref0 (_tmp97_->delegate_target_cvalue);

5820

_tmp97_->delegate_target_cvalue = (ValaCCodeExpression*) _tmp98_;

5821

}

5822

_tmp99_ = _result_;

5823

_tmp100_ = vala_ccode_constant_new ("NULL");

5824

_vala_ccode_node_unref0 (_tmp99_->delegate_target_destroy_notify_cvalue);

5825

_tmp99_->delegate_target_destroy_notify_cvalue = (ValaCCodeExpression*) _tmp100_;

5826

_tmp101_ = _result_;

5827

_tmp101_->lvalue = FALSE;

5828

}

5829

}

5830

_tmp102_ = _result_;

5831

_tmp103_ = vala_target_value_get_value_type ((ValaTargetValue*) _tmp102_);

5832

_tmp104_ = _tmp103_;

5833

vala_data_type_set_value_owned (_tmp104_, FALSE);

5834

use_temp = TRUE;

5835

_tmp105_ = _result_;

5836

_tmp106_ = vala_target_value_get_value_type ((ValaTargetValue*) _tmp105_);

5837

_tmp107_ = _tmp106_;

5838

_tmp108_ = vala_ccode_base_module_is_lvalue_access_allowed ((ValaCCodeBaseModule*) self, _tmp107_);

5839

if (!_tmp108_) {

5840

use_temp = FALSE;

5841

}

5842

_tmp110_ = variable;

5843

if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp110_, VALA_TYPE_PARAMETER)) {

5844

ValaVariable* _tmp111_;

5845

const gchar* _tmp112_;

5846

const gchar* _tmp113_;

5847

_tmp111_ = variable;

5848

_tmp112_ = vala_symbol_get_name ((ValaSymbol*) _tmp111_);

5849

_tmp113_ = _tmp112_;

5850

_tmp109_ = g_strcmp0 (_tmp113_, "this") == 0;

5851

} else {

5852

_tmp109_ = FALSE;

5853

}

5854

_tmp114_ = _tmp109_;

5855

if (_tmp114_) {

5856

use_temp = FALSE;

5857

}

5858

_tmp116_ = variable;

5859

_tmp117_ = vala_variable_get_single_assignment (_tmp116_);

5860

_tmp118_ = _tmp117_;

5861

if (_tmp118_) {

5862

ValaGLibValue* _tmp119_;

5863

ValaDataType* _tmp120_;

5864

ValaDataType* _tmp121_;

5865

gboolean _tmp122_ = FALSE;

5866

_tmp119_ = _result_;

5867

_tmp120_ = vala_target_value_get_value_type ((ValaTargetValue*) _tmp119_);

5868

_tmp121_ = _tmp120_;

5869

_tmp122_ = vala_data_type_is_real_non_null_struct_type (_tmp121_);

5870

_tmp115_ = !_tmp122_;

5871

} else {

5872

_tmp115_ = FALSE;

5873

}

5874

_tmp123_ = _tmp115_;

5875

if (_tmp123_) {

5876

use_temp = FALSE;

5877

}

5878

_tmp124_ = variable;

5879

_tmp125_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp124_, VALA_TYPE_LOCAL_VARIABLE) ? ((ValaLocalVariable*) _tmp124_) : NULL);

5880

local = _tmp125_;

5881

_tmp127_ = local;

5882

if (_tmp127_ != NULL) {

5883

ValaLocalVariable* _tmp128_;

5884

gboolean _tmp129_;

5885

gboolean _tmp130_;

5886

_tmp128_ = local;

5887

_tmp129_ = vala_local_variable_get_floating (_tmp128_);

5888

_tmp130_ = _tmp129_;

5889

_tmp126_ = _tmp130_;

5890

} else {

5891

_tmp126_ = FALSE;

5892

}

5893

_tmp131_ = _tmp126_;

5894

if (_tmp131_) {

5895

use_temp = FALSE;

5896

}

5897

_tmp132_ = use_temp;

5898

if (_tmp132_) {

5899

ValaGLibValue* _tmp133_;

5900

ValaVariable* _tmp134_;

5901

ValaTargetValue* _tmp135_ = NULL;

5902

_tmp133_ = _result_;

5903

_tmp134_ = variable;

5904

_tmp135_ = vala_ccode_base_module_store_temp_value ((ValaCCodeBaseModule*) self, (ValaTargetValue*) _tmp133_, (ValaCodeNode*) _tmp134_, NULL);

5905

_vala_target_value_unref0 (_result_);

5906

_result_ = G_TYPE_CHECK_INSTANCE_CAST (_tmp135_, VALA_TYPE_GLIB_VALUE, ValaGLibValue);

5907

}

5908

result = (ValaTargetValue*) _result_;

5909

_vala_code_node_unref0 (local);

5910

_vala_code_node_unref0 (delegate_type);

5911

_vala_code_node_unref0 (array_type);

5912

return result;

5913

}

5914

5915

5916

static ValaTargetValue* vala_ccode_member_access_module_real_load_local (ValaCodeGenerator* base, ValaLocalVariable* local) {

5917

ValaCCodeMemberAccessModule * self;

5918

ValaTargetValue* result = NULL;

5919

ValaLocalVariable* _tmp0_;

5920

ValaLocalVariable* _tmp1_;

5921

ValaTargetValue* _tmp2_ = NULL;

5922

ValaTargetValue* _tmp3_;

5923

ValaTargetValue* _tmp4_ = NULL;

5924

ValaTargetValue* _tmp5_;

5925

self = (ValaCCodeMemberAccessModule*) base;

5926

g_return_val_if_fail (local != NULL, NULL);

5927

_tmp0_ = local;

5928

_tmp1_ = local;

5929

_tmp2_ = vala_ccode_base_module_get_local_cvalue ((ValaCCodeBaseModule*) self, _tmp1_);

5930

_tmp3_ = _tmp2_;

5931

_tmp4_ = vala_ccode_base_module_load_variable ((ValaCCodeBaseModule*) self, (ValaVariable*) _tmp0_, _tmp3_);

5932

_tmp5_ = _tmp4_;

5933

_vala_target_value_unref0 (_tmp3_);

5934

result = _tmp5_;

5935

return result;

5936

}

5937

5938

5939

static ValaTargetValue* vala_ccode_member_access_module_real_load_parameter (ValaCodeGenerator* base, ValaParameter* param) {

5940

ValaCCodeMemberAccessModule * self;

5941

ValaTargetValue* result = NULL;

5942

ValaParameter* _tmp0_;

5943

ValaParameter* _tmp1_;

5944

ValaTargetValue* _tmp2_ = NULL;

5945

ValaTargetValue* _tmp3_;

5946

ValaTargetValue* _tmp4_ = NULL;

5947

ValaTargetValue* _tmp5_;

5948

self = (ValaCCodeMemberAccessModule*) base;

5949

g_return_val_if_fail (param != NULL, NULL);

5950

_tmp0_ = param;

5951

_tmp1_ = param;

5952

_tmp2_ = vala_ccode_base_module_get_parameter_cvalue ((ValaCCodeBaseModule*) self, _tmp1_);

5953

_tmp3_ = _tmp2_;

5954

_tmp4_ = vala_ccode_base_module_load_variable ((ValaCCodeBaseModule*) self, (ValaVariable*) _tmp0_, _tmp3_);

5955

_tmp5_ = _tmp4_;

5956

_vala_target_value_unref0 (_tmp3_);

5957

result = _tmp5_;

5958

return result;

5959

}

5960

5961

5962

static ValaTargetValue* vala_ccode_member_access_module_real_load_this_parameter (ValaCCodeBaseModule* base, ValaTypeSymbol* sym) {

5963

ValaCCodeMemberAccessModule * self;

5964

ValaTargetValue* result = NULL;

5965

ValaTypeSymbol* _tmp0_;

5966

ValaDataType* _tmp1_ = NULL;

5967

ValaDataType* _tmp2_;

5968

ValaParameter* _tmp3_;

5969

ValaParameter* _tmp4_;

5970

ValaParameter* param;

5971

ValaTargetValue* _tmp5_ = NULL;

5972

self = (ValaCCodeMemberAccessModule*) base;

5973

g_return_val_if_fail (sym != NULL, NULL);

5974

_tmp0_ = sym;

5975

_tmp1_ = vala_ccode_base_module_get_data_type_for_symbol (_tmp0_);

5976

_tmp2_ = _tmp1_;

5977

_tmp3_ = vala_parameter_new ("this", _tmp2_, NULL);

5978

_tmp4_ = _tmp3_;

5979

_vala_code_node_unref0 (_tmp2_);

5980

param = _tmp4_;

5981

_tmp5_ = vala_code_generator_load_parameter ((ValaCodeGenerator*) self, param);

5982

result = _tmp5_;

5983

_vala_code_node_unref0 (param);

5984

return result;

5985

}

5986

5987

5988

static ValaTargetValue* vala_ccode_member_access_module_real_load_field (ValaCodeGenerator* base, ValaField* field, ValaTargetValue* instance) {

5989

ValaCCodeMemberAccessModule * self;

5990

ValaTargetValue* result = NULL;

5991

ValaField* _tmp0_;

5992

ValaField* _tmp1_;

5993

ValaTargetValue* _tmp2_;

5994

ValaTargetValue* _tmp3_ = NULL;

5995

ValaTargetValue* _tmp4_;

5996

ValaTargetValue* _tmp5_ = NULL;

5997

ValaTargetValue* _tmp6_;

5998

self = (ValaCCodeMemberAccessModule*) base;

5999

g_return_val_if_fail (field != NULL, NULL);

6000

_tmp0_ = field;

6001

_tmp1_ = field;

6002

_tmp2_ = instance;

6003

_tmp3_ = vala_ccode_base_module_get_field_cvalue ((ValaCCodeBaseModule*) self, _tmp1_, _tmp2_);

6004

_tmp4_ = _tmp3_;

6005

_tmp5_ = vala_ccode_base_module_load_variable ((ValaCCodeBaseModule*) self, (ValaVariable*) _tmp0_, _tmp4_);

6006

_tmp6_ = _tmp5_;

6007

_vala_target_value_unref0 (_tmp4_);

6008

result = _tmp6_;

6009

return result;

6010

}

6011

6012

6013

ValaCCodeMemberAccessModule* vala_ccode_member_access_module_construct (GType object_type) {

6014

ValaCCodeMemberAccessModule* self = NULL;

6015

self = (ValaCCodeMemberAccessModule*) vala_ccode_control_flow_module_construct (object_type);

6016

return self;

6017

}

6018

6019

6020

static void vala_ccode_member_access_module_class_init (ValaCCodeMemberAccessModuleClass * klass) {

6021

vala_ccode_member_access_module_parent_class = g_type_class_peek_parent (klass);

6022

VALA_CODE_VISITOR_CLASS (klass)->visit_member_access = vala_ccode_member_access_module_real_visit_member_access;

6023

VALA_CCODE_BASE_MODULE_CLASS (klass)->get_local_cvalue = vala_ccode_member_access_module_real_get_local_cvalue;

6024

VALA_CCODE_BASE_MODULE_CLASS (klass)->get_parameter_cvalue = vala_ccode_member_access_module_real_get_parameter_cvalue;

6025

VALA_CCODE_BASE_MODULE_CLASS (klass)->get_field_cvalue = vala_ccode_member_access_module_real_get_field_cvalue;

6026

VALA_CCODE_BASE_MODULE_CLASS (klass)->load_variable = vala_ccode_member_access_module_real_load_variable;

6027

VALA_CODE_GENERATOR_CLASS (klass)->load_local = vala_ccode_member_access_module_real_load_local;

6028

VALA_CODE_GENERATOR_CLASS (klass)->load_parameter = vala_ccode_member_access_module_real_load_parameter;

6029

VALA_CCODE_BASE_MODULE_CLASS (klass)->load_this_parameter = vala_ccode_member_access_module_real_load_this_parameter;

6030

VALA_CODE_GENERATOR_CLASS (klass)->load_field = vala_ccode_member_access_module_real_load_field;

6031

}

6032

6033

6034

static void vala_ccode_member_access_module_instance_init (ValaCCodeMemberAccessModule * self) {

6035

}

6036

6037

6038

GType vala_ccode_member_access_module_get_type (void) {

6039

static volatile gsize vala_ccode_member_access_module_type_id__volatile = 0;

6040

if (g_once_init_enter (&vala_ccode_member_access_module_type_id__volatile)) {

6041

static const GTypeInfo g_define_type_info = { sizeof (ValaCCodeMemberAccessModuleClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) vala_ccode_member_access_module_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ValaCCodeMemberAccessModule), 0, (GInstanceInitFunc) vala_ccode_member_access_module_instance_init, NULL };

6042

GType vala_ccode_member_access_module_type_id;

6043

vala_ccode_member_access_module_type_id = g_type_register_static (VALA_TYPE_CCODE_CONTROL_FLOW_MODULE, "ValaCCodeMemberAccessModule", &g_define_type_info, G_TYPE_FLAG_ABSTRACT);

6044

g_once_init_leave (&vala_ccode_member_access_module_type_id__volatile, vala_ccode_member_access_module_type_id);

6045

}

6046

return vala_ccode_member_access_module_type_id__volatile;

6047

}

6048

6049

6050

Older »