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

#define VALA_CCODE_BASE_MODULE_EMIT_CONTEXT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_CCODE_BASE_MODULE_TYPE_EMIT_CONTEXT, ValaCCodeBaseModuleEmitContext))

#define VALA_CCODE_BASE_MODULE_EMIT_CONTEXT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_CCODE_BASE_MODULE_TYPE_EMIT_CONTEXT, ValaCCodeBaseModuleEmitContextClass))

#define VALA_CCODE_BASE_MODULE_IS_EMIT_CONTEXT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_CCODE_BASE_MODULE_TYPE_EMIT_CONTEXT))

#define VALA_CCODE_BASE_MODULE_IS_EMIT_CONTEXT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_CCODE_BASE_MODULE_TYPE_EMIT_CONTEXT))

#define VALA_CCODE_BASE_MODULE_EMIT_CONTEXT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_CCODE_BASE_MODULE_TYPE_EMIT_CONTEXT, ValaCCodeBaseModuleEmitContextClass))

typedef struct _ValaCCodeBaseModuleEmitContext ValaCCodeBaseModuleEmitContext;

typedef struct _ValaCCodeBaseModuleEmitContextClass ValaCCodeBaseModuleEmitContextClass;

#define VALA_TYPE_CCODE_STRUCT_MODULE (vala_ccode_struct_module_get_type ())

#define VALA_CCODE_STRUCT_MODULE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CCODE_STRUCT_MODULE, ValaCCodeStructModule))

#define VALA_CCODE_STRUCT_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CCODE_STRUCT_MODULE, ValaCCodeStructModuleClass))

#define VALA_IS_CCODE_STRUCT_MODULE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CCODE_STRUCT_MODULE))

#define VALA_IS_CCODE_STRUCT_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CCODE_STRUCT_MODULE))

#define VALA_CCODE_STRUCT_MODULE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CCODE_STRUCT_MODULE, ValaCCodeStructModuleClass))

typedef struct _ValaCCodeStructModule ValaCCodeStructModule;

typedef struct _ValaCCodeStructModuleClass ValaCCodeStructModuleClass;

typedef struct _ValaCCodeStructModulePrivate ValaCCodeStructModulePrivate;

#define VALA_TYPE_CCODE_METHOD_MODULE (vala_ccode_method_module_get_type ())

#define VALA_CCODE_METHOD_MODULE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CCODE_METHOD_MODULE, ValaCCodeMethodModule))

#define VALA_CCODE_METHOD_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CCODE_METHOD_MODULE, ValaCCodeMethodModuleClass))

#define VALA_IS_CCODE_METHOD_MODULE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CCODE_METHOD_MODULE))

#define VALA_IS_CCODE_METHOD_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CCODE_METHOD_MODULE))

#define VALA_CCODE_METHOD_MODULE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CCODE_METHOD_MODULE, ValaCCodeMethodModuleClass))

typedef struct _ValaCCodeMethodModule ValaCCodeMethodModule;

typedef struct _ValaCCodeMethodModuleClass ValaCCodeMethodModuleClass;

typedef struct _ValaCCodeMethodModulePrivate ValaCCodeMethodModulePrivate;

#define VALA_TYPE_CCODE_CONTROL_FLOW_MODULE (vala_ccode_control_flow_module_get_type ())

#define VALA_CCODE_CONTROL_FLOW_MODULE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CCODE_CONTROL_FLOW_MODULE, ValaCCodeControlFlowModule))

#define VALA_CCODE_CONTROL_FLOW_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CCODE_CONTROL_FLOW_MODULE, ValaCCodeControlFlowModuleClass))

#define VALA_IS_CCODE_CONTROL_FLOW_MODULE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CCODE_CONTROL_FLOW_MODULE))

#define VALA_IS_CCODE_CONTROL_FLOW_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CCODE_CONTROL_FLOW_MODULE))

#define VALA_CCODE_CONTROL_FLOW_MODULE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CCODE_CONTROL_FLOW_MODULE, ValaCCodeControlFlowModuleClass))

typedef struct _ValaCCodeControlFlowModule ValaCCodeControlFlowModule;

typedef struct _ValaCCodeControlFlowModuleClass ValaCCodeControlFlowModuleClass;

typedef struct _ValaCCodeControlFlowModulePrivate ValaCCodeControlFlowModulePrivate;

#define VALA_TYPE_CCODE_MEMBER_ACCESS_MODULE (vala_ccode_member_access_module_get_type ())

#define VALA_CCODE_MEMBER_ACCESS_MODULE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_CCODE_MEMBER_ACCESS_MODULE, ValaCCodeMemberAccessModule))

#define VALA_CCODE_MEMBER_ACCESS_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_CCODE_MEMBER_ACCESS_MODULE, ValaCCodeMemberAccessModuleClass))

#define VALA_IS_CCODE_MEMBER_ACCESS_MODULE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_CCODE_MEMBER_ACCESS_MODULE))

#define VALA_IS_CCODE_MEMBER_ACCESS_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_CCODE_MEMBER_ACCESS_MODULE))

#define VALA_CCODE_MEMBER_ACCESS_MODULE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_CCODE_MEMBER_ACCESS_MODULE, ValaCCodeMemberAccessModuleClass))

typedef struct _ValaCCodeMemberAccessModule ValaCCodeMemberAccessModule;

typedef struct _ValaCCodeMemberAccessModuleClass ValaCCodeMemberAccessModuleClass;

typedef struct _ValaCCodeMemberAccessModulePrivate ValaCCodeMemberAccessModulePrivate;

100

#define VALA_TYPE_CCODE_ASSIGNMENT_MODULE (vala_ccode_assignment_module_get_type ())

101

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

102

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

103

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

104

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

105

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

106

107

typedef struct _ValaCCodeAssignmentModule ValaCCodeAssignmentModule;

108

typedef struct _ValaCCodeAssignmentModuleClass ValaCCodeAssignmentModuleClass;

109

typedef struct _ValaCCodeAssignmentModulePrivate ValaCCodeAssignmentModulePrivate;

110

111

#define VALA_TYPE_CCODE_METHOD_CALL_MODULE (vala_ccode_method_call_module_get_type ())

112

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

113

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

114

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

115

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

116

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

117

118

typedef struct _ValaCCodeMethodCallModule ValaCCodeMethodCallModule;

119

typedef struct _ValaCCodeMethodCallModuleClass ValaCCodeMethodCallModuleClass;

120

typedef struct _ValaCCodeMethodCallModulePrivate ValaCCodeMethodCallModulePrivate;

121

122

#define VALA_TYPE_CCODE_ARRAY_MODULE (vala_ccode_array_module_get_type ())

123

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

124

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

125

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

126

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

127

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

128

129

typedef struct _ValaCCodeArrayModule ValaCCodeArrayModule;

130

typedef struct _ValaCCodeArrayModuleClass ValaCCodeArrayModuleClass;

131

typedef struct _ValaCCodeArrayModulePrivate ValaCCodeArrayModulePrivate;

132

133

#define VALA_TYPE_CCODE_DELEGATE_MODULE (vala_ccode_delegate_module_get_type ())

134

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

135

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

136

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

137

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

138

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

139

140

typedef struct _ValaCCodeDelegateModule ValaCCodeDelegateModule;

141

typedef struct _ValaCCodeDelegateModuleClass ValaCCodeDelegateModuleClass;

142

typedef struct _ValaCCodeDelegateModulePrivate ValaCCodeDelegateModulePrivate;

143

144

#define VALA_TYPE_GERROR_MODULE (vala_gerror_module_get_type ())

145

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

146

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

147

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

148

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

149

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

150

151

typedef struct _ValaGErrorModule ValaGErrorModule;

152

typedef struct _ValaGErrorModuleClass ValaGErrorModuleClass;

153

typedef struct _ValaGErrorModulePrivate ValaGErrorModulePrivate;

154

155

#define VALA_TYPE_GTYPE_MODULE (vala_gtype_module_get_type ())

156

#define VALA_GTYPE_MODULE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_GTYPE_MODULE, ValaGTypeModule))

157

#define VALA_GTYPE_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_GTYPE_MODULE, ValaGTypeModuleClass))

158

#define VALA_IS_GTYPE_MODULE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_GTYPE_MODULE))

159

#define VALA_IS_GTYPE_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_GTYPE_MODULE))

160

#define VALA_GTYPE_MODULE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_GTYPE_MODULE, ValaGTypeModuleClass))

161

162

typedef struct _ValaGTypeModule ValaGTypeModule;

163

typedef struct _ValaGTypeModuleClass ValaGTypeModuleClass;

164

typedef struct _ValaGTypeModulePrivate ValaGTypeModulePrivate;

165

166

#define VALA_TYPE_GOBJECT_MODULE (vala_gobject_module_get_type ())

167

#define VALA_GOBJECT_MODULE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_GOBJECT_MODULE, ValaGObjectModule))

168

#define VALA_GOBJECT_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_GOBJECT_MODULE, ValaGObjectModuleClass))

169

#define VALA_IS_GOBJECT_MODULE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_GOBJECT_MODULE))

170

#define VALA_IS_GOBJECT_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_GOBJECT_MODULE))

171

#define VALA_GOBJECT_MODULE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_GOBJECT_MODULE, ValaGObjectModuleClass))

172

173

typedef struct _ValaGObjectModule ValaGObjectModule;

174

typedef struct _ValaGObjectModuleClass ValaGObjectModuleClass;

175

typedef struct _ValaGObjectModulePrivate ValaGObjectModulePrivate;

176

177

#define VALA_TYPE_GSIGNAL_MODULE (vala_gsignal_module_get_type ())

178

#define VALA_GSIGNAL_MODULE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_GSIGNAL_MODULE, ValaGSignalModule))

179

#define VALA_GSIGNAL_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_GSIGNAL_MODULE, ValaGSignalModuleClass))

180

#define VALA_IS_GSIGNAL_MODULE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_GSIGNAL_MODULE))

181

#define VALA_IS_GSIGNAL_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_GSIGNAL_MODULE))

182

#define VALA_GSIGNAL_MODULE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_GSIGNAL_MODULE, ValaGSignalModuleClass))

183

184

typedef struct _ValaGSignalModule ValaGSignalModule;

185

typedef struct _ValaGSignalModuleClass ValaGSignalModuleClass;

186

typedef struct _ValaGSignalModulePrivate ValaGSignalModulePrivate;

187

188

#define VALA_TYPE_GASYNC_MODULE (vala_gasync_module_get_type ())

189

#define VALA_GASYNC_MODULE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_GASYNC_MODULE, ValaGAsyncModule))

190

#define VALA_GASYNC_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_GASYNC_MODULE, ValaGAsyncModuleClass))

191

#define VALA_IS_GASYNC_MODULE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_GASYNC_MODULE))

192

#define VALA_IS_GASYNC_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_GASYNC_MODULE))

193

#define VALA_GASYNC_MODULE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_GASYNC_MODULE, ValaGAsyncModuleClass))

194

195

typedef struct _ValaGAsyncModule ValaGAsyncModule;

196

typedef struct _ValaGAsyncModuleClass ValaGAsyncModuleClass;

197

typedef struct _ValaGAsyncModulePrivate ValaGAsyncModulePrivate;

198

199

#define VALA_TYPE_GVARIANT_MODULE (vala_gvariant_module_get_type ())

200

#define VALA_GVARIANT_MODULE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_GVARIANT_MODULE, ValaGVariantModule))

201

#define VALA_GVARIANT_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_GVARIANT_MODULE, ValaGVariantModuleClass))

202

#define VALA_IS_GVARIANT_MODULE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_GVARIANT_MODULE))

203

#define VALA_IS_GVARIANT_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_GVARIANT_MODULE))

204

#define VALA_GVARIANT_MODULE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_GVARIANT_MODULE, ValaGVariantModuleClass))

205

206

typedef struct _ValaGVariantModule ValaGVariantModule;

207

typedef struct _ValaGVariantModuleClass ValaGVariantModuleClass;

208

typedef struct _ValaGVariantModulePrivate ValaGVariantModulePrivate;

209

210

#define VALA_TYPE_GD_BUS_MODULE (vala_gd_bus_module_get_type ())

211

#define VALA_GD_BUS_MODULE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_GD_BUS_MODULE, ValaGDBusModule))

212

#define VALA_GD_BUS_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_GD_BUS_MODULE, ValaGDBusModuleClass))

213

#define VALA_IS_GD_BUS_MODULE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_GD_BUS_MODULE))

214

#define VALA_IS_GD_BUS_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_GD_BUS_MODULE))

215

#define VALA_GD_BUS_MODULE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_GD_BUS_MODULE, ValaGDBusModuleClass))

216

217

typedef struct _ValaGDBusModule ValaGDBusModule;

218

typedef struct _ValaGDBusModuleClass ValaGDBusModuleClass;

219

typedef struct _ValaGDBusModulePrivate ValaGDBusModulePrivate;

220

221

#define VALA_TYPE_GD_BUS_CLIENT_MODULE (vala_gd_bus_client_module_get_type ())

222

#define VALA_GD_BUS_CLIENT_MODULE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_GD_BUS_CLIENT_MODULE, ValaGDBusClientModule))

223

#define VALA_GD_BUS_CLIENT_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_GD_BUS_CLIENT_MODULE, ValaGDBusClientModuleClass))

224

#define VALA_IS_GD_BUS_CLIENT_MODULE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_GD_BUS_CLIENT_MODULE))

225

#define VALA_IS_GD_BUS_CLIENT_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_GD_BUS_CLIENT_MODULE))

226

#define VALA_GD_BUS_CLIENT_MODULE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_GD_BUS_CLIENT_MODULE, ValaGDBusClientModuleClass))

227

228

typedef struct _ValaGDBusClientModule ValaGDBusClientModule;

229

typedef struct _ValaGDBusClientModuleClass ValaGDBusClientModuleClass;

230

typedef struct _ValaGDBusClientModulePrivate ValaGDBusClientModulePrivate;

231

232

#define VALA_TYPE_GD_BUS_SERVER_MODULE (vala_gd_bus_server_module_get_type ())

233

#define VALA_GD_BUS_SERVER_MODULE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_GD_BUS_SERVER_MODULE, ValaGDBusServerModule))

234

#define VALA_GD_BUS_SERVER_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_GD_BUS_SERVER_MODULE, ValaGDBusServerModuleClass))

235

#define VALA_IS_GD_BUS_SERVER_MODULE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_GD_BUS_SERVER_MODULE))

236

#define VALA_IS_GD_BUS_SERVER_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_GD_BUS_SERVER_MODULE))

237

#define VALA_GD_BUS_SERVER_MODULE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_GD_BUS_SERVER_MODULE, ValaGDBusServerModuleClass))

238

239

typedef struct _ValaGDBusServerModule ValaGDBusServerModule;

240

typedef struct _ValaGDBusServerModuleClass ValaGDBusServerModuleClass;

241

typedef struct _ValaGDBusServerModulePrivate ValaGDBusServerModulePrivate;

242

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

243

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

244

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

245

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

246

#define _vala_map_unref0(var) ((var == NULL) ? NULL : (var = (vala_map_unref (var), NULL)))

247

248

struct _ValaCCodeBaseModule {

249

ValaCodeGenerator parent_instance;

250

ValaCCodeBaseModulePrivate * priv;

251

ValaSymbol* root_symbol;

252

ValaCCodeBaseModuleEmitContext* emit_context;

253

ValaCCodeLineDirective* current_line;

254

ValaCCodeFile* header_file;

255

ValaCCodeFile* internal_header_file;

256

ValaCCodeFile* cfile;

257

ValaCCodeBaseModuleEmitContext* class_init_context;

258

ValaCCodeBaseModuleEmitContext* base_init_context;

259

ValaCCodeBaseModuleEmitContext* class_finalize_context;

260

ValaCCodeBaseModuleEmitContext* base_finalize_context;

261

ValaCCodeBaseModuleEmitContext* instance_init_context;

262

ValaCCodeBaseModuleEmitContext* instance_finalize_context;

263

ValaCCodeStruct* param_spec_struct;

264

ValaCCodeStruct* closure_struct;

265

ValaCCodeEnum* prop_enum;

266

ValaSet* user_marshal_set;

267

ValaSet* predefined_marshal_set;

268

gint next_regex_id;

269

gint next_coroutine_state;

270

ValaDataType* void_type;

271

ValaDataType* bool_type;

272

ValaDataType* char_type;

273

ValaDataType* uchar_type;

274

ValaDataType* unichar_type;

275

ValaDataType* short_type;

276

ValaDataType* ushort_type;

277

ValaDataType* int_type;

278

ValaDataType* uint_type;

279

ValaDataType* long_type;

280

ValaDataType* ulong_type;

281

ValaDataType* int8_type;

282

ValaDataType* uint8_type;

283

ValaDataType* int16_type;

284

ValaDataType* uint16_type;

285

ValaDataType* int32_type;

286

ValaDataType* uint32_type;

287

ValaDataType* int64_type;

288

ValaDataType* uint64_type;

289

ValaDataType* string_type;

290

ValaDataType* regex_type;

291

ValaDataType* float_type;

292

ValaDataType* double_type;

293

ValaTypeSymbol* gtype_type;

294

ValaTypeSymbol* gobject_type;

295

ValaErrorType* gerror_type;

296

ValaClass* glist_type;

297

ValaClass* gslist_type;

298

ValaClass* gnode_type;

299

ValaClass* gqueue_type;

300

ValaClass* gvaluearray_type;

301

ValaTypeSymbol* gstringbuilder_type;

302

ValaTypeSymbol* garray_type;

303

ValaTypeSymbol* gbytearray_type;

304

ValaTypeSymbol* gptrarray_type;

305

ValaTypeSymbol* gthreadpool_type;

306

ValaDataType* gdestroynotify_type;

307

ValaDataType* gquark_type;

308

ValaStruct* gvalue_type;

309

ValaClass* gvariant_type;

310

ValaStruct* mutex_type;

311

ValaStruct* gmutex_type;

312

ValaStruct* grecmutex_type;

313

ValaStruct* grwlock_type;

314

ValaStruct* gcond_type;

315

ValaClass* gsource_type;

316

ValaTypeSymbol* type_module_type;

317

ValaTypeSymbol* dbus_proxy_type;

318

gboolean in_plugin;

319

gchar* module_init_param_name;

320

gboolean gvaluecollector_h_needed;

321

gboolean requires_assert;

322

gboolean requires_array_free;

323

gboolean requires_array_move;

324

gboolean requires_array_length;

325

gboolean requires_clear_mutex;

326

ValaSet* wrappers;

327

};

328

329

struct _ValaCCodeBaseModuleClass {

330

ValaCodeGeneratorClass parent_class;

331

void (*append_vala_array_free) (ValaCCodeBaseModule* self);

332

void (*append_vala_array_move) (ValaCCodeBaseModule* self);

333

void (*append_vala_array_length) (ValaCCodeBaseModule* self);

334

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

335

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

336

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

337

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

338

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

339

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

340

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

341

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

342

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

343

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

344

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

345

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

346

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

347

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

348

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

349

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

350

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

351

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

352

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

353

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

354

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

355

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

356

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

357

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

358

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

359

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

360

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

361

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

362

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

363

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

364

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

365

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

366

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

367

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

368

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

369

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

370

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

371

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

372

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

373

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

374

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

375

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

376

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

377

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

378

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

379

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

380

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

381

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

382

};

383

384

struct _ValaCCodeStructModule {

385

ValaCCodeBaseModule parent_instance;

386

ValaCCodeStructModulePrivate * priv;

387

};

388

389

struct _ValaCCodeStructModuleClass {

390

ValaCCodeBaseModuleClass parent_class;

391

};

392

393

struct _ValaCCodeMethodModule {

394

ValaCCodeStructModule parent_instance;

395

ValaCCodeMethodModulePrivate * priv;

396

};

397

398

struct _ValaCCodeMethodModuleClass {

399

ValaCCodeStructModuleClass parent_class;

400

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

401

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

402

};

403

404

struct _ValaCCodeControlFlowModule {

405

ValaCCodeMethodModule parent_instance;

406

ValaCCodeControlFlowModulePrivate * priv;

407

};

408

409

struct _ValaCCodeControlFlowModuleClass {

410

ValaCCodeMethodModuleClass parent_class;

411

};

412

413

struct _ValaCCodeMemberAccessModule {

414

ValaCCodeControlFlowModule parent_instance;

415

ValaCCodeMemberAccessModulePrivate * priv;

416

};

417

418

struct _ValaCCodeMemberAccessModuleClass {

419

ValaCCodeControlFlowModuleClass parent_class;

420

};

421

422

struct _ValaCCodeAssignmentModule {

423

ValaCCodeMemberAccessModule parent_instance;

424

ValaCCodeAssignmentModulePrivate * priv;

425

};

426

427

struct _ValaCCodeAssignmentModuleClass {

428

ValaCCodeMemberAccessModuleClass parent_class;

429

};

430

431

struct _ValaCCodeMethodCallModule {

432

ValaCCodeAssignmentModule parent_instance;

433

ValaCCodeMethodCallModulePrivate * priv;

434

};

435

436

struct _ValaCCodeMethodCallModuleClass {

437

ValaCCodeAssignmentModuleClass parent_class;

438

};

439

440

struct _ValaCCodeArrayModule {

441

ValaCCodeMethodCallModule parent_instance;

442

ValaCCodeArrayModulePrivate * priv;

443

};

444

445

struct _ValaCCodeArrayModuleClass {

446

ValaCCodeMethodCallModuleClass parent_class;

447

};

448

449

struct _ValaCCodeDelegateModule {

450

ValaCCodeArrayModule parent_instance;

451

ValaCCodeDelegateModulePrivate * priv;

452

};

453

454

struct _ValaCCodeDelegateModuleClass {

455

ValaCCodeArrayModuleClass parent_class;

456

};

457

458

struct _ValaGErrorModule {

459

ValaCCodeDelegateModule parent_instance;

460

ValaGErrorModulePrivate * priv;

461

};

462

463

struct _ValaGErrorModuleClass {

464

ValaCCodeDelegateModuleClass parent_class;

465

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

466

};

467

468

struct _ValaGTypeModule {

469

ValaGErrorModule parent_instance;

470

ValaGTypeModulePrivate * priv;

471

};

472

473

struct _ValaGTypeModuleClass {

474

ValaGErrorModuleClass parent_class;

475

void (*generate_virtual_method_declaration) (ValaGTypeModule* self, ValaMethod* m, ValaCCodeFile* decl_space, ValaCCodeStruct* type_struct);

476

void (*generate_class_init) (ValaGTypeModule* self, ValaClass* cl);

477

};

478

479

struct _ValaGObjectModule {

480

ValaGTypeModule parent_instance;

481

ValaGObjectModulePrivate * priv;

482

};

483

484

struct _ValaGObjectModuleClass {

485

ValaGTypeModuleClass parent_class;

486

};

487

488

struct _ValaGSignalModule {

489

ValaGObjectModule parent_instance;

490

ValaGSignalModulePrivate * priv;

491

};

492

493

struct _ValaGSignalModuleClass {

494

ValaGObjectModuleClass parent_class;

495

};

496

497

struct _ValaGAsyncModule {

498

ValaGSignalModule parent_instance;

499

ValaGAsyncModulePrivate * priv;

500

};

501

502

struct _ValaGAsyncModuleClass {

503

ValaGSignalModuleClass parent_class;

504

};

505

506

struct _ValaGVariantModule {

507

ValaGAsyncModule parent_instance;

508

ValaGVariantModulePrivate * priv;

509

};

510

511

struct _ValaGVariantModuleClass {

512

ValaGAsyncModuleClass parent_class;

513

};

514

515

struct _ValaGDBusModule {

516

ValaGVariantModule parent_instance;

517

ValaGDBusModulePrivate * priv;

518

};

519

520

struct _ValaGDBusModuleClass {

521

ValaGVariantModuleClass parent_class;

522

};

523

524

struct _ValaGDBusClientModule {

525

ValaGDBusModule parent_instance;

526

ValaGDBusClientModulePrivate * priv;

527

};

528

529

struct _ValaGDBusClientModuleClass {

530

ValaGDBusModuleClass parent_class;

531

};

532

533

struct _ValaGDBusServerModule {

534

ValaGDBusClientModule parent_instance;

535

ValaGDBusServerModulePrivate * priv;

536

};

537

538

struct _ValaGDBusServerModuleClass {

539

ValaGDBusClientModuleClass parent_class;

540

};

541

542

543

static gpointer vala_gd_bus_server_module_parent_class = NULL;

544

545

GType vala_ccode_base_module_get_type (void) G_GNUC_CONST;

546

gpointer vala_ccode_base_module_emit_context_ref (gpointer instance);

547

void vala_ccode_base_module_emit_context_unref (gpointer instance);

548

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

549

void vala_ccode_base_module_value_set_emit_context (GValue* value, gpointer v_object);

550

void vala_ccode_base_module_value_take_emit_context (GValue* value, gpointer v_object);

551

gpointer vala_ccode_base_module_value_get_emit_context (const GValue* value);

552

GType vala_ccode_base_module_emit_context_get_type (void) G_GNUC_CONST;

553

GType vala_ccode_struct_module_get_type (void) G_GNUC_CONST;

554

GType vala_ccode_method_module_get_type (void) G_GNUC_CONST;

555

GType vala_ccode_control_flow_module_get_type (void) G_GNUC_CONST;

556

GType vala_ccode_member_access_module_get_type (void) G_GNUC_CONST;

557

GType vala_ccode_assignment_module_get_type (void) G_GNUC_CONST;

558

GType vala_ccode_method_call_module_get_type (void) G_GNUC_CONST;

559

GType vala_ccode_array_module_get_type (void) G_GNUC_CONST;

560

GType vala_ccode_delegate_module_get_type (void) G_GNUC_CONST;

561

GType vala_gerror_module_get_type (void) G_GNUC_CONST;

562

GType vala_gtype_module_get_type (void) G_GNUC_CONST;

563

GType vala_gobject_module_get_type (void) G_GNUC_CONST;

564

GType vala_gsignal_module_get_type (void) G_GNUC_CONST;

565

GType vala_gasync_module_get_type (void) G_GNUC_CONST;

566

GType vala_gvariant_module_get_type (void) G_GNUC_CONST;

567

GType vala_gd_bus_module_get_type (void) G_GNUC_CONST;

568

GType vala_gd_bus_client_module_get_type (void) G_GNUC_CONST;

569

GType vala_gd_bus_server_module_get_type (void) G_GNUC_CONST;

570

enum {

571

VALA_GD_BUS_SERVER_MODULE_DUMMY_PROPERTY

572

};

573

gboolean vala_gd_bus_server_module_is_dbus_visible (ValaCodeNode* node);

574

gchar* vala_gd_bus_server_module_dbus_result_name (ValaMethod* m);

575

static gchar* vala_gd_bus_server_module_generate_dbus_wrapper (ValaGDBusServerModule* self, ValaMethod* m, ValaObjectTypeSymbol* sym, gboolean ready);

576

gchar* vala_ccode_base_module_get_ccode_name (ValaCodeNode* node);

577

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

578

ValaCCodeFunction* vala_ccode_base_module_get_ccode (ValaCCodeBaseModule* self);

579

gboolean vala_gd_bus_module_is_dbus_no_reply (ValaMethod* m);

580

gboolean vala_gd_bus_module_dbus_method_uses_file_descriptor (ValaGDBusModule* self, ValaMethod* method);

581

gchar* vala_ccode_base_module_get_ccode_finish_name (ValaMethod* m);

582

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

583

ValaCCodeExpression* vala_ccode_base_module_default_value_for_type (ValaCCodeBaseModule* self, ValaDataType* type, gboolean initializer_expression);

584

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

585

void vala_gd_bus_module_receive_dbus_value (ValaGDBusModule* self, ValaDataType* type, ValaCCodeExpression* message_expr, ValaCCodeExpression* iter_expr, ValaCCodeExpression* target_expr, ValaSymbol* sym, ValaCCodeExpression* error_expr, gboolean* may_fail);

586

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

587

void vala_gd_bus_module_send_dbus_value (ValaGDBusModule* self, ValaDataType* type, ValaCCodeExpression* builder_expr, ValaCCodeExpression* expr, ValaSymbol* sym);

588

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

589

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

590

void vala_ccode_base_module_pop_function (ValaCCodeBaseModule* self);

591

static gchar* vala_gd_bus_server_module_generate_dbus_signal_wrapper (ValaGDBusServerModule* self, ValaSignal* sig, ValaObjectTypeSymbol* sym, const gchar* dbus_iface_name);

592

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

593

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

594

void vala_gvariant_module_write_expression (ValaGVariantModule* self, ValaDataType* type, ValaCCodeExpression* builder_expr, ValaCCodeExpression* expr, ValaSymbol* sym);

595

gchar* vala_gd_bus_module_get_dbus_name_for_member (ValaSymbol* symbol);

596

static gchar* vala_gd_bus_server_module_generate_dbus_property_get_wrapper (ValaGDBusServerModule* self, ValaProperty* prop, ValaObjectTypeSymbol* sym);

597

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

598

static gchar* vala_gd_bus_server_module_generate_dbus_property_set_wrapper (ValaGDBusServerModule* self, ValaProperty* prop, ValaObjectTypeSymbol* sym);

599

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

600

static void vala_gd_bus_server_module_handle_signals (ValaGDBusServerModule* self, ValaObjectTypeSymbol* sym, gboolean connect);

601

gchar* vala_gd_bus_module_get_dbus_name (ValaTypeSymbol* symbol);

602

ValaCCodeConstant* vala_ccode_base_module_get_signal_canonical_constant (ValaCCodeBaseModule* self, ValaSignal* sig, const gchar* detail);

603

static void vala_gd_bus_server_module_generate_interface_method_call_function (ValaGDBusServerModule* self, ValaObjectTypeSymbol* sym);

604

gchar* vala_ccode_base_module_get_ccode_lower_case_prefix (ValaSymbol* sym);

605

static void vala_gd_bus_server_module_generate_interface_get_property_function (ValaGDBusServerModule* self, ValaObjectTypeSymbol* sym);

606

static void vala_gd_bus_server_module_generate_interface_set_property_function (ValaGDBusServerModule* self, ValaObjectTypeSymbol* sym);

607

static ValaCCodeExpression* vala_gd_bus_server_module_get_method_info (ValaGDBusServerModule* self, ValaObjectTypeSymbol* sym);

608

gchar* vala_gvariant_module_get_type_signature (ValaDataType* datatype, ValaSymbol* symbol);

609

static ValaCCodeExpression* vala_gd_bus_server_module_get_signal_info (ValaGDBusServerModule* self, ValaObjectTypeSymbol* sym);

610

static ValaCCodeExpression* vala_gd_bus_server_module_get_property_info (ValaGDBusServerModule* self, ValaObjectTypeSymbol* sym);

611

static ValaCCodeExpression* vala_gd_bus_server_module_get_interface_info (ValaGDBusServerModule* self, ValaObjectTypeSymbol* sym);

612

static ValaCCodeExpression* vala_gd_bus_server_module_get_interface_vtable (ValaGDBusServerModule* self, ValaObjectTypeSymbol* sym);

613

static gchar* vala_gd_bus_server_module_generate_register_object_function (ValaGDBusServerModule* self);

614

gboolean vala_ccode_base_module_add_wrapper (ValaCCodeBaseModule* self, const gchar* wrapper_name);

615

static void vala_gd_bus_server_module_real_visit_method_call (ValaCodeVisitor* base, ValaMethodCall* expr);

616

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

617

void vala_ccode_base_module_set_current_method_inner_error (ValaCCodeBaseModule* self, gboolean value);

618

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

619

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

620

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

621

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

622

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

623

static void vala_gd_bus_server_module_real_generate_class_declaration (ValaCCodeBaseModule* base, ValaClass* cl, ValaCCodeFile* decl_space);

624

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

625

static void vala_gd_bus_server_module_generate_object_type_symbol_declaration (ValaGDBusServerModule* self, ValaObjectTypeSymbol* sym, ValaCCodeFile* decl_space);

626

static void vala_gd_bus_server_module_real_generate_interface_declaration (ValaCCodeBaseModule* base, ValaInterface* iface, ValaCCodeFile* decl_space);

627

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

628

static void vala_gd_bus_server_module_real_visit_class (ValaCodeVisitor* base, ValaClass* cl);

629

static void vala_gd_bus_server_module_visit_object_type_symbol (ValaGDBusServerModule* self, ValaObjectTypeSymbol* sym);

630

static void vala_gd_bus_server_module_real_visit_interface (ValaCodeVisitor* base, ValaInterface* iface);

631

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

632

gchar* vala_ccode_base_module_get_ccode_ref_function (ValaTypeSymbol* sym);

633

gchar* vala_ccode_base_module_get_ccode_unref_function (ValaObjectTypeSymbol* sym);

634

static void vala_gd_bus_server_module_real_register_dbus_info (ValaCCodeBaseModule* base, ValaCCodeBlock* block, ValaObjectTypeSymbol* sym);

635

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

636

ValaGDBusServerModule* vala_gd_bus_server_module_new (void);

637

ValaGDBusServerModule* vala_gd_bus_server_module_construct (GType object_type);

638

ValaGDBusClientModule* vala_gd_bus_client_module_new (void);

639

ValaGDBusClientModule* vala_gd_bus_client_module_construct (GType object_type);

640

641

642

gboolean vala_gd_bus_server_module_is_dbus_visible (ValaCodeNode* node) {

643

gboolean result = FALSE;

644

ValaCodeNode* _tmp0_;

645

ValaAttribute* _tmp1_ = NULL;

646

ValaAttribute* dbus_attribute;

647

gboolean _tmp2_ = FALSE;

648

gboolean _tmp3_ = FALSE;

649

ValaAttribute* _tmp4_;

650

gboolean _tmp7_;

651

gboolean _tmp10_;

652

g_return_val_if_fail (node != NULL, FALSE);

653

_tmp0_ = node;

654

_tmp1_ = vala_code_node_get_attribute (_tmp0_, "DBus");

655

dbus_attribute = _tmp1_;

656

_tmp4_ = dbus_attribute;

657

if (_tmp4_ != NULL) {

658

ValaAttribute* _tmp5_;

659

gboolean _tmp6_ = FALSE;

660

_tmp5_ = dbus_attribute;

661

_tmp6_ = vala_attribute_has_argument (_tmp5_, "visible");

662

_tmp3_ = _tmp6_;

663

} else {

664

_tmp3_ = FALSE;

665

}

666

_tmp7_ = _tmp3_;

667

if (_tmp7_) {

668

ValaAttribute* _tmp8_;

669

gboolean _tmp9_ = FALSE;

670

_tmp8_ = dbus_attribute;

671

_tmp9_ = vala_attribute_get_bool (_tmp8_, "visible", FALSE);

672

_tmp2_ = !_tmp9_;

673

} else {

674

_tmp2_ = FALSE;

675

}

676

_tmp10_ = _tmp2_;

677

if (_tmp10_) {

678

result = FALSE;

679

_vala_code_node_unref0 (dbus_attribute);

680

return result;

681

}

682

result = TRUE;

683

_vala_code_node_unref0 (dbus_attribute);

684

return result;

685

}

686

687

688

gchar* vala_gd_bus_server_module_dbus_result_name (ValaMethod* m) {

689

gchar* result = NULL;

690

ValaMethod* _tmp0_;

691

gchar* _tmp1_ = NULL;

692

gchar* dbus_name;

693

gboolean _tmp2_ = FALSE;

694

const gchar* _tmp3_;

695

gboolean _tmp5_;

696

gchar* _tmp6_;

697

g_return_val_if_fail (m != NULL, NULL);

698

_tmp0_ = m;

699

_tmp1_ = vala_code_node_get_attribute_string ((ValaCodeNode*) _tmp0_, "DBus", "result");

700

dbus_name = _tmp1_;

701

_tmp3_ = dbus_name;

702

if (_tmp3_ != NULL) {

703

const gchar* _tmp4_;

704

_tmp4_ = dbus_name;

705

_tmp2_ = g_strcmp0 (_tmp4_, "") != 0;

706

} else {

707

_tmp2_ = FALSE;

708

}

709

_tmp5_ = _tmp2_;

710

if (_tmp5_) {

711

result = dbus_name;

712

return result;

713

}

714

_tmp6_ = g_strdup ("result");

715

result = _tmp6_;

716

_g_free0 (dbus_name);

717

return result;

718

}

719

720

721

static gpointer _vala_code_node_ref0 (gpointer self) {

722

return self ? vala_code_node_ref (self) : NULL;

723

}

724

725

726

static gchar* vala_gd_bus_server_module_generate_dbus_wrapper (ValaGDBusServerModule* self, ValaMethod* m, ValaObjectTypeSymbol* sym, gboolean ready) {

727

gchar* result = NULL;

728

ValaMethod* _tmp0_;

729

gchar* _tmp1_ = NULL;

730

gchar* _tmp2_;

731

gchar* _tmp3_ = NULL;

732

gchar* _tmp4_;

733

gchar* wrapper_name;

734

ValaMethod* _tmp5_;

735

ValaMethod* _tmp6_;

736

ValaMethod* _tmp7_;

737

gboolean _tmp17_;

738

const gchar* _tmp20_;

739

ValaCCodeFunction* _tmp21_;

740

ValaCCodeFunction* function;

741

ValaCCodeFunction* _tmp22_;

742

gboolean _tmp23_;

743

ValaCCodeFunction* _tmp47_;

744

gboolean _tmp48_;

745

ValaCCodeIdentifier* _tmp55_;

746

ValaCCodeIdentifier* _tmp56_;

747

ValaCCodeFunctionCall* _tmp57_;

748

ValaCCodeFunctionCall* _tmp58_;

749

ValaCCodeFunctionCall* connection;

750

ValaCCodeFunctionCall* _tmp59_;

751

ValaCCodeIdentifier* _tmp60_;

752

ValaCCodeIdentifier* _tmp61_;

753

ValaMethod* _tmp62_;

754

gboolean _tmp63_ = FALSE;

755

gboolean no_reply;

756

ValaMethod* _tmp64_;

757

gboolean _tmp65_ = FALSE;

758

gboolean uses_fd;

759

gboolean _tmp66_;

760

gboolean uses_error;

761

gboolean _tmp68_ = FALSE;

762

ValaMethod* _tmp69_;

763

gboolean _tmp70_;

764

gboolean _tmp71_;

765

gboolean _tmp73_;

766

gboolean _tmp80_;

767

ValaCCodeFunctionCall* ccall = NULL;

768

gboolean _tmp100_;

769

gboolean _tmp129_;

770

gboolean _tmp410_ = FALSE;

771

ValaMethod* _tmp411_;

772

gboolean _tmp412_;

773

gboolean _tmp413_;

774

gboolean _tmp415_;

775

gboolean _tmp448_ = FALSE;

776

ValaMethod* _tmp449_;

777

gboolean _tmp450_;

778

gboolean _tmp451_;

779

gboolean _tmp453_;

780

gboolean _tmp465_ = FALSE;

781

ValaMethod* _tmp466_;

782

gboolean _tmp467_;

783

gboolean _tmp468_;

784

gboolean _tmp470_;

785

gboolean _tmp482_ = FALSE;

786

gboolean _tmp483_;

787

gboolean _tmp490_;

788

gboolean _tmp881_ = FALSE;

789

gboolean _tmp882_;

790

gboolean _tmp889_;

791

ValaCCodeFile* _tmp930_;

792

ValaCCodeFunction* _tmp931_;

793

ValaCCodeFile* _tmp932_;

794

ValaCCodeFunction* _tmp933_;

795

gboolean _tmp934_ = FALSE;

796

ValaMethod* _tmp935_;

797

gboolean _tmp936_;

798

gboolean _tmp937_;

799

gboolean _tmp939_;

800

g_return_val_if_fail (self != NULL, NULL);

801

g_return_val_if_fail (m != NULL, NULL);

802

g_return_val_if_fail (sym != NULL, NULL);

803

_tmp0_ = m;

804

_tmp1_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp0_);

805

_tmp2_ = _tmp1_;

806

_tmp3_ = g_strdup_printf ("_dbus_%s", _tmp2_);

807

_tmp4_ = _tmp3_;

808

_g_free0 (_tmp2_);

809

wrapper_name = _tmp4_;

810

_tmp5_ = m;

811

_tmp6_ = vala_method_get_base_method (_tmp5_);

812

_tmp7_ = _tmp6_;

813

if (_tmp7_ != NULL) {

814

ValaMethod* _tmp8_;

815

ValaMethod* _tmp9_;

816

ValaMethod* _tmp10_;

817

_tmp8_ = m;

818

_tmp9_ = vala_method_get_base_method (_tmp8_);

819

_tmp10_ = _tmp9_;

820

m = _tmp10_;

821

} else {

822

ValaMethod* _tmp11_;

823

ValaMethod* _tmp12_;

824

ValaMethod* _tmp13_;

825

_tmp11_ = m;

826

_tmp12_ = vala_method_get_base_interface_method (_tmp11_);

827

_tmp13_ = _tmp12_;

828

if (_tmp13_ != NULL) {

829

ValaMethod* _tmp14_;

830

ValaMethod* _tmp15_;

831

ValaMethod* _tmp16_;

832

_tmp14_ = m;

833

_tmp15_ = vala_method_get_base_interface_method (_tmp14_);

834

_tmp16_ = _tmp15_;

835

m = _tmp16_;

836

}

837

}

838

_tmp17_ = ready;

839

if (_tmp17_) {

840

const gchar* _tmp18_;

841

gchar* _tmp19_;

842

_tmp18_ = wrapper_name;

843

_tmp19_ = g_strconcat (_tmp18_, "_ready", NULL);

844

_g_free0 (wrapper_name);

845

wrapper_name = _tmp19_;

846

}

847

_tmp20_ = wrapper_name;

848

_tmp21_ = vala_ccode_function_new (_tmp20_, "void");

849

function = _tmp21_;

850

_tmp22_ = function;

851

vala_ccode_function_set_modifiers (_tmp22_, VALA_CCODE_MODIFIERS_STATIC);

852

_tmp23_ = ready;

853

if (!_tmp23_) {

854

ValaCCodeFunction* _tmp24_;

855

ValaObjectTypeSymbol* _tmp25_;

856

gchar* _tmp26_ = NULL;

857

gchar* _tmp27_;

858

gchar* _tmp28_;

859

gchar* _tmp29_;

860

ValaCCodeParameter* _tmp30_;

861

ValaCCodeParameter* _tmp31_;

862

ValaCCodeFunction* _tmp32_;

863

ValaCCodeParameter* _tmp33_;

864

ValaCCodeParameter* _tmp34_;

865

ValaCCodeFunction* _tmp35_;

866

ValaCCodeParameter* _tmp36_;

867

ValaCCodeParameter* _tmp37_;

868

_tmp24_ = function;

869

_tmp25_ = sym;

870

_tmp26_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp25_);

871

_tmp27_ = _tmp26_;

872

_tmp28_ = g_strconcat (_tmp27_, "*", NULL);

873

_tmp29_ = _tmp28_;

874

_tmp30_ = vala_ccode_parameter_new ("self", _tmp29_);

875

_tmp31_ = _tmp30_;

876

vala_ccode_function_add_parameter (_tmp24_, _tmp31_);

877

_vala_ccode_node_unref0 (_tmp31_);

878

_g_free0 (_tmp29_);

879

_g_free0 (_tmp27_);

880

_tmp32_ = function;

881

_tmp33_ = vala_ccode_parameter_new ("parameters", "GVariant*");

882

_tmp34_ = _tmp33_;

883

vala_ccode_function_add_parameter (_tmp32_, _tmp34_);

884

_vala_ccode_node_unref0 (_tmp34_);

885

_tmp35_ = function;

886

_tmp36_ = vala_ccode_parameter_new ("invocation", "GDBusMethodInvocation*");

887

_tmp37_ = _tmp36_;

888

vala_ccode_function_add_parameter (_tmp35_, _tmp37_);

889

_vala_ccode_node_unref0 (_tmp37_);

890

} else {

891

ValaCCodeFunction* _tmp38_;

892

ValaCCodeParameter* _tmp39_;

893

ValaCCodeParameter* _tmp40_;

894

ValaCCodeFunction* _tmp41_;

895

ValaCCodeParameter* _tmp42_;

896

ValaCCodeParameter* _tmp43_;

897

ValaCCodeFunction* _tmp44_;

898

ValaCCodeParameter* _tmp45_;

899

ValaCCodeParameter* _tmp46_;

900

_tmp38_ = function;

901

_tmp39_ = vala_ccode_parameter_new ("source_object", "GObject *");

902

_tmp40_ = _tmp39_;

903

vala_ccode_function_add_parameter (_tmp38_, _tmp40_);

904

_vala_ccode_node_unref0 (_tmp40_);

905

_tmp41_ = function;

906

_tmp42_ = vala_ccode_parameter_new ("_res_", "GAsyncResult *");

907

_tmp43_ = _tmp42_;

908

vala_ccode_function_add_parameter (_tmp41_, _tmp43_);

909

_vala_ccode_node_unref0 (_tmp43_);

910

_tmp44_ = function;

911

_tmp45_ = vala_ccode_parameter_new ("_user_data_", "gpointer");

912

_tmp46_ = _tmp45_;

913

vala_ccode_function_add_parameter (_tmp44_, _tmp46_);

914

_vala_ccode_node_unref0 (_tmp46_);

915

}

916

_tmp47_ = function;

917

vala_ccode_base_module_push_function ((ValaCCodeBaseModule*) self, _tmp47_);

918

_tmp48_ = ready;

919

if (_tmp48_) {

920

ValaCCodeFunction* _tmp49_;

921

ValaCCodeFunction* _tmp50_;

922

ValaCCodeIdentifier* _tmp51_;

923

ValaCCodeIdentifier* _tmp52_;

924

ValaCCodeVariableDeclarator* _tmp53_;

925

ValaCCodeVariableDeclarator* _tmp54_;

926

_tmp49_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

927

_tmp50_ = _tmp49_;

928

_tmp51_ = vala_ccode_identifier_new ("_user_data_");

929

_tmp52_ = _tmp51_;

930

_tmp53_ = vala_ccode_variable_declarator_new ("invocation", (ValaCCodeExpression*) _tmp52_, NULL);

931

_tmp54_ = _tmp53_;

932

vala_ccode_function_add_declaration (_tmp50_, "GDBusMethodInvocation *", (ValaCCodeDeclarator*) _tmp54_, 0);

933

_vala_ccode_node_unref0 (_tmp54_);

934

_vala_ccode_node_unref0 (_tmp52_);

935

}

936

_tmp55_ = vala_ccode_identifier_new ("g_dbus_method_invocation_get_connection");

937

_tmp56_ = _tmp55_;

938

_tmp57_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp56_);

939

_tmp58_ = _tmp57_;

940

_vala_ccode_node_unref0 (_tmp56_);

941

connection = _tmp58_;

942

_tmp59_ = connection;

943

_tmp60_ = vala_ccode_identifier_new ("invocation");

944

_tmp61_ = _tmp60_;

945

vala_ccode_function_call_add_argument (_tmp59_, (ValaCCodeExpression*) _tmp61_);

946

_vala_ccode_node_unref0 (_tmp61_);

947

_tmp62_ = m;

948

_tmp63_ = vala_gd_bus_module_is_dbus_no_reply (_tmp62_);

949

no_reply = _tmp63_;

950

_tmp64_ = m;

951

_tmp65_ = vala_gd_bus_module_dbus_method_uses_file_descriptor ((ValaGDBusModule*) self, _tmp64_);

952

uses_fd = _tmp65_;

953

_tmp66_ = uses_fd;

954

if (_tmp66_) {

955

ValaCCodeFile* _tmp67_;

956

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

957

vala_ccode_file_add_include (_tmp67_, "gio/gunixfdlist.h", FALSE);

958

}

959

uses_error = FALSE;

960

_tmp69_ = m;

961

_tmp70_ = vala_method_get_coroutine (_tmp69_);

962

_tmp71_ = _tmp70_;

963

if (!_tmp71_) {

964

_tmp68_ = TRUE;

965

} else {

966

gboolean _tmp72_;

967

_tmp72_ = ready;

968

_tmp68_ = _tmp72_;

969

}

970

_tmp73_ = _tmp68_;

971

if (_tmp73_) {

972

ValaCCodeFunction* _tmp74_;

973

ValaCCodeFunction* _tmp75_;

974

ValaCCodeConstant* _tmp76_;

975

ValaCCodeConstant* _tmp77_;

976

ValaCCodeVariableDeclarator* _tmp78_;

977

ValaCCodeVariableDeclarator* _tmp79_;

978

_tmp74_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

979

_tmp75_ = _tmp74_;

980

_tmp76_ = vala_ccode_constant_new ("NULL");

981

_tmp77_ = _tmp76_;

982

_tmp78_ = vala_ccode_variable_declarator_new_zero ("error", (ValaCCodeExpression*) _tmp77_, NULL);

983

_tmp79_ = _tmp78_;

984

vala_ccode_function_add_declaration (_tmp75_, "GError*", (ValaCCodeDeclarator*) _tmp79_, 0);

985

_vala_ccode_node_unref0 (_tmp79_);

986

_vala_ccode_node_unref0 (_tmp77_);

987

uses_error = TRUE;

988

}

989

_tmp80_ = ready;

990

if (!_tmp80_) {

991

ValaCCodeFunction* _tmp81_;

992

ValaCCodeFunction* _tmp82_;

993

ValaCCodeVariableDeclarator* _tmp83_;

994

ValaCCodeVariableDeclarator* _tmp84_;

995

ValaCCodeIdentifier* _tmp85_;

996

ValaCCodeIdentifier* _tmp86_;

997

ValaCCodeFunctionCall* _tmp87_;

998

ValaCCodeFunctionCall* _tmp88_;

999

ValaCCodeFunctionCall* iter_init;

1000

ValaCCodeFunctionCall* _tmp89_;

1001

ValaCCodeIdentifier* _tmp90_;

1002

ValaCCodeIdentifier* _tmp91_;

1003

ValaCCodeUnaryExpression* _tmp92_;

1004

ValaCCodeUnaryExpression* _tmp93_;

1005

ValaCCodeFunctionCall* _tmp94_;

1006

ValaCCodeIdentifier* _tmp95_;

1007

ValaCCodeIdentifier* _tmp96_;

1008

ValaCCodeFunction* _tmp97_;

1009

ValaCCodeFunction* _tmp98_;

1010

ValaCCodeFunctionCall* _tmp99_;

1011

_tmp81_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

1012

_tmp82_ = _tmp81_;

1013

_tmp83_ = vala_ccode_variable_declarator_new ("_arguments_iter", NULL, NULL);

1014

_tmp84_ = _tmp83_;

1015

vala_ccode_function_add_declaration (_tmp82_, "GVariantIter", (ValaCCodeDeclarator*) _tmp84_, 0);

1016

_vala_ccode_node_unref0 (_tmp84_);

1017

_tmp85_ = vala_ccode_identifier_new ("g_variant_iter_init");

1018

_tmp86_ = _tmp85_;

1019

_tmp87_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp86_);

1020

_tmp88_ = _tmp87_;

1021

_vala_ccode_node_unref0 (_tmp86_);

1022

iter_init = _tmp88_;

1023

_tmp89_ = iter_init;

1024

_tmp90_ = vala_ccode_identifier_new ("_arguments_iter");

1025

_tmp91_ = _tmp90_;

1026

_tmp92_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, (ValaCCodeExpression*) _tmp91_);

1027

_tmp93_ = _tmp92_;

1028

vala_ccode_function_call_add_argument (_tmp89_, (ValaCCodeExpression*) _tmp93_);

1029

_vala_ccode_node_unref0 (_tmp93_);

1030

_vala_ccode_node_unref0 (_tmp91_);

1031

_tmp94_ = iter_init;

1032

_tmp95_ = vala_ccode_identifier_new ("parameters");

1033

_tmp96_ = _tmp95_;

1034

vala_ccode_function_call_add_argument (_tmp94_, (ValaCCodeExpression*) _tmp96_);

1035

_vala_ccode_node_unref0 (_tmp96_);

1036

_tmp97_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

1037

_tmp98_ = _tmp97_;

1038

_tmp99_ = iter_init;

1039

vala_ccode_function_add_expression (_tmp98_, (ValaCCodeExpression*) _tmp99_);

1040

_vala_ccode_node_unref0 (iter_init);

1041

}

1042

_tmp100_ = ready;

1043

if (!_tmp100_) {

1044

ValaMethod* _tmp101_;

1045

gchar* _tmp102_ = NULL;

1046

gchar* _tmp103_;

1047

ValaCCodeIdentifier* _tmp104_;

1048

ValaCCodeIdentifier* _tmp105_;

1049

ValaCCodeFunctionCall* _tmp106_;

1050

ValaCCodeFunctionCall* _tmp107_;

1051

ValaCCodeIdentifier* _tmp108_;

1052

ValaCCodeIdentifier* _tmp109_;

1053

_tmp101_ = m;

1054

_tmp102_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp101_);

1055

_tmp103_ = _tmp102_;

1056

_tmp104_ = vala_ccode_identifier_new (_tmp103_);

1057

_tmp105_ = _tmp104_;

1058

_tmp106_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp105_);

1059

_vala_ccode_node_unref0 (ccall);

1060

ccall = _tmp106_;

1061

_vala_ccode_node_unref0 (_tmp105_);

1062

_g_free0 (_tmp103_);

1063

_tmp107_ = ccall;

1064

_tmp108_ = vala_ccode_identifier_new ("self");

1065

_tmp109_ = _tmp108_;

1066

vala_ccode_function_call_add_argument (_tmp107_, (ValaCCodeExpression*) _tmp109_);

1067

_vala_ccode_node_unref0 (_tmp109_);

1068

} else {

1069

ValaMethod* _tmp110_;

1070

gchar* _tmp111_ = NULL;

1071

gchar* _tmp112_;

1072

ValaCCodeIdentifier* _tmp113_;

1073

ValaCCodeIdentifier* _tmp114_;

1074

ValaCCodeFunctionCall* _tmp115_;

1075

ValaCCodeFunctionCall* _tmp116_;

1076

ValaCCodeIdentifier* _tmp117_;

1077

ValaCCodeIdentifier* _tmp118_;

1078

ValaObjectTypeSymbol* _tmp119_;

1079

gchar* _tmp120_ = NULL;

1080

gchar* _tmp121_;

1081

gchar* _tmp122_;

1082

gchar* _tmp123_;

1083

ValaCCodeCastExpression* _tmp124_;

1084

ValaCCodeCastExpression* _tmp125_;

1085

ValaCCodeFunctionCall* _tmp126_;

1086

ValaCCodeIdentifier* _tmp127_;

1087

ValaCCodeIdentifier* _tmp128_;

1088

_tmp110_ = m;

1089

_tmp111_ = vala_ccode_base_module_get_ccode_finish_name (_tmp110_);

1090

_tmp112_ = _tmp111_;

1091

_tmp113_ = vala_ccode_identifier_new (_tmp112_);

1092

_tmp114_ = _tmp113_;

1093

_tmp115_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp114_);

1094

_vala_ccode_node_unref0 (ccall);

1095

ccall = _tmp115_;

1096

_vala_ccode_node_unref0 (_tmp114_);

1097

_g_free0 (_tmp112_);

1098

_tmp116_ = ccall;

1099

_tmp117_ = vala_ccode_identifier_new ("source_object");

1100

_tmp118_ = _tmp117_;

1101

_tmp119_ = sym;

1102

_tmp120_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp119_);

1103

_tmp121_ = _tmp120_;

1104

_tmp122_ = g_strconcat (_tmp121_, "*", NULL);

1105

_tmp123_ = _tmp122_;

1106

_tmp124_ = vala_ccode_cast_expression_new ((ValaCCodeExpression*) _tmp118_, _tmp123_);

1107

_tmp125_ = _tmp124_;

1108

vala_ccode_function_call_add_argument (_tmp116_, (ValaCCodeExpression*) _tmp125_);

1109

_vala_ccode_node_unref0 (_tmp125_);

1110

_g_free0 (_tmp123_);

1111

_g_free0 (_tmp121_);

1112

_vala_ccode_node_unref0 (_tmp118_);

1113

_tmp126_ = ccall;

1114

_tmp127_ = vala_ccode_identifier_new ("_res_");

1115

_tmp128_ = _tmp127_;

1116

vala_ccode_function_call_add_argument (_tmp126_, (ValaCCodeExpression*) _tmp128_);

1117

_vala_ccode_node_unref0 (_tmp128_);

1118

}

1119

_tmp129_ = ready;

1120

if (!_tmp129_) {

1121

gboolean _tmp130_;

1122

_tmp130_ = uses_fd;

1123

if (_tmp130_) {

1124

ValaCCodeFunction* _tmp131_;

1125

ValaCCodeFunction* _tmp132_;

1126

ValaCCodeConstant* _tmp133_;

1127

ValaCCodeConstant* _tmp134_;

1128

ValaCCodeVariableDeclarator* _tmp135_;

1129

ValaCCodeVariableDeclarator* _tmp136_;

1130

_tmp131_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

1131

_tmp132_ = _tmp131_;

1132

_tmp133_ = vala_ccode_constant_new ("0");

1133

_tmp134_ = _tmp133_;

1134

_tmp135_ = vala_ccode_variable_declarator_new_zero ("_fd_index", (ValaCCodeExpression*) _tmp134_, NULL);

1135

_tmp136_ = _tmp135_;

1136

vala_ccode_function_add_declaration (_tmp132_, "gint", (ValaCCodeDeclarator*) _tmp136_, 0);

1137

_vala_ccode_node_unref0 (_tmp136_);

1138

_vala_ccode_node_unref0 (_tmp134_);

1139

}

1140

{

1141

ValaMethod* _tmp137_;

1142

ValaList* _tmp138_ = NULL;

1143

ValaList* _param_list;

1144

ValaList* _tmp139_;

1145

gint _tmp140_;

1146

gint _tmp141_;

1147

gint _param_size;

1148

gint _param_index;

1149

_tmp137_ = m;

1150

_tmp138_ = vala_method_get_parameters (_tmp137_);

1151

_param_list = _tmp138_;

1152

_tmp139_ = _param_list;

1153

_tmp140_ = vala_collection_get_size ((ValaCollection*) _tmp139_);

1154

_tmp141_ = _tmp140_;

1155

_param_size = _tmp141_;

1156

_param_index = -1;

1157

while (TRUE) {

1158

gint _tmp142_;

1159

gint _tmp143_;

1160

gint _tmp144_;

1161

ValaList* _tmp145_;

1162

gint _tmp146_;

1163

gpointer _tmp147_ = NULL;

1164

ValaParameter* param;

1165

ValaParameter* _tmp148_;

1166

const gchar* _tmp149_;

1167

const gchar* _tmp150_;

1168

gchar* _tmp151_ = NULL;

1169

gchar* param_name;

1170

ValaParameter* _tmp152_;

1171

ValaParameterDirection _tmp153_;

1172

ValaParameterDirection _tmp154_;

1173

gboolean _tmp155_ = FALSE;

1174

ValaParameter* _tmp156_;

1175

ValaDataType* _tmp157_;

1176

ValaDataType* _tmp158_;

1177

gboolean _tmp166_;

1178

gboolean _tmp167_ = FALSE;

1179

ValaParameter* _tmp168_;

1180

ValaDataType* _tmp169_;

1181

ValaDataType* _tmp170_;

1182

gboolean _tmp178_;

1183

ValaParameter* _tmp179_;

1184

ValaDataType* _tmp180_;

1185

ValaDataType* _tmp181_;

1186

ValaDataType* _tmp182_ = NULL;

1187

ValaDataType* owned_type;

1188

ValaDataType* _tmp183_;

1189

ValaCCodeFunction* _tmp184_;

1190

ValaCCodeFunction* _tmp185_;

1191

ValaDataType* _tmp186_;

1192

gchar* _tmp187_ = NULL;

1193

gchar* _tmp188_;

1194

const gchar* _tmp189_;

1195

ValaParameter* _tmp190_;

1196

ValaDataType* _tmp191_;

1197

ValaDataType* _tmp192_;

1198

ValaCCodeExpression* _tmp193_ = NULL;

1199

ValaCCodeExpression* _tmp194_;

1200

ValaCCodeVariableDeclarator* _tmp195_;

1201

ValaCCodeVariableDeclarator* _tmp196_;

1202

ValaParameter* _tmp197_;

1203

ValaDataType* _tmp198_;

1204

ValaDataType* _tmp199_;

1205

ValaArrayType* _tmp200_;

1206

ValaArrayType* array_type;

1207

ValaArrayType* _tmp201_;

1208

ValaCCodeIdentifier* _tmp219_;

1209

ValaCCodeIdentifier* _tmp220_;

1210

ValaCCodeFunctionCall* _tmp221_;

1211

ValaCCodeFunctionCall* _tmp222_;

1212

ValaCCodeFunctionCall* message_expr;

1213

ValaCCodeFunctionCall* _tmp223_;

1214

ValaCCodeIdentifier* _tmp224_;

1215

ValaCCodeIdentifier* _tmp225_;

1216

gboolean may_fail = FALSE;

1217

ValaParameter* _tmp226_;

1218

ValaDataType* _tmp227_;

1219

ValaDataType* _tmp228_;

1220

ValaCCodeFunctionCall* _tmp229_;

1221

ValaCCodeIdentifier* _tmp230_;

1222

ValaCCodeIdentifier* _tmp231_;

1223

const gchar* _tmp232_;

1224

ValaCCodeIdentifier* _tmp233_;

1225

ValaCCodeIdentifier* _tmp234_;

1226

ValaParameter* _tmp235_;

1227

ValaCCodeIdentifier* _tmp236_;

1228

ValaCCodeIdentifier* _tmp237_;

1229

ValaCCodeUnaryExpression* _tmp238_;

1230

ValaCCodeUnaryExpression* _tmp239_;

1231

gboolean _tmp240_ = FALSE;

1232

gboolean _tmp241_;

1233

_tmp142_ = _param_index;

1234

_param_index = _tmp142_ + 1;

1235

_tmp143_ = _param_index;

1236

_tmp144_ = _param_size;

1237

if (!(_tmp143_ < _tmp144_)) {

1238

break;

1239

}

1240

_tmp145_ = _param_list;

1241

_tmp146_ = _param_index;

1242

_tmp147_ = vala_list_get (_tmp145_, _tmp146_);

1243

param = (ValaParameter*) _tmp147_;

1244

_tmp148_ = param;

1245

_tmp149_ = vala_symbol_get_name ((ValaSymbol*) _tmp148_);

1246

_tmp150_ = _tmp149_;

1247

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

1248

param_name = _tmp151_;

1249

_tmp152_ = param;

1250

_tmp153_ = vala_parameter_get_direction (_tmp152_);

1251

_tmp154_ = _tmp153_;

1252

if (_tmp154_ != VALA_PARAMETER_DIRECTION_IN) {

1253

_g_free0 (param_name);

1254

_vala_code_node_unref0 (param);

1255

continue;

1256

}

1257

_tmp156_ = param;

1258

_tmp157_ = vala_variable_get_variable_type ((ValaVariable*) _tmp156_);

1259

_tmp158_ = _tmp157_;

1260

if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp158_, VALA_TYPE_OBJECT_TYPE)) {

1261

ValaParameter* _tmp159_;

1262

ValaDataType* _tmp160_;

1263

ValaDataType* _tmp161_;

1264

ValaTypeSymbol* _tmp162_;

1265

ValaTypeSymbol* _tmp163_;

1266

gchar* _tmp164_ = NULL;

1267

gchar* _tmp165_;

1268

_tmp159_ = param;

1269

_tmp160_ = vala_variable_get_variable_type ((ValaVariable*) _tmp159_);

1270

_tmp161_ = _tmp160_;

1271

_tmp162_ = vala_data_type_get_data_type (_tmp161_);

1272

_tmp163_ = _tmp162_;

1273

_tmp164_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp163_);

1274

_tmp165_ = _tmp164_;

1275

_tmp155_ = g_strcmp0 (_tmp165_, "GLib.Cancellable") == 0;

1276

_g_free0 (_tmp165_);

1277

} else {

1278

_tmp155_ = FALSE;

1279

}

1280

_tmp166_ = _tmp155_;

1281

if (_tmp166_) {

1282

_g_free0 (param_name);

1283

_vala_code_node_unref0 (param);

1284

continue;

1285

}

1286

_tmp168_ = param;

1287

_tmp169_ = vala_variable_get_variable_type ((ValaVariable*) _tmp168_);

1288

_tmp170_ = _tmp169_;

1289

if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp170_, VALA_TYPE_OBJECT_TYPE)) {

1290

ValaParameter* _tmp171_;

1291

ValaDataType* _tmp172_;

1292

ValaDataType* _tmp173_;

1293

ValaTypeSymbol* _tmp174_;

1294

ValaTypeSymbol* _tmp175_;

1295

gchar* _tmp176_ = NULL;

1296

gchar* _tmp177_;

1297

_tmp171_ = param;

1298

_tmp172_ = vala_variable_get_variable_type ((ValaVariable*) _tmp171_);

1299

_tmp173_ = _tmp172_;

1300

_tmp174_ = vala_data_type_get_data_type (_tmp173_);

1301

_tmp175_ = _tmp174_;

1302

_tmp176_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp175_);

1303

_tmp177_ = _tmp176_;

1304

_tmp167_ = g_strcmp0 (_tmp177_, "GLib.BusName") == 0;

1305

_g_free0 (_tmp177_);

1306

} else {

1307

_tmp167_ = FALSE;

1308

}

1309

_tmp178_ = _tmp167_;

1310

if (_tmp178_) {

1311

_g_free0 (param_name);

1312

_vala_code_node_unref0 (param);

1313

continue;

1314

}

1315

_tmp179_ = param;

1316

_tmp180_ = vala_variable_get_variable_type ((ValaVariable*) _tmp179_);

1317

_tmp181_ = _tmp180_;

1318

_tmp182_ = vala_data_type_copy (_tmp181_);

1319

owned_type = _tmp182_;

1320

_tmp183_ = owned_type;

1321

vala_data_type_set_value_owned (_tmp183_, TRUE);

1322

_tmp184_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

1323

_tmp185_ = _tmp184_;

1324

_tmp186_ = owned_type;

1325

_tmp187_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp186_);

1326

_tmp188_ = _tmp187_;

1327

_tmp189_ = param_name;

1328

_tmp190_ = param;

1329

_tmp191_ = vala_variable_get_variable_type ((ValaVariable*) _tmp190_);

1330

_tmp192_ = _tmp191_;

1331

_tmp193_ = vala_ccode_base_module_default_value_for_type ((ValaCCodeBaseModule*) self, _tmp192_, TRUE);

1332

_tmp194_ = _tmp193_;

1333

_tmp195_ = vala_ccode_variable_declarator_new_zero (_tmp189_, _tmp194_, NULL);

1334

_tmp196_ = _tmp195_;

1335

vala_ccode_function_add_declaration (_tmp185_, _tmp188_, (ValaCCodeDeclarator*) _tmp196_, 0);

1336

_vala_ccode_node_unref0 (_tmp196_);

1337

_vala_ccode_node_unref0 (_tmp194_);

1338

_g_free0 (_tmp188_);

1339

_tmp197_ = param;

1340

_tmp198_ = vala_variable_get_variable_type ((ValaVariable*) _tmp197_);

1341

_tmp199_ = _tmp198_;

1342

_tmp200_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp199_, VALA_TYPE_ARRAY_TYPE) ? ((ValaArrayType*) _tmp199_) : NULL);

1343

array_type = _tmp200_;

1344

_tmp201_ = array_type;

1345

if (_tmp201_ != NULL) {

1346

{

1347

gint dim;

1348

dim = 1;

1349

{

1350

gboolean _tmp202_;

1351

_tmp202_ = TRUE;

1352

while (TRUE) {

1353

gboolean _tmp203_;

1354

gint _tmp205_;

1355

ValaArrayType* _tmp206_;

1356

gint _tmp207_;

1357

gint _tmp208_;

1358

ValaParameter* _tmp209_;

1359

gint _tmp210_;

1360

gchar* _tmp211_ = NULL;

1361

gchar* length_cname;

1362

ValaCCodeFunction* _tmp212_;

1363

ValaCCodeFunction* _tmp213_;

1364

const gchar* _tmp214_;

1365

ValaCCodeConstant* _tmp215_;

1366

ValaCCodeConstant* _tmp216_;

1367

ValaCCodeVariableDeclarator* _tmp217_;

1368

ValaCCodeVariableDeclarator* _tmp218_;

1369

_tmp203_ = _tmp202_;

1370

if (!_tmp203_) {

1371

gint _tmp204_;

1372

_tmp204_ = dim;

1373

dim = _tmp204_ + 1;

1374

}

1375

_tmp202_ = FALSE;

1376

_tmp205_ = dim;

1377

_tmp206_ = array_type;

1378

_tmp207_ = vala_array_type_get_rank (_tmp206_);

1379

_tmp208_ = _tmp207_;

1380

if (!(_tmp205_ <= _tmp208_)) {

1381

break;

1382

}

1383

_tmp209_ = param;

1384

_tmp210_ = dim;

1385

_tmp211_ = vala_ccode_base_module_get_parameter_array_length_cname ((ValaCCodeBaseModule*) self, _tmp209_, _tmp210_);

1386

length_cname = _tmp211_;

1387

_tmp212_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

1388

_tmp213_ = _tmp212_;

1389

_tmp214_ = length_cname;

1390

_tmp215_ = vala_ccode_constant_new ("0");

1391

_tmp216_ = _tmp215_;

1392

_tmp217_ = vala_ccode_variable_declarator_new_zero (_tmp214_, (ValaCCodeExpression*) _tmp216_, NULL);

1393

_tmp218_ = _tmp217_;

1394

vala_ccode_function_add_declaration (_tmp213_, "int", (ValaCCodeDeclarator*) _tmp218_, 0);

1395

_vala_ccode_node_unref0 (_tmp218_);

1396

_vala_ccode_node_unref0 (_tmp216_);

1397

_g_free0 (length_cname);

1398

}

1399

}

1400

}

1401

}

1402

_tmp219_ = vala_ccode_identifier_new ("g_dbus_method_invocation_get_message");

1403

_tmp220_ = _tmp219_;

1404

_tmp221_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp220_);

1405

_tmp222_ = _tmp221_;

1406

_vala_ccode_node_unref0 (_tmp220_);

1407

message_expr = _tmp222_;

1408

_tmp223_ = message_expr;

1409

_tmp224_ = vala_ccode_identifier_new ("invocation");

1410

_tmp225_ = _tmp224_;

1411

vala_ccode_function_call_add_argument (_tmp223_, (ValaCCodeExpression*) _tmp225_);

1412

_vala_ccode_node_unref0 (_tmp225_);

1413

_tmp226_ = param;

1414

_tmp227_ = vala_variable_get_variable_type ((ValaVariable*) _tmp226_);

1415

_tmp228_ = _tmp227_;

1416

_tmp229_ = message_expr;

1417

_tmp230_ = vala_ccode_identifier_new ("_arguments_iter");

1418

_tmp231_ = _tmp230_;

1419

_tmp232_ = param_name;

1420

_tmp233_ = vala_ccode_identifier_new (_tmp232_);

1421

_tmp234_ = _tmp233_;

1422

_tmp235_ = param;

1423

_tmp236_ = vala_ccode_identifier_new ("error");

1424

_tmp237_ = _tmp236_;

1425

_tmp238_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, (ValaCCodeExpression*) _tmp237_);

1426

_tmp239_ = _tmp238_;

1427

vala_gd_bus_module_receive_dbus_value ((ValaGDBusModule*) self, _tmp228_, (ValaCCodeExpression*) _tmp229_, (ValaCCodeExpression*) _tmp231_, (ValaCCodeExpression*) _tmp234_, (ValaSymbol*) _tmp235_, (ValaCCodeExpression*) _tmp239_, &_tmp240_);

1428

may_fail = _tmp240_;

1429

_vala_ccode_node_unref0 (_tmp239_);

1430

_vala_ccode_node_unref0 (_tmp237_);

1431

_vala_ccode_node_unref0 (_tmp234_);

1432

_vala_ccode_node_unref0 (_tmp231_);

1433

_tmp241_ = may_fail;

1434

if (_tmp241_) {

1435

gboolean _tmp242_;

1436

ValaCCodeFunction* _tmp249_;

1437

ValaCCodeFunction* _tmp250_;

1438

ValaCCodeIdentifier* _tmp251_;

1439

ValaCCodeIdentifier* _tmp252_;

1440

ValaCCodeIdentifier* _tmp253_;

1441

ValaCCodeIdentifier* _tmp254_;

1442

ValaCCodeFunctionCall* _tmp255_;

1443

ValaCCodeFunctionCall* _tmp256_;

1444

ValaCCodeFunctionCall* return_error;

1445

ValaCCodeFunctionCall* _tmp257_;

1446

ValaCCodeIdentifier* _tmp258_;

1447

ValaCCodeIdentifier* _tmp259_;

1448

ValaCCodeFunctionCall* _tmp260_;

1449

ValaCCodeIdentifier* _tmp261_;

1450

ValaCCodeIdentifier* _tmp262_;

1451

ValaCCodeFunction* _tmp263_;

1452

ValaCCodeFunction* _tmp264_;

1453

ValaCCodeFunctionCall* _tmp265_;

1454

ValaCCodeFunction* _tmp266_;

1455

ValaCCodeFunction* _tmp267_;

1456

ValaCCodeFunction* _tmp268_;

1457

ValaCCodeFunction* _tmp269_;

1458

_tmp242_ = uses_error;

1459

if (!_tmp242_) {

1460

ValaCCodeFunction* _tmp243_;

1461

ValaCCodeFunction* _tmp244_;

1462

ValaCCodeConstant* _tmp245_;

1463

ValaCCodeConstant* _tmp246_;

1464

ValaCCodeVariableDeclarator* _tmp247_;

1465

ValaCCodeVariableDeclarator* _tmp248_;

1466

_tmp243_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

1467

_tmp244_ = _tmp243_;

1468

_tmp245_ = vala_ccode_constant_new ("NULL");

1469

_tmp246_ = _tmp245_;

1470

_tmp247_ = vala_ccode_variable_declarator_new_zero ("error", (ValaCCodeExpression*) _tmp246_, NULL);

1471

_tmp248_ = _tmp247_;

1472

vala_ccode_function_add_declaration (_tmp244_, "GError*", (ValaCCodeDeclarator*) _tmp248_, 0);

1473

_vala_ccode_node_unref0 (_tmp248_);

1474

_vala_ccode_node_unref0 (_tmp246_);

1475

uses_error = TRUE;

1476

}

1477

_tmp249_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

1478

_tmp250_ = _tmp249_;

1479

_tmp251_ = vala_ccode_identifier_new ("error");

1480

_tmp252_ = _tmp251_;

1481

vala_ccode_function_open_if (_tmp250_, (ValaCCodeExpression*) _tmp252_);

1482

_vala_ccode_node_unref0 (_tmp252_);

1483

_tmp253_ = vala_ccode_identifier_new ("g_dbus_method_invocation_return_gerror");

1484

_tmp254_ = _tmp253_;

1485

_tmp255_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp254_);

1486

_tmp256_ = _tmp255_;

1487

_vala_ccode_node_unref0 (_tmp254_);

1488

return_error = _tmp256_;

1489

_tmp257_ = return_error;

1490

_tmp258_ = vala_ccode_identifier_new ("invocation");

1491

_tmp259_ = _tmp258_;

1492

vala_ccode_function_call_add_argument (_tmp257_, (ValaCCodeExpression*) _tmp259_);

1493

_vala_ccode_node_unref0 (_tmp259_);

1494

_tmp260_ = return_error;

1495

_tmp261_ = vala_ccode_identifier_new ("error");

1496

_tmp262_ = _tmp261_;

1497

vala_ccode_function_call_add_argument (_tmp260_, (ValaCCodeExpression*) _tmp262_);

1498

_vala_ccode_node_unref0 (_tmp262_);

1499

_tmp263_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

1500

_tmp264_ = _tmp263_;

1501

_tmp265_ = return_error;

1502

vala_ccode_function_add_expression (_tmp264_, (ValaCCodeExpression*) _tmp265_);

1503

_tmp266_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

1504

_tmp267_ = _tmp266_;

1505

vala_ccode_function_add_return (_tmp267_, NULL);

1506

_tmp268_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

1507

_tmp269_ = _tmp268_;

1508

vala_ccode_function_close (_tmp269_);

1509

_vala_ccode_node_unref0 (return_error);

1510

}

1511

_vala_ccode_node_unref0 (message_expr);

1512

_vala_code_node_unref0 (array_type);

1513

_vala_code_node_unref0 (owned_type);

1514

_g_free0 (param_name);

1515

_vala_code_node_unref0 (param);

1516

}

1517

_vala_iterable_unref0 (_param_list);

1518

}

1519

}

1520

{

1521

ValaMethod* _tmp270_;

1522

ValaList* _tmp271_ = NULL;

1523

ValaList* _param_list;

1524

ValaList* _tmp272_;

1525

gint _tmp273_;

1526

gint _tmp274_;

1527

gint _param_size;

1528

gint _param_index;

1529

_tmp270_ = m;

1530

_tmp271_ = vala_method_get_parameters (_tmp270_);

1531

_param_list = _tmp271_;

1532

_tmp272_ = _param_list;

1533

_tmp273_ = vala_collection_get_size ((ValaCollection*) _tmp272_);

1534

_tmp274_ = _tmp273_;

1535

_param_size = _tmp274_;

1536

_param_index = -1;

1537

while (TRUE) {

1538

gint _tmp275_;

1539

gint _tmp276_;

1540

gint _tmp277_;

1541

ValaList* _tmp278_;

1542

gint _tmp279_;

1543

gpointer _tmp280_ = NULL;

1544

ValaParameter* param;

1545

ValaParameter* _tmp281_;

1546

const gchar* _tmp282_;

1547

const gchar* _tmp283_;

1548

gchar* _tmp284_ = NULL;

1549

gchar* param_name;

1550

gboolean _tmp285_ = FALSE;

1551

ValaParameter* _tmp286_;

1552

ValaParameterDirection _tmp287_;

1553

ValaParameterDirection _tmp288_;

1554

gboolean _tmp290_;

1555

ValaParameter* _tmp365_;

1556

ValaDataType* _tmp366_;

1557

ValaDataType* _tmp367_;

1558

ValaArrayType* _tmp368_;

1559

ValaArrayType* array_type;

1560

ValaArrayType* _tmp369_;

1561

_tmp275_ = _param_index;

1562

_param_index = _tmp275_ + 1;

1563

_tmp276_ = _param_index;

1564

_tmp277_ = _param_size;

1565

if (!(_tmp276_ < _tmp277_)) {

1566

break;

1567

}

1568

_tmp278_ = _param_list;

1569

_tmp279_ = _param_index;

1570

_tmp280_ = vala_list_get (_tmp278_, _tmp279_);

1571

param = (ValaParameter*) _tmp280_;

1572

_tmp281_ = param;

1573

_tmp282_ = vala_symbol_get_name ((ValaSymbol*) _tmp281_);

1574

_tmp283_ = _tmp282_;

1575

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

1576

param_name = _tmp284_;

1577

_tmp286_ = param;

1578

_tmp287_ = vala_parameter_get_direction (_tmp286_);

1579

_tmp288_ = _tmp287_;

1580

if (_tmp288_ == VALA_PARAMETER_DIRECTION_IN) {

1581

gboolean _tmp289_;

1582

_tmp289_ = ready;

1583

_tmp285_ = !_tmp289_;

1584

} else {

1585

_tmp285_ = FALSE;

1586

}

1587

_tmp290_ = _tmp285_;

1588

if (_tmp290_) {

1589

gboolean _tmp291_ = FALSE;

1590

ValaParameter* _tmp292_;

1591

ValaDataType* _tmp293_;

1592

ValaDataType* _tmp294_;

1593

gboolean _tmp302_;

1594

gboolean _tmp306_ = FALSE;

1595

ValaParameter* _tmp307_;

1596

ValaDataType* _tmp308_;

1597

ValaDataType* _tmp309_;

1598

gboolean _tmp317_;

1599

ValaParameter* _tmp327_;

1600

ValaDataType* _tmp328_;

1601

ValaDataType* _tmp329_;

1602

ValaTypeSymbol* _tmp330_;

1603

ValaTypeSymbol* _tmp331_;

1604

ValaStruct* _tmp332_;

1605

ValaStruct* st;

1606

gboolean _tmp333_ = FALSE;

1607

ValaStruct* _tmp334_;

1608

gboolean _tmp337_;

1609

_tmp292_ = param;

1610

_tmp293_ = vala_variable_get_variable_type ((ValaVariable*) _tmp292_);

1611

_tmp294_ = _tmp293_;

1612

if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp294_, VALA_TYPE_OBJECT_TYPE)) {

1613

ValaParameter* _tmp295_;

1614

ValaDataType* _tmp296_;

1615

ValaDataType* _tmp297_;

1616

ValaTypeSymbol* _tmp298_;

1617

ValaTypeSymbol* _tmp299_;

1618

gchar* _tmp300_ = NULL;

1619

gchar* _tmp301_;

1620

_tmp295_ = param;

1621

_tmp296_ = vala_variable_get_variable_type ((ValaVariable*) _tmp295_);

1622

_tmp297_ = _tmp296_;

1623

_tmp298_ = vala_data_type_get_data_type (_tmp297_);

1624

_tmp299_ = _tmp298_;

1625

_tmp300_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp299_);

1626

_tmp301_ = _tmp300_;

1627

_tmp291_ = g_strcmp0 (_tmp301_, "GLib.Cancellable") == 0;

1628

_g_free0 (_tmp301_);

1629

} else {

1630

_tmp291_ = FALSE;

1631

}

1632

_tmp302_ = _tmp291_;

1633

if (_tmp302_) {

1634

ValaCCodeFunctionCall* _tmp303_;

1635

ValaCCodeConstant* _tmp304_;

1636

ValaCCodeConstant* _tmp305_;

1637

_tmp303_ = ccall;

1638

_tmp304_ = vala_ccode_constant_new ("NULL");

1639

_tmp305_ = _tmp304_;

1640

vala_ccode_function_call_add_argument (_tmp303_, (ValaCCodeExpression*) _tmp305_);

1641

_vala_ccode_node_unref0 (_tmp305_);

1642

_g_free0 (param_name);

1643

_vala_code_node_unref0 (param);

1644

continue;

1645

}

1646

_tmp307_ = param;

1647

_tmp308_ = vala_variable_get_variable_type ((ValaVariable*) _tmp307_);

1648

_tmp309_ = _tmp308_;

1649

if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp309_, VALA_TYPE_OBJECT_TYPE)) {

1650

ValaParameter* _tmp310_;

1651

ValaDataType* _tmp311_;

1652

ValaDataType* _tmp312_;

1653

ValaTypeSymbol* _tmp313_;

1654

ValaTypeSymbol* _tmp314_;

1655

gchar* _tmp315_ = NULL;

1656

gchar* _tmp316_;

1657

_tmp310_ = param;

1658

_tmp311_ = vala_variable_get_variable_type ((ValaVariable*) _tmp310_);

1659

_tmp312_ = _tmp311_;

1660

_tmp313_ = vala_data_type_get_data_type (_tmp312_);

1661

_tmp314_ = _tmp313_;

1662

_tmp315_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp314_);

1663

_tmp316_ = _tmp315_;

1664

_tmp306_ = g_strcmp0 (_tmp316_, "GLib.BusName") == 0;

1665

_g_free0 (_tmp316_);

1666

} else {

1667

_tmp306_ = FALSE;

1668

}

1669

_tmp317_ = _tmp306_;

1670

if (_tmp317_) {

1671

ValaCCodeIdentifier* _tmp318_;

1672

ValaCCodeIdentifier* _tmp319_;

1673

ValaCCodeFunctionCall* _tmp320_;

1674

ValaCCodeFunctionCall* _tmp321_;

1675

ValaCCodeFunctionCall* sender;

1676

ValaCCodeFunctionCall* _tmp322_;

1677

ValaCCodeIdentifier* _tmp323_;

1678

ValaCCodeIdentifier* _tmp324_;

1679

ValaCCodeFunctionCall* _tmp325_;

1680

ValaCCodeFunctionCall* _tmp326_;

1681

_tmp318_ = vala_ccode_identifier_new ("g_dbus_method_invocation_get_sender");

1682

_tmp319_ = _tmp318_;

1683

_tmp320_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp319_);

1684

_tmp321_ = _tmp320_;

1685

_vala_ccode_node_unref0 (_tmp319_);

1686

sender = _tmp321_;

1687

_tmp322_ = sender;

1688

_tmp323_ = vala_ccode_identifier_new ("invocation");

1689

_tmp324_ = _tmp323_;

1690

vala_ccode_function_call_add_argument (_tmp322_, (ValaCCodeExpression*) _tmp324_);

1691

_vala_ccode_node_unref0 (_tmp324_);

1692

_tmp325_ = ccall;

1693

_tmp326_ = sender;

1694

vala_ccode_function_call_add_argument (_tmp325_, (ValaCCodeExpression*) _tmp326_);

1695

_vala_ccode_node_unref0 (sender);

1696

_g_free0 (param_name);

1697

_vala_code_node_unref0 (param);

1698

continue;

1699

}

1700

_tmp327_ = param;

1701

_tmp328_ = vala_variable_get_variable_type ((ValaVariable*) _tmp327_);

1702

_tmp329_ = _tmp328_;

1703

_tmp330_ = vala_data_type_get_data_type (_tmp329_);

1704

_tmp331_ = _tmp330_;

1705

_tmp332_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp331_, VALA_TYPE_STRUCT) ? ((ValaStruct*) _tmp331_) : NULL);

1706

st = _tmp332_;

1707

_tmp334_ = st;

1708

if (_tmp334_ != NULL) {

1709

ValaStruct* _tmp335_;

1710

gboolean _tmp336_ = FALSE;

1711

_tmp335_ = st;

1712

_tmp336_ = vala_struct_is_simple_type (_tmp335_);

1713

_tmp333_ = !_tmp336_;

1714

} else {

1715

_tmp333_ = FALSE;

1716

}

1717

_tmp337_ = _tmp333_;

1718

if (_tmp337_) {

1719

ValaCCodeFunctionCall* _tmp338_;

1720

const gchar* _tmp339_;

1721

ValaCCodeIdentifier* _tmp340_;

1722

ValaCCodeIdentifier* _tmp341_;

1723

ValaCCodeUnaryExpression* _tmp342_;

1724

ValaCCodeUnaryExpression* _tmp343_;

1725

_tmp338_ = ccall;

1726

_tmp339_ = param_name;

1727

_tmp340_ = vala_ccode_identifier_new (_tmp339_);

1728

_tmp341_ = _tmp340_;

1729

_tmp342_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, (ValaCCodeExpression*) _tmp341_);

1730

_tmp343_ = _tmp342_;

1731

vala_ccode_function_call_add_argument (_tmp338_, (ValaCCodeExpression*) _tmp343_);

1732

_vala_ccode_node_unref0 (_tmp343_);

1733

_vala_ccode_node_unref0 (_tmp341_);

1734

} else {

1735

ValaCCodeFunctionCall* _tmp344_;

1736

const gchar* _tmp345_;

1737

ValaCCodeIdentifier* _tmp346_;

1738

ValaCCodeIdentifier* _tmp347_;

1739

_tmp344_ = ccall;

1740

_tmp345_ = param_name;

1741

_tmp346_ = vala_ccode_identifier_new (_tmp345_);

1742

_tmp347_ = _tmp346_;

1743

vala_ccode_function_call_add_argument (_tmp344_, (ValaCCodeExpression*) _tmp347_);

1744

_vala_ccode_node_unref0 (_tmp347_);

1745

}

1746

_vala_code_node_unref0 (st);

1747

} else {

1748

gboolean _tmp348_ = FALSE;

1749

ValaParameter* _tmp349_;

1750

ValaParameterDirection _tmp350_;

1751

ValaParameterDirection _tmp351_;

1752

gboolean _tmp358_;

1753

_tmp349_ = param;

1754

_tmp350_ = vala_parameter_get_direction (_tmp349_);

1755

_tmp351_ = _tmp350_;

1756

if (_tmp351_ == VALA_PARAMETER_DIRECTION_OUT) {

1757

gboolean _tmp352_ = FALSE;

1758

ValaMethod* _tmp353_;

1759

gboolean _tmp354_;

1760

gboolean _tmp355_;

1761

gboolean _tmp357_;

1762

_tmp353_ = m;

1763

_tmp354_ = vala_method_get_coroutine (_tmp353_);

1764

_tmp355_ = _tmp354_;

1765

if (!_tmp355_) {

1766

_tmp352_ = TRUE;

1767

} else {

1768

gboolean _tmp356_;

1769

_tmp356_ = ready;

1770

_tmp352_ = _tmp356_;

1771

}

1772

_tmp357_ = _tmp352_;

1773

_tmp348_ = _tmp357_;

1774

} else {

1775

_tmp348_ = FALSE;

1776

}

1777

_tmp358_ = _tmp348_;

1778

if (_tmp358_) {

1779

ValaCCodeFunctionCall* _tmp359_;

1780

const gchar* _tmp360_;

1781

ValaCCodeIdentifier* _tmp361_;

1782

ValaCCodeIdentifier* _tmp362_;

1783

ValaCCodeUnaryExpression* _tmp363_;

1784

ValaCCodeUnaryExpression* _tmp364_;

1785

_tmp359_ = ccall;

1786

_tmp360_ = param_name;

1787

_tmp361_ = vala_ccode_identifier_new (_tmp360_);

1788

_tmp362_ = _tmp361_;

1789

_tmp363_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, (ValaCCodeExpression*) _tmp362_);

1790

_tmp364_ = _tmp363_;

1791

vala_ccode_function_call_add_argument (_tmp359_, (ValaCCodeExpression*) _tmp364_);

1792

_vala_ccode_node_unref0 (_tmp364_);

1793

_vala_ccode_node_unref0 (_tmp362_);

1794

}

1795

}

1796

_tmp365_ = param;

1797

_tmp366_ = vala_variable_get_variable_type ((ValaVariable*) _tmp365_);

1798

_tmp367_ = _tmp366_;

1799

_tmp368_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp367_, VALA_TYPE_ARRAY_TYPE) ? ((ValaArrayType*) _tmp367_) : NULL);

1800

array_type = _tmp368_;

1801

_tmp369_ = array_type;

1802

if (_tmp369_ != NULL) {

1803

{

1804

gint dim;

1805

dim = 1;

1806

{

1807

gboolean _tmp370_;

1808

_tmp370_ = TRUE;

1809

while (TRUE) {

1810

gboolean _tmp371_;

1811

gint _tmp373_;

1812

ValaArrayType* _tmp374_;

1813

gint _tmp375_;

1814

gint _tmp376_;

1815

ValaParameter* _tmp377_;

1816

gint _tmp378_;

1817

gchar* _tmp379_ = NULL;

1818

gchar* length_cname;

1819

gboolean _tmp380_ = FALSE;

1820

ValaParameter* _tmp381_;

1821

ValaParameterDirection _tmp382_;

1822

ValaParameterDirection _tmp383_;

1823

gboolean _tmp385_;

1824

_tmp371_ = _tmp370_;

1825

if (!_tmp371_) {

1826

gint _tmp372_;

1827

_tmp372_ = dim;

1828

dim = _tmp372_ + 1;

1829

}

1830

_tmp370_ = FALSE;

1831

_tmp373_ = dim;

1832

_tmp374_ = array_type;

1833

_tmp375_ = vala_array_type_get_rank (_tmp374_);

1834

_tmp376_ = _tmp375_;

1835

if (!(_tmp373_ <= _tmp376_)) {

1836

break;

1837

}

1838

_tmp377_ = param;

1839

_tmp378_ = dim;

1840

_tmp379_ = vala_ccode_base_module_get_parameter_array_length_cname ((ValaCCodeBaseModule*) self, _tmp377_, _tmp378_);

1841

length_cname = _tmp379_;

1842

_tmp381_ = param;

1843

_tmp382_ = vala_parameter_get_direction (_tmp381_);

1844

_tmp383_ = _tmp382_;

1845

if (_tmp383_ == VALA_PARAMETER_DIRECTION_IN) {

1846

gboolean _tmp384_;

1847

_tmp384_ = ready;

1848

_tmp380_ = !_tmp384_;

1849

} else {

1850

_tmp380_ = FALSE;

1851

}

1852

_tmp385_ = _tmp380_;

1853

if (_tmp385_) {

1854

ValaCCodeFunctionCall* _tmp386_;

1855

const gchar* _tmp387_;

1856

ValaCCodeIdentifier* _tmp388_;

1857

ValaCCodeIdentifier* _tmp389_;

1858

_tmp386_ = ccall;

1859

_tmp387_ = length_cname;

1860

_tmp388_ = vala_ccode_identifier_new (_tmp387_);

1861

_tmp389_ = _tmp388_;

1862

vala_ccode_function_call_add_argument (_tmp386_, (ValaCCodeExpression*) _tmp389_);

1863

_vala_ccode_node_unref0 (_tmp389_);

1864

} else {

1865

gboolean _tmp390_ = FALSE;

1866

gboolean _tmp391_ = FALSE;

1867

ValaParameter* _tmp392_;

1868

ValaParameterDirection _tmp393_;

1869

ValaParameterDirection _tmp394_;

1870

gboolean _tmp396_;

1871

gboolean _tmp403_;

1872

_tmp392_ = param;

1873

_tmp393_ = vala_parameter_get_direction (_tmp392_);

1874

_tmp394_ = _tmp393_;

1875

if (_tmp394_ == VALA_PARAMETER_DIRECTION_OUT) {

1876

gboolean _tmp395_;

1877

_tmp395_ = no_reply;

1878

_tmp391_ = !_tmp395_;

1879

} else {

1880

_tmp391_ = FALSE;

1881

}

1882

_tmp396_ = _tmp391_;

1883

if (_tmp396_) {

1884

gboolean _tmp397_ = FALSE;

1885

ValaMethod* _tmp398_;

1886

gboolean _tmp399_;

1887

gboolean _tmp400_;

1888

gboolean _tmp402_;

1889

_tmp398_ = m;

1890

_tmp399_ = vala_method_get_coroutine (_tmp398_);

1891

_tmp400_ = _tmp399_;

1892

if (!_tmp400_) {

1893

_tmp397_ = TRUE;

1894

} else {

1895

gboolean _tmp401_;

1896

_tmp401_ = ready;

1897

_tmp397_ = _tmp401_;

1898

}

1899

_tmp402_ = _tmp397_;

1900

_tmp390_ = _tmp402_;

1901

} else {

1902

_tmp390_ = FALSE;

1903

}

1904

_tmp403_ = _tmp390_;

1905

if (_tmp403_) {

1906

ValaCCodeFunctionCall* _tmp404_;

1907

const gchar* _tmp405_;

1908

ValaCCodeIdentifier* _tmp406_;

1909

ValaCCodeIdentifier* _tmp407_;

1910

ValaCCodeUnaryExpression* _tmp408_;

1911

ValaCCodeUnaryExpression* _tmp409_;

1912

_tmp404_ = ccall;

1913

_tmp405_ = length_cname;

1914

_tmp406_ = vala_ccode_identifier_new (_tmp405_);

1915

_tmp407_ = _tmp406_;

1916

_tmp408_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, (ValaCCodeExpression*) _tmp407_);

1917

_tmp409_ = _tmp408_;

1918

vala_ccode_function_call_add_argument (_tmp404_, (ValaCCodeExpression*) _tmp409_);

1919

_vala_ccode_node_unref0 (_tmp409_);

1920

_vala_ccode_node_unref0 (_tmp407_);

1921

}

1922

}

1923

_g_free0 (length_cname);

1924

}

1925

}

1926

}

1927

}

1928

_vala_code_node_unref0 (array_type);

1929

_g_free0 (param_name);

1930

_vala_code_node_unref0 (param);

1931

}

1932

_vala_iterable_unref0 (_param_list);

1933

}

1934

_tmp411_ = m;

1935

_tmp412_ = vala_method_get_coroutine (_tmp411_);

1936

_tmp413_ = _tmp412_;

1937

if (!_tmp413_) {

1938

_tmp410_ = TRUE;

1939

} else {

1940

gboolean _tmp414_;

1941

_tmp414_ = ready;

1942

_tmp410_ = _tmp414_;

1943

}

1944

_tmp415_ = _tmp410_;

1945

if (_tmp415_) {

1946

ValaMethod* _tmp416_;

1947

ValaDataType* _tmp417_;

1948

ValaDataType* _tmp418_;

1949

_tmp416_ = m;

1950

_tmp417_ = vala_method_get_return_type (_tmp416_);

1951

_tmp418_ = _tmp417_;

1952

if (!G_TYPE_CHECK_INSTANCE_TYPE (_tmp418_, VALA_TYPE_VOID_TYPE)) {

1953

ValaMethod* _tmp419_;

1954

ValaDataType* _tmp420_;

1955

ValaDataType* _tmp421_;

1956

gboolean _tmp422_ = FALSE;

1957

_tmp419_ = m;

1958

_tmp420_ = vala_method_get_return_type (_tmp419_);

1959

_tmp421_ = _tmp420_;

1960

_tmp422_ = vala_data_type_is_real_non_null_struct_type (_tmp421_);

1961

if (_tmp422_) {

1962

ValaCCodeFunctionCall* _tmp423_;

1963

ValaCCodeIdentifier* _tmp424_;

1964

ValaCCodeIdentifier* _tmp425_;

1965

ValaCCodeUnaryExpression* _tmp426_;

1966

ValaCCodeUnaryExpression* _tmp427_;

1967

_tmp423_ = ccall;

1968

_tmp424_ = vala_ccode_identifier_new ("result");

1969

_tmp425_ = _tmp424_;

1970

_tmp426_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, (ValaCCodeExpression*) _tmp425_);

1971

_tmp427_ = _tmp426_;

1972

vala_ccode_function_call_add_argument (_tmp423_, (ValaCCodeExpression*) _tmp427_);

1973

_vala_ccode_node_unref0 (_tmp427_);

1974

_vala_ccode_node_unref0 (_tmp425_);

1975

} else {

1976

ValaMethod* _tmp428_;

1977

ValaDataType* _tmp429_;

1978

ValaDataType* _tmp430_;

1979

ValaArrayType* _tmp431_;

1980

ValaArrayType* array_type;

1981

ValaArrayType* _tmp432_;

1982

_tmp428_ = m;

1983

_tmp429_ = vala_method_get_return_type (_tmp428_);

1984

_tmp430_ = _tmp429_;

1985

_tmp431_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp430_, VALA_TYPE_ARRAY_TYPE) ? ((ValaArrayType*) _tmp430_) : NULL);

1986

array_type = _tmp431_;

1987

_tmp432_ = array_type;

1988

if (_tmp432_ != NULL) {

1989

{

1990

gint dim;

1991

dim = 1;

1992

{

1993

gboolean _tmp433_;

1994

_tmp433_ = TRUE;

1995

while (TRUE) {

1996

gboolean _tmp434_;

1997

gint _tmp436_;

1998

ValaArrayType* _tmp437_;

1999

gint _tmp438_;

2000

gint _tmp439_;

2001

gint _tmp440_;

2002

gchar* _tmp441_ = NULL;

2003

gchar* length_cname;

2004

ValaCCodeFunctionCall* _tmp442_;

2005

const gchar* _tmp443_;

2006

ValaCCodeIdentifier* _tmp444_;

2007

ValaCCodeIdentifier* _tmp445_;

2008

ValaCCodeUnaryExpression* _tmp446_;

2009

ValaCCodeUnaryExpression* _tmp447_;

2010

_tmp434_ = _tmp433_;

2011

if (!_tmp434_) {

2012

gint _tmp435_;

2013

_tmp435_ = dim;

2014

dim = _tmp435_ + 1;

2015

}

2016

_tmp433_ = FALSE;

2017

_tmp436_ = dim;

2018

_tmp437_ = array_type;

2019

_tmp438_ = vala_array_type_get_rank (_tmp437_);

2020

_tmp439_ = _tmp438_;

2021

if (!(_tmp436_ <= _tmp439_)) {

2022

break;

2023

}

2024

_tmp440_ = dim;

2025

_tmp441_ = vala_ccode_base_module_get_array_length_cname ((ValaCCodeBaseModule*) self, "result", _tmp440_);

2026

length_cname = _tmp441_;

2027

_tmp442_ = ccall;

2028

_tmp443_ = length_cname;

2029

_tmp444_ = vala_ccode_identifier_new (_tmp443_);

2030

_tmp445_ = _tmp444_;

2031

_tmp446_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, (ValaCCodeExpression*) _tmp445_);

2032

_tmp447_ = _tmp446_;

2033

vala_ccode_function_call_add_argument (_tmp442_, (ValaCCodeExpression*) _tmp447_);

2034

_vala_ccode_node_unref0 (_tmp447_);

2035

_vala_ccode_node_unref0 (_tmp445_);

2036

_g_free0 (length_cname);

2037

}

2038

}

2039

}

2040

}

2041

_vala_code_node_unref0 (array_type);

2042

}

2043

}

2044

}

2045

_tmp449_ = m;

2046

_tmp450_ = vala_method_get_coroutine (_tmp449_);

2047

_tmp451_ = _tmp450_;

2048

if (_tmp451_) {

2049

gboolean _tmp452_;

2050

_tmp452_ = ready;

2051

_tmp448_ = !_tmp452_;

2052

} else {

2053

_tmp448_ = FALSE;

2054

}

2055

_tmp453_ = _tmp448_;

2056

if (_tmp453_) {

2057

ValaCCodeFunctionCall* _tmp454_;

2058

const gchar* _tmp455_;

2059

gchar* _tmp456_;

2060

gchar* _tmp457_;

2061

ValaCCodeIdentifier* _tmp458_;

2062

ValaCCodeIdentifier* _tmp459_;

2063

ValaCCodeCastExpression* _tmp460_;

2064

ValaCCodeCastExpression* _tmp461_;

2065

ValaCCodeFunctionCall* _tmp462_;

2066

ValaCCodeIdentifier* _tmp463_;

2067

ValaCCodeIdentifier* _tmp464_;

2068

_tmp454_ = ccall;

2069

_tmp455_ = wrapper_name;

2070

_tmp456_ = g_strconcat (_tmp455_, "_ready", NULL);

2071

_tmp457_ = _tmp456_;

2072

_tmp458_ = vala_ccode_identifier_new (_tmp457_);

2073

_tmp459_ = _tmp458_;

2074

_tmp460_ = vala_ccode_cast_expression_new ((ValaCCodeExpression*) _tmp459_, "GAsyncReadyCallback");

2075

_tmp461_ = _tmp460_;

2076

vala_ccode_function_call_add_argument (_tmp454_, (ValaCCodeExpression*) _tmp461_);

2077

_vala_ccode_node_unref0 (_tmp461_);

2078

_vala_ccode_node_unref0 (_tmp459_);

2079

_g_free0 (_tmp457_);

2080

_tmp462_ = ccall;

2081

_tmp463_ = vala_ccode_identifier_new ("invocation");

2082

_tmp464_ = _tmp463_;

2083

vala_ccode_function_call_add_argument (_tmp462_, (ValaCCodeExpression*) _tmp464_);

2084

_vala_ccode_node_unref0 (_tmp464_);

2085

}

2086

_tmp466_ = m;

2087

_tmp467_ = vala_method_get_coroutine (_tmp466_);

2088

_tmp468_ = _tmp467_;

2089

if (!_tmp468_) {

2090

_tmp465_ = TRUE;

2091

} else {

2092

gboolean _tmp469_;

2093

_tmp469_ = ready;

2094

_tmp465_ = _tmp469_;

2095

}

2096

_tmp470_ = _tmp465_;

2097

if (_tmp470_) {

2098

ValaMethod* _tmp471_;

2099

ValaList* _tmp472_ = NULL;

2100

ValaList* _tmp473_;

2101

gint _tmp474_;

2102

gint _tmp475_;

2103

gboolean _tmp476_;

2104

_tmp471_ = m;

2105

_tmp472_ = vala_code_node_get_error_types ((ValaCodeNode*) _tmp471_);

2106

_tmp473_ = _tmp472_;

2107

_tmp474_ = vala_collection_get_size ((ValaCollection*) _tmp473_);

2108

_tmp475_ = _tmp474_;

2109

_tmp476_ = _tmp475_ > 0;

2110

_vala_iterable_unref0 (_tmp473_);

2111

if (_tmp476_) {

2112

ValaCCodeFunctionCall* _tmp477_;

2113

ValaCCodeIdentifier* _tmp478_;

2114

ValaCCodeIdentifier* _tmp479_;

2115

ValaCCodeUnaryExpression* _tmp480_;

2116

ValaCCodeUnaryExpression* _tmp481_;

2117

_tmp477_ = ccall;

2118

_tmp478_ = vala_ccode_identifier_new ("error");

2119

_tmp479_ = _tmp478_;

2120

_tmp480_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, (ValaCCodeExpression*) _tmp479_);

2121

_tmp481_ = _tmp480_;

2122

vala_ccode_function_call_add_argument (_tmp477_, (ValaCCodeExpression*) _tmp481_);

2123

_vala_ccode_node_unref0 (_tmp481_);

2124

_vala_ccode_node_unref0 (_tmp479_);

2125

}

2126

}

2127

_tmp483_ = no_reply;

2128

if (!_tmp483_) {

2129

gboolean _tmp484_ = FALSE;

2130

ValaMethod* _tmp485_;

2131

gboolean _tmp486_;

2132

gboolean _tmp487_;

2133

gboolean _tmp489_;

2134

_tmp485_ = m;

2135

_tmp486_ = vala_method_get_coroutine (_tmp485_);

2136

_tmp487_ = _tmp486_;

2137

if (!_tmp487_) {

2138

_tmp484_ = TRUE;

2139

} else {

2140

gboolean _tmp488_;

2141

_tmp488_ = ready;

2142

_tmp484_ = _tmp488_;

2143

}

2144

_tmp489_ = _tmp484_;

2145

_tmp482_ = _tmp489_;

2146

} else {

2147

_tmp482_ = FALSE;

2148

}

2149

_tmp490_ = _tmp482_;

2150

if (_tmp490_) {

2151

gboolean _tmp491_ = FALSE;

2152

ValaMethod* _tmp492_;

2153

ValaDataType* _tmp493_;

2154

ValaDataType* _tmp494_;

2155

gboolean _tmp499_;

2156

ValaMethod* _tmp508_;

2157

ValaList* _tmp509_ = NULL;

2158

ValaList* _tmp510_;

2159

gint _tmp511_;

2160

gint _tmp512_;

2161

gboolean _tmp513_;

2162

ValaCCodeFunction* _tmp535_;

2163

ValaCCodeFunction* _tmp536_;

2164

ValaCCodeVariableDeclarator* _tmp537_;

2165

ValaCCodeVariableDeclarator* _tmp538_;

2166

ValaCCodeIdentifier* _tmp539_;

2167

ValaCCodeIdentifier* _tmp540_;

2168

ValaCCodeFunctionCall* _tmp541_;

2169

ValaCCodeFunctionCall* _tmp542_;

2170

ValaCCodeFunctionCall* message_expr;

2171

ValaCCodeFunctionCall* _tmp543_;

2172

ValaCCodeIdentifier* _tmp544_;

2173

ValaCCodeIdentifier* _tmp545_;

2174

ValaCCodeIdentifier* _tmp546_;

2175

ValaCCodeIdentifier* _tmp547_;

2176

ValaCCodeFunctionCall* _tmp548_;

2177

ValaCCodeFunctionCall* _tmp549_;

2178

ValaCCodeFunctionCall* _tmp550_;

2179

ValaCCodeFunction* _tmp551_;

2180

ValaCCodeFunction* _tmp552_;

2181

ValaCCodeIdentifier* _tmp553_;

2182

ValaCCodeIdentifier* _tmp554_;

2183

ValaCCodeFunctionCall* _tmp555_;

2184

ValaCCodeFunction* _tmp556_;

2185

ValaCCodeFunction* _tmp557_;

2186

ValaCCodeVariableDeclarator* _tmp558_;

2187

ValaCCodeVariableDeclarator* _tmp559_;

2188

ValaCCodeFunction* _tmp560_;

2189

ValaCCodeFunction* _tmp561_;

2190

ValaCCodeVariableDeclarator* _tmp562_;

2191

ValaCCodeVariableDeclarator* _tmp563_;

2192

ValaCCodeIdentifier* _tmp564_;

2193

ValaCCodeIdentifier* _tmp565_;

2194

ValaCCodeFunctionCall* _tmp566_;

2195

ValaCCodeFunctionCall* _tmp567_;

2196

ValaCCodeFunctionCall* builder_init;

2197

ValaCCodeFunctionCall* _tmp568_;

2198

ValaCCodeIdentifier* _tmp569_;

2199

ValaCCodeIdentifier* _tmp570_;

2200

ValaCCodeUnaryExpression* _tmp571_;

2201

ValaCCodeUnaryExpression* _tmp572_;

2202

ValaCCodeFunctionCall* _tmp573_;

2203

ValaCCodeIdentifier* _tmp574_;

2204

ValaCCodeIdentifier* _tmp575_;

2205

ValaCCodeFunction* _tmp576_;

2206

ValaCCodeFunction* _tmp577_;

2207

ValaCCodeFunctionCall* _tmp578_;

2208

gboolean _tmp579_;

2209

ValaMethod* _tmp659_;

2210

ValaDataType* _tmp660_;

2211

ValaDataType* _tmp661_;

2212

ValaCCodeIdentifier* _tmp752_;

2213

ValaCCodeIdentifier* _tmp753_;

2214

ValaCCodeFunctionCall* _tmp754_;

2215

ValaCCodeFunctionCall* _tmp755_;

2216

ValaCCodeFunctionCall* builder_end;

2217

ValaCCodeFunctionCall* _tmp756_;

2218

ValaCCodeIdentifier* _tmp757_;

2219

ValaCCodeIdentifier* _tmp758_;

2220

ValaCCodeUnaryExpression* _tmp759_;

2221

ValaCCodeUnaryExpression* _tmp760_;

2222

ValaCCodeFunction* _tmp761_;

2223

ValaCCodeFunction* _tmp762_;

2224

ValaCCodeIdentifier* _tmp763_;

2225

ValaCCodeIdentifier* _tmp764_;

2226

ValaCCodeFunctionCall* _tmp765_;

2227

ValaCCodeIdentifier* _tmp766_;

2228

ValaCCodeIdentifier* _tmp767_;

2229

ValaCCodeFunctionCall* _tmp768_;

2230

ValaCCodeFunctionCall* _tmp769_;

2231

ValaCCodeFunctionCall* set_body;

2232

ValaCCodeFunctionCall* _tmp770_;

2233

ValaCCodeIdentifier* _tmp771_;

2234

ValaCCodeIdentifier* _tmp772_;

2235

ValaCCodeFunctionCall* _tmp773_;

2236

ValaCCodeIdentifier* _tmp774_;

2237

ValaCCodeIdentifier* _tmp775_;

2238

ValaCCodeFunction* _tmp776_;

2239

ValaCCodeFunction* _tmp777_;

2240

ValaCCodeFunctionCall* _tmp778_;

2241

gboolean _tmp779_;

2242

_tmp492_ = m;

2243

_tmp493_ = vala_method_get_return_type (_tmp492_);

2244

_tmp494_ = _tmp493_;

2245

if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp494_, VALA_TYPE_VOID_TYPE)) {

2246

_tmp491_ = TRUE;

2247

} else {

2248

ValaMethod* _tmp495_;

2249

ValaDataType* _tmp496_;

2250

ValaDataType* _tmp497_;

2251

gboolean _tmp498_ = FALSE;

2252

_tmp495_ = m;

2253

_tmp496_ = vala_method_get_return_type (_tmp495_);

2254

_tmp497_ = _tmp496_;

2255

_tmp498_ = vala_data_type_is_real_non_null_struct_type (_tmp497_);

2256

_tmp491_ = _tmp498_;

2257

}

2258

_tmp499_ = _tmp491_;

2259

if (_tmp499_) {

2260

ValaCCodeFunction* _tmp500_;

2261

ValaCCodeFunction* _tmp501_;

2262

ValaCCodeFunctionCall* _tmp502_;

2263

_tmp500_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

2264

_tmp501_ = _tmp500_;

2265

_tmp502_ = ccall;

2266

vala_ccode_function_add_expression (_tmp501_, (ValaCCodeExpression*) _tmp502_);

2267

} else {

2268

ValaCCodeFunction* _tmp503_;

2269

ValaCCodeFunction* _tmp504_;

2270

ValaCCodeIdentifier* _tmp505_;

2271

ValaCCodeIdentifier* _tmp506_;

2272

ValaCCodeFunctionCall* _tmp507_;

2273

_tmp503_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

2274

_tmp504_ = _tmp503_;

2275

_tmp505_ = vala_ccode_identifier_new ("result");

2276

_tmp506_ = _tmp505_;

2277

_tmp507_ = ccall;

2278

vala_ccode_function_add_assignment (_tmp504_, (ValaCCodeExpression*) _tmp506_, (ValaCCodeExpression*) _tmp507_);

2279

_vala_ccode_node_unref0 (_tmp506_);

2280

}

2281

_tmp508_ = m;

2282

_tmp509_ = vala_code_node_get_error_types ((ValaCodeNode*) _tmp508_);

2283

_tmp510_ = _tmp509_;

2284

_tmp511_ = vala_collection_get_size ((ValaCollection*) _tmp510_);

2285

_tmp512_ = _tmp511_;

2286

_tmp513_ = _tmp512_ > 0;

2287

_vala_iterable_unref0 (_tmp510_);

2288

if (_tmp513_) {

2289

ValaCCodeFunction* _tmp514_;

2290

ValaCCodeFunction* _tmp515_;

2291

ValaCCodeIdentifier* _tmp516_;

2292

ValaCCodeIdentifier* _tmp517_;

2293

ValaCCodeIdentifier* _tmp518_;

2294

ValaCCodeIdentifier* _tmp519_;

2295

ValaCCodeFunctionCall* _tmp520_;

2296

ValaCCodeFunctionCall* _tmp521_;

2297

ValaCCodeFunctionCall* return_error;

2298

ValaCCodeFunctionCall* _tmp522_;

2299

ValaCCodeIdentifier* _tmp523_;

2300

ValaCCodeIdentifier* _tmp524_;

2301

ValaCCodeFunctionCall* _tmp525_;

2302

ValaCCodeIdentifier* _tmp526_;

2303

ValaCCodeIdentifier* _tmp527_;

2304

ValaCCodeFunction* _tmp528_;

2305

ValaCCodeFunction* _tmp529_;

2306

ValaCCodeFunctionCall* _tmp530_;

2307

ValaCCodeFunction* _tmp531_;

2308

ValaCCodeFunction* _tmp532_;

2309

ValaCCodeFunction* _tmp533_;

2310

ValaCCodeFunction* _tmp534_;

2311

_tmp514_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

2312

_tmp515_ = _tmp514_;

2313

_tmp516_ = vala_ccode_identifier_new ("error");

2314

_tmp517_ = _tmp516_;

2315

vala_ccode_function_open_if (_tmp515_, (ValaCCodeExpression*) _tmp517_);

2316

_vala_ccode_node_unref0 (_tmp517_);

2317

_tmp518_ = vala_ccode_identifier_new ("g_dbus_method_invocation_return_gerror");

2318

_tmp519_ = _tmp518_;

2319

_tmp520_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp519_);

2320

_tmp521_ = _tmp520_;

2321

_vala_ccode_node_unref0 (_tmp519_);

2322

return_error = _tmp521_;

2323

_tmp522_ = return_error;

2324

_tmp523_ = vala_ccode_identifier_new ("invocation");

2325

_tmp524_ = _tmp523_;

2326

vala_ccode_function_call_add_argument (_tmp522_, (ValaCCodeExpression*) _tmp524_);

2327

_vala_ccode_node_unref0 (_tmp524_);

2328

_tmp525_ = return_error;

2329

_tmp526_ = vala_ccode_identifier_new ("error");

2330

_tmp527_ = _tmp526_;

2331

vala_ccode_function_call_add_argument (_tmp525_, (ValaCCodeExpression*) _tmp527_);

2332

_vala_ccode_node_unref0 (_tmp527_);

2333

_tmp528_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

2334

_tmp529_ = _tmp528_;

2335

_tmp530_ = return_error;

2336

vala_ccode_function_add_expression (_tmp529_, (ValaCCodeExpression*) _tmp530_);

2337

_tmp531_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

2338

_tmp532_ = _tmp531_;

2339

vala_ccode_function_add_return (_tmp532_, NULL);

2340

_tmp533_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

2341

_tmp534_ = _tmp533_;

2342

vala_ccode_function_close (_tmp534_);

2343

_vala_ccode_node_unref0 (return_error);

2344

}

2345

_tmp535_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

2346

_tmp536_ = _tmp535_;

2347

_tmp537_ = vala_ccode_variable_declarator_new ("_reply_message", NULL, NULL);

2348

_tmp538_ = _tmp537_;

2349

vala_ccode_function_add_declaration (_tmp536_, "GDBusMessage*", (ValaCCodeDeclarator*) _tmp538_, 0);

2350

_vala_ccode_node_unref0 (_tmp538_);

2351

_tmp539_ = vala_ccode_identifier_new ("g_dbus_method_invocation_get_message");

2352

_tmp540_ = _tmp539_;

2353

_tmp541_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp540_);

2354

_tmp542_ = _tmp541_;

2355

_vala_ccode_node_unref0 (_tmp540_);

2356

message_expr = _tmp542_;

2357

_tmp543_ = message_expr;

2358

_tmp544_ = vala_ccode_identifier_new ("invocation");

2359

_tmp545_ = _tmp544_;

2360

vala_ccode_function_call_add_argument (_tmp543_, (ValaCCodeExpression*) _tmp545_);

2361

_vala_ccode_node_unref0 (_tmp545_);

2362

_tmp546_ = vala_ccode_identifier_new ("g_dbus_message_new_method_reply");

2363

_tmp547_ = _tmp546_;

2364

_tmp548_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp547_);

2365

_vala_ccode_node_unref0 (ccall);

2366

ccall = _tmp548_;

2367

_vala_ccode_node_unref0 (_tmp547_);

2368

_tmp549_ = ccall;

2369

_tmp550_ = message_expr;

2370

vala_ccode_function_call_add_argument (_tmp549_, (ValaCCodeExpression*) _tmp550_);

2371

_tmp551_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

2372

_tmp552_ = _tmp551_;

2373

_tmp553_ = vala_ccode_identifier_new ("_reply_message");

2374

_tmp554_ = _tmp553_;

2375

_tmp555_ = ccall;

2376

vala_ccode_function_add_assignment (_tmp552_, (ValaCCodeExpression*) _tmp554_, (ValaCCodeExpression*) _tmp555_);

2377

_vala_ccode_node_unref0 (_tmp554_);

2378

_tmp556_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

2379

_tmp557_ = _tmp556_;

2380

_tmp558_ = vala_ccode_variable_declarator_new ("_reply", NULL, NULL);

2381

_tmp559_ = _tmp558_;

2382

vala_ccode_function_add_declaration (_tmp557_, "GVariant*", (ValaCCodeDeclarator*) _tmp559_, 0);

2383

_vala_ccode_node_unref0 (_tmp559_);

2384

_tmp560_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

2385

_tmp561_ = _tmp560_;

2386

_tmp562_ = vala_ccode_variable_declarator_new ("_reply_builder", NULL, NULL);

2387

_tmp563_ = _tmp562_;

2388

vala_ccode_function_add_declaration (_tmp561_, "GVariantBuilder", (ValaCCodeDeclarator*) _tmp563_, 0);

2389

_vala_ccode_node_unref0 (_tmp563_);

2390

_tmp564_ = vala_ccode_identifier_new ("g_variant_builder_init");

2391

_tmp565_ = _tmp564_;

2392

_tmp566_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp565_);

2393

_tmp567_ = _tmp566_;

2394

_vala_ccode_node_unref0 (_tmp565_);

2395

builder_init = _tmp567_;

2396

_tmp568_ = builder_init;

2397

_tmp569_ = vala_ccode_identifier_new ("_reply_builder");

2398

_tmp570_ = _tmp569_;

2399

_tmp571_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, (ValaCCodeExpression*) _tmp570_);

2400

_tmp572_ = _tmp571_;

2401

vala_ccode_function_call_add_argument (_tmp568_, (ValaCCodeExpression*) _tmp572_);

2402

_vala_ccode_node_unref0 (_tmp572_);

2403

_vala_ccode_node_unref0 (_tmp570_);

2404

_tmp573_ = builder_init;

2405

_tmp574_ = vala_ccode_identifier_new ("G_VARIANT_TYPE_TUPLE");

2406

_tmp575_ = _tmp574_;

2407

vala_ccode_function_call_add_argument (_tmp573_, (ValaCCodeExpression*) _tmp575_);

2408

_vala_ccode_node_unref0 (_tmp575_);

2409

_tmp576_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

2410

_tmp577_ = _tmp576_;

2411

_tmp578_ = builder_init;

2412

vala_ccode_function_add_expression (_tmp577_, (ValaCCodeExpression*) _tmp578_);

2413

_tmp579_ = uses_fd;

2414

if (_tmp579_) {

2415

ValaCCodeFunction* _tmp580_;

2416

ValaCCodeFunction* _tmp581_;

2417

ValaCCodeVariableDeclarator* _tmp582_;

2418

ValaCCodeVariableDeclarator* _tmp583_;

2419

ValaCCodeFunction* _tmp584_;

2420

ValaCCodeFunction* _tmp585_;

2421

ValaCCodeIdentifier* _tmp586_;

2422

ValaCCodeIdentifier* _tmp587_;

2423

ValaCCodeIdentifier* _tmp588_;

2424

ValaCCodeIdentifier* _tmp589_;

2425

ValaCCodeFunctionCall* _tmp590_;

2426

ValaCCodeFunctionCall* _tmp591_;

2427

_tmp580_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

2428

_tmp581_ = _tmp580_;

2429

_tmp582_ = vala_ccode_variable_declarator_new ("*_fd_list", NULL, NULL);

2430

_tmp583_ = _tmp582_;

2431

vala_ccode_function_add_declaration (_tmp581_, "GUnixFDList", (ValaCCodeDeclarator*) _tmp583_, 0);

2432

_vala_ccode_node_unref0 (_tmp583_);

2433

_tmp584_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

2434

_tmp585_ = _tmp584_;

2435

_tmp586_ = vala_ccode_identifier_new ("_fd_list");

2436

_tmp587_ = _tmp586_;

2437

_tmp588_ = vala_ccode_identifier_new ("g_unix_fd_list_new");

2438

_tmp589_ = _tmp588_;

2439

_tmp590_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp589_);

2440

_tmp591_ = _tmp590_;

2441

vala_ccode_function_add_assignment (_tmp585_, (ValaCCodeExpression*) _tmp587_, (ValaCCodeExpression*) _tmp591_);

2442

_vala_ccode_node_unref0 (_tmp591_);

2443

_vala_ccode_node_unref0 (_tmp589_);

2444

_vala_ccode_node_unref0 (_tmp587_);

2445

}

2446

{

2447

ValaMethod* _tmp592_;

2448

ValaList* _tmp593_ = NULL;

2449

ValaList* _param_list;

2450

ValaList* _tmp594_;

2451

gint _tmp595_;

2452

gint _tmp596_;

2453

gint _param_size;

2454

gint _param_index;

2455

_tmp592_ = m;

2456

_tmp593_ = vala_method_get_parameters (_tmp592_);

2457

_param_list = _tmp593_;

2458

_tmp594_ = _param_list;

2459

_tmp595_ = vala_collection_get_size ((ValaCollection*) _tmp594_);

2460

_tmp596_ = _tmp595_;

2461

_param_size = _tmp596_;

2462

_param_index = -1;

2463

while (TRUE) {

2464

gint _tmp597_;

2465

gint _tmp598_;

2466

gint _tmp599_;

2467

ValaList* _tmp600_;

2468

gint _tmp601_;

2469

gpointer _tmp602_ = NULL;

2470

ValaParameter* param;

2471

ValaParameter* _tmp603_;

2472

ValaParameterDirection _tmp604_;

2473

ValaParameterDirection _tmp605_;

2474

ValaParameter* _tmp606_;

2475

const gchar* _tmp607_;

2476

const gchar* _tmp608_;

2477

gchar* _tmp609_ = NULL;

2478

gchar* param_name;

2479

ValaParameter* _tmp610_;

2480

ValaDataType* _tmp611_;

2481

ValaDataType* _tmp612_;

2482

ValaDataType* _tmp613_ = NULL;

2483

ValaDataType* owned_type;

2484

ValaDataType* _tmp614_;

2485

ValaCCodeFunction* _tmp615_;

2486

ValaCCodeFunction* _tmp616_;

2487

ValaDataType* _tmp617_;

2488

gchar* _tmp618_ = NULL;

2489

gchar* _tmp619_;

2490

const gchar* _tmp620_;

2491

ValaParameter* _tmp621_;

2492

ValaDataType* _tmp622_;

2493

ValaDataType* _tmp623_;

2494

ValaCCodeExpression* _tmp624_ = NULL;

2495

ValaCCodeExpression* _tmp625_;

2496

ValaCCodeVariableDeclarator* _tmp626_;

2497

ValaCCodeVariableDeclarator* _tmp627_;

2498

ValaParameter* _tmp628_;

2499

ValaDataType* _tmp629_;

2500

ValaDataType* _tmp630_;

2501

ValaArrayType* _tmp631_;

2502

ValaArrayType* array_type;

2503

ValaArrayType* _tmp632_;

2504

ValaParameter* _tmp650_;

2505

ValaDataType* _tmp651_;

2506

ValaDataType* _tmp652_;

2507

ValaCCodeIdentifier* _tmp653_;

2508

ValaCCodeIdentifier* _tmp654_;

2509

const gchar* _tmp655_;

2510

ValaCCodeIdentifier* _tmp656_;

2511

ValaCCodeIdentifier* _tmp657_;

2512

ValaParameter* _tmp658_;

2513

_tmp597_ = _param_index;

2514

_param_index = _tmp597_ + 1;

2515

_tmp598_ = _param_index;

2516

_tmp599_ = _param_size;

2517

if (!(_tmp598_ < _tmp599_)) {

2518

break;

2519

}

2520

_tmp600_ = _param_list;

2521

_tmp601_ = _param_index;

2522

_tmp602_ = vala_list_get (_tmp600_, _tmp601_);

2523

param = (ValaParameter*) _tmp602_;

2524

_tmp603_ = param;

2525

_tmp604_ = vala_parameter_get_direction (_tmp603_);

2526

_tmp605_ = _tmp604_;

2527

if (_tmp605_ != VALA_PARAMETER_DIRECTION_OUT) {

2528

_vala_code_node_unref0 (param);

2529

continue;

2530

}

2531

_tmp606_ = param;

2532

_tmp607_ = vala_symbol_get_name ((ValaSymbol*) _tmp606_);

2533

_tmp608_ = _tmp607_;

2534

_tmp609_ = vala_ccode_base_module_get_variable_cname ((ValaCCodeBaseModule*) self, _tmp608_);

2535

param_name = _tmp609_;

2536

_tmp610_ = param;

2537

_tmp611_ = vala_variable_get_variable_type ((ValaVariable*) _tmp610_);

2538

_tmp612_ = _tmp611_;

2539

_tmp613_ = vala_data_type_copy (_tmp612_);

2540

owned_type = _tmp613_;

2541

_tmp614_ = owned_type;

2542

vala_data_type_set_value_owned (_tmp614_, TRUE);

2543

_tmp615_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

2544

_tmp616_ = _tmp615_;

2545

_tmp617_ = owned_type;

2546

_tmp618_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp617_);

2547

_tmp619_ = _tmp618_;

2548

_tmp620_ = param_name;

2549

_tmp621_ = param;

2550

_tmp622_ = vala_variable_get_variable_type ((ValaVariable*) _tmp621_);

2551

_tmp623_ = _tmp622_;

2552

_tmp624_ = vala_ccode_base_module_default_value_for_type ((ValaCCodeBaseModule*) self, _tmp623_, TRUE);

2553

_tmp625_ = _tmp624_;

2554

_tmp626_ = vala_ccode_variable_declarator_new_zero (_tmp620_, _tmp625_, NULL);

2555

_tmp627_ = _tmp626_;

2556

vala_ccode_function_add_declaration (_tmp616_, _tmp619_, (ValaCCodeDeclarator*) _tmp627_, 0);

2557

_vala_ccode_node_unref0 (_tmp627_);

2558

_vala_ccode_node_unref0 (_tmp625_);

2559

_g_free0 (_tmp619_);

2560

_tmp628_ = param;

2561

_tmp629_ = vala_variable_get_variable_type ((ValaVariable*) _tmp628_);

2562

_tmp630_ = _tmp629_;

2563

_tmp631_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp630_, VALA_TYPE_ARRAY_TYPE) ? ((ValaArrayType*) _tmp630_) : NULL);

2564

array_type = _tmp631_;

2565

_tmp632_ = array_type;

2566

if (_tmp632_ != NULL) {

2567

{

2568

gint dim;

2569

dim = 1;

2570

{

2571

gboolean _tmp633_;

2572

_tmp633_ = TRUE;

2573

while (TRUE) {

2574

gboolean _tmp634_;

2575

gint _tmp636_;

2576

ValaArrayType* _tmp637_;

2577

gint _tmp638_;

2578

gint _tmp639_;

2579

ValaParameter* _tmp640_;

2580

gint _tmp641_;

2581

gchar* _tmp642_ = NULL;

2582

gchar* length_cname;

2583

ValaCCodeFunction* _tmp643_;

2584

ValaCCodeFunction* _tmp644_;

2585

const gchar* _tmp645_;

2586

ValaCCodeConstant* _tmp646_;

2587

ValaCCodeConstant* _tmp647_;

2588

ValaCCodeVariableDeclarator* _tmp648_;

2589

ValaCCodeVariableDeclarator* _tmp649_;

2590

_tmp634_ = _tmp633_;

2591

if (!_tmp634_) {

2592

gint _tmp635_;

2593

_tmp635_ = dim;

2594

dim = _tmp635_ + 1;

2595

}

2596

_tmp633_ = FALSE;

2597

_tmp636_ = dim;

2598

_tmp637_ = array_type;

2599

_tmp638_ = vala_array_type_get_rank (_tmp637_);

2600

_tmp639_ = _tmp638_;

2601

if (!(_tmp636_ <= _tmp639_)) {

2602

break;

2603

}

2604

_tmp640_ = param;

2605

_tmp641_ = dim;

2606

_tmp642_ = vala_ccode_base_module_get_parameter_array_length_cname ((ValaCCodeBaseModule*) self, _tmp640_, _tmp641_);

2607

length_cname = _tmp642_;

2608

_tmp643_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

2609

_tmp644_ = _tmp643_;

2610

_tmp645_ = length_cname;

2611

_tmp646_ = vala_ccode_constant_new ("0");

2612

_tmp647_ = _tmp646_;

2613

_tmp648_ = vala_ccode_variable_declarator_new_zero (_tmp645_, (ValaCCodeExpression*) _tmp647_, NULL);

2614

_tmp649_ = _tmp648_;

2615

vala_ccode_function_add_declaration (_tmp644_, "int", (ValaCCodeDeclarator*) _tmp649_, 0);

2616

_vala_ccode_node_unref0 (_tmp649_);

2617

_vala_ccode_node_unref0 (_tmp647_);

2618

_g_free0 (length_cname);

2619

}

2620

}

2621

}

2622

}

2623

_tmp650_ = param;

2624

_tmp651_ = vala_variable_get_variable_type ((ValaVariable*) _tmp650_);

2625

_tmp652_ = _tmp651_;

2626

_tmp653_ = vala_ccode_identifier_new ("_reply_builder");

2627

_tmp654_ = _tmp653_;

2628

_tmp655_ = param_name;

2629

_tmp656_ = vala_ccode_identifier_new (_tmp655_);

2630

_tmp657_ = _tmp656_;

2631

_tmp658_ = param;

2632

vala_gd_bus_module_send_dbus_value ((ValaGDBusModule*) self, _tmp652_, (ValaCCodeExpression*) _tmp654_, (ValaCCodeExpression*) _tmp657_, (ValaSymbol*) _tmp658_);

2633

_vala_ccode_node_unref0 (_tmp657_);

2634

_vala_ccode_node_unref0 (_tmp654_);

2635

_vala_code_node_unref0 (array_type);

2636

_vala_code_node_unref0 (owned_type);

2637

_g_free0 (param_name);

2638

_vala_code_node_unref0 (param);

2639

}

2640

_vala_iterable_unref0 (_param_list);

2641

}

2642

_tmp659_ = m;

2643

_tmp660_ = vala_method_get_return_type (_tmp659_);

2644

_tmp661_ = _tmp660_;

2645

if (!G_TYPE_CHECK_INSTANCE_TYPE (_tmp661_, VALA_TYPE_VOID_TYPE)) {

2646

ValaMethod* _tmp662_;

2647

ValaDataType* _tmp663_;

2648

ValaDataType* _tmp664_;

2649

gboolean _tmp665_ = FALSE;

2650

_tmp662_ = m;

2651

_tmp663_ = vala_method_get_return_type (_tmp662_);

2652

_tmp664_ = _tmp663_;

2653

_tmp665_ = vala_data_type_is_real_non_null_struct_type (_tmp664_);

2654

if (_tmp665_) {

2655

ValaCCodeFunction* _tmp666_;

2656

ValaCCodeFunction* _tmp667_;

2657

ValaMethod* _tmp668_;

2658

ValaDataType* _tmp669_;

2659

ValaDataType* _tmp670_;

2660

gchar* _tmp671_ = NULL;

2661

gchar* _tmp672_;

2662

ValaMethod* _tmp673_;

2663

ValaDataType* _tmp674_;

2664

ValaDataType* _tmp675_;

2665

ValaCCodeExpression* _tmp676_ = NULL;

2666

ValaCCodeExpression* _tmp677_;

2667

ValaCCodeVariableDeclarator* _tmp678_;

2668

ValaCCodeVariableDeclarator* _tmp679_;

2669

ValaMethod* _tmp680_;

2670

ValaDataType* _tmp681_;

2671

ValaDataType* _tmp682_;

2672

ValaCCodeIdentifier* _tmp683_;

2673

ValaCCodeIdentifier* _tmp684_;

2674

ValaCCodeIdentifier* _tmp685_;

2675

ValaCCodeIdentifier* _tmp686_;

2676

ValaMethod* _tmp687_;

2677

ValaMethod* _tmp688_;

2678

ValaDataType* _tmp689_;

2679

ValaDataType* _tmp690_;

2680

gboolean _tmp691_ = FALSE;

2681

_tmp666_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

2682

_tmp667_ = _tmp666_;

2683

_tmp668_ = m;

2684

_tmp669_ = vala_method_get_return_type (_tmp668_);

2685

_tmp670_ = _tmp669_;

2686

_tmp671_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp670_);

2687

_tmp672_ = _tmp671_;

2688

_tmp673_ = m;

2689

_tmp674_ = vala_method_get_return_type (_tmp673_);

2690

_tmp675_ = _tmp674_;

2691

_tmp676_ = vala_ccode_base_module_default_value_for_type ((ValaCCodeBaseModule*) self, _tmp675_, TRUE);

2692

_tmp677_ = _tmp676_;

2693

_tmp678_ = vala_ccode_variable_declarator_new_zero ("result", _tmp677_, NULL);

2694

_tmp679_ = _tmp678_;

2695

vala_ccode_function_add_declaration (_tmp667_, _tmp672_, (ValaCCodeDeclarator*) _tmp679_, 0);

2696

_vala_ccode_node_unref0 (_tmp679_);

2697

_vala_ccode_node_unref0 (_tmp677_);

2698

_g_free0 (_tmp672_);

2699

_tmp680_ = m;

2700

_tmp681_ = vala_method_get_return_type (_tmp680_);

2701

_tmp682_ = _tmp681_;

2702

_tmp683_ = vala_ccode_identifier_new ("_reply_builder");

2703

_tmp684_ = _tmp683_;

2704

_tmp685_ = vala_ccode_identifier_new ("result");

2705

_tmp686_ = _tmp685_;

2706

_tmp687_ = m;

2707

vala_gd_bus_module_send_dbus_value ((ValaGDBusModule*) self, _tmp682_, (ValaCCodeExpression*) _tmp684_, (ValaCCodeExpression*) _tmp686_, (ValaSymbol*) _tmp687_);

2708

_vala_ccode_node_unref0 (_tmp686_);

2709

_vala_ccode_node_unref0 (_tmp684_);

2710

_tmp688_ = m;

2711

_tmp689_ = vala_method_get_return_type (_tmp688_);

2712

_tmp690_ = _tmp689_;

2713

_tmp691_ = vala_ccode_base_module_requires_destroy ((ValaCCodeBaseModule*) self, _tmp690_);

2714

if (_tmp691_) {

2715

ValaMethod* _tmp692_;

2716

ValaDataType* _tmp693_;

2717

ValaDataType* _tmp694_;

2718

ValaLocalVariable* _tmp695_;

2719

ValaLocalVariable* local;

2720

ValaCCodeFunction* _tmp696_;

2721

ValaCCodeFunction* _tmp697_;

2722

ValaLocalVariable* _tmp698_;

2723

ValaCCodeExpression* _tmp699_ = NULL;

2724

ValaCCodeExpression* _tmp700_;

2725

_tmp692_ = m;

2726

_tmp693_ = vala_method_get_return_type (_tmp692_);

2727

_tmp694_ = _tmp693_;

2728

_tmp695_ = vala_local_variable_new (_tmp694_, ".result", NULL, NULL);

2729

local = _tmp695_;

2730

_tmp696_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

2731

_tmp697_ = _tmp696_;

2732

_tmp698_ = local;

2733

_tmp699_ = vala_ccode_base_module_destroy_local ((ValaCCodeBaseModule*) self, _tmp698_);

2734

_tmp700_ = _tmp699_;

2735

vala_ccode_function_add_expression (_tmp697_, _tmp700_);

2736

_vala_ccode_node_unref0 (_tmp700_);

2737

_vala_code_node_unref0 (local);

2738

}

2739

} else {

2740

ValaCCodeFunction* _tmp701_;

2741

ValaCCodeFunction* _tmp702_;

2742

ValaMethod* _tmp703_;

2743

ValaDataType* _tmp704_;

2744

ValaDataType* _tmp705_;

2745

gchar* _tmp706_ = NULL;

2746

gchar* _tmp707_;

2747

ValaCCodeVariableDeclarator* _tmp708_;

2748

ValaCCodeVariableDeclarator* _tmp709_;

2749

ValaMethod* _tmp710_;

2750

ValaDataType* _tmp711_;

2751

ValaDataType* _tmp712_;

2752

ValaArrayType* _tmp713_;

2753

ValaArrayType* array_type;

2754

ValaArrayType* _tmp714_;

2755

ValaMethod* _tmp731_;

2756

ValaDataType* _tmp732_;

2757

ValaDataType* _tmp733_;

2758

ValaCCodeIdentifier* _tmp734_;

2759

ValaCCodeIdentifier* _tmp735_;

2760

ValaCCodeIdentifier* _tmp736_;

2761

ValaCCodeIdentifier* _tmp737_;

2762

ValaMethod* _tmp738_;

2763

ValaMethod* _tmp739_;

2764

ValaDataType* _tmp740_;

2765

ValaDataType* _tmp741_;

2766

gboolean _tmp742_ = FALSE;

2767

_tmp701_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

2768

_tmp702_ = _tmp701_;

2769

_tmp703_ = m;

2770

_tmp704_ = vala_method_get_return_type (_tmp703_);

2771

_tmp705_ = _tmp704_;

2772

_tmp706_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp705_);

2773

_tmp707_ = _tmp706_;

2774

_tmp708_ = vala_ccode_variable_declarator_new ("result", NULL, NULL);

2775

_tmp709_ = _tmp708_;

2776

vala_ccode_function_add_declaration (_tmp702_, _tmp707_, (ValaCCodeDeclarator*) _tmp709_, 0);

2777

_vala_ccode_node_unref0 (_tmp709_);

2778

_g_free0 (_tmp707_);

2779

_tmp710_ = m;

2780

_tmp711_ = vala_method_get_return_type (_tmp710_);

2781

_tmp712_ = _tmp711_;

2782

_tmp713_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp712_, VALA_TYPE_ARRAY_TYPE) ? ((ValaArrayType*) _tmp712_) : NULL);

2783

array_type = _tmp713_;

2784

_tmp714_ = array_type;

2785

if (_tmp714_ != NULL) {

2786

{

2787

gint dim;

2788

dim = 1;

2789

{

2790

gboolean _tmp715_;

2791

_tmp715_ = TRUE;

2792

while (TRUE) {

2793

gboolean _tmp716_;

2794

gint _tmp718_;

2795

ValaArrayType* _tmp719_;

2796

gint _tmp720_;

2797

gint _tmp721_;

2798

gint _tmp722_;

2799

gchar* _tmp723_ = NULL;

2800

gchar* length_cname;

2801

ValaCCodeFunction* _tmp724_;

2802

ValaCCodeFunction* _tmp725_;

2803

const gchar* _tmp726_;

2804

ValaCCodeConstant* _tmp727_;

2805

ValaCCodeConstant* _tmp728_;

2806

ValaCCodeVariableDeclarator* _tmp729_;

2807

ValaCCodeVariableDeclarator* _tmp730_;

2808

_tmp716_ = _tmp715_;

2809

if (!_tmp716_) {

2810

gint _tmp717_;

2811

_tmp717_ = dim;

2812

dim = _tmp717_ + 1;

2813

}

2814

_tmp715_ = FALSE;

2815

_tmp718_ = dim;

2816

_tmp719_ = array_type;

2817

_tmp720_ = vala_array_type_get_rank (_tmp719_);

2818

_tmp721_ = _tmp720_;

2819

if (!(_tmp718_ <= _tmp721_)) {

2820

break;

2821

}

2822

_tmp722_ = dim;

2823

_tmp723_ = vala_ccode_base_module_get_array_length_cname ((ValaCCodeBaseModule*) self, "result", _tmp722_);

2824

length_cname = _tmp723_;

2825

_tmp724_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

2826

_tmp725_ = _tmp724_;

2827

_tmp726_ = length_cname;

2828

_tmp727_ = vala_ccode_constant_new ("0");

2829

_tmp728_ = _tmp727_;

2830

_tmp729_ = vala_ccode_variable_declarator_new_zero (_tmp726_, (ValaCCodeExpression*) _tmp728_, NULL);

2831

_tmp730_ = _tmp729_;

2832

vala_ccode_function_add_declaration (_tmp725_, "int", (ValaCCodeDeclarator*) _tmp730_, 0);

2833

_vala_ccode_node_unref0 (_tmp730_);

2834

_vala_ccode_node_unref0 (_tmp728_);

2835

_g_free0 (length_cname);

2836

}

2837

}

2838

}

2839

}

2840

_tmp731_ = m;

2841

_tmp732_ = vala_method_get_return_type (_tmp731_);

2842

_tmp733_ = _tmp732_;

2843

_tmp734_ = vala_ccode_identifier_new ("_reply_builder");

2844

_tmp735_ = _tmp734_;

2845

_tmp736_ = vala_ccode_identifier_new ("result");

2846

_tmp737_ = _tmp736_;

2847

_tmp738_ = m;

2848

vala_gd_bus_module_send_dbus_value ((ValaGDBusModule*) self, _tmp733_, (ValaCCodeExpression*) _tmp735_, (ValaCCodeExpression*) _tmp737_, (ValaSymbol*) _tmp738_);

2849

_vala_ccode_node_unref0 (_tmp737_);

2850

_vala_ccode_node_unref0 (_tmp735_);

2851

_tmp739_ = m;

2852

_tmp740_ = vala_method_get_return_type (_tmp739_);

2853

_tmp741_ = _tmp740_;

2854

_tmp742_ = vala_ccode_base_module_requires_destroy ((ValaCCodeBaseModule*) self, _tmp741_);

2855

if (_tmp742_) {

2856

ValaMethod* _tmp743_;

2857

ValaDataType* _tmp744_;

2858

ValaDataType* _tmp745_;

2859

ValaLocalVariable* _tmp746_;

2860

ValaLocalVariable* local;

2861

ValaCCodeFunction* _tmp747_;

2862

ValaCCodeFunction* _tmp748_;

2863

ValaLocalVariable* _tmp749_;

2864

ValaCCodeExpression* _tmp750_ = NULL;

2865

ValaCCodeExpression* _tmp751_;

2866

_tmp743_ = m;

2867

_tmp744_ = vala_method_get_return_type (_tmp743_);

2868

_tmp745_ = _tmp744_;

2869

_tmp746_ = vala_local_variable_new (_tmp745_, ".result", NULL, NULL);

2870

local = _tmp746_;

2871

_tmp747_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

2872

_tmp748_ = _tmp747_;

2873

_tmp749_ = local;

2874

_tmp750_ = vala_ccode_base_module_destroy_local ((ValaCCodeBaseModule*) self, _tmp749_);

2875

_tmp751_ = _tmp750_;

2876

vala_ccode_function_add_expression (_tmp748_, _tmp751_);

2877

_vala_ccode_node_unref0 (_tmp751_);

2878

_vala_code_node_unref0 (local);

2879

}

2880

_vala_code_node_unref0 (array_type);

2881

}

2882

}

2883

_tmp752_ = vala_ccode_identifier_new ("g_variant_builder_end");

2884

_tmp753_ = _tmp752_;

2885

_tmp754_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp753_);

2886

_tmp755_ = _tmp754_;

2887

_vala_ccode_node_unref0 (_tmp753_);

2888

builder_end = _tmp755_;

2889

_tmp756_ = builder_end;

2890

_tmp757_ = vala_ccode_identifier_new ("_reply_builder");

2891

_tmp758_ = _tmp757_;

2892

_tmp759_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, (ValaCCodeExpression*) _tmp758_);

2893

_tmp760_ = _tmp759_;

2894

vala_ccode_function_call_add_argument (_tmp756_, (ValaCCodeExpression*) _tmp760_);

2895

_vala_ccode_node_unref0 (_tmp760_);

2896

_vala_ccode_node_unref0 (_tmp758_);

2897

_tmp761_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

2898

_tmp762_ = _tmp761_;

2899

_tmp763_ = vala_ccode_identifier_new ("_reply");

2900

_tmp764_ = _tmp763_;

2901

_tmp765_ = builder_end;

2902

vala_ccode_function_add_assignment (_tmp762_, (ValaCCodeExpression*) _tmp764_, (ValaCCodeExpression*) _tmp765_);

2903

_vala_ccode_node_unref0 (_tmp764_);

2904

_tmp766_ = vala_ccode_identifier_new ("g_dbus_message_set_body");

2905

_tmp767_ = _tmp766_;

2906

_tmp768_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp767_);

2907

_tmp769_ = _tmp768_;

2908

_vala_ccode_node_unref0 (_tmp767_);

2909

set_body = _tmp769_;

2910

_tmp770_ = set_body;

2911

_tmp771_ = vala_ccode_identifier_new ("_reply_message");

2912

_tmp772_ = _tmp771_;

2913

vala_ccode_function_call_add_argument (_tmp770_, (ValaCCodeExpression*) _tmp772_);

2914

_vala_ccode_node_unref0 (_tmp772_);

2915

_tmp773_ = set_body;

2916

_tmp774_ = vala_ccode_identifier_new ("_reply");

2917

_tmp775_ = _tmp774_;

2918

vala_ccode_function_call_add_argument (_tmp773_, (ValaCCodeExpression*) _tmp775_);

2919

_vala_ccode_node_unref0 (_tmp775_);

2920

_tmp776_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

2921

_tmp777_ = _tmp776_;

2922

_tmp778_ = set_body;

2923

vala_ccode_function_add_expression (_tmp777_, (ValaCCodeExpression*) _tmp778_);

2924

_tmp779_ = uses_fd;

2925

if (_tmp779_) {

2926

ValaCCodeIdentifier* _tmp780_;

2927

ValaCCodeIdentifier* _tmp781_;

2928

ValaCCodeFunctionCall* _tmp782_;

2929

ValaCCodeFunctionCall* _tmp783_;

2930

ValaCCodeIdentifier* _tmp784_;

2931

ValaCCodeIdentifier* _tmp785_;

2932

ValaCCodeFunctionCall* _tmp786_;

2933

ValaCCodeIdentifier* _tmp787_;

2934

ValaCCodeIdentifier* _tmp788_;

2935

ValaCCodeFunction* _tmp789_;

2936

ValaCCodeFunction* _tmp790_;

2937

ValaCCodeFunctionCall* _tmp791_;

2938

ValaCCodeIdentifier* _tmp792_;

2939

ValaCCodeIdentifier* _tmp793_;

2940

ValaCCodeFunctionCall* _tmp794_;

2941

ValaCCodeFunctionCall* _tmp795_;

2942

ValaCCodeIdentifier* _tmp796_;

2943

ValaCCodeIdentifier* _tmp797_;

2944

ValaCCodeFunction* _tmp798_;

2945

ValaCCodeFunction* _tmp799_;

2946

ValaCCodeFunctionCall* _tmp800_;

2947

_tmp780_ = vala_ccode_identifier_new ("g_dbus_message_set_unix_fd_list");

2948

_tmp781_ = _tmp780_;

2949

_tmp782_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp781_);

2950

_vala_ccode_node_unref0 (ccall);

2951

ccall = _tmp782_;

2952

_vala_ccode_node_unref0 (_tmp781_);

2953

_tmp783_ = ccall;

2954

_tmp784_ = vala_ccode_identifier_new ("_reply_message");

2955

_tmp785_ = _tmp784_;

2956

vala_ccode_function_call_add_argument (_tmp783_, (ValaCCodeExpression*) _tmp785_);

2957

_vala_ccode_node_unref0 (_tmp785_);

2958

_tmp786_ = ccall;

2959

_tmp787_ = vala_ccode_identifier_new ("_fd_list");

2960

_tmp788_ = _tmp787_;

2961

vala_ccode_function_call_add_argument (_tmp786_, (ValaCCodeExpression*) _tmp788_);

2962

_vala_ccode_node_unref0 (_tmp788_);

2963

_tmp789_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

2964

_tmp790_ = _tmp789_;

2965

_tmp791_ = ccall;

2966

vala_ccode_function_add_expression (_tmp790_, (ValaCCodeExpression*) _tmp791_);

2967

_tmp792_ = vala_ccode_identifier_new ("g_object_unref");

2968

_tmp793_ = _tmp792_;

2969

_tmp794_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp793_);

2970

_vala_ccode_node_unref0 (ccall);

2971

ccall = _tmp794_;

2972

_vala_ccode_node_unref0 (_tmp793_);

2973

_tmp795_ = ccall;

2974

_tmp796_ = vala_ccode_identifier_new ("_fd_list");

2975

_tmp797_ = _tmp796_;

2976

vala_ccode_function_call_add_argument (_tmp795_, (ValaCCodeExpression*) _tmp797_);

2977

_vala_ccode_node_unref0 (_tmp797_);

2978

_tmp798_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

2979

_tmp799_ = _tmp798_;

2980

_tmp800_ = ccall;

2981

vala_ccode_function_add_expression (_tmp799_, (ValaCCodeExpression*) _tmp800_);

2982

}

2983

_vala_ccode_node_unref0 (set_body);

2984

_vala_ccode_node_unref0 (builder_end);

2985

_vala_ccode_node_unref0 (builder_init);

2986

_vala_ccode_node_unref0 (message_expr);

2987

} else {

2988

ValaCCodeFunction* _tmp801_;

2989

ValaCCodeFunction* _tmp802_;

2990

ValaCCodeFunctionCall* _tmp803_;

2991

_tmp801_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

2992

_tmp802_ = _tmp801_;

2993

_tmp803_ = ccall;

2994

vala_ccode_function_add_expression (_tmp802_, (ValaCCodeExpression*) _tmp803_);

2995

}

2996

{

2997

ValaMethod* _tmp804_;

2998

ValaList* _tmp805_ = NULL;

2999

ValaList* _param_list;

3000

ValaList* _tmp806_;

3001

gint _tmp807_;

3002

gint _tmp808_;

3003

gint _param_size;

3004

gint _param_index;

3005

_tmp804_ = m;

3006

_tmp805_ = vala_method_get_parameters (_tmp804_);

3007

_param_list = _tmp805_;

3008

_tmp806_ = _param_list;

3009

_tmp807_ = vala_collection_get_size ((ValaCollection*) _tmp806_);

3010

_tmp808_ = _tmp807_;

3011

_param_size = _tmp808_;

3012

_param_index = -1;

3013

while (TRUE) {

3014

gint _tmp809_;

3015

gint _tmp810_;

3016

gint _tmp811_;

3017

ValaList* _tmp812_;

3018

gint _tmp813_;

3019

gpointer _tmp814_ = NULL;

3020

ValaParameter* param;

3021

gboolean _tmp815_ = FALSE;

3022

gboolean _tmp816_ = FALSE;

3023

ValaParameter* _tmp817_;

3024

ValaParameterDirection _tmp818_;

3025

ValaParameterDirection _tmp819_;

3026

gboolean _tmp821_;

3027

gboolean _tmp836_;

3028

_tmp809_ = _param_index;

3029

_param_index = _tmp809_ + 1;

3030

_tmp810_ = _param_index;

3031

_tmp811_ = _param_size;

3032

if (!(_tmp810_ < _tmp811_)) {

3033

break;

3034

}

3035

_tmp812_ = _param_list;

3036

_tmp813_ = _param_index;

3037

_tmp814_ = vala_list_get (_tmp812_, _tmp813_);

3038

param = (ValaParameter*) _tmp814_;

3039

_tmp817_ = param;

3040

_tmp818_ = vala_parameter_get_direction (_tmp817_);

3041

_tmp819_ = _tmp818_;

3042

if (_tmp819_ == VALA_PARAMETER_DIRECTION_IN) {

3043

gboolean _tmp820_;

3044

_tmp820_ = ready;

3045

_tmp816_ = !_tmp820_;

3046

} else {

3047

_tmp816_ = FALSE;

3048

}

3049

_tmp821_ = _tmp816_;

3050

if (_tmp821_) {

3051

_tmp815_ = TRUE;

3052

} else {

3053

gboolean _tmp822_ = FALSE;

3054

gboolean _tmp823_ = FALSE;

3055

ValaParameter* _tmp824_;

3056

ValaParameterDirection _tmp825_;

3057

ValaParameterDirection _tmp826_;

3058

gboolean _tmp828_;

3059

gboolean _tmp835_;

3060

_tmp824_ = param;

3061

_tmp825_ = vala_parameter_get_direction (_tmp824_);

3062

_tmp826_ = _tmp825_;

3063

if (_tmp826_ == VALA_PARAMETER_DIRECTION_OUT) {

3064

gboolean _tmp827_;

3065

_tmp827_ = no_reply;

3066

_tmp823_ = !_tmp827_;

3067

} else {

3068

_tmp823_ = FALSE;

3069

}

3070

_tmp828_ = _tmp823_;

3071

if (_tmp828_) {

3072

gboolean _tmp829_ = FALSE;

3073

ValaMethod* _tmp830_;

3074

gboolean _tmp831_;

3075

gboolean _tmp832_;

3076

gboolean _tmp834_;

3077

_tmp830_ = m;

3078

_tmp831_ = vala_method_get_coroutine (_tmp830_);

3079

_tmp832_ = _tmp831_;

3080

if (!_tmp832_) {

3081

_tmp829_ = TRUE;

3082

} else {

3083

gboolean _tmp833_;

3084

_tmp833_ = ready;

3085

_tmp829_ = _tmp833_;

3086

}

3087

_tmp834_ = _tmp829_;

3088

_tmp822_ = _tmp834_;

3089

} else {

3090

_tmp822_ = FALSE;

3091

}

3092

_tmp835_ = _tmp822_;

3093

_tmp815_ = _tmp835_;

3094

}

3095

_tmp836_ = _tmp815_;

3096

if (_tmp836_) {

3097

gboolean _tmp837_ = FALSE;

3098

ValaParameter* _tmp838_;

3099

ValaDataType* _tmp839_;

3100

ValaDataType* _tmp840_;

3101

gboolean _tmp848_;

3102

gboolean _tmp849_ = FALSE;

3103

ValaParameter* _tmp850_;

3104

ValaDataType* _tmp851_;

3105

ValaDataType* _tmp852_;

3106

gboolean _tmp860_;

3107

ValaParameter* _tmp861_;

3108

ValaDataType* _tmp862_;

3109

ValaDataType* _tmp863_;

3110

ValaDataType* _tmp864_ = NULL;

3111

ValaDataType* owned_type;

3112

ValaDataType* _tmp865_;

3113

ValaDataType* _tmp866_;

3114

gboolean _tmp867_ = FALSE;

3115

_tmp838_ = param;

3116

_tmp839_ = vala_variable_get_variable_type ((ValaVariable*) _tmp838_);

3117

_tmp840_ = _tmp839_;

3118

if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp840_, VALA_TYPE_OBJECT_TYPE)) {

3119

ValaParameter* _tmp841_;

3120

ValaDataType* _tmp842_;

3121

ValaDataType* _tmp843_;

3122

ValaTypeSymbol* _tmp844_;

3123

ValaTypeSymbol* _tmp845_;

3124

gchar* _tmp846_ = NULL;

3125

gchar* _tmp847_;

3126

_tmp841_ = param;

3127

_tmp842_ = vala_variable_get_variable_type ((ValaVariable*) _tmp841_);

3128

_tmp843_ = _tmp842_;

3129

_tmp844_ = vala_data_type_get_data_type (_tmp843_);

3130

_tmp845_ = _tmp844_;

3131

_tmp846_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp845_);

3132

_tmp847_ = _tmp846_;

3133

_tmp837_ = g_strcmp0 (_tmp847_, "GLib.Cancellable") == 0;

3134

_g_free0 (_tmp847_);

3135

} else {

3136

_tmp837_ = FALSE;

3137

}

3138

_tmp848_ = _tmp837_;

3139

if (_tmp848_) {

3140

_vala_code_node_unref0 (param);

3141

continue;

3142

}

3143

_tmp850_ = param;

3144

_tmp851_ = vala_variable_get_variable_type ((ValaVariable*) _tmp850_);

3145

_tmp852_ = _tmp851_;

3146

if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp852_, VALA_TYPE_OBJECT_TYPE)) {

3147

ValaParameter* _tmp853_;

3148

ValaDataType* _tmp854_;

3149

ValaDataType* _tmp855_;

3150

ValaTypeSymbol* _tmp856_;

3151

ValaTypeSymbol* _tmp857_;

3152

gchar* _tmp858_ = NULL;

3153

gchar* _tmp859_;

3154

_tmp853_ = param;

3155

_tmp854_ = vala_variable_get_variable_type ((ValaVariable*) _tmp853_);

3156

_tmp855_ = _tmp854_;

3157

_tmp856_ = vala_data_type_get_data_type (_tmp855_);

3158

_tmp857_ = _tmp856_;

3159

_tmp858_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp857_);

3160

_tmp859_ = _tmp858_;

3161

_tmp849_ = g_strcmp0 (_tmp859_, "GLib.BusName") == 0;

3162

_g_free0 (_tmp859_);

3163

} else {

3164

_tmp849_ = FALSE;

3165

}

3166

_tmp860_ = _tmp849_;

3167

if (_tmp860_) {

3168

_vala_code_node_unref0 (param);

3169

continue;

3170

}

3171

_tmp861_ = param;

3172

_tmp862_ = vala_variable_get_variable_type ((ValaVariable*) _tmp861_);

3173

_tmp863_ = _tmp862_;

3174

_tmp864_ = vala_data_type_copy (_tmp863_);

3175

owned_type = _tmp864_;

3176

_tmp865_ = owned_type;

3177

vala_data_type_set_value_owned (_tmp865_, TRUE);

3178

_tmp866_ = owned_type;

3179

_tmp867_ = vala_ccode_base_module_requires_destroy ((ValaCCodeBaseModule*) self, _tmp866_);

3180

if (_tmp867_) {

3181

ValaDataType* _tmp868_;

3182

ValaParameter* _tmp869_;

3183

const gchar* _tmp870_;

3184

const gchar* _tmp871_;

3185

gchar* _tmp872_ = NULL;

3186

gchar* _tmp873_;

3187

ValaLocalVariable* _tmp874_;

3188

ValaLocalVariable* _tmp875_;

3189

ValaLocalVariable* local;

3190

ValaCCodeFunction* _tmp876_;

3191

ValaCCodeFunction* _tmp877_;

3192

ValaLocalVariable* _tmp878_;

3193

ValaCCodeExpression* _tmp879_ = NULL;

3194

ValaCCodeExpression* _tmp880_;

3195

_tmp868_ = owned_type;

3196

_tmp869_ = param;

3197

_tmp870_ = vala_symbol_get_name ((ValaSymbol*) _tmp869_);

3198

_tmp871_ = _tmp870_;

3199

_tmp872_ = vala_ccode_base_module_get_variable_cname ((ValaCCodeBaseModule*) self, _tmp871_);

3200

_tmp873_ = _tmp872_;

3201

_tmp874_ = vala_local_variable_new (_tmp868_, _tmp873_, NULL, NULL);

3202

_tmp875_ = _tmp874_;

3203

_g_free0 (_tmp873_);

3204

local = _tmp875_;

3205

_tmp876_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

3206

_tmp877_ = _tmp876_;

3207

_tmp878_ = local;

3208

_tmp879_ = vala_ccode_base_module_destroy_local ((ValaCCodeBaseModule*) self, _tmp878_);

3209

_tmp880_ = _tmp879_;

3210

vala_ccode_function_add_expression (_tmp877_, _tmp880_);

3211

_vala_ccode_node_unref0 (_tmp880_);

3212

_vala_code_node_unref0 (local);

3213

}

3214

_vala_code_node_unref0 (owned_type);

3215

}

3216

_vala_code_node_unref0 (param);

3217

}

3218

_vala_iterable_unref0 (_param_list);

3219

}

3220

_tmp882_ = no_reply;

3221

if (!_tmp882_) {

3222

gboolean _tmp883_ = FALSE;

3223

ValaMethod* _tmp884_;

3224

gboolean _tmp885_;

3225

gboolean _tmp886_;

3226

gboolean _tmp888_;

3227

_tmp884_ = m;

3228

_tmp885_ = vala_method_get_coroutine (_tmp884_);

3229

_tmp886_ = _tmp885_;

3230

if (!_tmp886_) {

3231

_tmp883_ = TRUE;

3232

} else {

3233

gboolean _tmp887_;

3234

_tmp887_ = ready;

3235

_tmp883_ = _tmp887_;

3236

}

3237

_tmp888_ = _tmp883_;

3238

_tmp881_ = _tmp888_;

3239

} else {

3240

_tmp881_ = FALSE;

3241

}

3242

_tmp889_ = _tmp881_;

3243

if (_tmp889_) {

3244

ValaCCodeIdentifier* _tmp890_;

3245

ValaCCodeIdentifier* _tmp891_;

3246

ValaCCodeFunctionCall* _tmp892_;

3247

ValaCCodeFunctionCall* _tmp893_;

3248

ValaCCodeFunctionCall* return_value;

3249

ValaCCodeFunctionCall* _tmp894_;

3250

ValaCCodeFunctionCall* _tmp895_;

3251

ValaCCodeFunctionCall* _tmp896_;

3252

ValaCCodeIdentifier* _tmp897_;

3253

ValaCCodeIdentifier* _tmp898_;

3254

ValaCCodeFunctionCall* _tmp899_;

3255

ValaCCodeConstant* _tmp900_;

3256

ValaCCodeConstant* _tmp901_;

3257

ValaCCodeFunctionCall* _tmp902_;

3258

ValaCCodeConstant* _tmp903_;

3259

ValaCCodeConstant* _tmp904_;

3260

ValaCCodeFunctionCall* _tmp905_;

3261

ValaCCodeConstant* _tmp906_;

3262

ValaCCodeConstant* _tmp907_;

3263

ValaCCodeFunction* _tmp908_;

3264

ValaCCodeFunction* _tmp909_;

3265

ValaCCodeFunctionCall* _tmp910_;

3266

ValaCCodeIdentifier* _tmp911_;

3267

ValaCCodeIdentifier* _tmp912_;

3268

ValaCCodeFunctionCall* _tmp913_;

3269

ValaCCodeFunctionCall* _tmp914_;

3270

ValaCCodeFunctionCall* unref_call;

3271

ValaCCodeFunctionCall* _tmp915_;

3272

ValaCCodeIdentifier* _tmp916_;

3273

ValaCCodeIdentifier* _tmp917_;

3274

ValaCCodeFunction* _tmp918_;

3275

ValaCCodeFunction* _tmp919_;

3276

ValaCCodeFunctionCall* _tmp920_;

3277

ValaCCodeIdentifier* _tmp921_;

3278

ValaCCodeIdentifier* _tmp922_;

3279

ValaCCodeFunctionCall* _tmp923_;

3280

ValaCCodeFunctionCall* _tmp924_;

3281

ValaCCodeIdentifier* _tmp925_;

3282

ValaCCodeIdentifier* _tmp926_;

3283

ValaCCodeFunction* _tmp927_;

3284

ValaCCodeFunction* _tmp928_;

3285

ValaCCodeFunctionCall* _tmp929_;

3286

_tmp890_ = vala_ccode_identifier_new ("g_dbus_connection_send_message");

3287

_tmp891_ = _tmp890_;

3288

_tmp892_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp891_);

3289

_tmp893_ = _tmp892_;

3290

_vala_ccode_node_unref0 (_tmp891_);

3291

return_value = _tmp893_;

3292

_tmp894_ = return_value;

3293

_tmp895_ = connection;

3294

vala_ccode_function_call_add_argument (_tmp894_, (ValaCCodeExpression*) _tmp895_);

3295

_tmp896_ = return_value;

3296

_tmp897_ = vala_ccode_identifier_new ("_reply_message");

3297

_tmp898_ = _tmp897_;

3298

vala_ccode_function_call_add_argument (_tmp896_, (ValaCCodeExpression*) _tmp898_);

3299

_vala_ccode_node_unref0 (_tmp898_);

3300

_tmp899_ = return_value;

3301

_tmp900_ = vala_ccode_constant_new ("G_DBUS_SEND_MESSAGE_FLAGS_NONE");

3302

_tmp901_ = _tmp900_;

3303

vala_ccode_function_call_add_argument (_tmp899_, (ValaCCodeExpression*) _tmp901_);

3304

_vala_ccode_node_unref0 (_tmp901_);

3305

_tmp902_ = return_value;

3306

_tmp903_ = vala_ccode_constant_new ("NULL");

3307

_tmp904_ = _tmp903_;

3308

vala_ccode_function_call_add_argument (_tmp902_, (ValaCCodeExpression*) _tmp904_);

3309

_vala_ccode_node_unref0 (_tmp904_);

3310

_tmp905_ = return_value;

3311

_tmp906_ = vala_ccode_constant_new ("NULL");

3312

_tmp907_ = _tmp906_;

3313

vala_ccode_function_call_add_argument (_tmp905_, (ValaCCodeExpression*) _tmp907_);

3314

_vala_ccode_node_unref0 (_tmp907_);

3315

_tmp908_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

3316

_tmp909_ = _tmp908_;

3317

_tmp910_ = return_value;

3318

vala_ccode_function_add_expression (_tmp909_, (ValaCCodeExpression*) _tmp910_);

3319

_tmp911_ = vala_ccode_identifier_new ("g_object_unref");

3320

_tmp912_ = _tmp911_;

3321

_tmp913_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp912_);

3322

_tmp914_ = _tmp913_;

3323

_vala_ccode_node_unref0 (_tmp912_);

3324

unref_call = _tmp914_;

3325

_tmp915_ = unref_call;

3326

_tmp916_ = vala_ccode_identifier_new ("invocation");

3327

_tmp917_ = _tmp916_;

3328

vala_ccode_function_call_add_argument (_tmp915_, (ValaCCodeExpression*) _tmp917_);

3329

_vala_ccode_node_unref0 (_tmp917_);

3330

_tmp918_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

3331

_tmp919_ = _tmp918_;

3332

_tmp920_ = unref_call;

3333

vala_ccode_function_add_expression (_tmp919_, (ValaCCodeExpression*) _tmp920_);

3334

_tmp921_ = vala_ccode_identifier_new ("g_object_unref");

3335

_tmp922_ = _tmp921_;

3336

_tmp923_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp922_);

3337

_vala_ccode_node_unref0 (unref_call);

3338

unref_call = _tmp923_;

3339

_vala_ccode_node_unref0 (_tmp922_);

3340

_tmp924_ = unref_call;

3341

_tmp925_ = vala_ccode_identifier_new ("_reply_message");

3342

_tmp926_ = _tmp925_;

3343

vala_ccode_function_call_add_argument (_tmp924_, (ValaCCodeExpression*) _tmp926_);

3344

_vala_ccode_node_unref0 (_tmp926_);

3345

_tmp927_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

3346

_tmp928_ = _tmp927_;

3347

_tmp929_ = unref_call;

3348

vala_ccode_function_add_expression (_tmp928_, (ValaCCodeExpression*) _tmp929_);

3349

_vala_ccode_node_unref0 (unref_call);

3350

_vala_ccode_node_unref0 (return_value);

3351

}

3352

vala_ccode_base_module_pop_function ((ValaCCodeBaseModule*) self);

3353

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

3354

_tmp931_ = function;

3355

vala_ccode_file_add_function_declaration (_tmp930_, _tmp931_);

3356

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

3357

_tmp933_ = function;

3358

vala_ccode_file_add_function (_tmp932_, _tmp933_);

3359

_tmp935_ = m;

3360

_tmp936_ = vala_method_get_coroutine (_tmp935_);

3361

_tmp937_ = _tmp936_;

3362

if (_tmp937_) {

3363

gboolean _tmp938_;

3364

_tmp938_ = ready;

3365

_tmp934_ = !_tmp938_;

3366

} else {

3367

_tmp934_ = FALSE;

3368

}

3369

_tmp939_ = _tmp934_;

3370

if (_tmp939_) {

3371

ValaMethod* _tmp940_;

3372

ValaObjectTypeSymbol* _tmp941_;

3373

gchar* _tmp942_ = NULL;

3374

gchar* _tmp943_;

3375

_tmp940_ = m;

3376

_tmp941_ = sym;

3377

_tmp942_ = vala_gd_bus_server_module_generate_dbus_wrapper (self, _tmp940_, _tmp941_, TRUE);

3378

_tmp943_ = _tmp942_;

3379

_g_free0 (_tmp943_);

3380

}

3381

result = wrapper_name;

3382

_vala_ccode_node_unref0 (ccall);

3383

_vala_ccode_node_unref0 (connection);

3384

_vala_ccode_node_unref0 (function);

3385

return result;

3386

}

3387

3388

3389

static gchar* vala_gd_bus_server_module_generate_dbus_signal_wrapper (ValaGDBusServerModule* self, ValaSignal* sig, ValaObjectTypeSymbol* sym, const gchar* dbus_iface_name) {

3390

gchar* result = NULL;

3391

ValaObjectTypeSymbol* _tmp0_;

3392

gchar* _tmp1_ = NULL;

3393

gchar* _tmp2_;

3394

ValaSignal* _tmp3_;

3395

gchar* _tmp4_ = NULL;

3396

gchar* _tmp5_;

3397

gchar* _tmp6_ = NULL;

3398

gchar* _tmp7_;

3399

gchar* wrapper_name;

3400

const gchar* _tmp8_;

3401

ValaCCodeFunction* _tmp9_;

3402

ValaCCodeFunction* function;

3403

ValaCCodeFunction* _tmp10_;

3404

ValaCCodeFunction* _tmp11_;

3405

ValaCCodeParameter* _tmp12_;

3406

ValaCCodeParameter* _tmp13_;

3407

ValaCCodeFunction* _tmp57_;

3408

ValaCCodeParameter* _tmp58_;

3409

ValaCCodeParameter* _tmp59_;

3410

ValaCCodeFunction* _tmp60_;

3411

ValaCCodeFunction* _tmp61_;

3412

ValaCCodeFunction* _tmp62_;

3413

ValaCCodeIdentifier* _tmp63_;

3414

ValaCCodeIdentifier* _tmp64_;

3415

ValaCCodeConstant* _tmp65_;

3416

ValaCCodeConstant* _tmp66_;

3417

ValaCCodeElementAccess* _tmp67_;

3418

ValaCCodeElementAccess* _tmp68_;

3419

ValaCCodeVariableDeclarator* _tmp69_;

3420

ValaCCodeVariableDeclarator* _tmp70_;

3421

ValaCCodeFunction* _tmp71_;

3422

ValaCCodeFunction* _tmp72_;

3423

ValaCCodeIdentifier* _tmp73_;

3424

ValaCCodeIdentifier* _tmp74_;

3425

ValaCCodeConstant* _tmp75_;

3426

ValaCCodeConstant* _tmp76_;

3427

ValaCCodeElementAccess* _tmp77_;

3428

ValaCCodeElementAccess* _tmp78_;

3429

ValaCCodeVariableDeclarator* _tmp79_;

3430

ValaCCodeVariableDeclarator* _tmp80_;

3431

ValaCCodeFunction* _tmp81_;

3432

ValaCCodeFunction* _tmp82_;

3433

ValaCCodeVariableDeclarator* _tmp83_;

3434

ValaCCodeVariableDeclarator* _tmp84_;

3435

ValaCCodeFunction* _tmp85_;

3436

ValaCCodeFunction* _tmp86_;

3437

ValaCCodeVariableDeclarator* _tmp87_;

3438

ValaCCodeVariableDeclarator* _tmp88_;

3439

ValaCCodeIdentifier* _tmp89_;

3440

ValaCCodeIdentifier* _tmp90_;

3441

ValaCCodeFunctionCall* _tmp91_;

3442

ValaCCodeFunctionCall* _tmp92_;

3443

ValaCCodeFunctionCall* builder_init;

3444

ValaCCodeFunctionCall* _tmp93_;

3445

ValaCCodeIdentifier* _tmp94_;

3446

ValaCCodeIdentifier* _tmp95_;

3447

ValaCCodeUnaryExpression* _tmp96_;

3448

ValaCCodeUnaryExpression* _tmp97_;

3449

ValaCCodeFunctionCall* _tmp98_;

3450

ValaCCodeIdentifier* _tmp99_;

3451

ValaCCodeIdentifier* _tmp100_;

3452

ValaCCodeFunction* _tmp101_;

3453

ValaCCodeFunction* _tmp102_;

3454

ValaCCodeFunctionCall* _tmp103_;

3455

ValaCCodeIdentifier* _tmp134_;

3456

ValaCCodeIdentifier* _tmp135_;

3457

ValaCCodeFunctionCall* _tmp136_;

3458

ValaCCodeFunctionCall* _tmp137_;

3459

ValaCCodeFunctionCall* builder_end;

3460

ValaCCodeIdentifier* _tmp138_;

3461

ValaCCodeIdentifier* _tmp139_;

3462

ValaCCodeUnaryExpression* _tmp140_;

3463

ValaCCodeUnaryExpression* _tmp141_;

3464

ValaCCodeFunction* _tmp142_;

3465

ValaCCodeFunction* _tmp143_;

3466

ValaCCodeIdentifier* _tmp144_;

3467

ValaCCodeIdentifier* _tmp145_;

3468

ValaCCodeIdentifier* _tmp146_;

3469

ValaCCodeIdentifier* _tmp147_;

3470

ValaCCodeFunctionCall* _tmp148_;

3471

ValaCCodeFunctionCall* _tmp149_;

3472

ValaCCodeFunctionCall* ccall;

3473

ValaCCodeIdentifier* _tmp150_;

3474

ValaCCodeIdentifier* _tmp151_;

3475

ValaCCodeConstant* _tmp152_;

3476

ValaCCodeConstant* _tmp153_;

3477

ValaCCodeIdentifier* _tmp154_;

3478

ValaCCodeIdentifier* _tmp155_;

3479

const gchar* _tmp156_;

3480

gchar* _tmp157_ = NULL;

3481

gchar* _tmp158_;

3482

ValaCCodeConstant* _tmp159_;

3483

ValaCCodeConstant* _tmp160_;

3484

ValaSignal* _tmp161_;

3485

gchar* _tmp162_ = NULL;

3486

gchar* _tmp163_;

3487

gchar* _tmp164_ = NULL;

3488

gchar* _tmp165_;

3489

ValaCCodeConstant* _tmp166_;

3490

ValaCCodeConstant* _tmp167_;

3491

ValaCCodeIdentifier* _tmp168_;

3492

ValaCCodeIdentifier* _tmp169_;

3493

ValaCCodeConstant* _tmp170_;

3494

ValaCCodeConstant* _tmp171_;

3495

ValaCCodeFunction* _tmp172_;

3496

ValaCCodeFunction* _tmp173_;

3497

ValaCCodeFile* _tmp174_;

3498

ValaCCodeFunction* _tmp175_;

3499

ValaCCodeFile* _tmp176_;

3500

ValaCCodeFunction* _tmp177_;

3501

g_return_val_if_fail (self != NULL, NULL);

3502

g_return_val_if_fail (sig != NULL, NULL);

3503

g_return_val_if_fail (sym != NULL, NULL);

3504

g_return_val_if_fail (dbus_iface_name != NULL, NULL);

3505

_tmp0_ = sym;

3506

_tmp1_ = vala_ccode_base_module_get_ccode_lower_case_name ((ValaCodeNode*) _tmp0_, NULL);

3507

_tmp2_ = _tmp1_;

3508

_tmp3_ = sig;

3509

_tmp4_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp3_);

3510

_tmp5_ = _tmp4_;

3511

_tmp6_ = g_strdup_printf ("_dbus_%s_%s", _tmp2_, _tmp5_);

3512

_tmp7_ = _tmp6_;

3513

_g_free0 (_tmp5_);

3514

_g_free0 (_tmp2_);

3515

wrapper_name = _tmp7_;

3516

_tmp8_ = wrapper_name;

3517

_tmp9_ = vala_ccode_function_new (_tmp8_, "void");

3518

function = _tmp9_;

3519

_tmp10_ = function;

3520

vala_ccode_function_set_modifiers (_tmp10_, VALA_CCODE_MODIFIERS_STATIC);

3521

_tmp11_ = function;

3522

_tmp12_ = vala_ccode_parameter_new ("_sender", "GObject*");

3523

_tmp13_ = _tmp12_;

3524

vala_ccode_function_add_parameter (_tmp11_, _tmp13_);

3525

_vala_ccode_node_unref0 (_tmp13_);

3526

{

3527

ValaSignal* _tmp14_;

3528

ValaList* _tmp15_ = NULL;

3529

ValaList* _param_list;

3530

ValaList* _tmp16_;

3531

gint _tmp17_;

3532

gint _tmp18_;

3533

gint _param_size;

3534

gint _param_index;

3535

_tmp14_ = sig;

3536

_tmp15_ = vala_signal_get_parameters (_tmp14_);

3537

_param_list = _tmp15_;

3538

_tmp16_ = _param_list;

3539

_tmp17_ = vala_collection_get_size ((ValaCollection*) _tmp16_);

3540

_tmp18_ = _tmp17_;

3541

_param_size = _tmp18_;

3542

_param_index = -1;

3543

while (TRUE) {

3544

gint _tmp19_;

3545

gint _tmp20_;

3546

gint _tmp21_;

3547

ValaList* _tmp22_;

3548

gint _tmp23_;

3549

gpointer _tmp24_ = NULL;

3550

ValaParameter* param;

3551

ValaParameter* _tmp25_;

3552

ValaCCodeFile* _tmp26_;

3553

GHashFunc _tmp27_;

3554

GEqualFunc _tmp28_;

3555

GEqualFunc _tmp29_;

3556

ValaHashMap* _tmp30_;

3557

ValaHashMap* _tmp31_;

3558

ValaCCodeParameter* _tmp32_ = NULL;

3559

ValaCCodeParameter* _tmp33_;

3560

ValaCCodeParameter* cparam;

3561

ValaCCodeFunction* _tmp34_;

3562

ValaCCodeParameter* _tmp35_;

3563

ValaParameter* _tmp36_;

3564

ValaDataType* _tmp37_;

3565

ValaDataType* _tmp38_;

3566

_tmp19_ = _param_index;

3567

_param_index = _tmp19_ + 1;

3568

_tmp20_ = _param_index;

3569

_tmp21_ = _param_size;

3570

if (!(_tmp20_ < _tmp21_)) {

3571

break;

3572

}

3573

_tmp22_ = _param_list;

3574

_tmp23_ = _param_index;

3575

_tmp24_ = vala_list_get (_tmp22_, _tmp23_);

3576

param = (ValaParameter*) _tmp24_;

3577

_tmp25_ = param;

3578

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

3579

_tmp27_ = g_direct_hash;

3580

_tmp28_ = g_direct_equal;

3581

_tmp29_ = g_direct_equal;

3582

_tmp30_ = vala_hash_map_new (G_TYPE_INT, NULL, NULL, VALA_TYPE_CCODE_PARAMETER, (GBoxedCopyFunc) vala_ccode_node_ref, vala_ccode_node_unref, _tmp27_, _tmp28_, _tmp29_);

3583

_tmp31_ = _tmp30_;

3584

_tmp32_ = vala_ccode_method_module_generate_parameter ((ValaCCodeMethodModule*) self, _tmp25_, _tmp26_, (ValaMap*) _tmp31_, NULL);

3585

_tmp33_ = _tmp32_;

3586

_vala_map_unref0 (_tmp31_);

3587

cparam = _tmp33_;

3588

_tmp34_ = function;

3589

_tmp35_ = cparam;

3590

vala_ccode_function_add_parameter (_tmp34_, _tmp35_);

3591

_tmp36_ = param;

3592

_tmp37_ = vala_variable_get_variable_type ((ValaVariable*) _tmp36_);

3593

_tmp38_ = _tmp37_;

3594

if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp38_, VALA_TYPE_ARRAY_TYPE)) {

3595

ValaParameter* _tmp39_;

3596

ValaDataType* _tmp40_;

3597

ValaDataType* _tmp41_;

3598

ValaArrayType* _tmp42_;

3599

ValaArrayType* array_type;

3600

_tmp39_ = param;

3601

_tmp40_ = vala_variable_get_variable_type ((ValaVariable*) _tmp39_);

3602

_tmp41_ = _tmp40_;

3603

_tmp42_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp41_, VALA_TYPE_ARRAY_TYPE, ValaArrayType));

3604

array_type = _tmp42_;

3605

{

3606

gint dim;

3607

dim = 1;

3608

{

3609

gboolean _tmp43_;

3610

_tmp43_ = TRUE;

3611

while (TRUE) {

3612

gboolean _tmp44_;

3613

gint _tmp46_;

3614

ValaArrayType* _tmp47_;

3615

gint _tmp48_;

3616

gint _tmp49_;

3617

ValaCCodeFunction* _tmp50_;

3618

ValaParameter* _tmp51_;

3619

gint _tmp52_;

3620

gchar* _tmp53_ = NULL;

3621

gchar* _tmp54_;

3622

ValaCCodeParameter* _tmp55_;

3623

ValaCCodeParameter* _tmp56_;

3624

_tmp44_ = _tmp43_;

3625

if (!_tmp44_) {

3626

gint _tmp45_;

3627

_tmp45_ = dim;

3628

dim = _tmp45_ + 1;

3629

}

3630

_tmp43_ = FALSE;

3631

_tmp46_ = dim;

3632

_tmp47_ = array_type;

3633

_tmp48_ = vala_array_type_get_rank (_tmp47_);

3634

_tmp49_ = _tmp48_;

3635

if (!(_tmp46_ <= _tmp49_)) {

3636

break;

3637

}

3638

_tmp50_ = function;

3639

_tmp51_ = param;

3640

_tmp52_ = dim;

3641

_tmp53_ = vala_ccode_base_module_get_parameter_array_length_cname ((ValaCCodeBaseModule*) self, _tmp51_, _tmp52_);

3642

_tmp54_ = _tmp53_;

3643

_tmp55_ = vala_ccode_parameter_new (_tmp54_, "int");

3644

_tmp56_ = _tmp55_;

3645

vala_ccode_function_add_parameter (_tmp50_, _tmp56_);

3646

_vala_ccode_node_unref0 (_tmp56_);

3647

_g_free0 (_tmp54_);

3648

}

3649

}

3650

}

3651

_vala_code_node_unref0 (array_type);

3652

}

3653

_vala_ccode_node_unref0 (cparam);

3654

_vala_code_node_unref0 (param);

3655

}

3656

_vala_iterable_unref0 (_param_list);

3657

}

3658

_tmp57_ = function;

3659

_tmp58_ = vala_ccode_parameter_new ("_data", "gpointer*");

3660

_tmp59_ = _tmp58_;

3661

vala_ccode_function_add_parameter (_tmp57_, _tmp59_);

3662

_vala_ccode_node_unref0 (_tmp59_);

3663

_tmp60_ = function;

3664

vala_ccode_base_module_push_function ((ValaCCodeBaseModule*) self, _tmp60_);

3665

_tmp61_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

3666

_tmp62_ = _tmp61_;

3667

_tmp63_ = vala_ccode_identifier_new ("_data");

3668

_tmp64_ = _tmp63_;

3669

_tmp65_ = vala_ccode_constant_new ("1");

3670

_tmp66_ = _tmp65_;

3671

_tmp67_ = vala_ccode_element_access_new ((ValaCCodeExpression*) _tmp64_, (ValaCCodeExpression*) _tmp66_);

3672

_tmp68_ = _tmp67_;

3673

_tmp69_ = vala_ccode_variable_declarator_new ("_connection", (ValaCCodeExpression*) _tmp68_, NULL);

3674

_tmp70_ = _tmp69_;

3675

vala_ccode_function_add_declaration (_tmp62_, "GDBusConnection *", (ValaCCodeDeclarator*) _tmp70_, 0);

3676

_vala_ccode_node_unref0 (_tmp70_);

3677

_vala_ccode_node_unref0 (_tmp68_);

3678

_vala_ccode_node_unref0 (_tmp66_);

3679

_vala_ccode_node_unref0 (_tmp64_);

3680

_tmp71_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

3681

_tmp72_ = _tmp71_;

3682

_tmp73_ = vala_ccode_identifier_new ("_data");

3683

_tmp74_ = _tmp73_;

3684

_tmp75_ = vala_ccode_constant_new ("2");

3685

_tmp76_ = _tmp75_;

3686

_tmp77_ = vala_ccode_element_access_new ((ValaCCodeExpression*) _tmp74_, (ValaCCodeExpression*) _tmp76_);

3687

_tmp78_ = _tmp77_;

3688

_tmp79_ = vala_ccode_variable_declarator_new ("_path", (ValaCCodeExpression*) _tmp78_, NULL);

3689

_tmp80_ = _tmp79_;

3690

vala_ccode_function_add_declaration (_tmp72_, "const gchar *", (ValaCCodeDeclarator*) _tmp80_, 0);

3691

_vala_ccode_node_unref0 (_tmp80_);

3692

_vala_ccode_node_unref0 (_tmp78_);

3693

_vala_ccode_node_unref0 (_tmp76_);

3694

_vala_ccode_node_unref0 (_tmp74_);

3695

_tmp81_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

3696

_tmp82_ = _tmp81_;

3697

_tmp83_ = vala_ccode_variable_declarator_new ("*_arguments", NULL, NULL);

3698

_tmp84_ = _tmp83_;

3699

vala_ccode_function_add_declaration (_tmp82_, "GVariant", (ValaCCodeDeclarator*) _tmp84_, 0);

3700

_vala_ccode_node_unref0 (_tmp84_);

3701

_tmp85_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

3702

_tmp86_ = _tmp85_;

3703

_tmp87_ = vala_ccode_variable_declarator_new ("_arguments_builder", NULL, NULL);

3704

_tmp88_ = _tmp87_;

3705

vala_ccode_function_add_declaration (_tmp86_, "GVariantBuilder", (ValaCCodeDeclarator*) _tmp88_, 0);

3706

_vala_ccode_node_unref0 (_tmp88_);

3707

_tmp89_ = vala_ccode_identifier_new ("g_variant_builder_init");

3708

_tmp90_ = _tmp89_;

3709

_tmp91_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp90_);

3710

_tmp92_ = _tmp91_;

3711

_vala_ccode_node_unref0 (_tmp90_);

3712

builder_init = _tmp92_;

3713

_tmp93_ = builder_init;

3714

_tmp94_ = vala_ccode_identifier_new ("_arguments_builder");

3715

_tmp95_ = _tmp94_;

3716

_tmp96_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, (ValaCCodeExpression*) _tmp95_);

3717

_tmp97_ = _tmp96_;

3718

vala_ccode_function_call_add_argument (_tmp93_, (ValaCCodeExpression*) _tmp97_);

3719

_vala_ccode_node_unref0 (_tmp97_);

3720

_vala_ccode_node_unref0 (_tmp95_);

3721

_tmp98_ = builder_init;

3722

_tmp99_ = vala_ccode_identifier_new ("G_VARIANT_TYPE_TUPLE");

3723

_tmp100_ = _tmp99_;

3724

vala_ccode_function_call_add_argument (_tmp98_, (ValaCCodeExpression*) _tmp100_);

3725

_vala_ccode_node_unref0 (_tmp100_);

3726

_tmp101_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

3727

_tmp102_ = _tmp101_;

3728

_tmp103_ = builder_init;

3729

vala_ccode_function_add_expression (_tmp102_, (ValaCCodeExpression*) _tmp103_);

3730

{

3731

ValaSignal* _tmp104_;

3732

ValaList* _tmp105_ = NULL;

3733

ValaList* _param_list;

3734

ValaList* _tmp106_;

3735

gint _tmp107_;

3736

gint _tmp108_;

3737

gint _param_size;

3738

gint _param_index;

3739

_tmp104_ = sig;

3740

_tmp105_ = vala_signal_get_parameters (_tmp104_);

3741

_param_list = _tmp105_;

3742

_tmp106_ = _param_list;

3743

_tmp107_ = vala_collection_get_size ((ValaCollection*) _tmp106_);

3744

_tmp108_ = _tmp107_;

3745

_param_size = _tmp108_;

3746

_param_index = -1;

3747

while (TRUE) {

3748

gint _tmp109_;

3749

gint _tmp110_;

3750

gint _tmp111_;

3751

ValaList* _tmp112_;

3752

gint _tmp113_;

3753

gpointer _tmp114_ = NULL;

3754

ValaParameter* param;

3755

ValaParameter* _tmp115_;

3756

const gchar* _tmp116_;

3757

const gchar* _tmp117_;

3758

gchar* _tmp118_ = NULL;

3759

gchar* param_name;

3760

const gchar* _tmp119_;

3761

ValaCCodeIdentifier* _tmp120_;

3762

ValaCCodeExpression* expr;

3763

ValaParameter* _tmp121_;

3764

ValaDataType* _tmp122_;

3765

ValaDataType* _tmp123_;

3766

gboolean _tmp124_ = FALSE;

3767

ValaParameter* _tmp127_;

3768

ValaDataType* _tmp128_;

3769

ValaDataType* _tmp129_;

3770

ValaCCodeIdentifier* _tmp130_;

3771

ValaCCodeIdentifier* _tmp131_;

3772

ValaCCodeExpression* _tmp132_;

3773

ValaParameter* _tmp133_;

3774

_tmp109_ = _param_index;

3775

_param_index = _tmp109_ + 1;

3776

_tmp110_ = _param_index;

3777

_tmp111_ = _param_size;

3778

if (!(_tmp110_ < _tmp111_)) {

3779

break;

3780

}

3781

_tmp112_ = _param_list;

3782

_tmp113_ = _param_index;

3783

_tmp114_ = vala_list_get (_tmp112_, _tmp113_);

3784

param = (ValaParameter*) _tmp114_;

3785

_tmp115_ = param;

3786

_tmp116_ = vala_symbol_get_name ((ValaSymbol*) _tmp115_);

3787

_tmp117_ = _tmp116_;

3788

_tmp118_ = vala_ccode_base_module_get_variable_cname ((ValaCCodeBaseModule*) self, _tmp117_);

3789

param_name = _tmp118_;

3790

_tmp119_ = param_name;

3791

_tmp120_ = vala_ccode_identifier_new (_tmp119_);

3792

expr = (ValaCCodeExpression*) _tmp120_;

3793

_tmp121_ = param;

3794

_tmp122_ = vala_variable_get_variable_type ((ValaVariable*) _tmp121_);

3795

_tmp123_ = _tmp122_;

3796

_tmp124_ = vala_data_type_is_real_struct_type (_tmp123_);

3797

if (_tmp124_) {

3798

ValaCCodeExpression* _tmp125_;

3799

ValaCCodeUnaryExpression* _tmp126_;

3800

_tmp125_ = expr;

3801

_tmp126_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_POINTER_INDIRECTION, _tmp125_);

3802

_vala_ccode_node_unref0 (expr);

3803

expr = (ValaCCodeExpression*) _tmp126_;

3804

}

3805

_tmp127_ = param;

3806

_tmp128_ = vala_variable_get_variable_type ((ValaVariable*) _tmp127_);

3807

_tmp129_ = _tmp128_;

3808

_tmp130_ = vala_ccode_identifier_new ("_arguments_builder");

3809

_tmp131_ = _tmp130_;

3810

_tmp132_ = expr;

3811

_tmp133_ = param;

3812

vala_gvariant_module_write_expression ((ValaGVariantModule*) self, _tmp129_, (ValaCCodeExpression*) _tmp131_, _tmp132_, (ValaSymbol*) _tmp133_);

3813

_vala_ccode_node_unref0 (_tmp131_);

3814

_vala_ccode_node_unref0 (expr);

3815

_g_free0 (param_name);

3816

_vala_code_node_unref0 (param);

3817

}

3818

_vala_iterable_unref0 (_param_list);

3819

}

3820

_tmp134_ = vala_ccode_identifier_new ("g_variant_builder_end");

3821

_tmp135_ = _tmp134_;

3822

_tmp136_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp135_);

3823

_tmp137_ = _tmp136_;

3824

_vala_ccode_node_unref0 (_tmp135_);

3825

builder_end = _tmp137_;

3826

_tmp138_ = vala_ccode_identifier_new ("_arguments_builder");

3827

_tmp139_ = _tmp138_;

3828

_tmp140_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, (ValaCCodeExpression*) _tmp139_);

3829

_tmp141_ = _tmp140_;

3830

vala_ccode_function_call_add_argument (builder_end, (ValaCCodeExpression*) _tmp141_);

3831

_vala_ccode_node_unref0 (_tmp141_);

3832

_vala_ccode_node_unref0 (_tmp139_);

3833

_tmp142_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

3834

_tmp143_ = _tmp142_;

3835

_tmp144_ = vala_ccode_identifier_new ("_arguments");

3836

_tmp145_ = _tmp144_;

3837

vala_ccode_function_add_assignment (_tmp143_, (ValaCCodeExpression*) _tmp145_, (ValaCCodeExpression*) builder_end);

3838

_vala_ccode_node_unref0 (_tmp145_);

3839

_tmp146_ = vala_ccode_identifier_new ("g_dbus_connection_emit_signal");

3840

_tmp147_ = _tmp146_;

3841

_tmp148_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp147_);

3842

_tmp149_ = _tmp148_;

3843

_vala_ccode_node_unref0 (_tmp147_);

3844

ccall = _tmp149_;

3845

_tmp150_ = vala_ccode_identifier_new ("_connection");

3846

_tmp151_ = _tmp150_;

3847

vala_ccode_function_call_add_argument (ccall, (ValaCCodeExpression*) _tmp151_);

3848

_vala_ccode_node_unref0 (_tmp151_);

3849

_tmp152_ = vala_ccode_constant_new ("NULL");

3850

_tmp153_ = _tmp152_;

3851

vala_ccode_function_call_add_argument (ccall, (ValaCCodeExpression*) _tmp153_);

3852

_vala_ccode_node_unref0 (_tmp153_);

3853

_tmp154_ = vala_ccode_identifier_new ("_path");

3854

_tmp155_ = _tmp154_;

3855

vala_ccode_function_call_add_argument (ccall, (ValaCCodeExpression*) _tmp155_);

3856

_vala_ccode_node_unref0 (_tmp155_);

3857

_tmp156_ = dbus_iface_name;

3858

_tmp157_ = g_strdup_printf ("\"%s\"", _tmp156_);

3859

_tmp158_ = _tmp157_;

3860

_tmp159_ = vala_ccode_constant_new (_tmp158_);

3861

_tmp160_ = _tmp159_;

3862

vala_ccode_function_call_add_argument (ccall, (ValaCCodeExpression*) _tmp160_);

3863

_vala_ccode_node_unref0 (_tmp160_);

3864

_g_free0 (_tmp158_);

3865

_tmp161_ = sig;

3866

_tmp162_ = vala_gd_bus_module_get_dbus_name_for_member ((ValaSymbol*) _tmp161_);

3867

_tmp163_ = _tmp162_;

3868

_tmp164_ = g_strdup_printf ("\"%s\"", _tmp163_);

3869

_tmp165_ = _tmp164_;

3870

_tmp166_ = vala_ccode_constant_new (_tmp165_);

3871

_tmp167_ = _tmp166_;

3872

vala_ccode_function_call_add_argument (ccall, (ValaCCodeExpression*) _tmp167_);

3873

_vala_ccode_node_unref0 (_tmp167_);

3874

_g_free0 (_tmp165_);

3875

_g_free0 (_tmp163_);

3876

_tmp168_ = vala_ccode_identifier_new ("_arguments");

3877

_tmp169_ = _tmp168_;

3878

vala_ccode_function_call_add_argument (ccall, (ValaCCodeExpression*) _tmp169_);

3879

_vala_ccode_node_unref0 (_tmp169_);

3880

_tmp170_ = vala_ccode_constant_new ("NULL");

3881

_tmp171_ = _tmp170_;

3882

vala_ccode_function_call_add_argument (ccall, (ValaCCodeExpression*) _tmp171_);

3883

_vala_ccode_node_unref0 (_tmp171_);

3884

_tmp172_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

3885

_tmp173_ = _tmp172_;

3886

vala_ccode_function_add_expression (_tmp173_, (ValaCCodeExpression*) ccall);

3887

vala_ccode_base_module_pop_function ((ValaCCodeBaseModule*) self);

3888

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

3889

_tmp175_ = function;

3890

vala_ccode_file_add_function_declaration (_tmp174_, _tmp175_);

3891

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

3892

_tmp177_ = function;

3893

vala_ccode_file_add_function (_tmp176_, _tmp177_);

3894

result = wrapper_name;

3895

_vala_ccode_node_unref0 (ccall);

3896

_vala_ccode_node_unref0 (builder_end);

3897

_vala_ccode_node_unref0 (builder_init);

3898

_vala_ccode_node_unref0 (function);

3899

return result;

3900

}

3901

3902

3903

static gchar* vala_gd_bus_server_module_generate_dbus_property_get_wrapper (ValaGDBusServerModule* self, ValaProperty* prop, ValaObjectTypeSymbol* sym) {

3904

gchar* result = NULL;

3905

ValaProperty* _tmp0_;

3906

ValaPropertyAccessor* _tmp1_;

3907

ValaPropertyAccessor* _tmp2_;

3908

gchar* _tmp3_ = NULL;

3909

gchar* _tmp4_;

3910

gchar* _tmp5_ = NULL;

3911

gchar* _tmp6_;

3912

gchar* wrapper_name;

3913

const gchar* _tmp7_;

3914

ValaCCodeFunction* _tmp8_;

3915

ValaCCodeFunction* function;

3916

ValaCCodeFunction* _tmp9_;

3917

ValaCCodeFunction* _tmp10_;

3918

ValaObjectTypeSymbol* _tmp11_;

3919

gchar* _tmp12_ = NULL;

3920

gchar* _tmp13_;

3921

gchar* _tmp14_;

3922

gchar* _tmp15_;

3923

ValaCCodeParameter* _tmp16_;

3924

ValaCCodeParameter* _tmp17_;

3925

ValaCCodeFunction* _tmp18_;

3926

ValaProperty* _tmp19_;

3927

ValaPropertyAccessor* _tmp20_;

3928

ValaPropertyAccessor* _tmp21_;

3929

gchar* _tmp22_ = NULL;

3930

gchar* _tmp23_;

3931

ValaCCodeIdentifier* _tmp24_;

3932

ValaCCodeIdentifier* _tmp25_;

3933

ValaCCodeFunctionCall* _tmp26_;

3934

ValaCCodeFunctionCall* _tmp27_;

3935

ValaCCodeFunctionCall* ccall;

3936

ValaCCodeFunctionCall* _tmp28_;

3937

ValaCCodeIdentifier* _tmp29_;

3938

ValaCCodeIdentifier* _tmp30_;

3939

ValaProperty* _tmp31_;

3940

ValaPropertyAccessor* _tmp32_;

3941

ValaPropertyAccessor* _tmp33_;

3942

ValaDataType* _tmp34_;

3943

ValaDataType* _tmp35_;

3944

gboolean _tmp36_ = FALSE;

3945

ValaProperty* _tmp108_;

3946

ValaPropertyAccessor* _tmp109_;

3947

ValaPropertyAccessor* _tmp110_;

3948

ValaDataType* _tmp111_;

3949

ValaDataType* _tmp112_;

3950

ValaCCodeIdentifier* _tmp113_;

3951

ValaCCodeIdentifier* _tmp114_;

3952

ValaCCodeExpression* _tmp115_ = NULL;

3953

ValaCCodeExpression* _tmp116_;

3954

ValaCCodeExpression* reply_expr;

3955

ValaCCodeFunction* _tmp117_;

3956

ValaCCodeFunction* _tmp118_;

3957

ValaCCodeVariableDeclarator* _tmp119_;

3958

ValaCCodeVariableDeclarator* _tmp120_;

3959

ValaCCodeFunction* _tmp121_;

3960

ValaCCodeFunction* _tmp122_;

3961

ValaCCodeIdentifier* _tmp123_;

3962

ValaCCodeIdentifier* _tmp124_;

3963

ValaCCodeExpression* _tmp125_;

3964

ValaProperty* _tmp126_;

3965

ValaPropertyAccessor* _tmp127_;

3966

ValaPropertyAccessor* _tmp128_;

3967

ValaDataType* _tmp129_;

3968

ValaDataType* _tmp130_;

3969

gboolean _tmp131_ = FALSE;

3970

ValaCCodeFunction* _tmp143_;

3971

ValaCCodeFunction* _tmp144_;

3972

ValaCCodeIdentifier* _tmp145_;

3973

ValaCCodeIdentifier* _tmp146_;

3974

ValaCCodeFile* _tmp147_;

3975

ValaCCodeFunction* _tmp148_;

3976

ValaCCodeFile* _tmp149_;

3977

ValaCCodeFunction* _tmp150_;

3978

g_return_val_if_fail (self != NULL, NULL);

3979

g_return_val_if_fail (prop != NULL, NULL);

3980

g_return_val_if_fail (sym != NULL, NULL);

3981

_tmp0_ = prop;

3982

_tmp1_ = vala_property_get_get_accessor (_tmp0_);

3983

_tmp2_ = _tmp1_;

3984

_tmp3_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp2_);

3985

_tmp4_ = _tmp3_;

3986

_tmp5_ = g_strdup_printf ("_dbus_%s", _tmp4_);

3987

_tmp6_ = _tmp5_;

3988

_g_free0 (_tmp4_);

3989

wrapper_name = _tmp6_;

3990

_tmp7_ = wrapper_name;

3991

_tmp8_ = vala_ccode_function_new (_tmp7_, "GVariant*");

3992

function = _tmp8_;

3993

_tmp9_ = function;

3994

vala_ccode_function_set_modifiers (_tmp9_, VALA_CCODE_MODIFIERS_STATIC);

3995

_tmp10_ = function;

3996

_tmp11_ = sym;

3997

_tmp12_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp11_);

3998

_tmp13_ = _tmp12_;

3999

_tmp14_ = g_strconcat (_tmp13_, "*", NULL);

4000

_tmp15_ = _tmp14_;

4001

_tmp16_ = vala_ccode_parameter_new ("self", _tmp15_);

4002

_tmp17_ = _tmp16_;

4003

vala_ccode_function_add_parameter (_tmp10_, _tmp17_);

4004

_vala_ccode_node_unref0 (_tmp17_);

4005

_g_free0 (_tmp15_);

4006

_g_free0 (_tmp13_);

4007

_tmp18_ = function;

4008

vala_ccode_base_module_push_function ((ValaCCodeBaseModule*) self, _tmp18_);

4009

_tmp19_ = prop;

4010

_tmp20_ = vala_property_get_get_accessor (_tmp19_);

4011

_tmp21_ = _tmp20_;

4012

_tmp22_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp21_);

4013

_tmp23_ = _tmp22_;

4014

_tmp24_ = vala_ccode_identifier_new (_tmp23_);

4015

_tmp25_ = _tmp24_;

4016

_tmp26_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp25_);

4017

_tmp27_ = _tmp26_;

4018

_vala_ccode_node_unref0 (_tmp25_);

4019

_g_free0 (_tmp23_);

4020

ccall = _tmp27_;

4021

_tmp28_ = ccall;

4022

_tmp29_ = vala_ccode_identifier_new ("self");

4023

_tmp30_ = _tmp29_;

4024

vala_ccode_function_call_add_argument (_tmp28_, (ValaCCodeExpression*) _tmp30_);

4025

_vala_ccode_node_unref0 (_tmp30_);

4026

_tmp31_ = prop;

4027

_tmp32_ = vala_property_get_get_accessor (_tmp31_);

4028

_tmp33_ = _tmp32_;

4029

_tmp34_ = vala_property_accessor_get_value_type (_tmp33_);

4030

_tmp35_ = _tmp34_;

4031

_tmp36_ = vala_data_type_is_real_non_null_struct_type (_tmp35_);

4032

if (_tmp36_) {

4033

ValaCCodeFunction* _tmp37_;

4034

ValaCCodeFunction* _tmp38_;

4035

ValaProperty* _tmp39_;

4036

ValaPropertyAccessor* _tmp40_;

4037

ValaPropertyAccessor* _tmp41_;

4038

ValaDataType* _tmp42_;

4039

ValaDataType* _tmp43_;

4040

gchar* _tmp44_ = NULL;

4041

gchar* _tmp45_;

4042

ValaProperty* _tmp46_;

4043

ValaPropertyAccessor* _tmp47_;

4044

ValaPropertyAccessor* _tmp48_;

4045

ValaDataType* _tmp49_;

4046

ValaDataType* _tmp50_;

4047

ValaCCodeExpression* _tmp51_ = NULL;

4048

ValaCCodeExpression* _tmp52_;

4049

ValaCCodeVariableDeclarator* _tmp53_;

4050

ValaCCodeVariableDeclarator* _tmp54_;

4051

ValaCCodeFunctionCall* _tmp55_;

4052

ValaCCodeIdentifier* _tmp56_;

4053

ValaCCodeIdentifier* _tmp57_;

4054

ValaCCodeUnaryExpression* _tmp58_;

4055

ValaCCodeUnaryExpression* _tmp59_;

4056

ValaCCodeFunction* _tmp60_;

4057

ValaCCodeFunction* _tmp61_;

4058

ValaCCodeFunctionCall* _tmp62_;

4059

_tmp37_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

4060

_tmp38_ = _tmp37_;

4061

_tmp39_ = prop;

4062

_tmp40_ = vala_property_get_get_accessor (_tmp39_);

4063

_tmp41_ = _tmp40_;

4064

_tmp42_ = vala_property_accessor_get_value_type (_tmp41_);

4065

_tmp43_ = _tmp42_;

4066

_tmp44_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp43_);

4067

_tmp45_ = _tmp44_;

4068

_tmp46_ = prop;

4069

_tmp47_ = vala_property_get_get_accessor (_tmp46_);

4070

_tmp48_ = _tmp47_;

4071

_tmp49_ = vala_property_accessor_get_value_type (_tmp48_);

4072

_tmp50_ = _tmp49_;

4073

_tmp51_ = vala_ccode_base_module_default_value_for_type ((ValaCCodeBaseModule*) self, _tmp50_, TRUE);

4074

_tmp52_ = _tmp51_;

4075

_tmp53_ = vala_ccode_variable_declarator_new_zero ("result", _tmp52_, NULL);

4076

_tmp54_ = _tmp53_;

4077

vala_ccode_function_add_declaration (_tmp38_, _tmp45_, (ValaCCodeDeclarator*) _tmp54_, 0);

4078

_vala_ccode_node_unref0 (_tmp54_);

4079

_vala_ccode_node_unref0 (_tmp52_);

4080

_g_free0 (_tmp45_);

4081

_tmp55_ = ccall;

4082

_tmp56_ = vala_ccode_identifier_new ("result");

4083

_tmp57_ = _tmp56_;

4084

_tmp58_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, (ValaCCodeExpression*) _tmp57_);

4085

_tmp59_ = _tmp58_;

4086

vala_ccode_function_call_add_argument (_tmp55_, (ValaCCodeExpression*) _tmp59_);

4087

_vala_ccode_node_unref0 (_tmp59_);

4088

_vala_ccode_node_unref0 (_tmp57_);

4089

_tmp60_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

4090

_tmp61_ = _tmp60_;

4091

_tmp62_ = ccall;

4092

vala_ccode_function_add_expression (_tmp61_, (ValaCCodeExpression*) _tmp62_);

4093

} else {

4094

ValaCCodeFunction* _tmp63_;

4095

ValaCCodeFunction* _tmp64_;

4096

ValaProperty* _tmp65_;

4097

ValaPropertyAccessor* _tmp66_;

4098

ValaPropertyAccessor* _tmp67_;

4099

ValaDataType* _tmp68_;

4100

ValaDataType* _tmp69_;

4101

gchar* _tmp70_ = NULL;

4102

gchar* _tmp71_;

4103

ValaCCodeVariableDeclarator* _tmp72_;

4104

ValaCCodeVariableDeclarator* _tmp73_;

4105

ValaCCodeFunction* _tmp74_;

4106

ValaCCodeFunction* _tmp75_;

4107

ValaCCodeIdentifier* _tmp76_;

4108

ValaCCodeIdentifier* _tmp77_;

4109

ValaCCodeFunctionCall* _tmp78_;

4110

ValaProperty* _tmp79_;

4111

ValaPropertyAccessor* _tmp80_;

4112

ValaPropertyAccessor* _tmp81_;

4113

ValaDataType* _tmp82_;

4114

ValaDataType* _tmp83_;

4115

ValaArrayType* _tmp84_;

4116

ValaArrayType* array_type;

4117

ValaArrayType* _tmp85_;

4118

_tmp63_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

4119

_tmp64_ = _tmp63_;

4120

_tmp65_ = prop;

4121

_tmp66_ = vala_property_get_get_accessor (_tmp65_);

4122

_tmp67_ = _tmp66_;

4123

_tmp68_ = vala_property_accessor_get_value_type (_tmp67_);

4124

_tmp69_ = _tmp68_;

4125

_tmp70_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp69_);

4126

_tmp71_ = _tmp70_;

4127

_tmp72_ = vala_ccode_variable_declarator_new ("result", NULL, NULL);

4128

_tmp73_ = _tmp72_;

4129

vala_ccode_function_add_declaration (_tmp64_, _tmp71_, (ValaCCodeDeclarator*) _tmp73_, 0);

4130

_vala_ccode_node_unref0 (_tmp73_);

4131

_g_free0 (_tmp71_);

4132

_tmp74_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

4133

_tmp75_ = _tmp74_;

4134

_tmp76_ = vala_ccode_identifier_new ("result");

4135

_tmp77_ = _tmp76_;

4136

_tmp78_ = ccall;

4137

vala_ccode_function_add_assignment (_tmp75_, (ValaCCodeExpression*) _tmp77_, (ValaCCodeExpression*) _tmp78_);

4138

_vala_ccode_node_unref0 (_tmp77_);

4139

_tmp79_ = prop;

4140

_tmp80_ = vala_property_get_get_accessor (_tmp79_);

4141

_tmp81_ = _tmp80_;

4142

_tmp82_ = vala_property_accessor_get_value_type (_tmp81_);

4143

_tmp83_ = _tmp82_;

4144

_tmp84_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp83_, VALA_TYPE_ARRAY_TYPE) ? ((ValaArrayType*) _tmp83_) : NULL);

4145

array_type = _tmp84_;

4146

_tmp85_ = array_type;

4147

if (_tmp85_ != NULL) {

4148

{

4149

gint dim;

4150

dim = 1;

4151

{

4152

gboolean _tmp86_;

4153

_tmp86_ = TRUE;

4154

while (TRUE) {

4155

gboolean _tmp87_;

4156

gint _tmp89_;

4157

ValaArrayType* _tmp90_;

4158

gint _tmp91_;

4159

gint _tmp92_;

4160

gint _tmp93_;

4161

gchar* _tmp94_ = NULL;

4162

gchar* length_cname;

4163

ValaCCodeFunction* _tmp95_;

4164

ValaCCodeFunction* _tmp96_;

4165

const gchar* _tmp97_;

4166

ValaCCodeConstant* _tmp98_;

4167

ValaCCodeConstant* _tmp99_;

4168

ValaCCodeVariableDeclarator* _tmp100_;

4169

ValaCCodeVariableDeclarator* _tmp101_;

4170

ValaCCodeFunctionCall* _tmp102_;

4171

const gchar* _tmp103_;

4172

ValaCCodeIdentifier* _tmp104_;

4173

ValaCCodeIdentifier* _tmp105_;

4174

ValaCCodeUnaryExpression* _tmp106_;

4175

ValaCCodeUnaryExpression* _tmp107_;

4176

_tmp87_ = _tmp86_;

4177

if (!_tmp87_) {

4178

gint _tmp88_;

4179

_tmp88_ = dim;

4180

dim = _tmp88_ + 1;

4181

}

4182

_tmp86_ = FALSE;

4183

_tmp89_ = dim;

4184

_tmp90_ = array_type;

4185

_tmp91_ = vala_array_type_get_rank (_tmp90_);

4186

_tmp92_ = _tmp91_;

4187

if (!(_tmp89_ <= _tmp92_)) {

4188

break;

4189

}

4190

_tmp93_ = dim;

4191

_tmp94_ = vala_ccode_base_module_get_array_length_cname ((ValaCCodeBaseModule*) self, "result", _tmp93_);

4192

length_cname = _tmp94_;

4193

_tmp95_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

4194

_tmp96_ = _tmp95_;

4195

_tmp97_ = length_cname;

4196

_tmp98_ = vala_ccode_constant_new ("0");

4197

_tmp99_ = _tmp98_;

4198

_tmp100_ = vala_ccode_variable_declarator_new_zero (_tmp97_, (ValaCCodeExpression*) _tmp99_, NULL);

4199

_tmp101_ = _tmp100_;

4200

vala_ccode_function_add_declaration (_tmp96_, "int", (ValaCCodeDeclarator*) _tmp101_, 0);

4201

_vala_ccode_node_unref0 (_tmp101_);

4202

_vala_ccode_node_unref0 (_tmp99_);

4203

_tmp102_ = ccall;

4204

_tmp103_ = length_cname;

4205

_tmp104_ = vala_ccode_identifier_new (_tmp103_);

4206

_tmp105_ = _tmp104_;

4207

_tmp106_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, (ValaCCodeExpression*) _tmp105_);

4208

_tmp107_ = _tmp106_;

4209

vala_ccode_function_call_add_argument (_tmp102_, (ValaCCodeExpression*) _tmp107_);

4210

_vala_ccode_node_unref0 (_tmp107_);

4211

_vala_ccode_node_unref0 (_tmp105_);

4212

_g_free0 (length_cname);

4213

}

4214

}

4215

}

4216

}

4217

_vala_code_node_unref0 (array_type);

4218

}

4219

_tmp108_ = prop;

4220

_tmp109_ = vala_property_get_get_accessor (_tmp108_);

4221

_tmp110_ = _tmp109_;

4222

_tmp111_ = vala_property_accessor_get_value_type (_tmp110_);

4223

_tmp112_ = _tmp111_;

4224

_tmp113_ = vala_ccode_identifier_new ("result");

4225

_tmp114_ = _tmp113_;

4226

_tmp115_ = vala_ccode_base_module_serialize_expression ((ValaCCodeBaseModule*) self, _tmp112_, (ValaCCodeExpression*) _tmp114_);

4227

_tmp116_ = _tmp115_;

4228

_vala_ccode_node_unref0 (_tmp114_);

4229

reply_expr = _tmp116_;

4230

_tmp117_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

4231

_tmp118_ = _tmp117_;

4232

_tmp119_ = vala_ccode_variable_declarator_new ("_reply", NULL, NULL);

4233

_tmp120_ = _tmp119_;

4234

vala_ccode_function_add_declaration (_tmp118_, "GVariant*", (ValaCCodeDeclarator*) _tmp120_, 0);

4235

_vala_ccode_node_unref0 (_tmp120_);

4236

_tmp121_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

4237

_tmp122_ = _tmp121_;

4238

_tmp123_ = vala_ccode_identifier_new ("_reply");

4239

_tmp124_ = _tmp123_;

4240

_tmp125_ = reply_expr;

4241

vala_ccode_function_add_assignment (_tmp122_, (ValaCCodeExpression*) _tmp124_, _tmp125_);

4242

_vala_ccode_node_unref0 (_tmp124_);

4243

_tmp126_ = prop;

4244

_tmp127_ = vala_property_get_get_accessor (_tmp126_);

4245

_tmp128_ = _tmp127_;

4246

_tmp129_ = vala_property_accessor_get_value_type (_tmp128_);

4247

_tmp130_ = _tmp129_;

4248

_tmp131_ = vala_ccode_base_module_requires_destroy ((ValaCCodeBaseModule*) self, _tmp130_);

4249

if (_tmp131_) {

4250

ValaProperty* _tmp132_;

4251

ValaPropertyAccessor* _tmp133_;

4252

ValaPropertyAccessor* _tmp134_;

4253

ValaDataType* _tmp135_;

4254

ValaDataType* _tmp136_;

4255

ValaLocalVariable* _tmp137_;

4256

ValaLocalVariable* local;

4257

ValaCCodeFunction* _tmp138_;

4258

ValaCCodeFunction* _tmp139_;

4259

ValaLocalVariable* _tmp140_;

4260

ValaCCodeExpression* _tmp141_ = NULL;

4261

ValaCCodeExpression* _tmp142_;

4262

_tmp132_ = prop;

4263

_tmp133_ = vala_property_get_get_accessor (_tmp132_);

4264

_tmp134_ = _tmp133_;

4265

_tmp135_ = vala_property_accessor_get_value_type (_tmp134_);

4266

_tmp136_ = _tmp135_;

4267

_tmp137_ = vala_local_variable_new (_tmp136_, ".result", NULL, NULL);

4268

local = _tmp137_;

4269

_tmp138_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

4270

_tmp139_ = _tmp138_;

4271

_tmp140_ = local;

4272

_tmp141_ = vala_ccode_base_module_destroy_local ((ValaCCodeBaseModule*) self, _tmp140_);

4273

_tmp142_ = _tmp141_;

4274

vala_ccode_function_add_expression (_tmp139_, _tmp142_);

4275

_vala_ccode_node_unref0 (_tmp142_);

4276

_vala_code_node_unref0 (local);

4277

}

4278

_tmp143_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

4279

_tmp144_ = _tmp143_;

4280

_tmp145_ = vala_ccode_identifier_new ("_reply");

4281

_tmp146_ = _tmp145_;

4282

vala_ccode_function_add_return (_tmp144_, (ValaCCodeExpression*) _tmp146_);

4283

_vala_ccode_node_unref0 (_tmp146_);

4284

vala_ccode_base_module_pop_function ((ValaCCodeBaseModule*) self);

4285

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

4286

_tmp148_ = function;

4287

vala_ccode_file_add_function_declaration (_tmp147_, _tmp148_);

4288

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

4289

_tmp150_ = function;

4290

vala_ccode_file_add_function (_tmp149_, _tmp150_);

4291

result = wrapper_name;

4292

_vala_ccode_node_unref0 (reply_expr);

4293

_vala_ccode_node_unref0 (ccall);

4294

_vala_ccode_node_unref0 (function);

4295

return result;

4296

}

4297

4298

4299

static gchar* vala_gd_bus_server_module_generate_dbus_property_set_wrapper (ValaGDBusServerModule* self, ValaProperty* prop, ValaObjectTypeSymbol* sym) {

4300

gchar* result = NULL;

4301

ValaProperty* _tmp0_;

4302

ValaPropertyAccessor* _tmp1_;

4303

ValaPropertyAccessor* _tmp2_;

4304

gchar* _tmp3_ = NULL;

4305

gchar* _tmp4_;

4306

gchar* _tmp5_ = NULL;

4307

gchar* _tmp6_;

4308

gchar* wrapper_name;

4309

const gchar* _tmp7_;

4310

ValaCCodeFunction* _tmp8_;

4311

ValaCCodeFunction* function;

4312

ValaCCodeFunction* _tmp9_;

4313

ValaCCodeFunction* _tmp10_;

4314

ValaObjectTypeSymbol* _tmp11_;

4315

gchar* _tmp12_ = NULL;

4316

gchar* _tmp13_;

4317

gchar* _tmp14_;

4318

gchar* _tmp15_;

4319

ValaCCodeParameter* _tmp16_;

4320

ValaCCodeParameter* _tmp17_;

4321

ValaCCodeFunction* _tmp18_;

4322

ValaCCodeParameter* _tmp19_;

4323

ValaCCodeParameter* _tmp20_;

4324

ValaCCodeFunction* _tmp21_;

4325

ValaProperty* _tmp22_;

4326

ValaPropertyAccessor* _tmp23_;

4327

ValaPropertyAccessor* _tmp24_;

4328

gchar* _tmp25_ = NULL;

4329

gchar* _tmp26_;

4330

ValaCCodeIdentifier* _tmp27_;

4331

ValaCCodeIdentifier* _tmp28_;

4332

ValaCCodeFunctionCall* _tmp29_;

4333

ValaCCodeFunctionCall* _tmp30_;

4334

ValaCCodeFunctionCall* ccall;

4335

ValaCCodeFunctionCall* _tmp31_;

4336

ValaCCodeIdentifier* _tmp32_;

4337

ValaCCodeIdentifier* _tmp33_;

4338

ValaProperty* _tmp34_;

4339

ValaDataType* _tmp35_;

4340

ValaDataType* _tmp36_;

4341

ValaDataType* _tmp37_ = NULL;

4342

ValaDataType* owned_type;

4343

ValaDataType* _tmp38_;

4344

ValaCCodeFunction* _tmp39_;

4345

ValaCCodeFunction* _tmp40_;

4346

ValaDataType* _tmp41_;

4347

gchar* _tmp42_ = NULL;

4348

gchar* _tmp43_;

4349

ValaProperty* _tmp44_;

4350

ValaDataType* _tmp45_;

4351

ValaDataType* _tmp46_;

4352

ValaCCodeExpression* _tmp47_ = NULL;

4353

ValaCCodeExpression* _tmp48_;

4354

ValaCCodeVariableDeclarator* _tmp49_;

4355

ValaCCodeVariableDeclarator* _tmp50_;

4356

ValaProperty* _tmp51_;

4357

ValaDataType* _tmp52_;

4358

ValaDataType* _tmp53_;

4359

ValaTypeSymbol* _tmp54_;

4360

ValaTypeSymbol* _tmp55_;

4361

ValaStruct* _tmp56_;

4362

ValaStruct* st;

4363

gboolean _tmp57_ = FALSE;

4364

ValaStruct* _tmp58_;

4365

gboolean _tmp61_;

4366

ValaCCodeIdentifier* _tmp95_;

4367

ValaCCodeIdentifier* target;

4368

ValaProperty* _tmp96_;

4369

ValaDataType* _tmp97_;

4370

ValaDataType* _tmp98_;

4371

ValaCCodeIdentifier* _tmp99_;

4372

ValaCCodeIdentifier* _tmp100_;

4373

ValaCCodeIdentifier* _tmp101_;

4374

ValaCCodeExpression* _tmp102_ = NULL;

4375

ValaCCodeExpression* _tmp103_;

4376

ValaCCodeExpression* expr;

4377

ValaCCodeFunction* _tmp104_;

4378

ValaCCodeFunction* _tmp105_;

4379

ValaCCodeIdentifier* _tmp106_;

4380

ValaCCodeExpression* _tmp107_;

4381

ValaCCodeFunction* _tmp108_;

4382

ValaCCodeFunction* _tmp109_;

4383

ValaCCodeFunctionCall* _tmp110_;

4384

ValaDataType* _tmp111_;

4385

gboolean _tmp112_ = FALSE;

4386

ValaCCodeFile* _tmp120_;

4387

ValaCCodeFunction* _tmp121_;

4388

ValaCCodeFile* _tmp122_;

4389

ValaCCodeFunction* _tmp123_;

4390

g_return_val_if_fail (self != NULL, NULL);

4391

g_return_val_if_fail (prop != NULL, NULL);

4392

g_return_val_if_fail (sym != NULL, NULL);

4393

_tmp0_ = prop;

4394

_tmp1_ = vala_property_get_set_accessor (_tmp0_);

4395

_tmp2_ = _tmp1_;

4396

_tmp3_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp2_);

4397

_tmp4_ = _tmp3_;

4398

_tmp5_ = g_strdup_printf ("_dbus_%s", _tmp4_);

4399

_tmp6_ = _tmp5_;

4400

_g_free0 (_tmp4_);

4401

wrapper_name = _tmp6_;

4402

_tmp7_ = wrapper_name;

4403

_tmp8_ = vala_ccode_function_new (_tmp7_, "void");

4404

function = _tmp8_;

4405

_tmp9_ = function;

4406

vala_ccode_function_set_modifiers (_tmp9_, VALA_CCODE_MODIFIERS_STATIC);

4407

_tmp10_ = function;

4408

_tmp11_ = sym;

4409

_tmp12_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp11_);

4410

_tmp13_ = _tmp12_;

4411

_tmp14_ = g_strconcat (_tmp13_, "*", NULL);

4412

_tmp15_ = _tmp14_;

4413

_tmp16_ = vala_ccode_parameter_new ("self", _tmp15_);

4414

_tmp17_ = _tmp16_;

4415

vala_ccode_function_add_parameter (_tmp10_, _tmp17_);

4416

_vala_ccode_node_unref0 (_tmp17_);

4417

_g_free0 (_tmp15_);

4418

_g_free0 (_tmp13_);

4419

_tmp18_ = function;

4420

_tmp19_ = vala_ccode_parameter_new ("_value", "GVariant*");

4421

_tmp20_ = _tmp19_;

4422

vala_ccode_function_add_parameter (_tmp18_, _tmp20_);

4423

_vala_ccode_node_unref0 (_tmp20_);

4424

_tmp21_ = function;

4425

vala_ccode_base_module_push_function ((ValaCCodeBaseModule*) self, _tmp21_);

4426

_tmp22_ = prop;

4427

_tmp23_ = vala_property_get_set_accessor (_tmp22_);

4428

_tmp24_ = _tmp23_;

4429

_tmp25_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp24_);

4430

_tmp26_ = _tmp25_;

4431

_tmp27_ = vala_ccode_identifier_new (_tmp26_);

4432

_tmp28_ = _tmp27_;

4433

_tmp29_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp28_);

4434

_tmp30_ = _tmp29_;

4435

_vala_ccode_node_unref0 (_tmp28_);

4436

_g_free0 (_tmp26_);

4437

ccall = _tmp30_;

4438

_tmp31_ = ccall;

4439

_tmp32_ = vala_ccode_identifier_new ("self");

4440

_tmp33_ = _tmp32_;

4441

vala_ccode_function_call_add_argument (_tmp31_, (ValaCCodeExpression*) _tmp33_);

4442

_vala_ccode_node_unref0 (_tmp33_);

4443

_tmp34_ = prop;

4444

_tmp35_ = vala_property_get_property_type (_tmp34_);

4445

_tmp36_ = _tmp35_;

4446

_tmp37_ = vala_data_type_copy (_tmp36_);

4447

owned_type = _tmp37_;

4448

_tmp38_ = owned_type;

4449

vala_data_type_set_value_owned (_tmp38_, TRUE);

4450

_tmp39_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

4451

_tmp40_ = _tmp39_;

4452

_tmp41_ = owned_type;

4453

_tmp42_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp41_);

4454

_tmp43_ = _tmp42_;

4455

_tmp44_ = prop;

4456

_tmp45_ = vala_property_get_property_type (_tmp44_);

4457

_tmp46_ = _tmp45_;

4458

_tmp47_ = vala_ccode_base_module_default_value_for_type ((ValaCCodeBaseModule*) self, _tmp46_, TRUE);

4459

_tmp48_ = _tmp47_;

4460

_tmp49_ = vala_ccode_variable_declarator_new_zero ("value", _tmp48_, NULL);

4461

_tmp50_ = _tmp49_;

4462

vala_ccode_function_add_declaration (_tmp40_, _tmp43_, (ValaCCodeDeclarator*) _tmp50_, 0);

4463

_vala_ccode_node_unref0 (_tmp50_);

4464

_vala_ccode_node_unref0 (_tmp48_);

4465

_g_free0 (_tmp43_);

4466

_tmp51_ = prop;

4467

_tmp52_ = vala_property_get_property_type (_tmp51_);

4468

_tmp53_ = _tmp52_;

4469

_tmp54_ = vala_data_type_get_data_type (_tmp53_);

4470

_tmp55_ = _tmp54_;

4471

_tmp56_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp55_, VALA_TYPE_STRUCT) ? ((ValaStruct*) _tmp55_) : NULL);

4472

st = _tmp56_;

4473

_tmp58_ = st;

4474

if (_tmp58_ != NULL) {

4475

ValaStruct* _tmp59_;

4476

gboolean _tmp60_ = FALSE;

4477

_tmp59_ = st;

4478

_tmp60_ = vala_struct_is_simple_type (_tmp59_);

4479

_tmp57_ = !_tmp60_;

4480

} else {

4481

_tmp57_ = FALSE;

4482

}

4483

_tmp61_ = _tmp57_;

4484

if (_tmp61_) {

4485

ValaCCodeFunctionCall* _tmp62_;

4486

ValaCCodeIdentifier* _tmp63_;

4487

ValaCCodeIdentifier* _tmp64_;

4488

ValaCCodeUnaryExpression* _tmp65_;

4489

ValaCCodeUnaryExpression* _tmp66_;

4490

_tmp62_ = ccall;

4491

_tmp63_ = vala_ccode_identifier_new ("value");

4492

_tmp64_ = _tmp63_;

4493

_tmp65_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, (ValaCCodeExpression*) _tmp64_);

4494

_tmp66_ = _tmp65_;

4495

vala_ccode_function_call_add_argument (_tmp62_, (ValaCCodeExpression*) _tmp66_);

4496

_vala_ccode_node_unref0 (_tmp66_);

4497

_vala_ccode_node_unref0 (_tmp64_);

4498

} else {

4499

ValaCCodeFunctionCall* _tmp67_;

4500

ValaCCodeIdentifier* _tmp68_;

4501

ValaCCodeIdentifier* _tmp69_;

4502

ValaProperty* _tmp70_;

4503

ValaDataType* _tmp71_;

4504

ValaDataType* _tmp72_;

4505

ValaArrayType* _tmp73_;

4506

ValaArrayType* array_type;

4507

ValaArrayType* _tmp74_;

4508

_tmp67_ = ccall;

4509

_tmp68_ = vala_ccode_identifier_new ("value");

4510

_tmp69_ = _tmp68_;

4511

vala_ccode_function_call_add_argument (_tmp67_, (ValaCCodeExpression*) _tmp69_);

4512

_vala_ccode_node_unref0 (_tmp69_);

4513

_tmp70_ = prop;

4514

_tmp71_ = vala_property_get_property_type (_tmp70_);

4515

_tmp72_ = _tmp71_;

4516

_tmp73_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp72_, VALA_TYPE_ARRAY_TYPE) ? ((ValaArrayType*) _tmp72_) : NULL);

4517

array_type = _tmp73_;

4518

_tmp74_ = array_type;

4519

if (_tmp74_ != NULL) {

4520

{

4521

gint dim;

4522

dim = 1;

4523

{

4524

gboolean _tmp75_;

4525

_tmp75_ = TRUE;

4526

while (TRUE) {

4527

gboolean _tmp76_;

4528

gint _tmp78_;

4529

ValaArrayType* _tmp79_;

4530

gint _tmp80_;

4531

gint _tmp81_;

4532

ValaCCodeFunction* _tmp82_;

4533

ValaCCodeFunction* _tmp83_;

4534

gint _tmp84_;

4535

gchar* _tmp85_ = NULL;

4536

gchar* _tmp86_;

4537

ValaCCodeVariableDeclarator* _tmp87_;

4538

ValaCCodeVariableDeclarator* _tmp88_;

4539

ValaCCodeFunctionCall* _tmp89_;

4540

gint _tmp90_;

4541

gchar* _tmp91_ = NULL;

4542

gchar* _tmp92_;

4543

ValaCCodeIdentifier* _tmp93_;

4544

ValaCCodeIdentifier* _tmp94_;

4545

_tmp76_ = _tmp75_;

4546

if (!_tmp76_) {

4547

gint _tmp77_;

4548

_tmp77_ = dim;

4549

dim = _tmp77_ + 1;

4550

}

4551

_tmp75_ = FALSE;

4552

_tmp78_ = dim;

4553

_tmp79_ = array_type;

4554

_tmp80_ = vala_array_type_get_rank (_tmp79_);

4555

_tmp81_ = _tmp80_;

4556

if (!(_tmp78_ <= _tmp81_)) {

4557

break;

4558

}

4559

_tmp82_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

4560

_tmp83_ = _tmp82_;

4561

_tmp84_ = dim;

4562

_tmp85_ = vala_ccode_base_module_get_array_length_cname ((ValaCCodeBaseModule*) self, "value", _tmp84_);

4563

_tmp86_ = _tmp85_;

4564

_tmp87_ = vala_ccode_variable_declarator_new (_tmp86_, NULL, NULL);

4565

_tmp88_ = _tmp87_;

4566

vala_ccode_function_add_declaration (_tmp83_, "int", (ValaCCodeDeclarator*) _tmp88_, 0);

4567

_vala_ccode_node_unref0 (_tmp88_);

4568

_g_free0 (_tmp86_);

4569

_tmp89_ = ccall;

4570

_tmp90_ = dim;

4571

_tmp91_ = vala_ccode_base_module_get_array_length_cname ((ValaCCodeBaseModule*) self, "value", _tmp90_);

4572

_tmp92_ = _tmp91_;

4573

_tmp93_ = vala_ccode_identifier_new (_tmp92_);

4574

_tmp94_ = _tmp93_;

4575

vala_ccode_function_call_add_argument (_tmp89_, (ValaCCodeExpression*) _tmp94_);

4576

_vala_ccode_node_unref0 (_tmp94_);

4577

_g_free0 (_tmp92_);

4578

}

4579

}

4580

}

4581

}

4582

_vala_code_node_unref0 (array_type);

4583

}

4584

_tmp95_ = vala_ccode_identifier_new ("value");

4585

target = _tmp95_;

4586

_tmp96_ = prop;

4587

_tmp97_ = vala_property_get_property_type (_tmp96_);

4588

_tmp98_ = _tmp97_;

4589

_tmp99_ = vala_ccode_identifier_new ("_value");

4590

_tmp100_ = _tmp99_;

4591

_tmp101_ = target;

4592

_tmp102_ = vala_ccode_base_module_deserialize_expression ((ValaCCodeBaseModule*) self, _tmp98_, (ValaCCodeExpression*) _tmp100_, (ValaCCodeExpression*) _tmp101_, NULL, NULL);

4593

_tmp103_ = _tmp102_;

4594

_vala_ccode_node_unref0 (_tmp100_);

4595

expr = _tmp103_;

4596

_tmp104_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

4597

_tmp105_ = _tmp104_;

4598

_tmp106_ = target;

4599

_tmp107_ = expr;

4600

vala_ccode_function_add_assignment (_tmp105_, (ValaCCodeExpression*) _tmp106_, _tmp107_);

4601

_tmp108_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

4602

_tmp109_ = _tmp108_;

4603

_tmp110_ = ccall;

4604

vala_ccode_function_add_expression (_tmp109_, (ValaCCodeExpression*) _tmp110_);

4605

_tmp111_ = owned_type;

4606

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

4607

if (_tmp112_) {

4608

ValaDataType* _tmp113_;

4609

ValaLocalVariable* _tmp114_;

4610

ValaLocalVariable* local;

4611

ValaCCodeFunction* _tmp115_;

4612

ValaCCodeFunction* _tmp116_;

4613

ValaLocalVariable* _tmp117_;

4614

ValaCCodeExpression* _tmp118_ = NULL;

4615

ValaCCodeExpression* _tmp119_;

4616

_tmp113_ = owned_type;

4617

_tmp114_ = vala_local_variable_new (_tmp113_, "value", NULL, NULL);

4618

local = _tmp114_;

4619

_tmp115_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

4620

_tmp116_ = _tmp115_;

4621

_tmp117_ = local;

4622

_tmp118_ = vala_ccode_base_module_destroy_local ((ValaCCodeBaseModule*) self, _tmp117_);

4623

_tmp119_ = _tmp118_;

4624

vala_ccode_function_add_expression (_tmp116_, _tmp119_);

4625

_vala_ccode_node_unref0 (_tmp119_);

4626

_vala_code_node_unref0 (local);

4627

}

4628

vala_ccode_base_module_pop_function ((ValaCCodeBaseModule*) self);

4629

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

4630

_tmp121_ = function;

4631

vala_ccode_file_add_function_declaration (_tmp120_, _tmp121_);

4632

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

4633

_tmp123_ = function;

4634

vala_ccode_file_add_function (_tmp122_, _tmp123_);

4635

result = wrapper_name;

4636

_vala_ccode_node_unref0 (expr);

4637

_vala_ccode_node_unref0 (target);

4638

_vala_code_node_unref0 (st);

4639

_vala_code_node_unref0 (owned_type);

4640

_vala_ccode_node_unref0 (ccall);

4641

_vala_ccode_node_unref0 (function);

4642

return result;

4643

}

4644

4645

4646

static void vala_gd_bus_server_module_handle_signals (ValaGDBusServerModule* self, ValaObjectTypeSymbol* sym, gboolean connect) {

4647

ValaObjectTypeSymbol* _tmp0_;

4648

gchar* _tmp1_ = NULL;

4649

gchar* dbus_iface_name;

4650

const gchar* _tmp2_;

4651

g_return_if_fail (self != NULL);

4652

g_return_if_fail (sym != NULL);

4653

_tmp0_ = sym;

4654

_tmp1_ = vala_gd_bus_module_get_dbus_name ((ValaTypeSymbol*) _tmp0_);

4655

dbus_iface_name = _tmp1_;

4656

_tmp2_ = dbus_iface_name;

4657

if (_tmp2_ == NULL) {

4658

_g_free0 (dbus_iface_name);

4659

return;

4660

}

4661

{

4662

ValaObjectTypeSymbol* _tmp3_;

4663

ValaList* _tmp4_ = NULL;

4664

ValaList* _sig_list;

4665

ValaList* _tmp5_;

4666

gint _tmp6_;

4667

gint _tmp7_;

4668

gint _sig_size;

4669

gint _sig_index;

4670

_tmp3_ = sym;

4671

_tmp4_ = vala_object_type_symbol_get_signals (_tmp3_);

4672

_sig_list = _tmp4_;

4673

_tmp5_ = _sig_list;

4674

_tmp6_ = vala_collection_get_size ((ValaCollection*) _tmp5_);

4675

_tmp7_ = _tmp6_;

4676

_sig_size = _tmp7_;

4677

_sig_index = -1;

4678

while (TRUE) {

4679

gint _tmp8_;

4680

gint _tmp9_;

4681

gint _tmp10_;

4682

ValaList* _tmp11_;

4683

gint _tmp12_;

4684

gpointer _tmp13_ = NULL;

4685

ValaSignal* sig;

4686

ValaSignal* _tmp14_;

4687

ValaSymbolAccessibility _tmp15_;

4688

ValaSymbolAccessibility _tmp16_;

4689

ValaSignal* _tmp17_;

4690

gboolean _tmp18_ = FALSE;

4691

gboolean _tmp19_;

4692

_tmp8_ = _sig_index;

4693

_sig_index = _tmp8_ + 1;

4694

_tmp9_ = _sig_index;

4695

_tmp10_ = _sig_size;

4696

if (!(_tmp9_ < _tmp10_)) {

4697

break;

4698

}

4699

_tmp11_ = _sig_list;

4700

_tmp12_ = _sig_index;

4701

_tmp13_ = vala_list_get (_tmp11_, _tmp12_);

4702

sig = (ValaSignal*) _tmp13_;

4703

_tmp14_ = sig;

4704

_tmp15_ = vala_symbol_get_access ((ValaSymbol*) _tmp14_);

4705

_tmp16_ = _tmp15_;

4706

if (_tmp16_ != VALA_SYMBOL_ACCESSIBILITY_PUBLIC) {

4707

_vala_code_node_unref0 (sig);

4708

continue;

4709

}

4710

_tmp17_ = sig;

4711

_tmp18_ = vala_gd_bus_server_module_is_dbus_visible ((ValaCodeNode*) _tmp17_);

4712

if (!_tmp18_) {

4713

_vala_code_node_unref0 (sig);

4714

continue;

4715

}

4716

_tmp19_ = connect;

4717

if (_tmp19_) {

4718

ValaCCodeIdentifier* _tmp20_;

4719

ValaCCodeIdentifier* _tmp21_;

4720

ValaCCodeFunctionCall* _tmp22_;

4721

ValaCCodeFunctionCall* _tmp23_;

4722

ValaCCodeFunctionCall* connect_call;

4723

ValaCCodeFunctionCall* _tmp24_;

4724

ValaCCodeIdentifier* _tmp25_;

4725

ValaCCodeIdentifier* _tmp26_;

4726

ValaCCodeFunctionCall* _tmp27_;

4727

ValaSignal* _tmp28_;

4728

ValaCCodeConstant* _tmp29_ = NULL;

4729

ValaCCodeConstant* _tmp30_;

4730

ValaCCodeFunctionCall* _tmp31_;

4731

ValaSignal* _tmp32_;

4732

ValaObjectTypeSymbol* _tmp33_;

4733

const gchar* _tmp34_;

4734

gchar* _tmp35_ = NULL;

4735

gchar* _tmp36_;

4736

ValaCCodeIdentifier* _tmp37_;

4737

ValaCCodeIdentifier* _tmp38_;

4738

ValaCCodeCastExpression* _tmp39_;

4739

ValaCCodeCastExpression* _tmp40_;

4740

ValaCCodeFunctionCall* _tmp41_;

4741

ValaCCodeIdentifier* _tmp42_;

4742

ValaCCodeIdentifier* _tmp43_;

4743

ValaCCodeFunction* _tmp44_;

4744

ValaCCodeFunction* _tmp45_;

4745

ValaCCodeFunctionCall* _tmp46_;

4746

_tmp20_ = vala_ccode_identifier_new ("g_signal_connect");

4747

_tmp21_ = _tmp20_;

4748

_tmp22_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp21_);

4749

_tmp23_ = _tmp22_;

4750

_vala_ccode_node_unref0 (_tmp21_);

4751

connect_call = _tmp23_;

4752

_tmp24_ = connect_call;

4753

_tmp25_ = vala_ccode_identifier_new ("object");

4754

_tmp26_ = _tmp25_;

4755

vala_ccode_function_call_add_argument (_tmp24_, (ValaCCodeExpression*) _tmp26_);

4756

_vala_ccode_node_unref0 (_tmp26_);

4757

_tmp27_ = connect_call;

4758

_tmp28_ = sig;

4759

_tmp29_ = vala_ccode_base_module_get_signal_canonical_constant ((ValaCCodeBaseModule*) self, _tmp28_, NULL);

4760

_tmp30_ = _tmp29_;

4761

vala_ccode_function_call_add_argument (_tmp27_, (ValaCCodeExpression*) _tmp30_);

4762

_vala_ccode_node_unref0 (_tmp30_);

4763

_tmp31_ = connect_call;

4764

_tmp32_ = sig;

4765

_tmp33_ = sym;

4766

_tmp34_ = dbus_iface_name;

4767

_tmp35_ = vala_gd_bus_server_module_generate_dbus_signal_wrapper (self, _tmp32_, _tmp33_, _tmp34_);

4768

_tmp36_ = _tmp35_;

4769

_tmp37_ = vala_ccode_identifier_new (_tmp36_);

4770

_tmp38_ = _tmp37_;

4771

_tmp39_ = vala_ccode_cast_expression_new ((ValaCCodeExpression*) _tmp38_, "GCallback");

4772

_tmp40_ = _tmp39_;

4773

vala_ccode_function_call_add_argument (_tmp31_, (ValaCCodeExpression*) _tmp40_);

4774

_vala_ccode_node_unref0 (_tmp40_);

4775

_vala_ccode_node_unref0 (_tmp38_);

4776

_g_free0 (_tmp36_);

4777

_tmp41_ = connect_call;

4778

_tmp42_ = vala_ccode_identifier_new ("data");

4779

_tmp43_ = _tmp42_;

4780

vala_ccode_function_call_add_argument (_tmp41_, (ValaCCodeExpression*) _tmp43_);

4781

_vala_ccode_node_unref0 (_tmp43_);

4782

_tmp44_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

4783

_tmp45_ = _tmp44_;

4784

_tmp46_ = connect_call;

4785

vala_ccode_function_add_expression (_tmp45_, (ValaCCodeExpression*) _tmp46_);

4786

_vala_ccode_node_unref0 (connect_call);

4787

} else {

4788

ValaCCodeIdentifier* _tmp47_;

4789

ValaCCodeIdentifier* _tmp48_;

4790

ValaCCodeFunctionCall* _tmp49_;

4791

ValaCCodeFunctionCall* _tmp50_;

4792

ValaCCodeFunctionCall* disconnect_call;

4793

ValaCCodeFunctionCall* _tmp51_;

4794

ValaCCodeIdentifier* _tmp52_;

4795

ValaCCodeIdentifier* _tmp53_;

4796

ValaCCodeConstant* _tmp54_;

4797

ValaCCodeConstant* _tmp55_;

4798

ValaCCodeElementAccess* _tmp56_;

4799

ValaCCodeElementAccess* _tmp57_;

4800

ValaCCodeFunctionCall* _tmp58_;

4801

ValaObjectTypeSymbol* _tmp59_;

4802

gchar* _tmp60_ = NULL;

4803

gchar* _tmp61_;

4804

ValaSignal* _tmp62_;

4805

gchar* _tmp63_ = NULL;

4806

gchar* _tmp64_;

4807

gchar* _tmp65_ = NULL;

4808

gchar* _tmp66_;

4809

ValaCCodeIdentifier* _tmp67_;

4810

ValaCCodeIdentifier* _tmp68_;

4811

ValaCCodeFunctionCall* _tmp69_;

4812

ValaCCodeIdentifier* _tmp70_;

4813

ValaCCodeIdentifier* _tmp71_;

4814

ValaCCodeFunction* _tmp72_;

4815

ValaCCodeFunction* _tmp73_;

4816

ValaCCodeFunctionCall* _tmp74_;

4817

_tmp47_ = vala_ccode_identifier_new ("g_signal_handlers_disconnect_by_func");

4818

_tmp48_ = _tmp47_;

4819

_tmp49_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp48_);

4820

_tmp50_ = _tmp49_;

4821

_vala_ccode_node_unref0 (_tmp48_);

4822

disconnect_call = _tmp50_;

4823

_tmp51_ = disconnect_call;

4824

_tmp52_ = vala_ccode_identifier_new ("data");

4825

_tmp53_ = _tmp52_;

4826

_tmp54_ = vala_ccode_constant_new ("0");

4827

_tmp55_ = _tmp54_;

4828

_tmp56_ = vala_ccode_element_access_new ((ValaCCodeExpression*) _tmp53_, (ValaCCodeExpression*) _tmp55_);

4829

_tmp57_ = _tmp56_;

4830

vala_ccode_function_call_add_argument (_tmp51_, (ValaCCodeExpression*) _tmp57_);

4831

_vala_ccode_node_unref0 (_tmp57_);

4832

_vala_ccode_node_unref0 (_tmp55_);

4833

_vala_ccode_node_unref0 (_tmp53_);

4834

_tmp58_ = disconnect_call;

4835

_tmp59_ = sym;

4836

_tmp60_ = vala_ccode_base_module_get_ccode_lower_case_name ((ValaCodeNode*) _tmp59_, NULL);

4837

_tmp61_ = _tmp60_;

4838

_tmp62_ = sig;

4839

_tmp63_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp62_);

4840

_tmp64_ = _tmp63_;

4841

_tmp65_ = g_strdup_printf ("_dbus_%s_%s", _tmp61_, _tmp64_);

4842

_tmp66_ = _tmp65_;

4843

_tmp67_ = vala_ccode_identifier_new (_tmp66_);

4844

_tmp68_ = _tmp67_;

4845

vala_ccode_function_call_add_argument (_tmp58_, (ValaCCodeExpression*) _tmp68_);

4846

_vala_ccode_node_unref0 (_tmp68_);

4847

_g_free0 (_tmp66_);

4848

_g_free0 (_tmp64_);

4849

_g_free0 (_tmp61_);

4850

_tmp69_ = disconnect_call;

4851

_tmp70_ = vala_ccode_identifier_new ("data");

4852

_tmp71_ = _tmp70_;

4853

vala_ccode_function_call_add_argument (_tmp69_, (ValaCCodeExpression*) _tmp71_);

4854

_vala_ccode_node_unref0 (_tmp71_);

4855

_tmp72_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

4856

_tmp73_ = _tmp72_;

4857

_tmp74_ = disconnect_call;

4858

vala_ccode_function_add_expression (_tmp73_, (ValaCCodeExpression*) _tmp74_);

4859

_vala_ccode_node_unref0 (disconnect_call);

4860

}

4861

_vala_code_node_unref0 (sig);

4862

}

4863

_vala_iterable_unref0 (_sig_list);

4864

}

4865

_g_free0 (dbus_iface_name);

4866

}

4867

4868

4869

static void vala_gd_bus_server_module_generate_interface_method_call_function (ValaGDBusServerModule* self, ValaObjectTypeSymbol* sym) {

4870

ValaObjectTypeSymbol* _tmp0_;

4871

gchar* _tmp1_ = NULL;

4872

gchar* _tmp2_;

4873

gchar* _tmp3_;

4874

gchar* _tmp4_;

4875

ValaCCodeFunction* _tmp5_;

4876

ValaCCodeFunction* _tmp6_;

4877

ValaCCodeFunction* cfunc;

4878

ValaCCodeFunction* _tmp7_;

4879

ValaCCodeParameter* _tmp8_;

4880

ValaCCodeParameter* _tmp9_;

4881

ValaCCodeFunction* _tmp10_;

4882

ValaCCodeParameter* _tmp11_;

4883

ValaCCodeParameter* _tmp12_;

4884

ValaCCodeFunction* _tmp13_;

4885

ValaCCodeParameter* _tmp14_;

4886

ValaCCodeParameter* _tmp15_;

4887

ValaCCodeFunction* _tmp16_;

4888

ValaCCodeParameter* _tmp17_;

4889

ValaCCodeParameter* _tmp18_;

4890

ValaCCodeFunction* _tmp19_;

4891

ValaCCodeParameter* _tmp20_;

4892

ValaCCodeParameter* _tmp21_;

4893

ValaCCodeFunction* _tmp22_;

4894

ValaCCodeParameter* _tmp23_;

4895

ValaCCodeParameter* _tmp24_;

4896

ValaCCodeFunction* _tmp25_;

4897

ValaCCodeParameter* _tmp26_;

4898

ValaCCodeParameter* _tmp27_;

4899

ValaCCodeFunction* _tmp28_;

4900

ValaCCodeParameter* _tmp29_;

4901

ValaCCodeParameter* _tmp30_;

4902

ValaCCodeFunction* _tmp31_;

4903

ValaCCodeFunction* _tmp32_;

4904

ValaCCodeModifiers _tmp33_;

4905

ValaCCodeModifiers _tmp34_;

4906

ValaCCodeFunction* _tmp35_;

4907

ValaCCodeFunction* _tmp36_;

4908

ValaCCodeFunction* _tmp37_;

4909

ValaCCodeIdentifier* _tmp38_;

4910

ValaCCodeIdentifier* _tmp39_;

4911

ValaCCodeVariableDeclarator* _tmp40_;

4912

ValaCCodeVariableDeclarator* _tmp41_;

4913

ValaCCodeFunction* _tmp42_;

4914

ValaCCodeFunction* _tmp43_;

4915

ValaCCodeIdentifier* _tmp44_;

4916

ValaCCodeIdentifier* _tmp45_;

4917

ValaCCodeConstant* _tmp46_;

4918

ValaCCodeConstant* _tmp47_;

4919

ValaCCodeElementAccess* _tmp48_;

4920

ValaCCodeElementAccess* _tmp49_;

4921

ValaCCodeVariableDeclarator* _tmp50_;

4922

ValaCCodeVariableDeclarator* _tmp51_;

4923

gboolean first;

4924

gboolean _tmp132_;

4925

ValaCCodeIdentifier* _tmp135_;

4926

ValaCCodeIdentifier* _tmp136_;

4927

ValaCCodeFunctionCall* _tmp137_;

4928

ValaCCodeFunctionCall* _tmp138_;

4929

ValaCCodeFunctionCall* ccall;

4930

ValaCCodeFunctionCall* _tmp139_;

4931

ValaCCodeIdentifier* _tmp140_;

4932

ValaCCodeIdentifier* _tmp141_;

4933

ValaCCodeFunction* _tmp142_;

4934

ValaCCodeFunction* _tmp143_;

4935

ValaCCodeFunctionCall* _tmp144_;

4936

gboolean _tmp145_;

4937

ValaCCodeFile* _tmp148_;

4938

ValaCCodeFunction* _tmp149_;

4939

ValaCCodeFile* _tmp150_;

4940

ValaCCodeFunction* _tmp151_;

4941

g_return_if_fail (self != NULL);

4942

g_return_if_fail (sym != NULL);

4943

_tmp0_ = sym;

4944

_tmp1_ = vala_ccode_base_module_get_ccode_lower_case_prefix ((ValaSymbol*) _tmp0_);

4945

_tmp2_ = _tmp1_;

4946

_tmp3_ = g_strconcat (_tmp2_, "dbus_interface_method_call", NULL);

4947

_tmp4_ = _tmp3_;

4948

_tmp5_ = vala_ccode_function_new (_tmp4_, "void");

4949

_tmp6_ = _tmp5_;

4950

_g_free0 (_tmp4_);

4951

_g_free0 (_tmp2_);

4952

cfunc = _tmp6_;

4953

_tmp7_ = cfunc;

4954

_tmp8_ = vala_ccode_parameter_new ("connection", "GDBusConnection*");

4955

_tmp9_ = _tmp8_;

4956

vala_ccode_function_add_parameter (_tmp7_, _tmp9_);

4957

_vala_ccode_node_unref0 (_tmp9_);

4958

_tmp10_ = cfunc;

4959

_tmp11_ = vala_ccode_parameter_new ("sender", "const gchar*");

4960

_tmp12_ = _tmp11_;

4961

vala_ccode_function_add_parameter (_tmp10_, _tmp12_);

4962

_vala_ccode_node_unref0 (_tmp12_);

4963

_tmp13_ = cfunc;

4964

_tmp14_ = vala_ccode_parameter_new ("object_path", "const gchar*");

4965

_tmp15_ = _tmp14_;

4966

vala_ccode_function_add_parameter (_tmp13_, _tmp15_);

4967

_vala_ccode_node_unref0 (_tmp15_);

4968

_tmp16_ = cfunc;

4969

_tmp17_ = vala_ccode_parameter_new ("interface_name", "const gchar*");

4970

_tmp18_ = _tmp17_;

4971

vala_ccode_function_add_parameter (_tmp16_, _tmp18_);

4972

_vala_ccode_node_unref0 (_tmp18_);

4973

_tmp19_ = cfunc;

4974

_tmp20_ = vala_ccode_parameter_new ("method_name", "const gchar*");

4975

_tmp21_ = _tmp20_;

4976

vala_ccode_function_add_parameter (_tmp19_, _tmp21_);

4977

_vala_ccode_node_unref0 (_tmp21_);

4978

_tmp22_ = cfunc;

4979

_tmp23_ = vala_ccode_parameter_new ("parameters", "GVariant*");

4980

_tmp24_ = _tmp23_;

4981

vala_ccode_function_add_parameter (_tmp22_, _tmp24_);

4982

_vala_ccode_node_unref0 (_tmp24_);

4983

_tmp25_ = cfunc;

4984

_tmp26_ = vala_ccode_parameter_new ("invocation", "GDBusMethodInvocation*");

4985

_tmp27_ = _tmp26_;

4986

vala_ccode_function_add_parameter (_tmp25_, _tmp27_);

4987

_vala_ccode_node_unref0 (_tmp27_);

4988

_tmp28_ = cfunc;

4989

_tmp29_ = vala_ccode_parameter_new ("user_data", "gpointer");

4990

_tmp30_ = _tmp29_;

4991

vala_ccode_function_add_parameter (_tmp28_, _tmp30_);

4992

_vala_ccode_node_unref0 (_tmp30_);

4993

_tmp31_ = cfunc;

4994

_tmp32_ = cfunc;

4995

_tmp33_ = vala_ccode_function_get_modifiers (_tmp32_);

4996

_tmp34_ = _tmp33_;

4997

vala_ccode_function_set_modifiers (_tmp32_, _tmp34_ | VALA_CCODE_MODIFIERS_STATIC);

4998

_tmp35_ = cfunc;

4999

vala_ccode_base_module_push_function ((ValaCCodeBaseModule*) self, _tmp35_);

5000

_tmp36_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

5001

_tmp37_ = _tmp36_;

5002

_tmp38_ = vala_ccode_identifier_new ("user_data");

5003

_tmp39_ = _tmp38_;

5004

_tmp40_ = vala_ccode_variable_declarator_new ("data", (ValaCCodeExpression*) _tmp39_, NULL);

5005

_tmp41_ = _tmp40_;

5006

vala_ccode_function_add_declaration (_tmp37_, "gpointer*", (ValaCCodeDeclarator*) _tmp41_, 0);

5007

_vala_ccode_node_unref0 (_tmp41_);

5008

_vala_ccode_node_unref0 (_tmp39_);

5009

_tmp42_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

5010

_tmp43_ = _tmp42_;

5011

_tmp44_ = vala_ccode_identifier_new ("data");

5012

_tmp45_ = _tmp44_;

5013

_tmp46_ = vala_ccode_constant_new ("0");

5014

_tmp47_ = _tmp46_;

5015

_tmp48_ = vala_ccode_element_access_new ((ValaCCodeExpression*) _tmp45_, (ValaCCodeExpression*) _tmp47_);

5016

_tmp49_ = _tmp48_;

5017

_tmp50_ = vala_ccode_variable_declarator_new ("object", (ValaCCodeExpression*) _tmp49_, NULL);

5018

_tmp51_ = _tmp50_;

5019

vala_ccode_function_add_declaration (_tmp43_, "gpointer", (ValaCCodeDeclarator*) _tmp51_, 0);

5020

_vala_ccode_node_unref0 (_tmp51_);

5021

_vala_ccode_node_unref0 (_tmp49_);

5022

_vala_ccode_node_unref0 (_tmp47_);

5023

_vala_ccode_node_unref0 (_tmp45_);

5024

first = TRUE;

5025

{

5026

ValaObjectTypeSymbol* _tmp52_;

5027

ValaList* _tmp53_ = NULL;

5028

ValaList* _m_list;

5029

ValaList* _tmp54_;

5030

gint _tmp55_;

5031

gint _tmp56_;

5032

gint _m_size;

5033

gint _m_index;

5034

_tmp52_ = sym;

5035

_tmp53_ = vala_object_type_symbol_get_methods (_tmp52_);

5036

_m_list = _tmp53_;

5037

_tmp54_ = _m_list;

5038

_tmp55_ = vala_collection_get_size ((ValaCollection*) _tmp54_);

5039

_tmp56_ = _tmp55_;

5040

_m_size = _tmp56_;

5041

_m_index = -1;

5042

while (TRUE) {

5043

gint _tmp57_;

5044

gint _tmp58_;

5045

gint _tmp59_;

5046

ValaList* _tmp60_;

5047

gint _tmp61_;

5048

gpointer _tmp62_ = NULL;

5049

ValaMethod* m;

5050

gboolean _tmp63_ = FALSE;

5051

gboolean _tmp64_ = FALSE;

5052

gboolean _tmp65_ = FALSE;

5053

ValaMethod* _tmp66_;

5054

gboolean _tmp70_;

5055

gboolean _tmp74_;

5056

gboolean _tmp78_;

5057

ValaMethod* _tmp79_;

5058

gboolean _tmp80_ = FALSE;

5059

ValaCCodeFile* _tmp81_;

5060

ValaCCodeIdentifier* _tmp82_;

5061

ValaCCodeIdentifier* _tmp83_;

5062

ValaCCodeFunctionCall* _tmp84_;

5063

ValaCCodeFunctionCall* _tmp85_;

5064

ValaCCodeFunctionCall* ccheck;

5065

ValaCCodeFunctionCall* _tmp86_;

5066

ValaCCodeIdentifier* _tmp87_;

5067

ValaCCodeIdentifier* _tmp88_;

5068

ValaCCodeFunctionCall* _tmp89_;

5069

ValaMethod* _tmp90_;

5070

gchar* _tmp91_ = NULL;

5071

gchar* _tmp92_;

5072

gchar* _tmp93_ = NULL;

5073

gchar* _tmp94_;

5074

ValaCCodeConstant* _tmp95_;

5075

ValaCCodeConstant* _tmp96_;

5076

gboolean _tmp97_;

5077

ValaMethod* _tmp112_;

5078

ValaObjectTypeSymbol* _tmp113_;

5079

gchar* _tmp114_ = NULL;

5080

gchar* _tmp115_;

5081

ValaCCodeIdentifier* _tmp116_;

5082

ValaCCodeIdentifier* _tmp117_;

5083

ValaCCodeFunctionCall* _tmp118_;

5084

ValaCCodeFunctionCall* _tmp119_;

5085

ValaCCodeFunctionCall* ccall;

5086

ValaCCodeFunctionCall* _tmp120_;

5087

ValaCCodeIdentifier* _tmp121_;

5088

ValaCCodeIdentifier* _tmp122_;

5089

ValaCCodeFunctionCall* _tmp123_;

5090

ValaCCodeIdentifier* _tmp124_;

5091

ValaCCodeIdentifier* _tmp125_;

5092

ValaCCodeFunctionCall* _tmp126_;

5093

ValaCCodeIdentifier* _tmp127_;

5094

ValaCCodeIdentifier* _tmp128_;

5095

ValaCCodeFunction* _tmp129_;

5096

ValaCCodeFunction* _tmp130_;

5097

ValaCCodeFunctionCall* _tmp131_;

5098

_tmp57_ = _m_index;

5099

_m_index = _tmp57_ + 1;

5100

_tmp58_ = _m_index;

5101

_tmp59_ = _m_size;

5102

if (!(_tmp58_ < _tmp59_)) {

5103

break;

5104

}

5105

_tmp60_ = _m_list;

5106

_tmp61_ = _m_index;

5107

_tmp62_ = vala_list_get (_tmp60_, _tmp61_);

5108

m = (ValaMethod*) _tmp62_;

5109

_tmp66_ = m;

5110

if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp66_, VALA_TYPE_CREATION_METHOD)) {

5111

_tmp65_ = TRUE;

5112

} else {

5113

ValaMethod* _tmp67_;

5114

ValaMemberBinding _tmp68_;

5115

ValaMemberBinding _tmp69_;

5116

_tmp67_ = m;

5117

_tmp68_ = vala_method_get_binding (_tmp67_);

5118

_tmp69_ = _tmp68_;

5119

_tmp65_ = _tmp69_ != VALA_MEMBER_BINDING_INSTANCE;

5120

}

5121

_tmp70_ = _tmp65_;

5122

if (_tmp70_) {

5123

_tmp64_ = TRUE;

5124

} else {

5125

ValaMethod* _tmp71_;

5126

gboolean _tmp72_;

5127

gboolean _tmp73_;

5128

_tmp71_ = m;

5129

_tmp72_ = vala_method_get_overrides (_tmp71_);

5130

_tmp73_ = _tmp72_;

5131

_tmp64_ = _tmp73_;

5132

}

5133

_tmp74_ = _tmp64_;

5134

if (_tmp74_) {

5135

_tmp63_ = TRUE;

5136

} else {

5137

ValaMethod* _tmp75_;

5138

ValaSymbolAccessibility _tmp76_;

5139

ValaSymbolAccessibility _tmp77_;

5140

_tmp75_ = m;

5141

_tmp76_ = vala_symbol_get_access ((ValaSymbol*) _tmp75_);

5142

_tmp77_ = _tmp76_;

5143

_tmp63_ = _tmp77_ != VALA_SYMBOL_ACCESSIBILITY_PUBLIC;

5144

}

5145

_tmp78_ = _tmp63_;

5146

if (_tmp78_) {

5147

_vala_code_node_unref0 (m);

5148

continue;

5149

}

5150

_tmp79_ = m;

5151

_tmp80_ = vala_gd_bus_server_module_is_dbus_visible ((ValaCodeNode*) _tmp79_);

5152

if (!_tmp80_) {

5153

_vala_code_node_unref0 (m);

5154

continue;

5155

}

5156

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

5157

vala_ccode_file_add_include (_tmp81_, "string.h", FALSE);

5158

_tmp82_ = vala_ccode_identifier_new ("strcmp");

5159

_tmp83_ = _tmp82_;

5160

_tmp84_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp83_);

5161

_tmp85_ = _tmp84_;

5162

_vala_ccode_node_unref0 (_tmp83_);

5163

ccheck = _tmp85_;

5164

_tmp86_ = ccheck;

5165

_tmp87_ = vala_ccode_identifier_new ("method_name");

5166

_tmp88_ = _tmp87_;

5167

vala_ccode_function_call_add_argument (_tmp86_, (ValaCCodeExpression*) _tmp88_);

5168

_vala_ccode_node_unref0 (_tmp88_);

5169

_tmp89_ = ccheck;

5170

_tmp90_ = m;

5171

_tmp91_ = vala_gd_bus_module_get_dbus_name_for_member ((ValaSymbol*) _tmp90_);

5172

_tmp92_ = _tmp91_;

5173

_tmp93_ = g_strdup_printf ("\"%s\"", _tmp92_);

5174

_tmp94_ = _tmp93_;

5175

_tmp95_ = vala_ccode_constant_new (_tmp94_);

5176

_tmp96_ = _tmp95_;

5177

vala_ccode_function_call_add_argument (_tmp89_, (ValaCCodeExpression*) _tmp96_);

5178

_vala_ccode_node_unref0 (_tmp96_);

5179

_g_free0 (_tmp94_);

5180

_g_free0 (_tmp92_);

5181

_tmp97_ = first;

5182

if (_tmp97_) {

5183

ValaCCodeFunction* _tmp98_;

5184

ValaCCodeFunction* _tmp99_;

5185

ValaCCodeFunctionCall* _tmp100_;

5186

ValaCCodeConstant* _tmp101_;

5187

ValaCCodeConstant* _tmp102_;

5188

ValaCCodeBinaryExpression* _tmp103_;

5189

ValaCCodeBinaryExpression* _tmp104_;

5190

_tmp98_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

5191

_tmp99_ = _tmp98_;

5192

_tmp100_ = ccheck;

5193

_tmp101_ = vala_ccode_constant_new ("0");

5194

_tmp102_ = _tmp101_;

5195

_tmp103_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_EQUALITY, (ValaCCodeExpression*) _tmp100_, (ValaCCodeExpression*) _tmp102_);

5196

_tmp104_ = _tmp103_;

5197

vala_ccode_function_open_if (_tmp99_, (ValaCCodeExpression*) _tmp104_);

5198

_vala_ccode_node_unref0 (_tmp104_);

5199

_vala_ccode_node_unref0 (_tmp102_);

5200

first = FALSE;

5201

} else {

5202

ValaCCodeFunction* _tmp105_;

5203

ValaCCodeFunction* _tmp106_;

5204

ValaCCodeFunctionCall* _tmp107_;

5205

ValaCCodeConstant* _tmp108_;

5206

ValaCCodeConstant* _tmp109_;

5207

ValaCCodeBinaryExpression* _tmp110_;

5208

ValaCCodeBinaryExpression* _tmp111_;

5209

_tmp105_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

5210

_tmp106_ = _tmp105_;

5211

_tmp107_ = ccheck;

5212

_tmp108_ = vala_ccode_constant_new ("0");

5213

_tmp109_ = _tmp108_;

5214

_tmp110_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_EQUALITY, (ValaCCodeExpression*) _tmp107_, (ValaCCodeExpression*) _tmp109_);

5215

_tmp111_ = _tmp110_;

5216

vala_ccode_function_else_if (_tmp106_, (ValaCCodeExpression*) _tmp111_);

5217

_vala_ccode_node_unref0 (_tmp111_);

5218

_vala_ccode_node_unref0 (_tmp109_);

5219

}

5220

_tmp112_ = m;

5221

_tmp113_ = sym;

5222

_tmp114_ = vala_gd_bus_server_module_generate_dbus_wrapper (self, _tmp112_, _tmp113_, FALSE);

5223

_tmp115_ = _tmp114_;

5224

_tmp116_ = vala_ccode_identifier_new (_tmp115_);

5225

_tmp117_ = _tmp116_;

5226

_tmp118_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp117_);

5227

_tmp119_ = _tmp118_;

5228

_vala_ccode_node_unref0 (_tmp117_);

5229

_g_free0 (_tmp115_);

5230

ccall = _tmp119_;

5231

_tmp120_ = ccall;

5232

_tmp121_ = vala_ccode_identifier_new ("object");

5233

_tmp122_ = _tmp121_;

5234

vala_ccode_function_call_add_argument (_tmp120_, (ValaCCodeExpression*) _tmp122_);

5235

_vala_ccode_node_unref0 (_tmp122_);

5236

_tmp123_ = ccall;

5237

_tmp124_ = vala_ccode_identifier_new ("parameters");

5238

_tmp125_ = _tmp124_;

5239

vala_ccode_function_call_add_argument (_tmp123_, (ValaCCodeExpression*) _tmp125_);

5240

_vala_ccode_node_unref0 (_tmp125_);

5241

_tmp126_ = ccall;

5242

_tmp127_ = vala_ccode_identifier_new ("invocation");

5243

_tmp128_ = _tmp127_;

5244

vala_ccode_function_call_add_argument (_tmp126_, (ValaCCodeExpression*) _tmp128_);

5245

_vala_ccode_node_unref0 (_tmp128_);

5246

_tmp129_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

5247

_tmp130_ = _tmp129_;

5248

_tmp131_ = ccall;

5249

vala_ccode_function_add_expression (_tmp130_, (ValaCCodeExpression*) _tmp131_);

5250

_vala_ccode_node_unref0 (ccall);

5251

_vala_ccode_node_unref0 (ccheck);

5252

_vala_code_node_unref0 (m);

5253

}

5254

_vala_iterable_unref0 (_m_list);

5255

}

5256

_tmp132_ = first;

5257

if (!_tmp132_) {

5258

ValaCCodeFunction* _tmp133_;

5259

ValaCCodeFunction* _tmp134_;

5260

_tmp133_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

5261

_tmp134_ = _tmp133_;

5262

vala_ccode_function_add_else (_tmp134_);

5263

}

5264

_tmp135_ = vala_ccode_identifier_new ("g_object_unref");

5265

_tmp136_ = _tmp135_;

5266

_tmp137_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp136_);

5267

_tmp138_ = _tmp137_;

5268

_vala_ccode_node_unref0 (_tmp136_);

5269

ccall = _tmp138_;

5270

_tmp139_ = ccall;

5271

_tmp140_ = vala_ccode_identifier_new ("invocation");

5272

_tmp141_ = _tmp140_;

5273

vala_ccode_function_call_add_argument (_tmp139_, (ValaCCodeExpression*) _tmp141_);

5274

_vala_ccode_node_unref0 (_tmp141_);

5275

_tmp142_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

5276

_tmp143_ = _tmp142_;

5277

_tmp144_ = ccall;

5278

vala_ccode_function_add_expression (_tmp143_, (ValaCCodeExpression*) _tmp144_);

5279

_tmp145_ = first;

5280

if (!_tmp145_) {

5281

ValaCCodeFunction* _tmp146_;

5282

ValaCCodeFunction* _tmp147_;

5283

_tmp146_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

5284

_tmp147_ = _tmp146_;

5285

vala_ccode_function_close (_tmp147_);

5286

}

5287

vala_ccode_base_module_pop_function ((ValaCCodeBaseModule*) self);

5288

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

5289

_tmp149_ = cfunc;

5290

vala_ccode_file_add_function_declaration (_tmp148_, _tmp149_);

5291

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

5292

_tmp151_ = cfunc;

5293

vala_ccode_file_add_function (_tmp150_, _tmp151_);

5294

_vala_ccode_node_unref0 (ccall);

5295

_vala_ccode_node_unref0 (cfunc);

5296

}

5297

5298

5299

static void vala_gd_bus_server_module_generate_interface_get_property_function (ValaGDBusServerModule* self, ValaObjectTypeSymbol* sym) {

5300

ValaObjectTypeSymbol* _tmp0_;

5301

gchar* _tmp1_ = NULL;

5302

gchar* _tmp2_;

5303

gchar* _tmp3_;

5304

gchar* _tmp4_;

5305

ValaCCodeFunction* _tmp5_;

5306

ValaCCodeFunction* _tmp6_;

5307

ValaCCodeFunction* cfunc;

5308

ValaCCodeFunction* _tmp7_;

5309

ValaCCodeParameter* _tmp8_;

5310

ValaCCodeParameter* _tmp9_;

5311

ValaCCodeFunction* _tmp10_;

5312

ValaCCodeParameter* _tmp11_;

5313

ValaCCodeParameter* _tmp12_;

5314

ValaCCodeFunction* _tmp13_;

5315

ValaCCodeParameter* _tmp14_;

5316

ValaCCodeParameter* _tmp15_;

5317

ValaCCodeFunction* _tmp16_;

5318

ValaCCodeParameter* _tmp17_;

5319

ValaCCodeParameter* _tmp18_;

5320

ValaCCodeFunction* _tmp19_;

5321

ValaCCodeParameter* _tmp20_;

5322

ValaCCodeParameter* _tmp21_;

5323

ValaCCodeFunction* _tmp22_;

5324

ValaCCodeParameter* _tmp23_;

5325

ValaCCodeParameter* _tmp24_;

5326

ValaCCodeFunction* _tmp25_;

5327

ValaCCodeParameter* _tmp26_;

5328

ValaCCodeParameter* _tmp27_;

5329

ValaCCodeFunction* _tmp28_;

5330

ValaCCodeFunction* _tmp29_;

5331

ValaCCodeModifiers _tmp30_;

5332

ValaCCodeModifiers _tmp31_;

5333

ValaCCodeFile* _tmp32_;

5334

ValaCCodeFunction* _tmp33_;

5335

ValaCCodeFunction* _tmp34_;

5336

ValaCCodeFunction* _tmp35_;

5337

ValaCCodeFunction* _tmp36_;

5338

ValaCCodeIdentifier* _tmp37_;

5339

ValaCCodeIdentifier* _tmp38_;

5340

ValaCCodeVariableDeclarator* _tmp39_;

5341

ValaCCodeVariableDeclarator* _tmp40_;

5342

ValaCCodeFunction* _tmp41_;

5343

ValaCCodeFunction* _tmp42_;

5344

ValaCCodeIdentifier* _tmp43_;

5345

ValaCCodeIdentifier* _tmp44_;

5346

ValaCCodeConstant* _tmp45_;

5347

ValaCCodeConstant* _tmp46_;

5348

ValaCCodeElementAccess* _tmp47_;

5349

ValaCCodeElementAccess* _tmp48_;

5350

ValaCCodeVariableDeclarator* _tmp49_;

5351

ValaCCodeVariableDeclarator* _tmp50_;

5352

gboolean firstif;

5353

gboolean _tmp122_;

5354

ValaCCodeFunction* _tmp125_;

5355

ValaCCodeFunction* _tmp126_;

5356

ValaCCodeConstant* _tmp127_;

5357

ValaCCodeConstant* _tmp128_;

5358

ValaCCodeFile* _tmp129_;

5359

ValaCCodeFunction* _tmp130_;

5360

g_return_if_fail (self != NULL);

5361

g_return_if_fail (sym != NULL);

5362

_tmp0_ = sym;

5363

_tmp1_ = vala_ccode_base_module_get_ccode_lower_case_prefix ((ValaSymbol*) _tmp0_);

5364

_tmp2_ = _tmp1_;

5365

_tmp3_ = g_strconcat (_tmp2_, "dbus_interface_get_property", NULL);

5366

_tmp4_ = _tmp3_;

5367

_tmp5_ = vala_ccode_function_new (_tmp4_, "GVariant*");

5368

_tmp6_ = _tmp5_;

5369

_g_free0 (_tmp4_);

5370

_g_free0 (_tmp2_);

5371

cfunc = _tmp6_;

5372

_tmp7_ = cfunc;

5373

_tmp8_ = vala_ccode_parameter_new ("connection", "GDBusConnection*");

5374

_tmp9_ = _tmp8_;

5375

vala_ccode_function_add_parameter (_tmp7_, _tmp9_);

5376

_vala_ccode_node_unref0 (_tmp9_);

5377

_tmp10_ = cfunc;

5378

_tmp11_ = vala_ccode_parameter_new ("sender", "const gchar*");

5379

_tmp12_ = _tmp11_;

5380

vala_ccode_function_add_parameter (_tmp10_, _tmp12_);

5381

_vala_ccode_node_unref0 (_tmp12_);

5382

_tmp13_ = cfunc;

5383

_tmp14_ = vala_ccode_parameter_new ("object_path", "const gchar*");

5384

_tmp15_ = _tmp14_;

5385

vala_ccode_function_add_parameter (_tmp13_, _tmp15_);

5386

_vala_ccode_node_unref0 (_tmp15_);

5387

_tmp16_ = cfunc;

5388

_tmp17_ = vala_ccode_parameter_new ("interface_name", "const gchar*");

5389

_tmp18_ = _tmp17_;

5390

vala_ccode_function_add_parameter (_tmp16_, _tmp18_);

5391

_vala_ccode_node_unref0 (_tmp18_);

5392

_tmp19_ = cfunc;

5393

_tmp20_ = vala_ccode_parameter_new ("property_name", "const gchar*");

5394

_tmp21_ = _tmp20_;

5395

vala_ccode_function_add_parameter (_tmp19_, _tmp21_);

5396

_vala_ccode_node_unref0 (_tmp21_);

5397

_tmp22_ = cfunc;

5398

_tmp23_ = vala_ccode_parameter_new ("error", "GError**");

5399

_tmp24_ = _tmp23_;

5400

vala_ccode_function_add_parameter (_tmp22_, _tmp24_);

5401

_vala_ccode_node_unref0 (_tmp24_);

5402

_tmp25_ = cfunc;

5403

_tmp26_ = vala_ccode_parameter_new ("user_data", "gpointer");

5404

_tmp27_ = _tmp26_;

5405

vala_ccode_function_add_parameter (_tmp25_, _tmp27_);

5406

_vala_ccode_node_unref0 (_tmp27_);

5407

_tmp28_ = cfunc;

5408

_tmp29_ = cfunc;

5409

_tmp30_ = vala_ccode_function_get_modifiers (_tmp29_);

5410

_tmp31_ = _tmp30_;

5411

vala_ccode_function_set_modifiers (_tmp29_, _tmp31_ | VALA_CCODE_MODIFIERS_STATIC);

5412

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

5413

_tmp33_ = cfunc;

5414

vala_ccode_file_add_function_declaration (_tmp32_, _tmp33_);

5415

_tmp34_ = cfunc;

5416

vala_ccode_base_module_push_function ((ValaCCodeBaseModule*) self, _tmp34_);

5417

_tmp35_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

5418

_tmp36_ = _tmp35_;

5419

_tmp37_ = vala_ccode_identifier_new ("user_data");

5420

_tmp38_ = _tmp37_;

5421

_tmp39_ = vala_ccode_variable_declarator_new ("data", (ValaCCodeExpression*) _tmp38_, NULL);

5422

_tmp40_ = _tmp39_;

5423

vala_ccode_function_add_declaration (_tmp36_, "gpointer*", (ValaCCodeDeclarator*) _tmp40_, 0);

5424

_vala_ccode_node_unref0 (_tmp40_);

5425

_vala_ccode_node_unref0 (_tmp38_);

5426

_tmp41_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

5427

_tmp42_ = _tmp41_;

5428

_tmp43_ = vala_ccode_identifier_new ("data");

5429

_tmp44_ = _tmp43_;

5430

_tmp45_ = vala_ccode_constant_new ("0");

5431

_tmp46_ = _tmp45_;

5432

_tmp47_ = vala_ccode_element_access_new ((ValaCCodeExpression*) _tmp44_, (ValaCCodeExpression*) _tmp46_);

5433

_tmp48_ = _tmp47_;

5434

_tmp49_ = vala_ccode_variable_declarator_new ("object", (ValaCCodeExpression*) _tmp48_, NULL);

5435

_tmp50_ = _tmp49_;

5436

vala_ccode_function_add_declaration (_tmp42_, "gpointer", (ValaCCodeDeclarator*) _tmp50_, 0);

5437

_vala_ccode_node_unref0 (_tmp50_);

5438

_vala_ccode_node_unref0 (_tmp48_);

5439

_vala_ccode_node_unref0 (_tmp46_);

5440

_vala_ccode_node_unref0 (_tmp44_);

5441

firstif = TRUE;

5442

{

5443

ValaObjectTypeSymbol* _tmp51_;

5444

ValaList* _tmp52_ = NULL;

5445

ValaList* _prop_list;

5446

ValaList* _tmp53_;

5447

gint _tmp54_;

5448

gint _tmp55_;

5449

gint _prop_size;

5450

gint _prop_index;

5451

_tmp51_ = sym;

5452

_tmp52_ = vala_object_type_symbol_get_properties (_tmp51_);

5453

_prop_list = _tmp52_;

5454

_tmp53_ = _prop_list;

5455

_tmp54_ = vala_collection_get_size ((ValaCollection*) _tmp53_);

5456

_tmp55_ = _tmp54_;

5457

_prop_size = _tmp55_;

5458

_prop_index = -1;

5459

while (TRUE) {

5460

gint _tmp56_;

5461

gint _tmp57_;

5462

gint _tmp58_;

5463

ValaList* _tmp59_;

5464

gint _tmp60_;

5465

gpointer _tmp61_ = NULL;

5466

ValaProperty* prop;

5467

gboolean _tmp62_ = FALSE;

5468

gboolean _tmp63_ = FALSE;

5469

ValaProperty* _tmp64_;

5470

ValaMemberBinding _tmp65_;

5471

ValaMemberBinding _tmp66_;

5472

gboolean _tmp70_;

5473

gboolean _tmp74_;

5474

ValaProperty* _tmp75_;

5475

gboolean _tmp76_ = FALSE;

5476

ValaProperty* _tmp77_;

5477

ValaPropertyAccessor* _tmp78_;

5478

ValaPropertyAccessor* _tmp79_;

5479

ValaCCodeFile* _tmp80_;

5480

ValaCCodeIdentifier* _tmp81_;

5481

ValaCCodeIdentifier* _tmp82_;

5482

ValaCCodeFunctionCall* _tmp83_;

5483

ValaCCodeFunctionCall* _tmp84_;

5484

ValaCCodeFunctionCall* ccheck;

5485

ValaCCodeFunctionCall* _tmp85_;

5486

ValaCCodeIdentifier* _tmp86_;

5487

ValaCCodeIdentifier* _tmp87_;

5488

ValaCCodeFunctionCall* _tmp88_;

5489

ValaProperty* _tmp89_;

5490

gchar* _tmp90_ = NULL;

5491

gchar* _tmp91_;

5492

gchar* _tmp92_ = NULL;

5493

gchar* _tmp93_;

5494

ValaCCodeConstant* _tmp94_;

5495

ValaCCodeConstant* _tmp95_;

5496

ValaCCodeFunctionCall* _tmp96_;

5497

ValaCCodeConstant* _tmp97_;

5498

ValaCCodeConstant* _tmp98_;

5499

ValaCCodeBinaryExpression* _tmp99_;

5500

ValaCCodeBinaryExpression* _tmp100_;

5501

ValaCCodeBinaryExpression* cond;

5502

gboolean _tmp101_;

5503

ValaProperty* _tmp108_;

5504

ValaObjectTypeSymbol* _tmp109_;

5505

gchar* _tmp110_ = NULL;

5506

gchar* _tmp111_;

5507

ValaCCodeIdentifier* _tmp112_;

5508

ValaCCodeIdentifier* _tmp113_;

5509

ValaCCodeFunctionCall* _tmp114_;

5510

ValaCCodeFunctionCall* _tmp115_;

5511

ValaCCodeFunctionCall* ccall;

5512

ValaCCodeFunctionCall* _tmp116_;

5513

ValaCCodeIdentifier* _tmp117_;

5514

ValaCCodeIdentifier* _tmp118_;

5515

ValaCCodeFunction* _tmp119_;

5516

ValaCCodeFunction* _tmp120_;

5517

ValaCCodeFunctionCall* _tmp121_;

5518

_tmp56_ = _prop_index;

5519

_prop_index = _tmp56_ + 1;

5520

_tmp57_ = _prop_index;

5521

_tmp58_ = _prop_size;

5522

if (!(_tmp57_ < _tmp58_)) {

5523

break;

5524

}

5525

_tmp59_ = _prop_list;

5526

_tmp60_ = _prop_index;

5527

_tmp61_ = vala_list_get (_tmp59_, _tmp60_);

5528

prop = (ValaProperty*) _tmp61_;

5529

_tmp64_ = prop;

5530

_tmp65_ = vala_property_get_binding (_tmp64_);

5531

_tmp66_ = _tmp65_;

5532

if (_tmp66_ != VALA_MEMBER_BINDING_INSTANCE) {

5533

_tmp63_ = TRUE;

5534

} else {

5535

ValaProperty* _tmp67_;

5536

gboolean _tmp68_;

5537

gboolean _tmp69_;

5538

_tmp67_ = prop;

5539

_tmp68_ = vala_property_get_overrides (_tmp67_);

5540

_tmp69_ = _tmp68_;

5541

_tmp63_ = _tmp69_;

5542

}

5543

_tmp70_ = _tmp63_;

5544

if (_tmp70_) {

5545

_tmp62_ = TRUE;

5546

} else {

5547

ValaProperty* _tmp71_;

5548

ValaSymbolAccessibility _tmp72_;

5549

ValaSymbolAccessibility _tmp73_;

5550

_tmp71_ = prop;

5551

_tmp72_ = vala_symbol_get_access ((ValaSymbol*) _tmp71_);

5552

_tmp73_ = _tmp72_;

5553

_tmp62_ = _tmp73_ != VALA_SYMBOL_ACCESSIBILITY_PUBLIC;

5554

}

5555

_tmp74_ = _tmp62_;

5556

if (_tmp74_) {

5557

_vala_code_node_unref0 (prop);

5558

continue;

5559

}

5560

_tmp75_ = prop;

5561

_tmp76_ = vala_gd_bus_server_module_is_dbus_visible ((ValaCodeNode*) _tmp75_);

5562

if (!_tmp76_) {

5563

_vala_code_node_unref0 (prop);

5564

continue;

5565

}

5566

_tmp77_ = prop;

5567

_tmp78_ = vala_property_get_get_accessor (_tmp77_);

5568

_tmp79_ = _tmp78_;

5569

if (_tmp79_ == NULL) {

5570

_vala_code_node_unref0 (prop);

5571

continue;

5572

}

5573

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

5574

vala_ccode_file_add_include (_tmp80_, "string.h", FALSE);

5575

_tmp81_ = vala_ccode_identifier_new ("strcmp");

5576

_tmp82_ = _tmp81_;

5577

_tmp83_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp82_);

5578

_tmp84_ = _tmp83_;

5579

_vala_ccode_node_unref0 (_tmp82_);

5580

ccheck = _tmp84_;

5581

_tmp85_ = ccheck;

5582

_tmp86_ = vala_ccode_identifier_new ("property_name");

5583

_tmp87_ = _tmp86_;

5584

vala_ccode_function_call_add_argument (_tmp85_, (ValaCCodeExpression*) _tmp87_);

5585

_vala_ccode_node_unref0 (_tmp87_);

5586

_tmp88_ = ccheck;

5587

_tmp89_ = prop;

5588

_tmp90_ = vala_gd_bus_module_get_dbus_name_for_member ((ValaSymbol*) _tmp89_);

5589

_tmp91_ = _tmp90_;

5590

_tmp92_ = g_strdup_printf ("\"%s\"", _tmp91_);

5591

_tmp93_ = _tmp92_;

5592

_tmp94_ = vala_ccode_constant_new (_tmp93_);

5593

_tmp95_ = _tmp94_;

5594

vala_ccode_function_call_add_argument (_tmp88_, (ValaCCodeExpression*) _tmp95_);

5595

_vala_ccode_node_unref0 (_tmp95_);

5596

_g_free0 (_tmp93_);

5597

_g_free0 (_tmp91_);

5598

_tmp96_ = ccheck;

5599

_tmp97_ = vala_ccode_constant_new ("0");

5600

_tmp98_ = _tmp97_;

5601

_tmp99_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_EQUALITY, (ValaCCodeExpression*) _tmp96_, (ValaCCodeExpression*) _tmp98_);

5602

_tmp100_ = _tmp99_;

5603

_vala_ccode_node_unref0 (_tmp98_);

5604

cond = _tmp100_;

5605

_tmp101_ = firstif;

5606

if (_tmp101_) {

5607

ValaCCodeFunction* _tmp102_;

5608

ValaCCodeFunction* _tmp103_;

5609

ValaCCodeBinaryExpression* _tmp104_;

5610

_tmp102_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

5611

_tmp103_ = _tmp102_;

5612

_tmp104_ = cond;

5613

vala_ccode_function_open_if (_tmp103_, (ValaCCodeExpression*) _tmp104_);

5614

firstif = FALSE;

5615

} else {

5616

ValaCCodeFunction* _tmp105_;

5617

ValaCCodeFunction* _tmp106_;

5618

ValaCCodeBinaryExpression* _tmp107_;

5619

_tmp105_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

5620

_tmp106_ = _tmp105_;

5621

_tmp107_ = cond;

5622

vala_ccode_function_else_if (_tmp106_, (ValaCCodeExpression*) _tmp107_);

5623

}

5624

_tmp108_ = prop;

5625

_tmp109_ = sym;

5626

_tmp110_ = vala_gd_bus_server_module_generate_dbus_property_get_wrapper (self, _tmp108_, _tmp109_);

5627

_tmp111_ = _tmp110_;

5628

_tmp112_ = vala_ccode_identifier_new (_tmp111_);

5629

_tmp113_ = _tmp112_;

5630

_tmp114_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp113_);

5631

_tmp115_ = _tmp114_;

5632

_vala_ccode_node_unref0 (_tmp113_);

5633

_g_free0 (_tmp111_);

5634

ccall = _tmp115_;

5635

_tmp116_ = ccall;

5636

_tmp117_ = vala_ccode_identifier_new ("object");

5637

_tmp118_ = _tmp117_;

5638

vala_ccode_function_call_add_argument (_tmp116_, (ValaCCodeExpression*) _tmp118_);

5639

_vala_ccode_node_unref0 (_tmp118_);

5640

_tmp119_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

5641

_tmp120_ = _tmp119_;

5642

_tmp121_ = ccall;

5643

vala_ccode_function_add_return (_tmp120_, (ValaCCodeExpression*) _tmp121_);

5644

_vala_ccode_node_unref0 (ccall);

5645

_vala_ccode_node_unref0 (cond);

5646

_vala_ccode_node_unref0 (ccheck);

5647

_vala_code_node_unref0 (prop);

5648

}

5649

_vala_iterable_unref0 (_prop_list);

5650

}

5651

_tmp122_ = firstif;

5652

if (!_tmp122_) {

5653

ValaCCodeFunction* _tmp123_;

5654

ValaCCodeFunction* _tmp124_;

5655

_tmp123_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

5656

_tmp124_ = _tmp123_;

5657

vala_ccode_function_close (_tmp124_);

5658

}

5659

_tmp125_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

5660

_tmp126_ = _tmp125_;

5661

_tmp127_ = vala_ccode_constant_new ("NULL");

5662

_tmp128_ = _tmp127_;

5663

vala_ccode_function_add_return (_tmp126_, (ValaCCodeExpression*) _tmp128_);

5664

_vala_ccode_node_unref0 (_tmp128_);

5665

vala_ccode_base_module_pop_function ((ValaCCodeBaseModule*) self);

5666

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

5667

_tmp130_ = cfunc;

5668

vala_ccode_file_add_function (_tmp129_, _tmp130_);

5669

_vala_ccode_node_unref0 (cfunc);

5670

}

5671

5672

5673

static void vala_gd_bus_server_module_generate_interface_set_property_function (ValaGDBusServerModule* self, ValaObjectTypeSymbol* sym) {

5674

ValaObjectTypeSymbol* _tmp0_;

5675

gchar* _tmp1_ = NULL;

5676

gchar* _tmp2_;

5677

gchar* _tmp3_;

5678

gchar* _tmp4_;

5679

ValaCCodeFunction* _tmp5_;

5680

ValaCCodeFunction* _tmp6_;

5681

ValaCCodeFunction* cfunc;

5682

ValaCCodeFunction* _tmp7_;

5683

ValaCCodeParameter* _tmp8_;

5684

ValaCCodeParameter* _tmp9_;

5685

ValaCCodeFunction* _tmp10_;

5686

ValaCCodeParameter* _tmp11_;

5687

ValaCCodeParameter* _tmp12_;

5688

ValaCCodeFunction* _tmp13_;

5689

ValaCCodeParameter* _tmp14_;

5690

ValaCCodeParameter* _tmp15_;

5691

ValaCCodeFunction* _tmp16_;

5692

ValaCCodeParameter* _tmp17_;

5693

ValaCCodeParameter* _tmp18_;

5694

ValaCCodeFunction* _tmp19_;

5695

ValaCCodeParameter* _tmp20_;

5696

ValaCCodeParameter* _tmp21_;

5697

ValaCCodeFunction* _tmp22_;

5698

ValaCCodeParameter* _tmp23_;

5699

ValaCCodeParameter* _tmp24_;

5700

ValaCCodeFunction* _tmp25_;

5701

ValaCCodeParameter* _tmp26_;

5702

ValaCCodeParameter* _tmp27_;

5703

ValaCCodeFunction* _tmp28_;

5704

ValaCCodeParameter* _tmp29_;

5705

ValaCCodeParameter* _tmp30_;

5706

ValaCCodeFunction* _tmp31_;

5707

ValaCCodeFunction* _tmp32_;

5708

ValaCCodeModifiers _tmp33_;

5709

ValaCCodeModifiers _tmp34_;

5710

ValaCCodeFile* _tmp35_;

5711

ValaCCodeFunction* _tmp36_;

5712

ValaCCodeFunction* _tmp37_;

5713

ValaCCodeFunction* _tmp38_;

5714

ValaCCodeFunction* _tmp39_;

5715

ValaCCodeIdentifier* _tmp40_;

5716

ValaCCodeIdentifier* _tmp41_;

5717

ValaCCodeVariableDeclarator* _tmp42_;

5718

ValaCCodeVariableDeclarator* _tmp43_;

5719

ValaCCodeFunction* _tmp44_;

5720

ValaCCodeFunction* _tmp45_;

5721

ValaCCodeIdentifier* _tmp46_;

5722

ValaCCodeIdentifier* _tmp47_;

5723

ValaCCodeConstant* _tmp48_;

5724

ValaCCodeConstant* _tmp49_;

5725

ValaCCodeElementAccess* _tmp50_;

5726

ValaCCodeElementAccess* _tmp51_;

5727

ValaCCodeVariableDeclarator* _tmp52_;

5728

ValaCCodeVariableDeclarator* _tmp53_;

5729

gboolean firstif;

5730

gboolean _tmp132_;

5731

ValaCCodeFunction* _tmp135_;

5732

ValaCCodeFunction* _tmp136_;

5733

ValaCCodeConstant* _tmp137_;

5734

ValaCCodeConstant* _tmp138_;

5735

ValaCCodeFile* _tmp139_;

5736

ValaCCodeFunction* _tmp140_;

5737

g_return_if_fail (self != NULL);

5738

g_return_if_fail (sym != NULL);

5739

_tmp0_ = sym;

5740

_tmp1_ = vala_ccode_base_module_get_ccode_lower_case_prefix ((ValaSymbol*) _tmp0_);

5741

_tmp2_ = _tmp1_;

5742

_tmp3_ = g_strconcat (_tmp2_, "dbus_interface_set_property", NULL);

5743

_tmp4_ = _tmp3_;

5744

_tmp5_ = vala_ccode_function_new (_tmp4_, "gboolean");

5745

_tmp6_ = _tmp5_;

5746

_g_free0 (_tmp4_);

5747

_g_free0 (_tmp2_);

5748

cfunc = _tmp6_;

5749

_tmp7_ = cfunc;

5750

_tmp8_ = vala_ccode_parameter_new ("connection", "GDBusConnection*");

5751

_tmp9_ = _tmp8_;

5752

vala_ccode_function_add_parameter (_tmp7_, _tmp9_);

5753

_vala_ccode_node_unref0 (_tmp9_);

5754

_tmp10_ = cfunc;

5755

_tmp11_ = vala_ccode_parameter_new ("sender", "const gchar*");

5756

_tmp12_ = _tmp11_;

5757

vala_ccode_function_add_parameter (_tmp10_, _tmp12_);

5758

_vala_ccode_node_unref0 (_tmp12_);

5759

_tmp13_ = cfunc;

5760

_tmp14_ = vala_ccode_parameter_new ("object_path", "const gchar*");

5761

_tmp15_ = _tmp14_;

5762

vala_ccode_function_add_parameter (_tmp13_, _tmp15_);

5763

_vala_ccode_node_unref0 (_tmp15_);

5764

_tmp16_ = cfunc;

5765

_tmp17_ = vala_ccode_parameter_new ("interface_name", "const gchar*");

5766

_tmp18_ = _tmp17_;

5767

vala_ccode_function_add_parameter (_tmp16_, _tmp18_);

5768

_vala_ccode_node_unref0 (_tmp18_);

5769

_tmp19_ = cfunc;

5770

_tmp20_ = vala_ccode_parameter_new ("property_name", "const gchar*");

5771

_tmp21_ = _tmp20_;

5772

vala_ccode_function_add_parameter (_tmp19_, _tmp21_);

5773

_vala_ccode_node_unref0 (_tmp21_);

5774

_tmp22_ = cfunc;

5775

_tmp23_ = vala_ccode_parameter_new ("value", "GVariant*");

5776

_tmp24_ = _tmp23_;

5777

vala_ccode_function_add_parameter (_tmp22_, _tmp24_);

5778

_vala_ccode_node_unref0 (_tmp24_);

5779

_tmp25_ = cfunc;

5780

_tmp26_ = vala_ccode_parameter_new ("error", "GError**");

5781

_tmp27_ = _tmp26_;

5782

vala_ccode_function_add_parameter (_tmp25_, _tmp27_);

5783

_vala_ccode_node_unref0 (_tmp27_);

5784

_tmp28_ = cfunc;

5785

_tmp29_ = vala_ccode_parameter_new ("user_data", "gpointer");

5786

_tmp30_ = _tmp29_;

5787

vala_ccode_function_add_parameter (_tmp28_, _tmp30_);

5788

_vala_ccode_node_unref0 (_tmp30_);

5789

_tmp31_ = cfunc;

5790

_tmp32_ = cfunc;

5791

_tmp33_ = vala_ccode_function_get_modifiers (_tmp32_);

5792

_tmp34_ = _tmp33_;

5793

vala_ccode_function_set_modifiers (_tmp32_, _tmp34_ | VALA_CCODE_MODIFIERS_STATIC);

5794

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

5795

_tmp36_ = cfunc;

5796

vala_ccode_file_add_function_declaration (_tmp35_, _tmp36_);

5797

_tmp37_ = cfunc;

5798

vala_ccode_base_module_push_function ((ValaCCodeBaseModule*) self, _tmp37_);

5799

_tmp38_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

5800

_tmp39_ = _tmp38_;

5801

_tmp40_ = vala_ccode_identifier_new ("user_data");

5802

_tmp41_ = _tmp40_;

5803

_tmp42_ = vala_ccode_variable_declarator_new ("data", (ValaCCodeExpression*) _tmp41_, NULL);

5804

_tmp43_ = _tmp42_;

5805

vala_ccode_function_add_declaration (_tmp39_, "gpointer*", (ValaCCodeDeclarator*) _tmp43_, 0);

5806

_vala_ccode_node_unref0 (_tmp43_);

5807

_vala_ccode_node_unref0 (_tmp41_);

5808

_tmp44_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

5809

_tmp45_ = _tmp44_;

5810

_tmp46_ = vala_ccode_identifier_new ("data");

5811

_tmp47_ = _tmp46_;

5812

_tmp48_ = vala_ccode_constant_new ("0");

5813

_tmp49_ = _tmp48_;

5814

_tmp50_ = vala_ccode_element_access_new ((ValaCCodeExpression*) _tmp47_, (ValaCCodeExpression*) _tmp49_);

5815

_tmp51_ = _tmp50_;

5816

_tmp52_ = vala_ccode_variable_declarator_new ("object", (ValaCCodeExpression*) _tmp51_, NULL);

5817

_tmp53_ = _tmp52_;

5818

vala_ccode_function_add_declaration (_tmp45_, "gpointer", (ValaCCodeDeclarator*) _tmp53_, 0);

5819

_vala_ccode_node_unref0 (_tmp53_);

5820

_vala_ccode_node_unref0 (_tmp51_);

5821

_vala_ccode_node_unref0 (_tmp49_);

5822

_vala_ccode_node_unref0 (_tmp47_);

5823

firstif = TRUE;

5824

{

5825

ValaObjectTypeSymbol* _tmp54_;

5826

ValaList* _tmp55_ = NULL;

5827

ValaList* _prop_list;

5828

ValaList* _tmp56_;

5829

gint _tmp57_;

5830

gint _tmp58_;

5831

gint _prop_size;

5832

gint _prop_index;

5833

_tmp54_ = sym;

5834

_tmp55_ = vala_object_type_symbol_get_properties (_tmp54_);

5835

_prop_list = _tmp55_;

5836

_tmp56_ = _prop_list;

5837

_tmp57_ = vala_collection_get_size ((ValaCollection*) _tmp56_);

5838

_tmp58_ = _tmp57_;

5839

_prop_size = _tmp58_;

5840

_prop_index = -1;

5841

while (TRUE) {

5842

gint _tmp59_;

5843

gint _tmp60_;

5844

gint _tmp61_;

5845

ValaList* _tmp62_;

5846

gint _tmp63_;

5847

gpointer _tmp64_ = NULL;

5848

ValaProperty* prop;

5849

gboolean _tmp65_ = FALSE;

5850

gboolean _tmp66_ = FALSE;

5851

ValaProperty* _tmp67_;

5852

ValaMemberBinding _tmp68_;

5853

ValaMemberBinding _tmp69_;

5854

gboolean _tmp73_;

5855

gboolean _tmp77_;

5856

ValaProperty* _tmp78_;

5857

gboolean _tmp79_ = FALSE;

5858

ValaProperty* _tmp80_;

5859

ValaPropertyAccessor* _tmp81_;

5860

ValaPropertyAccessor* _tmp82_;

5861

ValaCCodeFile* _tmp83_;

5862

ValaCCodeIdentifier* _tmp84_;

5863

ValaCCodeIdentifier* _tmp85_;

5864

ValaCCodeFunctionCall* _tmp86_;

5865

ValaCCodeFunctionCall* _tmp87_;

5866

ValaCCodeFunctionCall* ccheck;

5867

ValaCCodeFunctionCall* _tmp88_;

5868

ValaCCodeIdentifier* _tmp89_;

5869

ValaCCodeIdentifier* _tmp90_;

5870

ValaCCodeFunctionCall* _tmp91_;

5871

ValaProperty* _tmp92_;

5872

gchar* _tmp93_ = NULL;

5873

gchar* _tmp94_;

5874

gchar* _tmp95_ = NULL;

5875

gchar* _tmp96_;

5876

ValaCCodeConstant* _tmp97_;

5877

ValaCCodeConstant* _tmp98_;

5878

ValaCCodeFunctionCall* _tmp99_;

5879

ValaCCodeConstant* _tmp100_;

5880

ValaCCodeConstant* _tmp101_;

5881

ValaCCodeBinaryExpression* _tmp102_;

5882

ValaCCodeBinaryExpression* _tmp103_;

5883

ValaCCodeBinaryExpression* cond;

5884

gboolean _tmp104_;

5885

ValaProperty* _tmp111_;

5886

ValaObjectTypeSymbol* _tmp112_;

5887

gchar* _tmp113_ = NULL;

5888

gchar* _tmp114_;

5889

ValaCCodeIdentifier* _tmp115_;

5890

ValaCCodeIdentifier* _tmp116_;

5891

ValaCCodeFunctionCall* _tmp117_;

5892

ValaCCodeFunctionCall* _tmp118_;

5893

ValaCCodeFunctionCall* ccall;

5894

ValaCCodeFunctionCall* _tmp119_;

5895

ValaCCodeIdentifier* _tmp120_;

5896

ValaCCodeIdentifier* _tmp121_;

5897

ValaCCodeFunctionCall* _tmp122_;

5898

ValaCCodeIdentifier* _tmp123_;

5899

ValaCCodeIdentifier* _tmp124_;

5900

ValaCCodeFunction* _tmp125_;

5901

ValaCCodeFunction* _tmp126_;

5902

ValaCCodeFunctionCall* _tmp127_;

5903

ValaCCodeFunction* _tmp128_;

5904

ValaCCodeFunction* _tmp129_;

5905

ValaCCodeConstant* _tmp130_;

5906

ValaCCodeConstant* _tmp131_;

5907

_tmp59_ = _prop_index;

5908

_prop_index = _tmp59_ + 1;

5909

_tmp60_ = _prop_index;

5910

_tmp61_ = _prop_size;

5911

if (!(_tmp60_ < _tmp61_)) {

5912

break;

5913

}

5914

_tmp62_ = _prop_list;

5915

_tmp63_ = _prop_index;

5916

_tmp64_ = vala_list_get (_tmp62_, _tmp63_);

5917

prop = (ValaProperty*) _tmp64_;

5918

_tmp67_ = prop;

5919

_tmp68_ = vala_property_get_binding (_tmp67_);

5920

_tmp69_ = _tmp68_;

5921

if (_tmp69_ != VALA_MEMBER_BINDING_INSTANCE) {

5922

_tmp66_ = TRUE;

5923

} else {

5924

ValaProperty* _tmp70_;

5925

gboolean _tmp71_;

5926

gboolean _tmp72_;

5927

_tmp70_ = prop;

5928

_tmp71_ = vala_property_get_overrides (_tmp70_);

5929

_tmp72_ = _tmp71_;

5930

_tmp66_ = _tmp72_;

5931

}

5932

_tmp73_ = _tmp66_;

5933

if (_tmp73_) {

5934

_tmp65_ = TRUE;

5935

} else {

5936

ValaProperty* _tmp74_;

5937

ValaSymbolAccessibility _tmp75_;

5938

ValaSymbolAccessibility _tmp76_;

5939

_tmp74_ = prop;

5940

_tmp75_ = vala_symbol_get_access ((ValaSymbol*) _tmp74_);

5941

_tmp76_ = _tmp75_;

5942

_tmp65_ = _tmp76_ != VALA_SYMBOL_ACCESSIBILITY_PUBLIC;

5943

}

5944

_tmp77_ = _tmp65_;

5945

if (_tmp77_) {

5946

_vala_code_node_unref0 (prop);

5947

continue;

5948

}

5949

_tmp78_ = prop;

5950

_tmp79_ = vala_gd_bus_server_module_is_dbus_visible ((ValaCodeNode*) _tmp78_);

5951

if (!_tmp79_) {

5952

_vala_code_node_unref0 (prop);

5953

continue;

5954

}

5955

_tmp80_ = prop;

5956

_tmp81_ = vala_property_get_set_accessor (_tmp80_);

5957

_tmp82_ = _tmp81_;

5958

if (_tmp82_ == NULL) {

5959

_vala_code_node_unref0 (prop);

5960

continue;

5961

}

5962

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

5963

vala_ccode_file_add_include (_tmp83_, "string.h", FALSE);

5964

_tmp84_ = vala_ccode_identifier_new ("strcmp");

5965

_tmp85_ = _tmp84_;

5966

_tmp86_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp85_);

5967

_tmp87_ = _tmp86_;

5968

_vala_ccode_node_unref0 (_tmp85_);

5969

ccheck = _tmp87_;

5970

_tmp88_ = ccheck;

5971

_tmp89_ = vala_ccode_identifier_new ("property_name");

5972

_tmp90_ = _tmp89_;

5973

vala_ccode_function_call_add_argument (_tmp88_, (ValaCCodeExpression*) _tmp90_);

5974

_vala_ccode_node_unref0 (_tmp90_);

5975

_tmp91_ = ccheck;

5976

_tmp92_ = prop;

5977

_tmp93_ = vala_gd_bus_module_get_dbus_name_for_member ((ValaSymbol*) _tmp92_);

5978

_tmp94_ = _tmp93_;

5979

_tmp95_ = g_strdup_printf ("\"%s\"", _tmp94_);

5980

_tmp96_ = _tmp95_;

5981

_tmp97_ = vala_ccode_constant_new (_tmp96_);

5982

_tmp98_ = _tmp97_;

5983

vala_ccode_function_call_add_argument (_tmp91_, (ValaCCodeExpression*) _tmp98_);

5984

_vala_ccode_node_unref0 (_tmp98_);

5985

_g_free0 (_tmp96_);

5986

_g_free0 (_tmp94_);

5987

_tmp99_ = ccheck;

5988

_tmp100_ = vala_ccode_constant_new ("0");

5989

_tmp101_ = _tmp100_;

5990

_tmp102_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_EQUALITY, (ValaCCodeExpression*) _tmp99_, (ValaCCodeExpression*) _tmp101_);

5991

_tmp103_ = _tmp102_;

5992

_vala_ccode_node_unref0 (_tmp101_);

5993

cond = _tmp103_;

5994

_tmp104_ = firstif;

5995

if (_tmp104_) {

5996

ValaCCodeFunction* _tmp105_;

5997

ValaCCodeFunction* _tmp106_;

5998

ValaCCodeBinaryExpression* _tmp107_;

5999

_tmp105_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

6000

_tmp106_ = _tmp105_;

6001

_tmp107_ = cond;

6002

vala_ccode_function_open_if (_tmp106_, (ValaCCodeExpression*) _tmp107_);

6003

firstif = FALSE;

6004

} else {

6005

ValaCCodeFunction* _tmp108_;

6006

ValaCCodeFunction* _tmp109_;

6007

ValaCCodeBinaryExpression* _tmp110_;

6008

_tmp108_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

6009

_tmp109_ = _tmp108_;

6010

_tmp110_ = cond;

6011

vala_ccode_function_else_if (_tmp109_, (ValaCCodeExpression*) _tmp110_);

6012

}

6013

_tmp111_ = prop;

6014

_tmp112_ = sym;

6015

_tmp113_ = vala_gd_bus_server_module_generate_dbus_property_set_wrapper (self, _tmp111_, _tmp112_);

6016

_tmp114_ = _tmp113_;

6017

_tmp115_ = vala_ccode_identifier_new (_tmp114_);

6018

_tmp116_ = _tmp115_;

6019

_tmp117_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp116_);

6020

_tmp118_ = _tmp117_;

6021

_vala_ccode_node_unref0 (_tmp116_);

6022

_g_free0 (_tmp114_);

6023

ccall = _tmp118_;

6024

_tmp119_ = ccall;

6025

_tmp120_ = vala_ccode_identifier_new ("object");

6026

_tmp121_ = _tmp120_;

6027

vala_ccode_function_call_add_argument (_tmp119_, (ValaCCodeExpression*) _tmp121_);

6028

_vala_ccode_node_unref0 (_tmp121_);

6029

_tmp122_ = ccall;

6030

_tmp123_ = vala_ccode_identifier_new ("value");

6031

_tmp124_ = _tmp123_;

6032

vala_ccode_function_call_add_argument (_tmp122_, (ValaCCodeExpression*) _tmp124_);

6033

_vala_ccode_node_unref0 (_tmp124_);

6034

_tmp125_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

6035

_tmp126_ = _tmp125_;

6036

_tmp127_ = ccall;

6037

vala_ccode_function_add_expression (_tmp126_, (ValaCCodeExpression*) _tmp127_);

6038

_tmp128_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

6039

_tmp129_ = _tmp128_;

6040

_tmp130_ = vala_ccode_constant_new ("TRUE");

6041

_tmp131_ = _tmp130_;

6042

vala_ccode_function_add_return (_tmp129_, (ValaCCodeExpression*) _tmp131_);

6043

_vala_ccode_node_unref0 (_tmp131_);

6044

_vala_ccode_node_unref0 (ccall);

6045

_vala_ccode_node_unref0 (cond);

6046

_vala_ccode_node_unref0 (ccheck);

6047

_vala_code_node_unref0 (prop);

6048

}

6049

_vala_iterable_unref0 (_prop_list);

6050

}

6051

_tmp132_ = firstif;

6052

if (!_tmp132_) {

6053

ValaCCodeFunction* _tmp133_;

6054

ValaCCodeFunction* _tmp134_;

6055

_tmp133_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

6056

_tmp134_ = _tmp133_;

6057

vala_ccode_function_close (_tmp134_);

6058

}

6059

_tmp135_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

6060

_tmp136_ = _tmp135_;

6061

_tmp137_ = vala_ccode_constant_new ("FALSE");

6062

_tmp138_ = _tmp137_;

6063

vala_ccode_function_add_return (_tmp136_, (ValaCCodeExpression*) _tmp138_);

6064

_vala_ccode_node_unref0 (_tmp138_);

6065

vala_ccode_base_module_pop_function ((ValaCCodeBaseModule*) self);

6066

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

6067

_tmp140_ = cfunc;

6068

vala_ccode_file_add_function (_tmp139_, _tmp140_);

6069

_vala_ccode_node_unref0 (cfunc);

6070

}

6071

6072

6073

static ValaCCodeExpression* vala_gd_bus_server_module_get_method_info (ValaGDBusServerModule* self, ValaObjectTypeSymbol* sym) {

6074

ValaCCodeExpression* result = NULL;

6075

ValaCCodeInitializerList* _tmp0_;

6076

ValaCCodeInitializerList* infos;

6077

ValaCCodeInitializerList* _tmp376_;

6078

ValaCCodeConstant* _tmp377_;

6079

ValaCCodeConstant* _tmp378_;

6080

ValaCCodeDeclaration* _tmp379_;

6081

ValaCCodeDeclaration* _cdecl_;

6082

ValaObjectTypeSymbol* _tmp380_;

6083

gchar* _tmp381_ = NULL;

6084

gchar* _tmp382_;

6085

gchar* _tmp383_;

6086

gchar* _tmp384_;

6087

gchar* _tmp385_;

6088

gchar* _tmp386_;

6089

ValaCCodeInitializerList* _tmp387_;

6090

ValaCCodeVariableDeclarator* _tmp388_;

6091

ValaCCodeVariableDeclarator* _tmp389_;

6092

ValaCCodeFile* _tmp390_;

6093

ValaObjectTypeSymbol* _tmp391_;

6094

gchar* _tmp392_ = NULL;

6095

gchar* _tmp393_;

6096

gchar* _tmp394_;

6097

gchar* _tmp395_;

6098

gchar* _tmp396_;

6099

gchar* _tmp397_;

6100

ValaCCodeIdentifier* _tmp398_;

6101

ValaCCodeExpression* _tmp399_;

6102

g_return_val_if_fail (self != NULL, NULL);

6103

g_return_val_if_fail (sym != NULL, NULL);

6104

_tmp0_ = vala_ccode_initializer_list_new ();

6105

infos = _tmp0_;

6106

{

6107

ValaObjectTypeSymbol* _tmp1_;

6108

ValaList* _tmp2_ = NULL;

6109

ValaList* _m_list;

6110

ValaList* _tmp3_;

6111

gint _tmp4_;

6112

gint _tmp5_;

6113

gint _m_size;

6114

gint _m_index;

6115

_tmp1_ = sym;

6116

_tmp2_ = vala_object_type_symbol_get_methods (_tmp1_);

6117

_m_list = _tmp2_;

6118

_tmp3_ = _m_list;

6119

_tmp4_ = vala_collection_get_size ((ValaCollection*) _tmp3_);

6120

_tmp5_ = _tmp4_;

6121

_m_size = _tmp5_;

6122

_m_index = -1;

6123

while (TRUE) {

6124

gint _tmp6_;

6125

gint _tmp7_;

6126

gint _tmp8_;

6127

ValaList* _tmp9_;

6128

gint _tmp10_;

6129

gpointer _tmp11_ = NULL;

6130

ValaMethod* m;

6131

gboolean _tmp12_ = FALSE;

6132

gboolean _tmp13_ = FALSE;

6133

gboolean _tmp14_ = FALSE;

6134

ValaMethod* _tmp15_;

6135

gboolean _tmp19_;

6136

gboolean _tmp23_;

6137

gboolean _tmp27_;

6138

ValaMethod* _tmp28_;

6139

gboolean _tmp29_ = FALSE;

6140

ValaCCodeInitializerList* _tmp30_;

6141

ValaCCodeInitializerList* in_args_info;

6142

ValaCCodeInitializerList* _tmp31_;

6143

ValaCCodeInitializerList* out_args_info;

6144

ValaMethod* _tmp168_;

6145

ValaDataType* _tmp169_;

6146

ValaDataType* _tmp170_;

6147

ValaCCodeInitializerList* _tmp235_;

6148

ValaCCodeConstant* _tmp236_;

6149

ValaCCodeConstant* _tmp237_;

6150

ValaCCodeInitializerList* _tmp238_;

6151

ValaCCodeConstant* _tmp239_;

6152

ValaCCodeConstant* _tmp240_;

6153

ValaCCodeDeclaration* _tmp241_;

6154

ValaCCodeDeclaration* _cdecl_;

6155

ValaCCodeDeclaration* _tmp242_;

6156

ValaObjectTypeSymbol* _tmp243_;

6157

gchar* _tmp244_ = NULL;

6158

gchar* _tmp245_;

6159

gchar* _tmp246_;

6160

gchar* _tmp247_;

6161

gchar* _tmp248_;

6162

gchar* _tmp249_;

6163

ValaMethod* _tmp250_;

6164

const gchar* _tmp251_;

6165

const gchar* _tmp252_;

6166

gchar* _tmp253_;

6167

gchar* _tmp254_;

6168

gchar* _tmp255_;

6169

gchar* _tmp256_;

6170

ValaCCodeInitializerList* _tmp257_;

6171

ValaCCodeVariableDeclarator* _tmp258_;

6172

ValaCCodeVariableDeclarator* _tmp259_;

6173

ValaCCodeDeclaration* _tmp260_;

6174

ValaCCodeFile* _tmp261_;

6175

ValaCCodeDeclaration* _tmp262_;

6176

ValaCCodeDeclaration* _tmp263_;

6177

ValaCCodeDeclaration* _tmp264_;

6178

ValaObjectTypeSymbol* _tmp265_;

6179

gchar* _tmp266_ = NULL;

6180

gchar* _tmp267_;

6181

gchar* _tmp268_;

6182

gchar* _tmp269_;

6183

gchar* _tmp270_;

6184

gchar* _tmp271_;

6185

ValaMethod* _tmp272_;

6186

const gchar* _tmp273_;

6187

const gchar* _tmp274_;

6188

gchar* _tmp275_;

6189

gchar* _tmp276_;

6190

gchar* _tmp277_;

6191

gchar* _tmp278_;

6192

ValaCCodeInitializerList* _tmp279_;

6193

ValaCCodeVariableDeclarator* _tmp280_;

6194

ValaCCodeVariableDeclarator* _tmp281_;

6195

ValaCCodeDeclaration* _tmp282_;

6196

ValaCCodeFile* _tmp283_;

6197

ValaCCodeDeclaration* _tmp284_;

6198

ValaCCodeInitializerList* _tmp285_;

6199

ValaCCodeInitializerList* info;

6200

ValaCCodeInitializerList* _tmp286_;

6201

ValaCCodeConstant* _tmp287_;

6202

ValaCCodeConstant* _tmp288_;

6203

ValaCCodeInitializerList* _tmp289_;

6204

ValaMethod* _tmp290_;

6205

gchar* _tmp291_ = NULL;

6206

gchar* _tmp292_;

6207

gchar* _tmp293_ = NULL;

6208

gchar* _tmp294_;

6209

ValaCCodeConstant* _tmp295_;

6210

ValaCCodeConstant* _tmp296_;

6211

ValaCCodeInitializerList* _tmp297_;

6212

ValaObjectTypeSymbol* _tmp298_;

6213

gchar* _tmp299_ = NULL;

6214

gchar* _tmp300_;

6215

gchar* _tmp301_;

6216

gchar* _tmp302_;

6217

gchar* _tmp303_;

6218

gchar* _tmp304_;

6219

ValaMethod* _tmp305_;

6220

const gchar* _tmp306_;

6221

const gchar* _tmp307_;

6222

gchar* _tmp308_;

6223

gchar* _tmp309_;

6224

gchar* _tmp310_;

6225

gchar* _tmp311_;

6226

ValaCCodeIdentifier* _tmp312_;

6227

ValaCCodeIdentifier* _tmp313_;

6228

ValaCCodeUnaryExpression* _tmp314_;

6229

ValaCCodeUnaryExpression* _tmp315_;

6230

ValaCCodeCastExpression* _tmp316_;

6231

ValaCCodeCastExpression* _tmp317_;

6232

ValaCCodeInitializerList* _tmp318_;

6233

ValaObjectTypeSymbol* _tmp319_;

6234

gchar* _tmp320_ = NULL;

6235

gchar* _tmp321_;

6236

gchar* _tmp322_;

6237

gchar* _tmp323_;

6238

gchar* _tmp324_;

6239

gchar* _tmp325_;

6240

ValaMethod* _tmp326_;

6241

const gchar* _tmp327_;

6242

const gchar* _tmp328_;

6243

gchar* _tmp329_;

6244

gchar* _tmp330_;

6245

gchar* _tmp331_;

6246

gchar* _tmp332_;

6247

ValaCCodeIdentifier* _tmp333_;

6248

ValaCCodeIdentifier* _tmp334_;

6249

ValaCCodeUnaryExpression* _tmp335_;

6250

ValaCCodeUnaryExpression* _tmp336_;

6251

ValaCCodeCastExpression* _tmp337_;

6252

ValaCCodeCastExpression* _tmp338_;

6253

ValaCCodeDeclaration* _tmp339_;

6254

ValaCCodeDeclaration* _tmp340_;

6255

ValaObjectTypeSymbol* _tmp341_;

6256

gchar* _tmp342_ = NULL;

6257

gchar* _tmp343_;

6258

gchar* _tmp344_;

6259

gchar* _tmp345_;

6260

gchar* _tmp346_;

6261

gchar* _tmp347_;

6262

ValaMethod* _tmp348_;

6263

const gchar* _tmp349_;

6264

const gchar* _tmp350_;

6265

gchar* _tmp351_;

6266

gchar* _tmp352_;

6267

ValaCCodeInitializerList* _tmp353_;

6268

ValaCCodeVariableDeclarator* _tmp354_;

6269

ValaCCodeVariableDeclarator* _tmp355_;

6270

ValaCCodeDeclaration* _tmp356_;

6271

ValaCCodeFile* _tmp357_;

6272

ValaCCodeDeclaration* _tmp358_;

6273

ValaCCodeInitializerList* _tmp359_;

6274

ValaObjectTypeSymbol* _tmp360_;

6275

gchar* _tmp361_ = NULL;

6276

gchar* _tmp362_;

6277

gchar* _tmp363_;

6278

gchar* _tmp364_;

6279

gchar* _tmp365_;

6280

gchar* _tmp366_;

6281

ValaMethod* _tmp367_;

6282

const gchar* _tmp368_;

6283

const gchar* _tmp369_;

6284

gchar* _tmp370_;

6285

gchar* _tmp371_;

6286

ValaCCodeIdentifier* _tmp372_;

6287

ValaCCodeIdentifier* _tmp373_;

6288

ValaCCodeUnaryExpression* _tmp374_;

6289

ValaCCodeUnaryExpression* _tmp375_;

6290

_tmp6_ = _m_index;

6291

_m_index = _tmp6_ + 1;

6292

_tmp7_ = _m_index;

6293

_tmp8_ = _m_size;

6294

if (!(_tmp7_ < _tmp8_)) {

6295

break;

6296

}

6297

_tmp9_ = _m_list;

6298

_tmp10_ = _m_index;

6299

_tmp11_ = vala_list_get (_tmp9_, _tmp10_);

6300

m = (ValaMethod*) _tmp11_;

6301

_tmp15_ = m;

6302

if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp15_, VALA_TYPE_CREATION_METHOD)) {

6303

_tmp14_ = TRUE;

6304

} else {

6305

ValaMethod* _tmp16_;

6306

ValaMemberBinding _tmp17_;

6307

ValaMemberBinding _tmp18_;

6308

_tmp16_ = m;

6309

_tmp17_ = vala_method_get_binding (_tmp16_);

6310

_tmp18_ = _tmp17_;

6311

_tmp14_ = _tmp18_ != VALA_MEMBER_BINDING_INSTANCE;

6312

}

6313

_tmp19_ = _tmp14_;

6314

if (_tmp19_) {

6315

_tmp13_ = TRUE;

6316

} else {

6317

ValaMethod* _tmp20_;

6318

gboolean _tmp21_;

6319

gboolean _tmp22_;

6320

_tmp20_ = m;

6321

_tmp21_ = vala_method_get_overrides (_tmp20_);

6322

_tmp22_ = _tmp21_;

6323

_tmp13_ = _tmp22_;

6324

}

6325

_tmp23_ = _tmp13_;

6326

if (_tmp23_) {

6327

_tmp12_ = TRUE;

6328

} else {

6329

ValaMethod* _tmp24_;

6330

ValaSymbolAccessibility _tmp25_;

6331

ValaSymbolAccessibility _tmp26_;

6332

_tmp24_ = m;

6333

_tmp25_ = vala_symbol_get_access ((ValaSymbol*) _tmp24_);

6334

_tmp26_ = _tmp25_;

6335

_tmp12_ = _tmp26_ != VALA_SYMBOL_ACCESSIBILITY_PUBLIC;

6336

}

6337

_tmp27_ = _tmp12_;

6338

if (_tmp27_) {

6339

_vala_code_node_unref0 (m);

6340

continue;

6341

}

6342

_tmp28_ = m;

6343

_tmp29_ = vala_gd_bus_server_module_is_dbus_visible ((ValaCodeNode*) _tmp28_);

6344

if (!_tmp29_) {

6345

_vala_code_node_unref0 (m);

6346

continue;

6347

}

6348

_tmp30_ = vala_ccode_initializer_list_new ();

6349

in_args_info = _tmp30_;

6350

_tmp31_ = vala_ccode_initializer_list_new ();

6351

out_args_info = _tmp31_;

6352

{

6353

ValaMethod* _tmp32_;

6354

ValaList* _tmp33_ = NULL;

6355

ValaList* _param_list;

6356

ValaList* _tmp34_;

6357

gint _tmp35_;

6358

gint _tmp36_;

6359

gint _param_size;

6360

gint _param_index;

6361

_tmp32_ = m;

6362

_tmp33_ = vala_method_get_parameters (_tmp32_);

6363

_param_list = _tmp33_;

6364

_tmp34_ = _param_list;

6365

_tmp35_ = vala_collection_get_size ((ValaCollection*) _tmp34_);

6366

_tmp36_ = _tmp35_;

6367

_param_size = _tmp36_;

6368

_param_index = -1;

6369

while (TRUE) {

6370

gint _tmp37_;

6371

gint _tmp38_;

6372

gint _tmp39_;

6373

ValaList* _tmp40_;

6374

gint _tmp41_;

6375

gpointer _tmp42_ = NULL;

6376

ValaParameter* param;

6377

gboolean _tmp43_ = FALSE;

6378

ValaParameter* _tmp44_;

6379

ValaDataType* _tmp45_;

6380

ValaDataType* _tmp46_;

6381

gboolean _tmp54_;

6382

gboolean _tmp55_ = FALSE;

6383

ValaParameter* _tmp56_;

6384

ValaDataType* _tmp57_;

6385

ValaDataType* _tmp58_;

6386

gboolean _tmp66_;

6387

ValaCCodeInitializerList* _tmp67_;

6388

ValaCCodeInitializerList* info;

6389

ValaCCodeInitializerList* _tmp68_;

6390

ValaCCodeConstant* _tmp69_;

6391

ValaCCodeConstant* _tmp70_;

6392

ValaCCodeInitializerList* _tmp71_;

6393

ValaParameter* _tmp72_;

6394

const gchar* _tmp73_;

6395

const gchar* _tmp74_;

6396

gchar* _tmp75_ = NULL;

6397

gchar* _tmp76_;

6398

ValaCCodeConstant* _tmp77_;

6399

ValaCCodeConstant* _tmp78_;

6400

ValaCCodeInitializerList* _tmp79_;

6401

ValaParameter* _tmp80_;

6402

ValaDataType* _tmp81_;

6403

ValaDataType* _tmp82_;

6404

ValaParameter* _tmp83_;

6405

gchar* _tmp84_ = NULL;

6406

gchar* _tmp85_;

6407

gchar* _tmp86_ = NULL;

6408

gchar* _tmp87_;

6409

ValaCCodeConstant* _tmp88_;

6410

ValaCCodeConstant* _tmp89_;

6411

ValaCCodeDeclaration* _tmp90_;

6412

ValaCCodeDeclaration* _cdecl_;

6413

ValaCCodeDeclaration* _tmp91_;

6414

ValaObjectTypeSymbol* _tmp92_;

6415

gchar* _tmp93_ = NULL;

6416

gchar* _tmp94_;

6417

gchar* _tmp95_;

6418

gchar* _tmp96_;

6419

gchar* _tmp97_;

6420

gchar* _tmp98_;

6421

ValaMethod* _tmp99_;

6422

const gchar* _tmp100_;

6423

const gchar* _tmp101_;

6424

gchar* _tmp102_;

6425

gchar* _tmp103_;

6426

gchar* _tmp104_;

6427

gchar* _tmp105_;

6428

ValaParameter* _tmp106_;

6429

const gchar* _tmp107_;

6430

const gchar* _tmp108_;

6431

gchar* _tmp109_;

6432

gchar* _tmp110_;

6433

ValaCCodeInitializerList* _tmp111_;

6434

ValaCCodeVariableDeclarator* _tmp112_;

6435

ValaCCodeVariableDeclarator* _tmp113_;

6436

ValaCCodeDeclaration* _tmp114_;

6437

ValaCCodeFile* _tmp115_;

6438

ValaCCodeDeclaration* _tmp116_;

6439

ValaParameter* _tmp117_;

6440

ValaParameterDirection _tmp118_;

6441

ValaParameterDirection _tmp119_;

6442

_tmp37_ = _param_index;

6443

_param_index = _tmp37_ + 1;

6444

_tmp38_ = _param_index;

6445

_tmp39_ = _param_size;

6446

if (!(_tmp38_ < _tmp39_)) {

6447

break;

6448

}

6449

_tmp40_ = _param_list;

6450

_tmp41_ = _param_index;

6451

_tmp42_ = vala_list_get (_tmp40_, _tmp41_);

6452

param = (ValaParameter*) _tmp42_;

6453

_tmp44_ = param;

6454

_tmp45_ = vala_variable_get_variable_type ((ValaVariable*) _tmp44_);

6455

_tmp46_ = _tmp45_;

6456

if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp46_, VALA_TYPE_OBJECT_TYPE)) {

6457

ValaParameter* _tmp47_;

6458

ValaDataType* _tmp48_;

6459

ValaDataType* _tmp49_;

6460

ValaTypeSymbol* _tmp50_;

6461

ValaTypeSymbol* _tmp51_;

6462

gchar* _tmp52_ = NULL;

6463

gchar* _tmp53_;

6464

_tmp47_ = param;

6465

_tmp48_ = vala_variable_get_variable_type ((ValaVariable*) _tmp47_);

6466

_tmp49_ = _tmp48_;

6467

_tmp50_ = vala_data_type_get_data_type (_tmp49_);

6468

_tmp51_ = _tmp50_;

6469

_tmp52_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp51_);

6470

_tmp53_ = _tmp52_;

6471

_tmp43_ = g_strcmp0 (_tmp53_, "GLib.Cancellable") == 0;

6472

_g_free0 (_tmp53_);

6473

} else {

6474

_tmp43_ = FALSE;

6475

}

6476

_tmp54_ = _tmp43_;

6477

if (_tmp54_) {

6478

_vala_code_node_unref0 (param);

6479

continue;

6480

}

6481

_tmp56_ = param;

6482

_tmp57_ = vala_variable_get_variable_type ((ValaVariable*) _tmp56_);

6483

_tmp58_ = _tmp57_;

6484

if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp58_, VALA_TYPE_OBJECT_TYPE)) {

6485

ValaParameter* _tmp59_;

6486

ValaDataType* _tmp60_;

6487

ValaDataType* _tmp61_;

6488

ValaTypeSymbol* _tmp62_;

6489

ValaTypeSymbol* _tmp63_;

6490

gchar* _tmp64_ = NULL;

6491

gchar* _tmp65_;

6492

_tmp59_ = param;

6493

_tmp60_ = vala_variable_get_variable_type ((ValaVariable*) _tmp59_);

6494

_tmp61_ = _tmp60_;

6495

_tmp62_ = vala_data_type_get_data_type (_tmp61_);

6496

_tmp63_ = _tmp62_;

6497

_tmp64_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp63_);

6498

_tmp65_ = _tmp64_;

6499

_tmp55_ = g_strcmp0 (_tmp65_, "GLib.BusName") == 0;

6500

_g_free0 (_tmp65_);

6501

} else {

6502

_tmp55_ = FALSE;

6503

}

6504

_tmp66_ = _tmp55_;

6505

if (_tmp66_) {

6506

_vala_code_node_unref0 (param);

6507

continue;

6508

}

6509

_tmp67_ = vala_ccode_initializer_list_new ();

6510

info = _tmp67_;

6511

_tmp68_ = info;

6512

_tmp69_ = vala_ccode_constant_new ("-1");

6513

_tmp70_ = _tmp69_;

6514

vala_ccode_initializer_list_append (_tmp68_, (ValaCCodeExpression*) _tmp70_);

6515

_vala_ccode_node_unref0 (_tmp70_);

6516

_tmp71_ = info;

6517

_tmp72_ = param;

6518

_tmp73_ = vala_symbol_get_name ((ValaSymbol*) _tmp72_);

6519

_tmp74_ = _tmp73_;

6520

_tmp75_ = g_strdup_printf ("\"%s\"", _tmp74_);

6521

_tmp76_ = _tmp75_;

6522

_tmp77_ = vala_ccode_constant_new (_tmp76_);

6523

_tmp78_ = _tmp77_;

6524

vala_ccode_initializer_list_append (_tmp71_, (ValaCCodeExpression*) _tmp78_);

6525

_vala_ccode_node_unref0 (_tmp78_);

6526

_g_free0 (_tmp76_);

6527

_tmp79_ = info;

6528

_tmp80_ = param;

6529

_tmp81_ = vala_variable_get_variable_type ((ValaVariable*) _tmp80_);

6530

_tmp82_ = _tmp81_;

6531

_tmp83_ = param;

6532

_tmp84_ = vala_gvariant_module_get_type_signature (_tmp82_, (ValaSymbol*) _tmp83_);

6533

_tmp85_ = _tmp84_;

6534

_tmp86_ = g_strdup_printf ("\"%s\"", _tmp85_);

6535

_tmp87_ = _tmp86_;

6536

_tmp88_ = vala_ccode_constant_new (_tmp87_);

6537

_tmp89_ = _tmp88_;

6538

vala_ccode_initializer_list_append (_tmp79_, (ValaCCodeExpression*) _tmp89_);

6539

_vala_ccode_node_unref0 (_tmp89_);

6540

_g_free0 (_tmp87_);

6541

_g_free0 (_tmp85_);

6542

_tmp90_ = vala_ccode_declaration_new ("const GDBusArgInfo");

6543

_cdecl_ = _tmp90_;

6544

_tmp91_ = _cdecl_;

6545

_tmp92_ = sym;

6546

_tmp93_ = vala_ccode_base_module_get_ccode_lower_case_prefix ((ValaSymbol*) _tmp92_);

6547

_tmp94_ = _tmp93_;

6548

_tmp95_ = g_strconcat ("_", _tmp94_, NULL);

6549

_tmp96_ = _tmp95_;

6550

_tmp97_ = g_strconcat (_tmp96_, "dbus_arg_info_", NULL);

6551

_tmp98_ = _tmp97_;

6552

_tmp99_ = m;

6553

_tmp100_ = vala_symbol_get_name ((ValaSymbol*) _tmp99_);

6554

_tmp101_ = _tmp100_;

6555

_tmp102_ = g_strconcat (_tmp98_, _tmp101_, NULL);

6556

_tmp103_ = _tmp102_;

6557

_tmp104_ = g_strconcat (_tmp103_, "_", NULL);

6558

_tmp105_ = _tmp104_;

6559

_tmp106_ = param;

6560

_tmp107_ = vala_symbol_get_name ((ValaSymbol*) _tmp106_);

6561

_tmp108_ = _tmp107_;

6562

_tmp109_ = g_strconcat (_tmp105_, _tmp108_, NULL);

6563

_tmp110_ = _tmp109_;

6564

_tmp111_ = info;

6565

_tmp112_ = vala_ccode_variable_declarator_new (_tmp110_, (ValaCCodeExpression*) _tmp111_, NULL);

6566

_tmp113_ = _tmp112_;

6567

vala_ccode_declaration_add_declarator (_tmp91_, (ValaCCodeDeclarator*) _tmp113_);

6568

_vala_ccode_node_unref0 (_tmp113_);

6569

_g_free0 (_tmp110_);

6570

_g_free0 (_tmp105_);

6571

_g_free0 (_tmp103_);

6572

_g_free0 (_tmp98_);

6573

_g_free0 (_tmp96_);

6574

_g_free0 (_tmp94_);

6575

_tmp114_ = _cdecl_;

6576

vala_ccode_declaration_set_modifiers (_tmp114_, VALA_CCODE_MODIFIERS_STATIC);

6577

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

6578

_tmp116_ = _cdecl_;

6579

vala_ccode_file_add_constant_declaration (_tmp115_, (ValaCCodeNode*) _tmp116_);

6580

_tmp117_ = param;

6581

_tmp118_ = vala_parameter_get_direction (_tmp117_);

6582

_tmp119_ = _tmp118_;

6583

if (_tmp119_ == VALA_PARAMETER_DIRECTION_IN) {

6584

ValaCCodeInitializerList* _tmp120_;

6585

ValaObjectTypeSymbol* _tmp121_;

6586

gchar* _tmp122_ = NULL;

6587

gchar* _tmp123_;

6588

gchar* _tmp124_;

6589

gchar* _tmp125_;

6590

gchar* _tmp126_;

6591

gchar* _tmp127_;

6592

ValaMethod* _tmp128_;

6593

const gchar* _tmp129_;

6594

const gchar* _tmp130_;

6595

gchar* _tmp131_;

6596

gchar* _tmp132_;

6597

gchar* _tmp133_;

6598

gchar* _tmp134_;

6599

ValaParameter* _tmp135_;

6600

const gchar* _tmp136_;

6601

const gchar* _tmp137_;

6602

gchar* _tmp138_;

6603

gchar* _tmp139_;

6604

ValaCCodeIdentifier* _tmp140_;

6605

ValaCCodeIdentifier* _tmp141_;

6606

ValaCCodeUnaryExpression* _tmp142_;

6607

ValaCCodeUnaryExpression* _tmp143_;

6608

_tmp120_ = in_args_info;

6609

_tmp121_ = sym;

6610

_tmp122_ = vala_ccode_base_module_get_ccode_lower_case_prefix ((ValaSymbol*) _tmp121_);

6611

_tmp123_ = _tmp122_;

6612

_tmp124_ = g_strconcat ("_", _tmp123_, NULL);

6613

_tmp125_ = _tmp124_;

6614

_tmp126_ = g_strconcat (_tmp125_, "dbus_arg_info_", NULL);

6615

_tmp127_ = _tmp126_;

6616

_tmp128_ = m;

6617

_tmp129_ = vala_symbol_get_name ((ValaSymbol*) _tmp128_);

6618

_tmp130_ = _tmp129_;

6619

_tmp131_ = g_strconcat (_tmp127_, _tmp130_, NULL);

6620

_tmp132_ = _tmp131_;

6621

_tmp133_ = g_strconcat (_tmp132_, "_", NULL);

6622

_tmp134_ = _tmp133_;

6623

_tmp135_ = param;

6624

_tmp136_ = vala_symbol_get_name ((ValaSymbol*) _tmp135_);

6625

_tmp137_ = _tmp136_;

6626

_tmp138_ = g_strconcat (_tmp134_, _tmp137_, NULL);

6627

_tmp139_ = _tmp138_;

6628

_tmp140_ = vala_ccode_identifier_new (_tmp139_);

6629

_tmp141_ = _tmp140_;

6630

_tmp142_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, (ValaCCodeExpression*) _tmp141_);

6631

_tmp143_ = _tmp142_;

6632

vala_ccode_initializer_list_append (_tmp120_, (ValaCCodeExpression*) _tmp143_);

6633

_vala_ccode_node_unref0 (_tmp143_);

6634

_vala_ccode_node_unref0 (_tmp141_);

6635

_g_free0 (_tmp139_);

6636

_g_free0 (_tmp134_);

6637

_g_free0 (_tmp132_);

6638

_g_free0 (_tmp127_);

6639

_g_free0 (_tmp125_);

6640

_g_free0 (_tmp123_);

6641

} else {

6642

ValaCCodeInitializerList* _tmp144_;

6643

ValaObjectTypeSymbol* _tmp145_;

6644

gchar* _tmp146_ = NULL;

6645

gchar* _tmp147_;

6646

gchar* _tmp148_;

6647

gchar* _tmp149_;

6648

gchar* _tmp150_;

6649

gchar* _tmp151_;

6650

ValaMethod* _tmp152_;

6651

const gchar* _tmp153_;

6652

const gchar* _tmp154_;

6653

gchar* _tmp155_;

6654

gchar* _tmp156_;

6655

gchar* _tmp157_;

6656

gchar* _tmp158_;

6657

ValaParameter* _tmp159_;

6658

const gchar* _tmp160_;

6659

const gchar* _tmp161_;

6660

gchar* _tmp162_;

6661

gchar* _tmp163_;

6662

ValaCCodeIdentifier* _tmp164_;

6663

ValaCCodeIdentifier* _tmp165_;

6664

ValaCCodeUnaryExpression* _tmp166_;

6665

ValaCCodeUnaryExpression* _tmp167_;

6666

_tmp144_ = out_args_info;

6667

_tmp145_ = sym;

6668

_tmp146_ = vala_ccode_base_module_get_ccode_lower_case_prefix ((ValaSymbol*) _tmp145_);

6669

_tmp147_ = _tmp146_;

6670

_tmp148_ = g_strconcat ("_", _tmp147_, NULL);

6671

_tmp149_ = _tmp148_;

6672

_tmp150_ = g_strconcat (_tmp149_, "dbus_arg_info_", NULL);

6673

_tmp151_ = _tmp150_;

6674

_tmp152_ = m;

6675

_tmp153_ = vala_symbol_get_name ((ValaSymbol*) _tmp152_);

6676

_tmp154_ = _tmp153_;

6677

_tmp155_ = g_strconcat (_tmp151_, _tmp154_, NULL);

6678

_tmp156_ = _tmp155_;

6679

_tmp157_ = g_strconcat (_tmp156_, "_", NULL);

6680

_tmp158_ = _tmp157_;

6681

_tmp159_ = param;

6682

_tmp160_ = vala_symbol_get_name ((ValaSymbol*) _tmp159_);

6683

_tmp161_ = _tmp160_;

6684

_tmp162_ = g_strconcat (_tmp158_, _tmp161_, NULL);

6685

_tmp163_ = _tmp162_;

6686

_tmp164_ = vala_ccode_identifier_new (_tmp163_);

6687

_tmp165_ = _tmp164_;

6688

_tmp166_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, (ValaCCodeExpression*) _tmp165_);

6689

_tmp167_ = _tmp166_;

6690

vala_ccode_initializer_list_append (_tmp144_, (ValaCCodeExpression*) _tmp167_);

6691

_vala_ccode_node_unref0 (_tmp167_);

6692

_vala_ccode_node_unref0 (_tmp165_);

6693

_g_free0 (_tmp163_);

6694

_g_free0 (_tmp158_);

6695

_g_free0 (_tmp156_);

6696

_g_free0 (_tmp151_);

6697

_g_free0 (_tmp149_);

6698

_g_free0 (_tmp147_);

6699

}

6700

_vala_ccode_node_unref0 (_cdecl_);

6701

_vala_ccode_node_unref0 (info);

6702

_vala_code_node_unref0 (param);

6703

}

6704

_vala_iterable_unref0 (_param_list);

6705

}

6706

_tmp168_ = m;

6707

_tmp169_ = vala_method_get_return_type (_tmp168_);

6708

_tmp170_ = _tmp169_;

6709

if (!G_TYPE_CHECK_INSTANCE_TYPE (_tmp170_, VALA_TYPE_VOID_TYPE)) {

6710

ValaCCodeInitializerList* _tmp171_;

6711

ValaCCodeInitializerList* info;

6712

ValaCCodeInitializerList* _tmp172_;

6713

ValaCCodeConstant* _tmp173_;

6714

ValaCCodeConstant* _tmp174_;

6715

ValaCCodeInitializerList* _tmp175_;

6716

ValaMethod* _tmp176_;

6717

gchar* _tmp177_ = NULL;

6718

gchar* _tmp178_;

6719

gchar* _tmp179_ = NULL;

6720

gchar* _tmp180_;

6721

ValaCCodeConstant* _tmp181_;

6722

ValaCCodeConstant* _tmp182_;

6723

ValaCCodeInitializerList* _tmp183_;

6724

ValaMethod* _tmp184_;

6725

ValaDataType* _tmp185_;

6726

ValaDataType* _tmp186_;

6727

ValaMethod* _tmp187_;

6728

gchar* _tmp188_ = NULL;

6729

gchar* _tmp189_;

6730

gchar* _tmp190_ = NULL;

6731

gchar* _tmp191_;

6732

ValaCCodeConstant* _tmp192_;

6733

ValaCCodeConstant* _tmp193_;

6734

ValaCCodeDeclaration* _tmp194_;

6735

ValaCCodeDeclaration* _cdecl_;

6736

ValaCCodeDeclaration* _tmp195_;

6737

ValaObjectTypeSymbol* _tmp196_;

6738

gchar* _tmp197_ = NULL;

6739

gchar* _tmp198_;

6740

gchar* _tmp199_;

6741

gchar* _tmp200_;

6742

gchar* _tmp201_;

6743

gchar* _tmp202_;

6744

ValaMethod* _tmp203_;

6745

const gchar* _tmp204_;

6746

const gchar* _tmp205_;

6747

gchar* _tmp206_;

6748

gchar* _tmp207_;

6749

gchar* _tmp208_;

6750

gchar* _tmp209_;

6751

ValaCCodeInitializerList* _tmp210_;

6752

ValaCCodeVariableDeclarator* _tmp211_;

6753

ValaCCodeVariableDeclarator* _tmp212_;

6754

ValaCCodeDeclaration* _tmp213_;

6755

ValaCCodeFile* _tmp214_;

6756

ValaCCodeDeclaration* _tmp215_;

6757

ValaCCodeInitializerList* _tmp216_;

6758

ValaObjectTypeSymbol* _tmp217_;

6759

gchar* _tmp218_ = NULL;

6760

gchar* _tmp219_;

6761

gchar* _tmp220_;

6762

gchar* _tmp221_;

6763

gchar* _tmp222_;

6764

gchar* _tmp223_;

6765

ValaMethod* _tmp224_;

6766

const gchar* _tmp225_;

6767

const gchar* _tmp226_;

6768

gchar* _tmp227_;

6769

gchar* _tmp228_;

6770

gchar* _tmp229_;

6771

gchar* _tmp230_;

6772

ValaCCodeIdentifier* _tmp231_;

6773

ValaCCodeIdentifier* _tmp232_;

6774

ValaCCodeUnaryExpression* _tmp233_;

6775

ValaCCodeUnaryExpression* _tmp234_;

6776

_tmp171_ = vala_ccode_initializer_list_new ();

6777

info = _tmp171_;

6778

_tmp172_ = info;

6779

_tmp173_ = vala_ccode_constant_new ("-1");

6780

_tmp174_ = _tmp173_;

6781

vala_ccode_initializer_list_append (_tmp172_, (ValaCCodeExpression*) _tmp174_);

6782

_vala_ccode_node_unref0 (_tmp174_);

6783

_tmp175_ = info;

6784

_tmp176_ = m;

6785

_tmp177_ = vala_gd_bus_server_module_dbus_result_name (_tmp176_);

6786

_tmp178_ = _tmp177_;

6787

_tmp179_ = g_strdup_printf ("\"%s\"", _tmp178_);

6788

_tmp180_ = _tmp179_;

6789

_tmp181_ = vala_ccode_constant_new (_tmp180_);

6790

_tmp182_ = _tmp181_;

6791

vala_ccode_initializer_list_append (_tmp175_, (ValaCCodeExpression*) _tmp182_);

6792

_vala_ccode_node_unref0 (_tmp182_);

6793

_g_free0 (_tmp180_);

6794

_g_free0 (_tmp178_);

6795

_tmp183_ = info;

6796

_tmp184_ = m;

6797

_tmp185_ = vala_method_get_return_type (_tmp184_);

6798

_tmp186_ = _tmp185_;

6799

_tmp187_ = m;

6800

_tmp188_ = vala_gvariant_module_get_type_signature (_tmp186_, (ValaSymbol*) _tmp187_);

6801

_tmp189_ = _tmp188_;

6802

_tmp190_ = g_strdup_printf ("\"%s\"", _tmp189_);

6803

_tmp191_ = _tmp190_;

6804

_tmp192_ = vala_ccode_constant_new (_tmp191_);

6805

_tmp193_ = _tmp192_;

6806

vala_ccode_initializer_list_append (_tmp183_, (ValaCCodeExpression*) _tmp193_);

6807

_vala_ccode_node_unref0 (_tmp193_);

6808

_g_free0 (_tmp191_);

6809

_g_free0 (_tmp189_);

6810

_tmp194_ = vala_ccode_declaration_new ("const GDBusArgInfo");

6811

_cdecl_ = _tmp194_;

6812

_tmp195_ = _cdecl_;

6813

_tmp196_ = sym;

6814

_tmp197_ = vala_ccode_base_module_get_ccode_lower_case_prefix ((ValaSymbol*) _tmp196_);

6815

_tmp198_ = _tmp197_;

6816

_tmp199_ = g_strconcat ("_", _tmp198_, NULL);

6817

_tmp200_ = _tmp199_;

6818

_tmp201_ = g_strconcat (_tmp200_, "dbus_arg_info_", NULL);

6819

_tmp202_ = _tmp201_;

6820

_tmp203_ = m;

6821

_tmp204_ = vala_symbol_get_name ((ValaSymbol*) _tmp203_);

6822

_tmp205_ = _tmp204_;

6823

_tmp206_ = g_strconcat (_tmp202_, _tmp205_, NULL);

6824

_tmp207_ = _tmp206_;

6825

_tmp208_ = g_strconcat (_tmp207_, "_result", NULL);

6826

_tmp209_ = _tmp208_;

6827

_tmp210_ = info;

6828

_tmp211_ = vala_ccode_variable_declarator_new (_tmp209_, (ValaCCodeExpression*) _tmp210_, NULL);

6829

_tmp212_ = _tmp211_;

6830

vala_ccode_declaration_add_declarator (_tmp195_, (ValaCCodeDeclarator*) _tmp212_);

6831

_vala_ccode_node_unref0 (_tmp212_);

6832

_g_free0 (_tmp209_);

6833

_g_free0 (_tmp207_);

6834

_g_free0 (_tmp202_);

6835

_g_free0 (_tmp200_);

6836

_g_free0 (_tmp198_);

6837

_tmp213_ = _cdecl_;

6838

vala_ccode_declaration_set_modifiers (_tmp213_, VALA_CCODE_MODIFIERS_STATIC);

6839

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

6840

_tmp215_ = _cdecl_;

6841

vala_ccode_file_add_constant_declaration (_tmp214_, (ValaCCodeNode*) _tmp215_);

6842

_tmp216_ = out_args_info;

6843

_tmp217_ = sym;

6844

_tmp218_ = vala_ccode_base_module_get_ccode_lower_case_prefix ((ValaSymbol*) _tmp217_);

6845

_tmp219_ = _tmp218_;

6846

_tmp220_ = g_strconcat ("_", _tmp219_, NULL);

6847

_tmp221_ = _tmp220_;

6848

_tmp222_ = g_strconcat (_tmp221_, "dbus_arg_info_", NULL);

6849

_tmp223_ = _tmp222_;

6850

_tmp224_ = m;

6851

_tmp225_ = vala_symbol_get_name ((ValaSymbol*) _tmp224_);

6852

_tmp226_ = _tmp225_;

6853

_tmp227_ = g_strconcat (_tmp223_, _tmp226_, NULL);

6854

_tmp228_ = _tmp227_;

6855

_tmp229_ = g_strconcat (_tmp228_, "_result", NULL);

6856

_tmp230_ = _tmp229_;

6857

_tmp231_ = vala_ccode_identifier_new (_tmp230_);

6858

_tmp232_ = _tmp231_;

6859

_tmp233_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, (ValaCCodeExpression*) _tmp232_);

6860

_tmp234_ = _tmp233_;

6861

vala_ccode_initializer_list_append (_tmp216_, (ValaCCodeExpression*) _tmp234_);

6862

_vala_ccode_node_unref0 (_tmp234_);

6863

_vala_ccode_node_unref0 (_tmp232_);

6864

_g_free0 (_tmp230_);

6865

_g_free0 (_tmp228_);

6866

_g_free0 (_tmp223_);

6867

_g_free0 (_tmp221_);

6868

_g_free0 (_tmp219_);

6869

_vala_ccode_node_unref0 (_cdecl_);

6870

_vala_ccode_node_unref0 (info);

6871

}

6872

_tmp235_ = in_args_info;

6873

_tmp236_ = vala_ccode_constant_new ("NULL");

6874

_tmp237_ = _tmp236_;

6875

vala_ccode_initializer_list_append (_tmp235_, (ValaCCodeExpression*) _tmp237_);

6876

_vala_ccode_node_unref0 (_tmp237_);

6877

_tmp238_ = out_args_info;

6878

_tmp239_ = vala_ccode_constant_new ("NULL");

6879

_tmp240_ = _tmp239_;

6880

vala_ccode_initializer_list_append (_tmp238_, (ValaCCodeExpression*) _tmp240_);

6881

_vala_ccode_node_unref0 (_tmp240_);

6882

_tmp241_ = vala_ccode_declaration_new ("const GDBusArgInfo * const");

6883

_cdecl_ = _tmp241_;

6884

_tmp242_ = _cdecl_;

6885

_tmp243_ = sym;

6886

_tmp244_ = vala_ccode_base_module_get_ccode_lower_case_prefix ((ValaSymbol*) _tmp243_);

6887

_tmp245_ = _tmp244_;

6888

_tmp246_ = g_strconcat ("_", _tmp245_, NULL);

6889

_tmp247_ = _tmp246_;

6890

_tmp248_ = g_strconcat (_tmp247_, "dbus_arg_info_", NULL);

6891

_tmp249_ = _tmp248_;

6892

_tmp250_ = m;

6893

_tmp251_ = vala_symbol_get_name ((ValaSymbol*) _tmp250_);

6894

_tmp252_ = _tmp251_;

6895

_tmp253_ = g_strconcat (_tmp249_, _tmp252_, NULL);

6896

_tmp254_ = _tmp253_;

6897

_tmp255_ = g_strconcat (_tmp254_, "_in[]", NULL);

6898

_tmp256_ = _tmp255_;

6899

_tmp257_ = in_args_info;

6900

_tmp258_ = vala_ccode_variable_declarator_new (_tmp256_, (ValaCCodeExpression*) _tmp257_, NULL);

6901

_tmp259_ = _tmp258_;

6902

vala_ccode_declaration_add_declarator (_tmp242_, (ValaCCodeDeclarator*) _tmp259_);

6903

_vala_ccode_node_unref0 (_tmp259_);

6904

_g_free0 (_tmp256_);

6905

_g_free0 (_tmp254_);

6906

_g_free0 (_tmp249_);

6907

_g_free0 (_tmp247_);

6908

_g_free0 (_tmp245_);

6909

_tmp260_ = _cdecl_;

6910

vala_ccode_declaration_set_modifiers (_tmp260_, VALA_CCODE_MODIFIERS_STATIC);

6911

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

6912

_tmp262_ = _cdecl_;

6913

vala_ccode_file_add_constant_declaration (_tmp261_, (ValaCCodeNode*) _tmp262_);

6914

_tmp263_ = vala_ccode_declaration_new ("const GDBusArgInfo * const");

6915

_vala_ccode_node_unref0 (_cdecl_);

6916

_cdecl_ = _tmp263_;

6917

_tmp264_ = _cdecl_;

6918

_tmp265_ = sym;

6919

_tmp266_ = vala_ccode_base_module_get_ccode_lower_case_prefix ((ValaSymbol*) _tmp265_);

6920

_tmp267_ = _tmp266_;

6921

_tmp268_ = g_strconcat ("_", _tmp267_, NULL);

6922

_tmp269_ = _tmp268_;

6923

_tmp270_ = g_strconcat (_tmp269_, "dbus_arg_info_", NULL);

6924

_tmp271_ = _tmp270_;

6925

_tmp272_ = m;

6926

_tmp273_ = vala_symbol_get_name ((ValaSymbol*) _tmp272_);

6927

_tmp274_ = _tmp273_;

6928

_tmp275_ = g_strconcat (_tmp271_, _tmp274_, NULL);

6929

_tmp276_ = _tmp275_;

6930

_tmp277_ = g_strconcat (_tmp276_, "_out[]", NULL);

6931

_tmp278_ = _tmp277_;

6932

_tmp279_ = out_args_info;

6933

_tmp280_ = vala_ccode_variable_declarator_new (_tmp278_, (ValaCCodeExpression*) _tmp279_, NULL);

6934

_tmp281_ = _tmp280_;

6935

vala_ccode_declaration_add_declarator (_tmp264_, (ValaCCodeDeclarator*) _tmp281_);

6936

_vala_ccode_node_unref0 (_tmp281_);

6937

_g_free0 (_tmp278_);

6938

_g_free0 (_tmp276_);

6939

_g_free0 (_tmp271_);

6940

_g_free0 (_tmp269_);

6941

_g_free0 (_tmp267_);

6942

_tmp282_ = _cdecl_;

6943

vala_ccode_declaration_set_modifiers (_tmp282_, VALA_CCODE_MODIFIERS_STATIC);

6944

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

6945

_tmp284_ = _cdecl_;

6946

vala_ccode_file_add_constant_declaration (_tmp283_, (ValaCCodeNode*) _tmp284_);

6947

_tmp285_ = vala_ccode_initializer_list_new ();

6948

info = _tmp285_;

6949

_tmp286_ = info;

6950

_tmp287_ = vala_ccode_constant_new ("-1");

6951

_tmp288_ = _tmp287_;

6952

vala_ccode_initializer_list_append (_tmp286_, (ValaCCodeExpression*) _tmp288_);

6953

_vala_ccode_node_unref0 (_tmp288_);

6954

_tmp289_ = info;

6955

_tmp290_ = m;

6956

_tmp291_ = vala_gd_bus_module_get_dbus_name_for_member ((ValaSymbol*) _tmp290_);

6957

_tmp292_ = _tmp291_;

6958

_tmp293_ = g_strdup_printf ("\"%s\"", _tmp292_);

6959

_tmp294_ = _tmp293_;

6960

_tmp295_ = vala_ccode_constant_new (_tmp294_);

6961

_tmp296_ = _tmp295_;

6962

vala_ccode_initializer_list_append (_tmp289_, (ValaCCodeExpression*) _tmp296_);

6963

_vala_ccode_node_unref0 (_tmp296_);

6964

_g_free0 (_tmp294_);

6965

_g_free0 (_tmp292_);

6966

_tmp297_ = info;

6967

_tmp298_ = sym;

6968

_tmp299_ = vala_ccode_base_module_get_ccode_lower_case_prefix ((ValaSymbol*) _tmp298_);

6969

_tmp300_ = _tmp299_;

6970

_tmp301_ = g_strconcat ("_", _tmp300_, NULL);

6971

_tmp302_ = _tmp301_;

6972

_tmp303_ = g_strconcat (_tmp302_, "dbus_arg_info_", NULL);

6973

_tmp304_ = _tmp303_;

6974

_tmp305_ = m;

6975

_tmp306_ = vala_symbol_get_name ((ValaSymbol*) _tmp305_);

6976

_tmp307_ = _tmp306_;

6977

_tmp308_ = g_strconcat (_tmp304_, _tmp307_, NULL);

6978

_tmp309_ = _tmp308_;

6979

_tmp310_ = g_strconcat (_tmp309_, "_in", NULL);

6980

_tmp311_ = _tmp310_;

6981

_tmp312_ = vala_ccode_identifier_new (_tmp311_);

6982

_tmp313_ = _tmp312_;

6983

_tmp314_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, (ValaCCodeExpression*) _tmp313_);

6984

_tmp315_ = _tmp314_;

6985

_tmp316_ = vala_ccode_cast_expression_new ((ValaCCodeExpression*) _tmp315_, "GDBusArgInfo **");

6986

_tmp317_ = _tmp316_;

6987

vala_ccode_initializer_list_append (_tmp297_, (ValaCCodeExpression*) _tmp317_);

6988

_vala_ccode_node_unref0 (_tmp317_);

6989

_vala_ccode_node_unref0 (_tmp315_);

6990

_vala_ccode_node_unref0 (_tmp313_);

6991

_g_free0 (_tmp311_);

6992

_g_free0 (_tmp309_);

6993

_g_free0 (_tmp304_);

6994

_g_free0 (_tmp302_);

6995

_g_free0 (_tmp300_);

6996

_tmp318_ = info;

6997

_tmp319_ = sym;

6998

_tmp320_ = vala_ccode_base_module_get_ccode_lower_case_prefix ((ValaSymbol*) _tmp319_);

6999

_tmp321_ = _tmp320_;

7000

_tmp322_ = g_strconcat ("_", _tmp321_, NULL);

7001

_tmp323_ = _tmp322_;

7002

_tmp324_ = g_strconcat (_tmp323_, "dbus_arg_info_", NULL);

7003

_tmp325_ = _tmp324_;

7004

_tmp326_ = m;

7005

_tmp327_ = vala_symbol_get_name ((ValaSymbol*) _tmp326_);

7006

_tmp328_ = _tmp327_;

7007

_tmp329_ = g_strconcat (_tmp325_, _tmp328_, NULL);

7008

_tmp330_ = _tmp329_;

7009

_tmp331_ = g_strconcat (_tmp330_, "_out", NULL);

7010

_tmp332_ = _tmp331_;

7011

_tmp333_ = vala_ccode_identifier_new (_tmp332_);

7012

_tmp334_ = _tmp333_;

7013

_tmp335_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, (ValaCCodeExpression*) _tmp334_);

7014

_tmp336_ = _tmp335_;

7015

_tmp337_ = vala_ccode_cast_expression_new ((ValaCCodeExpression*) _tmp336_, "GDBusArgInfo **");

7016

_tmp338_ = _tmp337_;

7017

vala_ccode_initializer_list_append (_tmp318_, (ValaCCodeExpression*) _tmp338_);

7018

_vala_ccode_node_unref0 (_tmp338_);

7019

_vala_ccode_node_unref0 (_tmp336_);

7020

_vala_ccode_node_unref0 (_tmp334_);

7021

_g_free0 (_tmp332_);

7022

_g_free0 (_tmp330_);

7023

_g_free0 (_tmp325_);

7024

_g_free0 (_tmp323_);

7025

_g_free0 (_tmp321_);

7026

_tmp339_ = vala_ccode_declaration_new ("const GDBusMethodInfo");

7027

_vala_ccode_node_unref0 (_cdecl_);

7028

_cdecl_ = _tmp339_;

7029

_tmp340_ = _cdecl_;

7030

_tmp341_ = sym;

7031

_tmp342_ = vala_ccode_base_module_get_ccode_lower_case_prefix ((ValaSymbol*) _tmp341_);

7032

_tmp343_ = _tmp342_;

7033

_tmp344_ = g_strconcat ("_", _tmp343_, NULL);

7034

_tmp345_ = _tmp344_;

7035

_tmp346_ = g_strconcat (_tmp345_, "dbus_method_info_", NULL);

7036

_tmp347_ = _tmp346_;

7037

_tmp348_ = m;

7038

_tmp349_ = vala_symbol_get_name ((ValaSymbol*) _tmp348_);

7039

_tmp350_ = _tmp349_;

7040

_tmp351_ = g_strconcat (_tmp347_, _tmp350_, NULL);

7041

_tmp352_ = _tmp351_;

7042

_tmp353_ = info;

7043

_tmp354_ = vala_ccode_variable_declarator_new (_tmp352_, (ValaCCodeExpression*) _tmp353_, NULL);

7044

_tmp355_ = _tmp354_;

7045

vala_ccode_declaration_add_declarator (_tmp340_, (ValaCCodeDeclarator*) _tmp355_);

7046

_vala_ccode_node_unref0 (_tmp355_);

7047

_g_free0 (_tmp352_);

7048

_g_free0 (_tmp347_);

7049

_g_free0 (_tmp345_);

7050

_g_free0 (_tmp343_);

7051

_tmp356_ = _cdecl_;

7052

vala_ccode_declaration_set_modifiers (_tmp356_, VALA_CCODE_MODIFIERS_STATIC);

7053

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

7054

_tmp358_ = _cdecl_;

7055

vala_ccode_file_add_constant_declaration (_tmp357_, (ValaCCodeNode*) _tmp358_);

7056

_tmp359_ = infos;

7057

_tmp360_ = sym;

7058

_tmp361_ = vala_ccode_base_module_get_ccode_lower_case_prefix ((ValaSymbol*) _tmp360_);

7059

_tmp362_ = _tmp361_;

7060

_tmp363_ = g_strconcat ("_", _tmp362_, NULL);

7061

_tmp364_ = _tmp363_;

7062

_tmp365_ = g_strconcat (_tmp364_, "dbus_method_info_", NULL);

7063

_tmp366_ = _tmp365_;

7064

_tmp367_ = m;

7065

_tmp368_ = vala_symbol_get_name ((ValaSymbol*) _tmp367_);

7066

_tmp369_ = _tmp368_;

7067

_tmp370_ = g_strconcat (_tmp366_, _tmp369_, NULL);

7068

_tmp371_ = _tmp370_;

7069

_tmp372_ = vala_ccode_identifier_new (_tmp371_);

7070

_tmp373_ = _tmp372_;

7071

_tmp374_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, (ValaCCodeExpression*) _tmp373_);

7072

_tmp375_ = _tmp374_;

7073

vala_ccode_initializer_list_append (_tmp359_, (ValaCCodeExpression*) _tmp375_);

7074

_vala_ccode_node_unref0 (_tmp375_);

7075

_vala_ccode_node_unref0 (_tmp373_);

7076

_g_free0 (_tmp371_);

7077

_g_free0 (_tmp366_);

7078

_g_free0 (_tmp364_);

7079

_g_free0 (_tmp362_);

7080

_vala_ccode_node_unref0 (info);

7081

_vala_ccode_node_unref0 (_cdecl_);

7082

_vala_ccode_node_unref0 (out_args_info);

7083

_vala_ccode_node_unref0 (in_args_info);

7084

_vala_code_node_unref0 (m);

7085

}

7086

_vala_iterable_unref0 (_m_list);

7087

}

7088

_tmp376_ = infos;

7089

_tmp377_ = vala_ccode_constant_new ("NULL");

7090

_tmp378_ = _tmp377_;

7091

vala_ccode_initializer_list_append (_tmp376_, (ValaCCodeExpression*) _tmp378_);

7092

_vala_ccode_node_unref0 (_tmp378_);

7093

_tmp379_ = vala_ccode_declaration_new ("const GDBusMethodInfo * const");

7094

_cdecl_ = _tmp379_;

7095

_tmp380_ = sym;

7096

_tmp381_ = vala_ccode_base_module_get_ccode_lower_case_prefix ((ValaSymbol*) _tmp380_);

7097

_tmp382_ = _tmp381_;

7098

_tmp383_ = g_strconcat ("_", _tmp382_, NULL);

7099

_tmp384_ = _tmp383_;

7100

_tmp385_ = g_strconcat (_tmp384_, "dbus_method_info[]", NULL);

7101

_tmp386_ = _tmp385_;

7102

_tmp387_ = infos;

7103

_tmp388_ = vala_ccode_variable_declarator_new (_tmp386_, (ValaCCodeExpression*) _tmp387_, NULL);

7104

_tmp389_ = _tmp388_;

7105

vala_ccode_declaration_add_declarator (_cdecl_, (ValaCCodeDeclarator*) _tmp389_);

7106

_vala_ccode_node_unref0 (_tmp389_);

7107

_g_free0 (_tmp386_);

7108

_g_free0 (_tmp384_);

7109

_g_free0 (_tmp382_);

7110

vala_ccode_declaration_set_modifiers (_cdecl_, VALA_CCODE_MODIFIERS_STATIC);

7111

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

7112

vala_ccode_file_add_constant_declaration (_tmp390_, (ValaCCodeNode*) _cdecl_);

7113

_tmp391_ = sym;

7114

_tmp392_ = vala_ccode_base_module_get_ccode_lower_case_prefix ((ValaSymbol*) _tmp391_);

7115

_tmp393_ = _tmp392_;

7116

_tmp394_ = g_strconcat ("_", _tmp393_, NULL);

7117

_tmp395_ = _tmp394_;

7118

_tmp396_ = g_strconcat (_tmp395_, "dbus_method_info", NULL);

7119

_tmp397_ = _tmp396_;

7120

_tmp398_ = vala_ccode_identifier_new (_tmp397_);

7121

_tmp399_ = (ValaCCodeExpression*) _tmp398_;

7122

_g_free0 (_tmp397_);

7123

_g_free0 (_tmp395_);

7124

_g_free0 (_tmp393_);

7125

result = _tmp399_;

7126

_vala_ccode_node_unref0 (_cdecl_);

7127

_vala_ccode_node_unref0 (infos);

7128

return result;

7129

}

7130

7131

7132

static ValaCCodeExpression* vala_gd_bus_server_module_get_signal_info (ValaGDBusServerModule* self, ValaObjectTypeSymbol* sym) {

7133

ValaCCodeExpression* result = NULL;

7134

ValaCCodeInitializerList* _tmp0_;

7135

ValaCCodeInitializerList* infos;

7136

ValaCCodeInitializerList* _tmp196_;

7137

ValaCCodeConstant* _tmp197_;

7138

ValaCCodeConstant* _tmp198_;

7139

ValaCCodeDeclaration* _tmp199_;

7140

ValaCCodeDeclaration* _cdecl_;

7141

ValaObjectTypeSymbol* _tmp200_;

7142

gchar* _tmp201_ = NULL;

7143

gchar* _tmp202_;

7144

gchar* _tmp203_;

7145

gchar* _tmp204_;

7146

gchar* _tmp205_;

7147

gchar* _tmp206_;

7148

ValaCCodeInitializerList* _tmp207_;

7149

ValaCCodeVariableDeclarator* _tmp208_;

7150

ValaCCodeVariableDeclarator* _tmp209_;

7151

ValaCCodeFile* _tmp210_;

7152

ValaObjectTypeSymbol* _tmp211_;

7153

gchar* _tmp212_ = NULL;

7154

gchar* _tmp213_;

7155

gchar* _tmp214_;

7156

gchar* _tmp215_;

7157

gchar* _tmp216_;

7158

gchar* _tmp217_;

7159

ValaCCodeIdentifier* _tmp218_;

7160

ValaCCodeExpression* _tmp219_;

7161

g_return_val_if_fail (self != NULL, NULL);

7162

g_return_val_if_fail (sym != NULL, NULL);

7163

_tmp0_ = vala_ccode_initializer_list_new ();

7164

infos = _tmp0_;

7165

{

7166

ValaObjectTypeSymbol* _tmp1_;

7167

ValaList* _tmp2_ = NULL;

7168

ValaList* _sig_list;

7169

ValaList* _tmp3_;

7170

gint _tmp4_;

7171

gint _tmp5_;

7172

gint _sig_size;

7173

gint _sig_index;

7174

_tmp1_ = sym;

7175

_tmp2_ = vala_object_type_symbol_get_signals (_tmp1_);

7176

_sig_list = _tmp2_;

7177

_tmp3_ = _sig_list;

7178

_tmp4_ = vala_collection_get_size ((ValaCollection*) _tmp3_);

7179

_tmp5_ = _tmp4_;

7180

_sig_size = _tmp5_;

7181

_sig_index = -1;

7182

while (TRUE) {

7183

gint _tmp6_;

7184

gint _tmp7_;

7185

gint _tmp8_;

7186

ValaList* _tmp9_;

7187

gint _tmp10_;

7188

gpointer _tmp11_ = NULL;

7189

ValaSignal* sig;

7190

ValaSignal* _tmp12_;

7191

ValaSymbolAccessibility _tmp13_;

7192

ValaSymbolAccessibility _tmp14_;

7193

ValaSignal* _tmp15_;

7194

gboolean _tmp16_ = FALSE;

7195

ValaCCodeInitializerList* _tmp17_;

7196

ValaCCodeInitializerList* args_info;

7197

ValaCCodeInitializerList* _tmp103_;

7198

ValaCCodeConstant* _tmp104_;

7199

ValaCCodeConstant* _tmp105_;

7200

ValaCCodeDeclaration* _tmp106_;

7201

ValaCCodeDeclaration* _cdecl_;

7202

ValaCCodeDeclaration* _tmp107_;

7203

ValaObjectTypeSymbol* _tmp108_;

7204

gchar* _tmp109_ = NULL;

7205

gchar* _tmp110_;

7206

gchar* _tmp111_;

7207

gchar* _tmp112_;

7208

gchar* _tmp113_;

7209

gchar* _tmp114_;

7210

ValaSignal* _tmp115_;

7211

gchar* _tmp116_ = NULL;

7212

gchar* _tmp117_;

7213

gchar* _tmp118_;

7214

gchar* _tmp119_;

7215

gchar* _tmp120_;

7216

gchar* _tmp121_;

7217

ValaCCodeInitializerList* _tmp122_;

7218

ValaCCodeVariableDeclarator* _tmp123_;

7219

ValaCCodeVariableDeclarator* _tmp124_;

7220

ValaCCodeDeclaration* _tmp125_;

7221

ValaCCodeFile* _tmp126_;

7222

ValaCCodeDeclaration* _tmp127_;

7223

ValaCCodeInitializerList* _tmp128_;

7224

ValaCCodeInitializerList* info;

7225

ValaCCodeInitializerList* _tmp129_;

7226

ValaCCodeConstant* _tmp130_;

7227

ValaCCodeConstant* _tmp131_;

7228

ValaCCodeInitializerList* _tmp132_;

7229

ValaSignal* _tmp133_;

7230

gchar* _tmp134_ = NULL;

7231

gchar* _tmp135_;

7232

gchar* _tmp136_ = NULL;

7233

gchar* _tmp137_;

7234

ValaCCodeConstant* _tmp138_;

7235

ValaCCodeConstant* _tmp139_;

7236

ValaCCodeInitializerList* _tmp140_;

7237

ValaObjectTypeSymbol* _tmp141_;

7238

gchar* _tmp142_ = NULL;

7239

gchar* _tmp143_;

7240

gchar* _tmp144_;

7241

gchar* _tmp145_;

7242

gchar* _tmp146_;

7243

gchar* _tmp147_;

7244

ValaSignal* _tmp148_;

7245

gchar* _tmp149_ = NULL;

7246

gchar* _tmp150_;

7247

gchar* _tmp151_;

7248

gchar* _tmp152_;

7249

ValaCCodeIdentifier* _tmp153_;

7250

ValaCCodeIdentifier* _tmp154_;

7251

ValaCCodeUnaryExpression* _tmp155_;

7252

ValaCCodeUnaryExpression* _tmp156_;

7253

ValaCCodeCastExpression* _tmp157_;

7254

ValaCCodeCastExpression* _tmp158_;

7255

ValaCCodeDeclaration* _tmp159_;

7256

ValaCCodeDeclaration* _tmp160_;

7257

ValaObjectTypeSymbol* _tmp161_;

7258

gchar* _tmp162_ = NULL;

7259

gchar* _tmp163_;

7260

gchar* _tmp164_;

7261

gchar* _tmp165_;

7262

gchar* _tmp166_;

7263

gchar* _tmp167_;

7264

ValaSignal* _tmp168_;

7265

gchar* _tmp169_ = NULL;

7266

gchar* _tmp170_;

7267

gchar* _tmp171_;

7268

gchar* _tmp172_;

7269

ValaCCodeInitializerList* _tmp173_;

7270

ValaCCodeVariableDeclarator* _tmp174_;

7271

ValaCCodeVariableDeclarator* _tmp175_;

7272

ValaCCodeDeclaration* _tmp176_;

7273

ValaCCodeFile* _tmp177_;

7274

ValaCCodeDeclaration* _tmp178_;

7275

ValaCCodeInitializerList* _tmp179_;

7276

ValaObjectTypeSymbol* _tmp180_;

7277

gchar* _tmp181_ = NULL;

7278

gchar* _tmp182_;

7279

gchar* _tmp183_;

7280

gchar* _tmp184_;

7281

gchar* _tmp185_;

7282

gchar* _tmp186_;

7283

ValaSignal* _tmp187_;

7284

gchar* _tmp188_ = NULL;

7285

gchar* _tmp189_;

7286

gchar* _tmp190_;

7287

gchar* _tmp191_;

7288

ValaCCodeIdentifier* _tmp192_;

7289

ValaCCodeIdentifier* _tmp193_;

7290

ValaCCodeUnaryExpression* _tmp194_;

7291

ValaCCodeUnaryExpression* _tmp195_;

7292

_tmp6_ = _sig_index;

7293

_sig_index = _tmp6_ + 1;

7294

_tmp7_ = _sig_index;

7295

_tmp8_ = _sig_size;

7296

if (!(_tmp7_ < _tmp8_)) {

7297

break;

7298

}

7299

_tmp9_ = _sig_list;

7300

_tmp10_ = _sig_index;

7301

_tmp11_ = vala_list_get (_tmp9_, _tmp10_);

7302

sig = (ValaSignal*) _tmp11_;

7303

_tmp12_ = sig;

7304

_tmp13_ = vala_symbol_get_access ((ValaSymbol*) _tmp12_);

7305

_tmp14_ = _tmp13_;

7306

if (_tmp14_ != VALA_SYMBOL_ACCESSIBILITY_PUBLIC) {

7307

_vala_code_node_unref0 (sig);

7308

continue;

7309

}

7310

_tmp15_ = sig;

7311

_tmp16_ = vala_gd_bus_server_module_is_dbus_visible ((ValaCodeNode*) _tmp15_);

7312

if (!_tmp16_) {

7313

_vala_code_node_unref0 (sig);

7314

continue;

7315

}

7316

_tmp17_ = vala_ccode_initializer_list_new ();

7317

args_info = _tmp17_;

7318

{

7319

ValaSignal* _tmp18_;

7320

ValaList* _tmp19_ = NULL;

7321

ValaList* _param_list;

7322

ValaList* _tmp20_;

7323

gint _tmp21_;

7324

gint _tmp22_;

7325

gint _param_size;

7326

gint _param_index;

7327

_tmp18_ = sig;

7328

_tmp19_ = vala_signal_get_parameters (_tmp18_);

7329

_param_list = _tmp19_;

7330

_tmp20_ = _param_list;

7331

_tmp21_ = vala_collection_get_size ((ValaCollection*) _tmp20_);

7332

_tmp22_ = _tmp21_;

7333

_param_size = _tmp22_;

7334

_param_index = -1;

7335

while (TRUE) {

7336

gint _tmp23_;

7337

gint _tmp24_;

7338

gint _tmp25_;

7339

ValaList* _tmp26_;

7340

gint _tmp27_;

7341

gpointer _tmp28_ = NULL;

7342

ValaParameter* param;

7343

ValaCCodeInitializerList* _tmp29_;

7344

ValaCCodeInitializerList* info;

7345

ValaCCodeInitializerList* _tmp30_;

7346

ValaCCodeConstant* _tmp31_;

7347

ValaCCodeConstant* _tmp32_;

7348

ValaCCodeInitializerList* _tmp33_;

7349

ValaParameter* _tmp34_;

7350

const gchar* _tmp35_;

7351

const gchar* _tmp36_;

7352

gchar* _tmp37_ = NULL;

7353

gchar* _tmp38_;

7354

ValaCCodeConstant* _tmp39_;

7355

ValaCCodeConstant* _tmp40_;

7356

ValaCCodeInitializerList* _tmp41_;

7357

ValaParameter* _tmp42_;

7358

ValaDataType* _tmp43_;

7359

ValaDataType* _tmp44_;

7360

ValaParameter* _tmp45_;

7361

gchar* _tmp46_ = NULL;

7362

gchar* _tmp47_;

7363

gchar* _tmp48_ = NULL;

7364

gchar* _tmp49_;

7365

ValaCCodeConstant* _tmp50_;

7366

ValaCCodeConstant* _tmp51_;

7367

ValaCCodeDeclaration* _tmp52_;

7368

ValaCCodeDeclaration* _cdecl_;

7369

ValaCCodeDeclaration* _tmp53_;

7370

ValaObjectTypeSymbol* _tmp54_;

7371

gchar* _tmp55_ = NULL;

7372

gchar* _tmp56_;

7373

gchar* _tmp57_;

7374

gchar* _tmp58_;

7375

gchar* _tmp59_;

7376

gchar* _tmp60_;

7377

ValaSignal* _tmp61_;

7378

gchar* _tmp62_ = NULL;

7379

gchar* _tmp63_;

7380

gchar* _tmp64_;

7381

gchar* _tmp65_;

7382

gchar* _tmp66_;

7383

gchar* _tmp67_;

7384

ValaParameter* _tmp68_;

7385

const gchar* _tmp69_;

7386

const gchar* _tmp70_;

7387

gchar* _tmp71_;

7388

gchar* _tmp72_;

7389

ValaCCodeInitializerList* _tmp73_;

7390

ValaCCodeVariableDeclarator* _tmp74_;

7391

ValaCCodeVariableDeclarator* _tmp75_;

7392

ValaCCodeDeclaration* _tmp76_;

7393

ValaCCodeFile* _tmp77_;

7394

ValaCCodeDeclaration* _tmp78_;

7395

ValaCCodeInitializerList* _tmp79_;

7396

ValaObjectTypeSymbol* _tmp80_;

7397

gchar* _tmp81_ = NULL;

7398

gchar* _tmp82_;

7399

gchar* _tmp83_;

7400

gchar* _tmp84_;

7401

gchar* _tmp85_;

7402

gchar* _tmp86_;

7403

ValaSignal* _tmp87_;

7404

gchar* _tmp88_ = NULL;

7405

gchar* _tmp89_;

7406

gchar* _tmp90_;

7407

gchar* _tmp91_;

7408

gchar* _tmp92_;

7409

gchar* _tmp93_;

7410

ValaParameter* _tmp94_;

7411

const gchar* _tmp95_;

7412

const gchar* _tmp96_;

7413

gchar* _tmp97_;

7414

gchar* _tmp98_;

7415

ValaCCodeIdentifier* _tmp99_;

7416

ValaCCodeIdentifier* _tmp100_;

7417

ValaCCodeUnaryExpression* _tmp101_;

7418

ValaCCodeUnaryExpression* _tmp102_;

7419

_tmp23_ = _param_index;

7420

_param_index = _tmp23_ + 1;

7421

_tmp24_ = _param_index;

7422

_tmp25_ = _param_size;

7423

if (!(_tmp24_ < _tmp25_)) {

7424

break;

7425

}

7426

_tmp26_ = _param_list;

7427

_tmp27_ = _param_index;

7428

_tmp28_ = vala_list_get (_tmp26_, _tmp27_);

7429

param = (ValaParameter*) _tmp28_;

7430

_tmp29_ = vala_ccode_initializer_list_new ();

7431

info = _tmp29_;

7432

_tmp30_ = info;

7433

_tmp31_ = vala_ccode_constant_new ("-1");

7434

_tmp32_ = _tmp31_;

7435

vala_ccode_initializer_list_append (_tmp30_, (ValaCCodeExpression*) _tmp32_);

7436

_vala_ccode_node_unref0 (_tmp32_);

7437

_tmp33_ = info;

7438

_tmp34_ = param;

7439

_tmp35_ = vala_symbol_get_name ((ValaSymbol*) _tmp34_);

7440

_tmp36_ = _tmp35_;

7441

_tmp37_ = g_strdup_printf ("\"%s\"", _tmp36_);

7442

_tmp38_ = _tmp37_;

7443

_tmp39_ = vala_ccode_constant_new (_tmp38_);

7444

_tmp40_ = _tmp39_;

7445

vala_ccode_initializer_list_append (_tmp33_, (ValaCCodeExpression*) _tmp40_);

7446

_vala_ccode_node_unref0 (_tmp40_);

7447

_g_free0 (_tmp38_);

7448

_tmp41_ = info;

7449

_tmp42_ = param;

7450

_tmp43_ = vala_variable_get_variable_type ((ValaVariable*) _tmp42_);

7451

_tmp44_ = _tmp43_;

7452

_tmp45_ = param;

7453

_tmp46_ = vala_gvariant_module_get_type_signature (_tmp44_, (ValaSymbol*) _tmp45_);

7454

_tmp47_ = _tmp46_;

7455

_tmp48_ = g_strdup_printf ("\"%s\"", _tmp47_);

7456

_tmp49_ = _tmp48_;

7457

_tmp50_ = vala_ccode_constant_new (_tmp49_);

7458

_tmp51_ = _tmp50_;

7459

vala_ccode_initializer_list_append (_tmp41_, (ValaCCodeExpression*) _tmp51_);

7460

_vala_ccode_node_unref0 (_tmp51_);

7461

_g_free0 (_tmp49_);

7462

_g_free0 (_tmp47_);

7463

_tmp52_ = vala_ccode_declaration_new ("const GDBusArgInfo");

7464

_cdecl_ = _tmp52_;

7465

_tmp53_ = _cdecl_;

7466

_tmp54_ = sym;

7467

_tmp55_ = vala_ccode_base_module_get_ccode_lower_case_prefix ((ValaSymbol*) _tmp54_);

7468

_tmp56_ = _tmp55_;

7469

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

7470

_tmp58_ = _tmp57_;

7471

_tmp59_ = g_strconcat (_tmp58_, "dbus_arg_info_", NULL);

7472

_tmp60_ = _tmp59_;

7473

_tmp61_ = sig;

7474

_tmp62_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp61_);

7475

_tmp63_ = _tmp62_;

7476

_tmp64_ = g_strconcat (_tmp60_, _tmp63_, NULL);

7477

_tmp65_ = _tmp64_;

7478

_tmp66_ = g_strconcat (_tmp65_, "_", NULL);

7479

_tmp67_ = _tmp66_;

7480

_tmp68_ = param;

7481

_tmp69_ = vala_symbol_get_name ((ValaSymbol*) _tmp68_);

7482

_tmp70_ = _tmp69_;

7483

_tmp71_ = g_strconcat (_tmp67_, _tmp70_, NULL);

7484

_tmp72_ = _tmp71_;

7485

_tmp73_ = info;

7486

_tmp74_ = vala_ccode_variable_declarator_new (_tmp72_, (ValaCCodeExpression*) _tmp73_, NULL);

7487

_tmp75_ = _tmp74_;

7488

vala_ccode_declaration_add_declarator (_tmp53_, (ValaCCodeDeclarator*) _tmp75_);

7489

_vala_ccode_node_unref0 (_tmp75_);

7490

_g_free0 (_tmp72_);

7491

_g_free0 (_tmp67_);

7492

_g_free0 (_tmp65_);

7493

_g_free0 (_tmp63_);

7494

_g_free0 (_tmp60_);

7495

_g_free0 (_tmp58_);

7496

_g_free0 (_tmp56_);

7497

_tmp76_ = _cdecl_;

7498

vala_ccode_declaration_set_modifiers (_tmp76_, VALA_CCODE_MODIFIERS_STATIC);

7499

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

7500

_tmp78_ = _cdecl_;

7501

vala_ccode_file_add_constant_declaration (_tmp77_, (ValaCCodeNode*) _tmp78_);

7502

_tmp79_ = args_info;

7503

_tmp80_ = sym;

7504

_tmp81_ = vala_ccode_base_module_get_ccode_lower_case_prefix ((ValaSymbol*) _tmp80_);

7505

_tmp82_ = _tmp81_;

7506

_tmp83_ = g_strconcat ("_", _tmp82_, NULL);

7507

_tmp84_ = _tmp83_;

7508

_tmp85_ = g_strconcat (_tmp84_, "dbus_arg_info_", NULL);

7509

_tmp86_ = _tmp85_;

7510

_tmp87_ = sig;

7511

_tmp88_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp87_);

7512

_tmp89_ = _tmp88_;

7513

_tmp90_ = g_strconcat (_tmp86_, _tmp89_, NULL);

7514

_tmp91_ = _tmp90_;

7515

_tmp92_ = g_strconcat (_tmp91_, "_", NULL);

7516

_tmp93_ = _tmp92_;

7517

_tmp94_ = param;

7518

_tmp95_ = vala_symbol_get_name ((ValaSymbol*) _tmp94_);

7519

_tmp96_ = _tmp95_;

7520

_tmp97_ = g_strconcat (_tmp93_, _tmp96_, NULL);

7521

_tmp98_ = _tmp97_;

7522

_tmp99_ = vala_ccode_identifier_new (_tmp98_);

7523

_tmp100_ = _tmp99_;

7524

_tmp101_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, (ValaCCodeExpression*) _tmp100_);

7525

_tmp102_ = _tmp101_;

7526

vala_ccode_initializer_list_append (_tmp79_, (ValaCCodeExpression*) _tmp102_);

7527

_vala_ccode_node_unref0 (_tmp102_);

7528

_vala_ccode_node_unref0 (_tmp100_);

7529

_g_free0 (_tmp98_);

7530

_g_free0 (_tmp93_);

7531

_g_free0 (_tmp91_);

7532

_g_free0 (_tmp89_);

7533

_g_free0 (_tmp86_);

7534

_g_free0 (_tmp84_);

7535

_g_free0 (_tmp82_);

7536

_vala_ccode_node_unref0 (_cdecl_);

7537

_vala_ccode_node_unref0 (info);

7538

_vala_code_node_unref0 (param);

7539

}

7540

_vala_iterable_unref0 (_param_list);

7541

}

7542

_tmp103_ = args_info;

7543

_tmp104_ = vala_ccode_constant_new ("NULL");

7544

_tmp105_ = _tmp104_;

7545

vala_ccode_initializer_list_append (_tmp103_, (ValaCCodeExpression*) _tmp105_);

7546

_vala_ccode_node_unref0 (_tmp105_);

7547

_tmp106_ = vala_ccode_declaration_new ("const GDBusArgInfo * const");

7548

_cdecl_ = _tmp106_;

7549

_tmp107_ = _cdecl_;

7550

_tmp108_ = sym;

7551

_tmp109_ = vala_ccode_base_module_get_ccode_lower_case_prefix ((ValaSymbol*) _tmp108_);

7552

_tmp110_ = _tmp109_;

7553

_tmp111_ = g_strconcat ("_", _tmp110_, NULL);

7554

_tmp112_ = _tmp111_;

7555

_tmp113_ = g_strconcat (_tmp112_, "dbus_arg_info_", NULL);

7556

_tmp114_ = _tmp113_;

7557

_tmp115_ = sig;

7558

_tmp116_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp115_);

7559

_tmp117_ = _tmp116_;

7560

_tmp118_ = g_strconcat (_tmp114_, _tmp117_, NULL);

7561

_tmp119_ = _tmp118_;

7562

_tmp120_ = g_strconcat (_tmp119_, "[]", NULL);

7563

_tmp121_ = _tmp120_;

7564

_tmp122_ = args_info;

7565

_tmp123_ = vala_ccode_variable_declarator_new (_tmp121_, (ValaCCodeExpression*) _tmp122_, NULL);

7566

_tmp124_ = _tmp123_;

7567

vala_ccode_declaration_add_declarator (_tmp107_, (ValaCCodeDeclarator*) _tmp124_);

7568

_vala_ccode_node_unref0 (_tmp124_);

7569

_g_free0 (_tmp121_);

7570

_g_free0 (_tmp119_);

7571

_g_free0 (_tmp117_);

7572

_g_free0 (_tmp114_);

7573

_g_free0 (_tmp112_);

7574

_g_free0 (_tmp110_);

7575

_tmp125_ = _cdecl_;

7576

vala_ccode_declaration_set_modifiers (_tmp125_, VALA_CCODE_MODIFIERS_STATIC);

7577

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

7578

_tmp127_ = _cdecl_;

7579

vala_ccode_file_add_constant_declaration (_tmp126_, (ValaCCodeNode*) _tmp127_);

7580

_tmp128_ = vala_ccode_initializer_list_new ();

7581

info = _tmp128_;

7582

_tmp129_ = info;

7583

_tmp130_ = vala_ccode_constant_new ("-1");

7584

_tmp131_ = _tmp130_;

7585

vala_ccode_initializer_list_append (_tmp129_, (ValaCCodeExpression*) _tmp131_);

7586

_vala_ccode_node_unref0 (_tmp131_);

7587

_tmp132_ = info;

7588

_tmp133_ = sig;

7589

_tmp134_ = vala_gd_bus_module_get_dbus_name_for_member ((ValaSymbol*) _tmp133_);

7590

_tmp135_ = _tmp134_;

7591

_tmp136_ = g_strdup_printf ("\"%s\"", _tmp135_);

7592

_tmp137_ = _tmp136_;

7593

_tmp138_ = vala_ccode_constant_new (_tmp137_);

7594

_tmp139_ = _tmp138_;

7595

vala_ccode_initializer_list_append (_tmp132_, (ValaCCodeExpression*) _tmp139_);

7596

_vala_ccode_node_unref0 (_tmp139_);

7597

_g_free0 (_tmp137_);

7598

_g_free0 (_tmp135_);

7599

_tmp140_ = info;

7600

_tmp141_ = sym;

7601

_tmp142_ = vala_ccode_base_module_get_ccode_lower_case_prefix ((ValaSymbol*) _tmp141_);

7602

_tmp143_ = _tmp142_;

7603

_tmp144_ = g_strconcat ("_", _tmp143_, NULL);

7604

_tmp145_ = _tmp144_;

7605

_tmp146_ = g_strconcat (_tmp145_, "dbus_arg_info_", NULL);

7606

_tmp147_ = _tmp146_;

7607

_tmp148_ = sig;

7608

_tmp149_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp148_);

7609

_tmp150_ = _tmp149_;

7610

_tmp151_ = g_strconcat (_tmp147_, _tmp150_, NULL);

7611

_tmp152_ = _tmp151_;

7612

_tmp153_ = vala_ccode_identifier_new (_tmp152_);

7613

_tmp154_ = _tmp153_;

7614

_tmp155_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, (ValaCCodeExpression*) _tmp154_);

7615

_tmp156_ = _tmp155_;

7616

_tmp157_ = vala_ccode_cast_expression_new ((ValaCCodeExpression*) _tmp156_, "GDBusArgInfo **");

7617

_tmp158_ = _tmp157_;

7618

vala_ccode_initializer_list_append (_tmp140_, (ValaCCodeExpression*) _tmp158_);

7619

_vala_ccode_node_unref0 (_tmp158_);

7620

_vala_ccode_node_unref0 (_tmp156_);

7621

_vala_ccode_node_unref0 (_tmp154_);

7622

_g_free0 (_tmp152_);

7623

_g_free0 (_tmp150_);

7624

_g_free0 (_tmp147_);

7625

_g_free0 (_tmp145_);

7626

_g_free0 (_tmp143_);

7627

_tmp159_ = vala_ccode_declaration_new ("const GDBusSignalInfo");

7628

_vala_ccode_node_unref0 (_cdecl_);

7629

_cdecl_ = _tmp159_;

7630

_tmp160_ = _cdecl_;

7631

_tmp161_ = sym;

7632

_tmp162_ = vala_ccode_base_module_get_ccode_lower_case_prefix ((ValaSymbol*) _tmp161_);

7633

_tmp163_ = _tmp162_;

7634

_tmp164_ = g_strconcat ("_", _tmp163_, NULL);

7635

_tmp165_ = _tmp164_;

7636

_tmp166_ = g_strconcat (_tmp165_, "dbus_signal_info_", NULL);

7637

_tmp167_ = _tmp166_;

7638

_tmp168_ = sig;

7639

_tmp169_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp168_);

7640

_tmp170_ = _tmp169_;

7641

_tmp171_ = g_strconcat (_tmp167_, _tmp170_, NULL);

7642

_tmp172_ = _tmp171_;

7643

_tmp173_ = info;

7644

_tmp174_ = vala_ccode_variable_declarator_new (_tmp172_, (ValaCCodeExpression*) _tmp173_, NULL);

7645

_tmp175_ = _tmp174_;

7646

vala_ccode_declaration_add_declarator (_tmp160_, (ValaCCodeDeclarator*) _tmp175_);

7647

_vala_ccode_node_unref0 (_tmp175_);

7648

_g_free0 (_tmp172_);

7649

_g_free0 (_tmp170_);

7650

_g_free0 (_tmp167_);

7651

_g_free0 (_tmp165_);

7652

_g_free0 (_tmp163_);

7653

_tmp176_ = _cdecl_;

7654

vala_ccode_declaration_set_modifiers (_tmp176_, VALA_CCODE_MODIFIERS_STATIC);

7655

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

7656

_tmp178_ = _cdecl_;

7657

vala_ccode_file_add_constant_declaration (_tmp177_, (ValaCCodeNode*) _tmp178_);

7658

_tmp179_ = infos;

7659

_tmp180_ = sym;

7660

_tmp181_ = vala_ccode_base_module_get_ccode_lower_case_prefix ((ValaSymbol*) _tmp180_);

7661

_tmp182_ = _tmp181_;

7662

_tmp183_ = g_strconcat ("_", _tmp182_, NULL);

7663

_tmp184_ = _tmp183_;

7664

_tmp185_ = g_strconcat (_tmp184_, "dbus_signal_info_", NULL);

7665

_tmp186_ = _tmp185_;

7666

_tmp187_ = sig;

7667

_tmp188_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp187_);

7668

_tmp189_ = _tmp188_;

7669

_tmp190_ = g_strconcat (_tmp186_, _tmp189_, NULL);

7670

_tmp191_ = _tmp190_;

7671

_tmp192_ = vala_ccode_identifier_new (_tmp191_);

7672

_tmp193_ = _tmp192_;

7673

_tmp194_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, (ValaCCodeExpression*) _tmp193_);

7674

_tmp195_ = _tmp194_;

7675

vala_ccode_initializer_list_append (_tmp179_, (ValaCCodeExpression*) _tmp195_);

7676

_vala_ccode_node_unref0 (_tmp195_);

7677

_vala_ccode_node_unref0 (_tmp193_);

7678

_g_free0 (_tmp191_);

7679

_g_free0 (_tmp189_);

7680

_g_free0 (_tmp186_);

7681

_g_free0 (_tmp184_);

7682

_g_free0 (_tmp182_);

7683

_vala_ccode_node_unref0 (info);

7684

_vala_ccode_node_unref0 (_cdecl_);

7685

_vala_ccode_node_unref0 (args_info);

7686

_vala_code_node_unref0 (sig);

7687

}

7688

_vala_iterable_unref0 (_sig_list);

7689

}

7690

_tmp196_ = infos;

7691

_tmp197_ = vala_ccode_constant_new ("NULL");

7692

_tmp198_ = _tmp197_;

7693

vala_ccode_initializer_list_append (_tmp196_, (ValaCCodeExpression*) _tmp198_);

7694

_vala_ccode_node_unref0 (_tmp198_);

7695

_tmp199_ = vala_ccode_declaration_new ("const GDBusSignalInfo * const");

7696

_cdecl_ = _tmp199_;

7697

_tmp200_ = sym;

7698

_tmp201_ = vala_ccode_base_module_get_ccode_lower_case_prefix ((ValaSymbol*) _tmp200_);

7699

_tmp202_ = _tmp201_;

7700

_tmp203_ = g_strconcat ("_", _tmp202_, NULL);

7701

_tmp204_ = _tmp203_;

7702

_tmp205_ = g_strconcat (_tmp204_, "dbus_signal_info[]", NULL);

7703

_tmp206_ = _tmp205_;

7704

_tmp207_ = infos;

7705

_tmp208_ = vala_ccode_variable_declarator_new (_tmp206_, (ValaCCodeExpression*) _tmp207_, NULL);

7706

_tmp209_ = _tmp208_;

7707

vala_ccode_declaration_add_declarator (_cdecl_, (ValaCCodeDeclarator*) _tmp209_);

7708

_vala_ccode_node_unref0 (_tmp209_);

7709

_g_free0 (_tmp206_);

7710

_g_free0 (_tmp204_);

7711

_g_free0 (_tmp202_);

7712

vala_ccode_declaration_set_modifiers (_cdecl_, VALA_CCODE_MODIFIERS_STATIC);

7713

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

7714

vala_ccode_file_add_constant_declaration (_tmp210_, (ValaCCodeNode*) _cdecl_);

7715

_tmp211_ = sym;

7716

_tmp212_ = vala_ccode_base_module_get_ccode_lower_case_prefix ((ValaSymbol*) _tmp211_);

7717

_tmp213_ = _tmp212_;

7718

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

7719

_tmp215_ = _tmp214_;

7720

_tmp216_ = g_strconcat (_tmp215_, "dbus_signal_info", NULL);

7721

_tmp217_ = _tmp216_;

7722

_tmp218_ = vala_ccode_identifier_new (_tmp217_);

7723

_tmp219_ = (ValaCCodeExpression*) _tmp218_;

7724

_g_free0 (_tmp217_);

7725

_g_free0 (_tmp215_);

7726

_g_free0 (_tmp213_);

7727

result = _tmp219_;

7728

_vala_ccode_node_unref0 (_cdecl_);

7729

_vala_ccode_node_unref0 (infos);

7730

return result;

7731

}

7732

7733

7734

static ValaCCodeExpression* vala_gd_bus_server_module_get_property_info (ValaGDBusServerModule* self, ValaObjectTypeSymbol* sym) {

7735

ValaCCodeExpression* result = NULL;

7736

ValaCCodeInitializerList* _tmp0_;

7737

ValaCCodeInitializerList* infos;

7738

ValaCCodeInitializerList* _tmp113_;

7739

ValaCCodeConstant* _tmp114_;

7740

ValaCCodeConstant* _tmp115_;

7741

ValaCCodeDeclaration* _tmp116_;

7742

ValaCCodeDeclaration* _cdecl_;

7743

ValaObjectTypeSymbol* _tmp117_;

7744

gchar* _tmp118_ = NULL;

7745

gchar* _tmp119_;

7746

gchar* _tmp120_;

7747

gchar* _tmp121_;

7748

gchar* _tmp122_;

7749

gchar* _tmp123_;

7750

ValaCCodeInitializerList* _tmp124_;

7751

ValaCCodeVariableDeclarator* _tmp125_;

7752

ValaCCodeVariableDeclarator* _tmp126_;

7753

ValaCCodeFile* _tmp127_;

7754

ValaObjectTypeSymbol* _tmp128_;

7755

gchar* _tmp129_ = NULL;

7756

gchar* _tmp130_;

7757

gchar* _tmp131_;

7758

gchar* _tmp132_;

7759

gchar* _tmp133_;

7760

gchar* _tmp134_;

7761

ValaCCodeIdentifier* _tmp135_;

7762

ValaCCodeExpression* _tmp136_;

7763

g_return_val_if_fail (self != NULL, NULL);

7764

g_return_val_if_fail (sym != NULL, NULL);

7765

_tmp0_ = vala_ccode_initializer_list_new ();

7766

infos = _tmp0_;

7767

{

7768

ValaObjectTypeSymbol* _tmp1_;

7769

ValaList* _tmp2_ = NULL;

7770

ValaList* _prop_list;

7771

ValaList* _tmp3_;

7772

gint _tmp4_;

7773

gint _tmp5_;

7774

gint _prop_size;

7775

gint _prop_index;

7776

_tmp1_ = sym;

7777

_tmp2_ = vala_object_type_symbol_get_properties (_tmp1_);

7778

_prop_list = _tmp2_;

7779

_tmp3_ = _prop_list;

7780

_tmp4_ = vala_collection_get_size ((ValaCollection*) _tmp3_);

7781

_tmp5_ = _tmp4_;

7782

_prop_size = _tmp5_;

7783

_prop_index = -1;

7784

while (TRUE) {

7785

gint _tmp6_;

7786

gint _tmp7_;

7787

gint _tmp8_;

7788

ValaList* _tmp9_;

7789

gint _tmp10_;

7790

gpointer _tmp11_ = NULL;

7791

ValaProperty* prop;

7792

gboolean _tmp12_ = FALSE;

7793

gboolean _tmp13_ = FALSE;

7794

ValaProperty* _tmp14_;

7795

ValaMemberBinding _tmp15_;

7796

ValaMemberBinding _tmp16_;

7797

gboolean _tmp20_;

7798

gboolean _tmp24_;

7799

ValaProperty* _tmp25_;

7800

gboolean _tmp26_ = FALSE;

7801

ValaCCodeInitializerList* _tmp27_;

7802

ValaCCodeInitializerList* info;

7803

ValaCCodeInitializerList* _tmp28_;

7804

ValaCCodeConstant* _tmp29_;

7805

ValaCCodeConstant* _tmp30_;

7806

ValaCCodeInitializerList* _tmp31_;

7807

ValaProperty* _tmp32_;

7808

gchar* _tmp33_ = NULL;

7809

gchar* _tmp34_;

7810

gchar* _tmp35_ = NULL;

7811

gchar* _tmp36_;

7812

ValaCCodeConstant* _tmp37_;

7813

ValaCCodeConstant* _tmp38_;

7814

ValaCCodeInitializerList* _tmp39_;

7815

ValaProperty* _tmp40_;

7816

ValaDataType* _tmp41_;

7817

ValaDataType* _tmp42_;

7818

ValaProperty* _tmp43_;

7819

gchar* _tmp44_ = NULL;

7820

gchar* _tmp45_;

7821

gchar* _tmp46_ = NULL;

7822

gchar* _tmp47_;

7823

ValaCCodeConstant* _tmp48_;

7824

ValaCCodeConstant* _tmp49_;

7825

gboolean _tmp50_ = FALSE;

7826

ValaProperty* _tmp51_;

7827

ValaPropertyAccessor* _tmp52_;

7828

ValaPropertyAccessor* _tmp53_;

7829

gboolean _tmp57_;

7830

ValaCCodeDeclaration* _tmp76_;

7831

ValaCCodeDeclaration* _cdecl_;

7832

ValaCCodeDeclaration* _tmp77_;

7833

ValaObjectTypeSymbol* _tmp78_;

7834

gchar* _tmp79_ = NULL;

7835

gchar* _tmp80_;

7836

gchar* _tmp81_;

7837

gchar* _tmp82_;

7838

gchar* _tmp83_;

7839

gchar* _tmp84_;

7840

ValaProperty* _tmp85_;

7841

const gchar* _tmp86_;

7842

const gchar* _tmp87_;

7843

gchar* _tmp88_;

7844

gchar* _tmp89_;

7845

ValaCCodeInitializerList* _tmp90_;

7846

ValaCCodeVariableDeclarator* _tmp91_;

7847

ValaCCodeVariableDeclarator* _tmp92_;

7848

ValaCCodeDeclaration* _tmp93_;

7849

ValaCCodeFile* _tmp94_;

7850

ValaCCodeDeclaration* _tmp95_;

7851

ValaCCodeInitializerList* _tmp96_;

7852

ValaObjectTypeSymbol* _tmp97_;

7853

gchar* _tmp98_ = NULL;

7854

gchar* _tmp99_;

7855

gchar* _tmp100_;

7856

gchar* _tmp101_;

7857

gchar* _tmp102_;

7858

gchar* _tmp103_;

7859

ValaProperty* _tmp104_;

7860

const gchar* _tmp105_;

7861

const gchar* _tmp106_;

7862

gchar* _tmp107_;

7863

gchar* _tmp108_;

7864

ValaCCodeIdentifier* _tmp109_;

7865

ValaCCodeIdentifier* _tmp110_;

7866

ValaCCodeUnaryExpression* _tmp111_;

7867

ValaCCodeUnaryExpression* _tmp112_;

7868

_tmp6_ = _prop_index;

7869

_prop_index = _tmp6_ + 1;

7870

_tmp7_ = _prop_index;

7871

_tmp8_ = _prop_size;

7872

if (!(_tmp7_ < _tmp8_)) {

7873

break;

7874

}

7875

_tmp9_ = _prop_list;

7876

_tmp10_ = _prop_index;

7877

_tmp11_ = vala_list_get (_tmp9_, _tmp10_);

7878

prop = (ValaProperty*) _tmp11_;

7879

_tmp14_ = prop;

7880

_tmp15_ = vala_property_get_binding (_tmp14_);

7881

_tmp16_ = _tmp15_;

7882

if (_tmp16_ != VALA_MEMBER_BINDING_INSTANCE) {

7883

_tmp13_ = TRUE;

7884

} else {

7885

ValaProperty* _tmp17_;

7886

gboolean _tmp18_;

7887

gboolean _tmp19_;

7888

_tmp17_ = prop;

7889

_tmp18_ = vala_property_get_overrides (_tmp17_);

7890

_tmp19_ = _tmp18_;

7891

_tmp13_ = _tmp19_;

7892

}

7893

_tmp20_ = _tmp13_;

7894

if (_tmp20_) {

7895

_tmp12_ = TRUE;

7896

} else {

7897

ValaProperty* _tmp21_;

7898

ValaSymbolAccessibility _tmp22_;

7899

ValaSymbolAccessibility _tmp23_;

7900

_tmp21_ = prop;

7901

_tmp22_ = vala_symbol_get_access ((ValaSymbol*) _tmp21_);

7902

_tmp23_ = _tmp22_;

7903

_tmp12_ = _tmp23_ != VALA_SYMBOL_ACCESSIBILITY_PUBLIC;

7904

}

7905

_tmp24_ = _tmp12_;

7906

if (_tmp24_) {

7907

_vala_code_node_unref0 (prop);

7908

continue;

7909

}

7910

_tmp25_ = prop;

7911

_tmp26_ = vala_gd_bus_server_module_is_dbus_visible ((ValaCodeNode*) _tmp25_);

7912

if (!_tmp26_) {

7913

_vala_code_node_unref0 (prop);

7914

continue;

7915

}

7916

_tmp27_ = vala_ccode_initializer_list_new ();

7917

info = _tmp27_;

7918

_tmp28_ = info;

7919

_tmp29_ = vala_ccode_constant_new ("-1");

7920

_tmp30_ = _tmp29_;

7921

vala_ccode_initializer_list_append (_tmp28_, (ValaCCodeExpression*) _tmp30_);

7922

_vala_ccode_node_unref0 (_tmp30_);

7923

_tmp31_ = info;

7924

_tmp32_ = prop;

7925

_tmp33_ = vala_gd_bus_module_get_dbus_name_for_member ((ValaSymbol*) _tmp32_);

7926

_tmp34_ = _tmp33_;

7927

_tmp35_ = g_strdup_printf ("\"%s\"", _tmp34_);

7928

_tmp36_ = _tmp35_;

7929

_tmp37_ = vala_ccode_constant_new (_tmp36_);

7930

_tmp38_ = _tmp37_;

7931

vala_ccode_initializer_list_append (_tmp31_, (ValaCCodeExpression*) _tmp38_);

7932

_vala_ccode_node_unref0 (_tmp38_);

7933

_g_free0 (_tmp36_);

7934

_g_free0 (_tmp34_);

7935

_tmp39_ = info;

7936

_tmp40_ = prop;

7937

_tmp41_ = vala_property_get_property_type (_tmp40_);

7938

_tmp42_ = _tmp41_;

7939

_tmp43_ = prop;

7940

_tmp44_ = vala_gvariant_module_get_type_signature (_tmp42_, (ValaSymbol*) _tmp43_);

7941

_tmp45_ = _tmp44_;

7942

_tmp46_ = g_strdup_printf ("\"%s\"", _tmp45_);

7943

_tmp47_ = _tmp46_;

7944

_tmp48_ = vala_ccode_constant_new (_tmp47_);

7945

_tmp49_ = _tmp48_;

7946

vala_ccode_initializer_list_append (_tmp39_, (ValaCCodeExpression*) _tmp49_);

7947

_vala_ccode_node_unref0 (_tmp49_);

7948

_g_free0 (_tmp47_);

7949

_g_free0 (_tmp45_);

7950

_tmp51_ = prop;

7951

_tmp52_ = vala_property_get_get_accessor (_tmp51_);

7952

_tmp53_ = _tmp52_;

7953

if (_tmp53_ != NULL) {

7954

ValaProperty* _tmp54_;

7955

ValaPropertyAccessor* _tmp55_;

7956

ValaPropertyAccessor* _tmp56_;

7957

_tmp54_ = prop;

7958

_tmp55_ = vala_property_get_set_accessor (_tmp54_);

7959

_tmp56_ = _tmp55_;

7960

_tmp50_ = _tmp56_ != NULL;

7961

} else {

7962

_tmp50_ = FALSE;

7963

}

7964

_tmp57_ = _tmp50_;

7965

if (_tmp57_) {

7966

ValaCCodeInitializerList* _tmp58_;

7967

ValaCCodeConstant* _tmp59_;

7968

ValaCCodeConstant* _tmp60_;

7969

_tmp58_ = info;

7970

_tmp59_ = vala_ccode_constant_new ("G_DBUS_PROPERTY_INFO_FLAGS_READABLE | G_DBUS_PROPERTY_INFO_FLAGS_WRITA" \

7971

"BLE");

7972

_tmp60_ = _tmp59_;

7973

vala_ccode_initializer_list_append (_tmp58_, (ValaCCodeExpression*) _tmp60_);

7974

_vala_ccode_node_unref0 (_tmp60_);

7975

} else {

7976

ValaProperty* _tmp61_;

7977

ValaPropertyAccessor* _tmp62_;

7978

ValaPropertyAccessor* _tmp63_;

7979

_tmp61_ = prop;

7980

_tmp62_ = vala_property_get_get_accessor (_tmp61_);

7981

_tmp63_ = _tmp62_;

7982

if (_tmp63_ != NULL) {

7983

ValaCCodeInitializerList* _tmp64_;

7984

ValaCCodeConstant* _tmp65_;

7985

ValaCCodeConstant* _tmp66_;

7986

_tmp64_ = info;

7987

_tmp65_ = vala_ccode_constant_new ("G_DBUS_PROPERTY_INFO_FLAGS_READABLE");

7988

_tmp66_ = _tmp65_;

7989

vala_ccode_initializer_list_append (_tmp64_, (ValaCCodeExpression*) _tmp66_);

7990

_vala_ccode_node_unref0 (_tmp66_);

7991

} else {

7992

ValaProperty* _tmp67_;

7993

ValaPropertyAccessor* _tmp68_;

7994

ValaPropertyAccessor* _tmp69_;

7995

_tmp67_ = prop;

7996

_tmp68_ = vala_property_get_set_accessor (_tmp67_);

7997

_tmp69_ = _tmp68_;

7998

if (_tmp69_ != NULL) {

7999

ValaCCodeInitializerList* _tmp70_;

8000

ValaCCodeConstant* _tmp71_;

8001

ValaCCodeConstant* _tmp72_;

8002

_tmp70_ = info;

8003

_tmp71_ = vala_ccode_constant_new ("G_DBUS_PROPERTY_INFO_FLAGS_WRITABLE");

8004

_tmp72_ = _tmp71_;

8005

vala_ccode_initializer_list_append (_tmp70_, (ValaCCodeExpression*) _tmp72_);

8006

_vala_ccode_node_unref0 (_tmp72_);

8007

} else {

8008

ValaCCodeInitializerList* _tmp73_;

8009

ValaCCodeConstant* _tmp74_;

8010

ValaCCodeConstant* _tmp75_;

8011

_tmp73_ = info;

8012

_tmp74_ = vala_ccode_constant_new ("G_DBUS_PROPERTY_INFO_FLAGS_NONE");

8013

_tmp75_ = _tmp74_;

8014

vala_ccode_initializer_list_append (_tmp73_, (ValaCCodeExpression*) _tmp75_);

8015

_vala_ccode_node_unref0 (_tmp75_);

8016

}

8017

}

8018

}

8019

_tmp76_ = vala_ccode_declaration_new ("const GDBusPropertyInfo");

8020

_cdecl_ = _tmp76_;

8021

_tmp77_ = _cdecl_;

8022

_tmp78_ = sym;

8023

_tmp79_ = vala_ccode_base_module_get_ccode_lower_case_prefix ((ValaSymbol*) _tmp78_);

8024

_tmp80_ = _tmp79_;

8025

_tmp81_ = g_strconcat ("_", _tmp80_, NULL);

8026

_tmp82_ = _tmp81_;

8027

_tmp83_ = g_strconcat (_tmp82_, "dbus_property_info_", NULL);

8028

_tmp84_ = _tmp83_;

8029

_tmp85_ = prop;

8030

_tmp86_ = vala_symbol_get_name ((ValaSymbol*) _tmp85_);

8031

_tmp87_ = _tmp86_;

8032

_tmp88_ = g_strconcat (_tmp84_, _tmp87_, NULL);

8033

_tmp89_ = _tmp88_;

8034

_tmp90_ = info;

8035

_tmp91_ = vala_ccode_variable_declarator_new (_tmp89_, (ValaCCodeExpression*) _tmp90_, NULL);

8036

_tmp92_ = _tmp91_;

8037

vala_ccode_declaration_add_declarator (_tmp77_, (ValaCCodeDeclarator*) _tmp92_);

8038

_vala_ccode_node_unref0 (_tmp92_);

8039

_g_free0 (_tmp89_);

8040

_g_free0 (_tmp84_);

8041

_g_free0 (_tmp82_);

8042

_g_free0 (_tmp80_);

8043

_tmp93_ = _cdecl_;

8044

vala_ccode_declaration_set_modifiers (_tmp93_, VALA_CCODE_MODIFIERS_STATIC);

8045

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

8046

_tmp95_ = _cdecl_;

8047

vala_ccode_file_add_constant_declaration (_tmp94_, (ValaCCodeNode*) _tmp95_);

8048

_tmp96_ = infos;

8049

_tmp97_ = sym;

8050

_tmp98_ = vala_ccode_base_module_get_ccode_lower_case_prefix ((ValaSymbol*) _tmp97_);

8051

_tmp99_ = _tmp98_;

8052

_tmp100_ = g_strconcat ("_", _tmp99_, NULL);

8053

_tmp101_ = _tmp100_;

8054

_tmp102_ = g_strconcat (_tmp101_, "dbus_property_info_", NULL);

8055

_tmp103_ = _tmp102_;

8056

_tmp104_ = prop;

8057

_tmp105_ = vala_symbol_get_name ((ValaSymbol*) _tmp104_);

8058

_tmp106_ = _tmp105_;

8059

_tmp107_ = g_strconcat (_tmp103_, _tmp106_, NULL);

8060

_tmp108_ = _tmp107_;

8061

_tmp109_ = vala_ccode_identifier_new (_tmp108_);

8062

_tmp110_ = _tmp109_;

8063

_tmp111_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, (ValaCCodeExpression*) _tmp110_);

8064

_tmp112_ = _tmp111_;

8065

vala_ccode_initializer_list_append (_tmp96_, (ValaCCodeExpression*) _tmp112_);

8066

_vala_ccode_node_unref0 (_tmp112_);

8067

_vala_ccode_node_unref0 (_tmp110_);

8068

_g_free0 (_tmp108_);

8069

_g_free0 (_tmp103_);

8070

_g_free0 (_tmp101_);

8071

_g_free0 (_tmp99_);

8072

_vala_ccode_node_unref0 (_cdecl_);

8073

_vala_ccode_node_unref0 (info);

8074

_vala_code_node_unref0 (prop);

8075

}

8076

_vala_iterable_unref0 (_prop_list);

8077

}

8078

_tmp113_ = infos;

8079

_tmp114_ = vala_ccode_constant_new ("NULL");

8080

_tmp115_ = _tmp114_;

8081

vala_ccode_initializer_list_append (_tmp113_, (ValaCCodeExpression*) _tmp115_);

8082

_vala_ccode_node_unref0 (_tmp115_);

8083

_tmp116_ = vala_ccode_declaration_new ("const GDBusPropertyInfo * const");

8084

_cdecl_ = _tmp116_;

8085

_tmp117_ = sym;

8086

_tmp118_ = vala_ccode_base_module_get_ccode_lower_case_prefix ((ValaSymbol*) _tmp117_);

8087

_tmp119_ = _tmp118_;

8088

_tmp120_ = g_strconcat ("_", _tmp119_, NULL);

8089

_tmp121_ = _tmp120_;

8090

_tmp122_ = g_strconcat (_tmp121_, "dbus_property_info[]", NULL);

8091

_tmp123_ = _tmp122_;

8092

_tmp124_ = infos;

8093

_tmp125_ = vala_ccode_variable_declarator_new (_tmp123_, (ValaCCodeExpression*) _tmp124_, NULL);

8094

_tmp126_ = _tmp125_;

8095

vala_ccode_declaration_add_declarator (_cdecl_, (ValaCCodeDeclarator*) _tmp126_);

8096

_vala_ccode_node_unref0 (_tmp126_);

8097

_g_free0 (_tmp123_);

8098

_g_free0 (_tmp121_);

8099

_g_free0 (_tmp119_);

8100

vala_ccode_declaration_set_modifiers (_cdecl_, VALA_CCODE_MODIFIERS_STATIC);

8101

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

8102

vala_ccode_file_add_constant_declaration (_tmp127_, (ValaCCodeNode*) _cdecl_);

8103

_tmp128_ = sym;

8104

_tmp129_ = vala_ccode_base_module_get_ccode_lower_case_prefix ((ValaSymbol*) _tmp128_);

8105

_tmp130_ = _tmp129_;

8106

_tmp131_ = g_strconcat ("_", _tmp130_, NULL);

8107

_tmp132_ = _tmp131_;

8108

_tmp133_ = g_strconcat (_tmp132_, "dbus_property_info", NULL);

8109

_tmp134_ = _tmp133_;

8110

_tmp135_ = vala_ccode_identifier_new (_tmp134_);

8111

_tmp136_ = (ValaCCodeExpression*) _tmp135_;

8112

_g_free0 (_tmp134_);

8113

_g_free0 (_tmp132_);

8114

_g_free0 (_tmp130_);

8115

result = _tmp136_;

8116

_vala_ccode_node_unref0 (_cdecl_);

8117

_vala_ccode_node_unref0 (infos);

8118

return result;

8119

}

8120

8121

8122

static ValaCCodeExpression* vala_gd_bus_server_module_get_interface_info (ValaGDBusServerModule* self, ValaObjectTypeSymbol* sym) {

8123

ValaCCodeExpression* result = NULL;

8124

ValaCCodeInitializerList* _tmp0_;

8125

ValaCCodeInitializerList* info;

8126

ValaCCodeConstant* _tmp1_;

8127

ValaCCodeConstant* _tmp2_;

8128

ValaObjectTypeSymbol* _tmp3_;

8129

gchar* _tmp4_ = NULL;

8130

gchar* _tmp5_;

8131

gchar* _tmp6_ = NULL;

8132

gchar* _tmp7_;

8133

ValaCCodeConstant* _tmp8_;

8134

ValaCCodeConstant* _tmp9_;

8135

ValaObjectTypeSymbol* _tmp10_;

8136

ValaCCodeExpression* _tmp11_ = NULL;

8137

ValaCCodeExpression* _tmp12_;

8138

ValaCCodeUnaryExpression* _tmp13_;

8139

ValaCCodeUnaryExpression* _tmp14_;

8140

ValaCCodeCastExpression* _tmp15_;

8141

ValaCCodeCastExpression* _tmp16_;

8142

ValaObjectTypeSymbol* _tmp17_;

8143

ValaCCodeExpression* _tmp18_ = NULL;

8144

ValaCCodeExpression* _tmp19_;

8145

ValaCCodeUnaryExpression* _tmp20_;

8146

ValaCCodeUnaryExpression* _tmp21_;

8147

ValaCCodeCastExpression* _tmp22_;

8148

ValaCCodeCastExpression* _tmp23_;

8149

ValaObjectTypeSymbol* _tmp24_;

8150

ValaCCodeExpression* _tmp25_ = NULL;

8151

ValaCCodeExpression* _tmp26_;

8152

ValaCCodeUnaryExpression* _tmp27_;

8153

ValaCCodeUnaryExpression* _tmp28_;

8154

ValaCCodeCastExpression* _tmp29_;

8155

ValaCCodeCastExpression* _tmp30_;

8156

ValaCCodeDeclaration* _tmp31_;

8157

ValaCCodeDeclaration* _cdecl_;

8158

ValaObjectTypeSymbol* _tmp32_;

8159

gchar* _tmp33_ = NULL;

8160

gchar* _tmp34_;

8161

gchar* _tmp35_;

8162

gchar* _tmp36_;

8163

gchar* _tmp37_;

8164

gchar* _tmp38_;

8165

ValaCCodeVariableDeclarator* _tmp39_;

8166

ValaCCodeVariableDeclarator* _tmp40_;

8167

ValaCCodeFile* _tmp41_;

8168

ValaObjectTypeSymbol* _tmp42_;

8169

gchar* _tmp43_ = NULL;

8170

gchar* _tmp44_;

8171

gchar* _tmp45_;

8172

gchar* _tmp46_;

8173

gchar* _tmp47_;

8174

gchar* _tmp48_;

8175

ValaCCodeIdentifier* _tmp49_;

8176

ValaCCodeExpression* _tmp50_;

8177

g_return_val_if_fail (self != NULL, NULL);

8178

g_return_val_if_fail (sym != NULL, NULL);

8179

_tmp0_ = vala_ccode_initializer_list_new ();

8180

info = _tmp0_;

8181

_tmp1_ = vala_ccode_constant_new ("-1");

8182

_tmp2_ = _tmp1_;

8183

vala_ccode_initializer_list_append (info, (ValaCCodeExpression*) _tmp2_);

8184

_vala_ccode_node_unref0 (_tmp2_);

8185

_tmp3_ = sym;

8186

_tmp4_ = vala_gd_bus_module_get_dbus_name ((ValaTypeSymbol*) _tmp3_);

8187

_tmp5_ = _tmp4_;

8188

_tmp6_ = g_strdup_printf ("\"%s\"", _tmp5_);

8189

_tmp7_ = _tmp6_;

8190

_tmp8_ = vala_ccode_constant_new (_tmp7_);

8191

_tmp9_ = _tmp8_;

8192

vala_ccode_initializer_list_append (info, (ValaCCodeExpression*) _tmp9_);

8193

_vala_ccode_node_unref0 (_tmp9_);

8194

_g_free0 (_tmp7_);

8195

_g_free0 (_tmp5_);

8196

_tmp10_ = sym;

8197

_tmp11_ = vala_gd_bus_server_module_get_method_info (self, _tmp10_);

8198

_tmp12_ = _tmp11_;

8199

_tmp13_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, _tmp12_);

8200

_tmp14_ = _tmp13_;

8201

_tmp15_ = vala_ccode_cast_expression_new ((ValaCCodeExpression*) _tmp14_, "GDBusMethodInfo **");

8202

_tmp16_ = _tmp15_;

8203

vala_ccode_initializer_list_append (info, (ValaCCodeExpression*) _tmp16_);

8204

_vala_ccode_node_unref0 (_tmp16_);

8205

_vala_ccode_node_unref0 (_tmp14_);

8206

_vala_ccode_node_unref0 (_tmp12_);

8207

_tmp17_ = sym;

8208

_tmp18_ = vala_gd_bus_server_module_get_signal_info (self, _tmp17_);

8209

_tmp19_ = _tmp18_;

8210

_tmp20_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, _tmp19_);

8211

_tmp21_ = _tmp20_;

8212

_tmp22_ = vala_ccode_cast_expression_new ((ValaCCodeExpression*) _tmp21_, "GDBusSignalInfo **");

8213

_tmp23_ = _tmp22_;

8214

vala_ccode_initializer_list_append (info, (ValaCCodeExpression*) _tmp23_);

8215

_vala_ccode_node_unref0 (_tmp23_);

8216

_vala_ccode_node_unref0 (_tmp21_);

8217

_vala_ccode_node_unref0 (_tmp19_);

8218

_tmp24_ = sym;

8219

_tmp25_ = vala_gd_bus_server_module_get_property_info (self, _tmp24_);

8220

_tmp26_ = _tmp25_;

8221

_tmp27_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, _tmp26_);

8222

_tmp28_ = _tmp27_;

8223

_tmp29_ = vala_ccode_cast_expression_new ((ValaCCodeExpression*) _tmp28_, "GDBusPropertyInfo **");

8224

_tmp30_ = _tmp29_;

8225

vala_ccode_initializer_list_append (info, (ValaCCodeExpression*) _tmp30_);

8226

_vala_ccode_node_unref0 (_tmp30_);

8227

_vala_ccode_node_unref0 (_tmp28_);

8228

_vala_ccode_node_unref0 (_tmp26_);

8229

_tmp31_ = vala_ccode_declaration_new ("const GDBusInterfaceInfo");

8230

_cdecl_ = _tmp31_;

8231

_tmp32_ = sym;

8232

_tmp33_ = vala_ccode_base_module_get_ccode_lower_case_prefix ((ValaSymbol*) _tmp32_);

8233

_tmp34_ = _tmp33_;

8234

_tmp35_ = g_strconcat ("_", _tmp34_, NULL);

8235

_tmp36_ = _tmp35_;

8236

_tmp37_ = g_strconcat (_tmp36_, "dbus_interface_info", NULL);

8237

_tmp38_ = _tmp37_;

8238

_tmp39_ = vala_ccode_variable_declarator_new (_tmp38_, (ValaCCodeExpression*) info, NULL);

8239

_tmp40_ = _tmp39_;

8240

vala_ccode_declaration_add_declarator (_cdecl_, (ValaCCodeDeclarator*) _tmp40_);

8241

_vala_ccode_node_unref0 (_tmp40_);

8242

_g_free0 (_tmp38_);

8243

_g_free0 (_tmp36_);

8244

_g_free0 (_tmp34_);

8245

vala_ccode_declaration_set_modifiers (_cdecl_, VALA_CCODE_MODIFIERS_STATIC);

8246

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

8247

vala_ccode_file_add_constant_declaration (_tmp41_, (ValaCCodeNode*) _cdecl_);

8248

_tmp42_ = sym;

8249

_tmp43_ = vala_ccode_base_module_get_ccode_lower_case_prefix ((ValaSymbol*) _tmp42_);

8250

_tmp44_ = _tmp43_;

8251

_tmp45_ = g_strconcat ("_", _tmp44_, NULL);

8252

_tmp46_ = _tmp45_;

8253

_tmp47_ = g_strconcat (_tmp46_, "dbus_interface_info", NULL);

8254

_tmp48_ = _tmp47_;

8255

_tmp49_ = vala_ccode_identifier_new (_tmp48_);

8256

_tmp50_ = (ValaCCodeExpression*) _tmp49_;

8257

_g_free0 (_tmp48_);

8258

_g_free0 (_tmp46_);

8259

_g_free0 (_tmp44_);

8260

result = _tmp50_;

8261

_vala_ccode_node_unref0 (_cdecl_);

8262

_vala_ccode_node_unref0 (info);

8263

return result;

8264

}

8265

8266

8267

static ValaCCodeExpression* vala_gd_bus_server_module_get_interface_vtable (ValaGDBusServerModule* self, ValaObjectTypeSymbol* sym) {

8268

ValaCCodeExpression* result = NULL;

8269

ValaCCodeInitializerList* _tmp0_;

8270

ValaCCodeInitializerList* vtable;

8271

ValaObjectTypeSymbol* _tmp1_;

8272

gchar* _tmp2_ = NULL;

8273

gchar* _tmp3_;

8274

gchar* _tmp4_;

8275

gchar* _tmp5_;

8276

ValaCCodeIdentifier* _tmp6_;

8277

ValaCCodeIdentifier* _tmp7_;

8278

ValaObjectTypeSymbol* _tmp8_;

8279

gchar* _tmp9_ = NULL;

8280

gchar* _tmp10_;

8281

gchar* _tmp11_;

8282

gchar* _tmp12_;

8283

ValaCCodeIdentifier* _tmp13_;

8284

ValaCCodeIdentifier* _tmp14_;

8285

ValaObjectTypeSymbol* _tmp15_;

8286

gchar* _tmp16_ = NULL;

8287

gchar* _tmp17_;

8288

gchar* _tmp18_;

8289

gchar* _tmp19_;

8290

ValaCCodeIdentifier* _tmp20_;

8291

ValaCCodeIdentifier* _tmp21_;

8292

ValaObjectTypeSymbol* _tmp22_;

8293

ValaObjectTypeSymbol* _tmp23_;

8294

ValaObjectTypeSymbol* _tmp24_;

8295

ValaCCodeDeclaration* _tmp25_;

8296

ValaCCodeDeclaration* _cdecl_;

8297

ValaObjectTypeSymbol* _tmp26_;

8298

gchar* _tmp27_ = NULL;

8299

gchar* _tmp28_;

8300

gchar* _tmp29_;

8301

gchar* _tmp30_;

8302

gchar* _tmp31_;

8303

gchar* _tmp32_;

8304

ValaCCodeVariableDeclarator* _tmp33_;

8305

ValaCCodeVariableDeclarator* _tmp34_;

8306

ValaCCodeFile* _tmp35_;

8307

ValaObjectTypeSymbol* _tmp36_;

8308

gchar* _tmp37_ = NULL;

8309

gchar* _tmp38_;

8310

gchar* _tmp39_;

8311

gchar* _tmp40_;

8312

gchar* _tmp41_;

8313

gchar* _tmp42_;

8314

ValaCCodeIdentifier* _tmp43_;

8315

ValaCCodeExpression* _tmp44_;

8316

g_return_val_if_fail (self != NULL, NULL);

8317

g_return_val_if_fail (sym != NULL, NULL);

8318

_tmp0_ = vala_ccode_initializer_list_new ();

8319

vtable = _tmp0_;

8320

_tmp1_ = sym;

8321

_tmp2_ = vala_ccode_base_module_get_ccode_lower_case_prefix ((ValaSymbol*) _tmp1_);

8322

_tmp3_ = _tmp2_;

8323

_tmp4_ = g_strconcat (_tmp3_, "dbus_interface_method_call", NULL);

8324

_tmp5_ = _tmp4_;

8325

_tmp6_ = vala_ccode_identifier_new (_tmp5_);

8326

_tmp7_ = _tmp6_;

8327

vala_ccode_initializer_list_append (vtable, (ValaCCodeExpression*) _tmp7_);

8328

_vala_ccode_node_unref0 (_tmp7_);

8329

_g_free0 (_tmp5_);

8330

_g_free0 (_tmp3_);

8331

_tmp8_ = sym;

8332

_tmp9_ = vala_ccode_base_module_get_ccode_lower_case_prefix ((ValaSymbol*) _tmp8_);

8333

_tmp10_ = _tmp9_;

8334

_tmp11_ = g_strconcat (_tmp10_, "dbus_interface_get_property", NULL);

8335

_tmp12_ = _tmp11_;

8336

_tmp13_ = vala_ccode_identifier_new (_tmp12_);

8337

_tmp14_ = _tmp13_;

8338

vala_ccode_initializer_list_append (vtable, (ValaCCodeExpression*) _tmp14_);

8339

_vala_ccode_node_unref0 (_tmp14_);

8340

_g_free0 (_tmp12_);

8341

_g_free0 (_tmp10_);

8342

_tmp15_ = sym;

8343

_tmp16_ = vala_ccode_base_module_get_ccode_lower_case_prefix ((ValaSymbol*) _tmp15_);

8344

_tmp17_ = _tmp16_;

8345

_tmp18_ = g_strconcat (_tmp17_, "dbus_interface_set_property", NULL);

8346

_tmp19_ = _tmp18_;

8347

_tmp20_ = vala_ccode_identifier_new (_tmp19_);

8348

_tmp21_ = _tmp20_;

8349

vala_ccode_initializer_list_append (vtable, (ValaCCodeExpression*) _tmp21_);

8350

_vala_ccode_node_unref0 (_tmp21_);

8351

_g_free0 (_tmp19_);

8352

_g_free0 (_tmp17_);

8353

_tmp22_ = sym;

8354

vala_gd_bus_server_module_generate_interface_method_call_function (self, _tmp22_);

8355

_tmp23_ = sym;

8356

vala_gd_bus_server_module_generate_interface_get_property_function (self, _tmp23_);

8357

_tmp24_ = sym;

8358

vala_gd_bus_server_module_generate_interface_set_property_function (self, _tmp24_);

8359

_tmp25_ = vala_ccode_declaration_new ("const GDBusInterfaceVTable");

8360

_cdecl_ = _tmp25_;

8361

_tmp26_ = sym;

8362

_tmp27_ = vala_ccode_base_module_get_ccode_lower_case_prefix ((ValaSymbol*) _tmp26_);

8363

_tmp28_ = _tmp27_;

8364

_tmp29_ = g_strconcat ("_", _tmp28_, NULL);

8365

_tmp30_ = _tmp29_;

8366

_tmp31_ = g_strconcat (_tmp30_, "dbus_interface_vtable", NULL);

8367

_tmp32_ = _tmp31_;

8368

_tmp33_ = vala_ccode_variable_declarator_new (_tmp32_, (ValaCCodeExpression*) vtable, NULL);

8369

_tmp34_ = _tmp33_;

8370

vala_ccode_declaration_add_declarator (_cdecl_, (ValaCCodeDeclarator*) _tmp34_);

8371

_vala_ccode_node_unref0 (_tmp34_);

8372

_g_free0 (_tmp32_);

8373

_g_free0 (_tmp30_);

8374

_g_free0 (_tmp28_);

8375

vala_ccode_declaration_set_modifiers (_cdecl_, VALA_CCODE_MODIFIERS_STATIC);

8376

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

8377

vala_ccode_file_add_constant_declaration (_tmp35_, (ValaCCodeNode*) _cdecl_);

8378

_tmp36_ = sym;

8379

_tmp37_ = vala_ccode_base_module_get_ccode_lower_case_prefix ((ValaSymbol*) _tmp36_);

8380

_tmp38_ = _tmp37_;

8381

_tmp39_ = g_strconcat ("_", _tmp38_, NULL);

8382

_tmp40_ = _tmp39_;

8383

_tmp41_ = g_strconcat (_tmp40_, "dbus_interface_vtable", NULL);

8384

_tmp42_ = _tmp41_;

8385

_tmp43_ = vala_ccode_identifier_new (_tmp42_);

8386

_tmp44_ = (ValaCCodeExpression*) _tmp43_;

8387

_g_free0 (_tmp42_);

8388

_g_free0 (_tmp40_);

8389

_g_free0 (_tmp38_);

8390

result = _tmp44_;

8391

_vala_ccode_node_unref0 (_cdecl_);

8392

_vala_ccode_node_unref0 (vtable);

8393

return result;

8394

}

8395

8396

8397

static gchar* vala_gd_bus_server_module_generate_register_object_function (ValaGDBusServerModule* self) {

8398

gchar* result = NULL;

8399

gchar* _tmp0_;

8400

gchar* register_object_func;

8401

const gchar* _tmp1_;

8402

gboolean _tmp2_ = FALSE;

8403

ValaCCodeFile* _tmp3_;

8404

const gchar* _tmp4_;

8405

ValaCCodeFunction* _tmp5_;

8406

ValaCCodeFunction* function;

8407

ValaCCodeFunction* _tmp6_;

8408

ValaCCodeFunction* _tmp7_;

8409

ValaCCodeParameter* _tmp8_;

8410

ValaCCodeParameter* _tmp9_;

8411

ValaCCodeFunction* _tmp10_;

8412

ValaCCodeParameter* _tmp11_;

8413

ValaCCodeParameter* _tmp12_;

8414

ValaCCodeFunction* _tmp13_;

8415

ValaCCodeParameter* _tmp14_;

8416

ValaCCodeParameter* _tmp15_;

8417

ValaCCodeFunction* _tmp16_;

8418

ValaCCodeParameter* _tmp17_;

8419

ValaCCodeParameter* _tmp18_;

8420

ValaCCodeFunction* _tmp19_;

8421

ValaCCodeParameter* _tmp20_;

8422

ValaCCodeParameter* _tmp21_;

8423

ValaCCodeFunction* _tmp22_;

8424

ValaCCodeIdentifier* _tmp23_;

8425

ValaCCodeIdentifier* _tmp24_;

8426

ValaCCodeFunctionCall* _tmp25_;

8427

ValaCCodeFunctionCall* _tmp26_;

8428

ValaCCodeFunctionCall* quark;

8429

ValaCCodeFunctionCall* _tmp27_;

8430

ValaCCodeConstant* _tmp28_;

8431

ValaCCodeConstant* _tmp29_;

8432

ValaCCodeIdentifier* _tmp30_;

8433

ValaCCodeIdentifier* _tmp31_;

8434

ValaCCodeFunctionCall* _tmp32_;

8435

ValaCCodeFunctionCall* _tmp33_;

8436

ValaCCodeFunctionCall* get_qdata;

8437

ValaCCodeFunctionCall* _tmp34_;

8438

ValaCCodeIdentifier* _tmp35_;

8439

ValaCCodeIdentifier* _tmp36_;

8440

ValaCCodeFunctionCall* _tmp37_;

8441

ValaCCodeFunctionCall* _tmp38_;

8442

ValaCCodeFunction* _tmp39_;

8443

ValaCCodeFunction* _tmp40_;

8444

ValaCCodeVariableDeclarator* _tmp41_;

8445

ValaCCodeVariableDeclarator* _tmp42_;

8446

ValaCCodeFunction* _tmp43_;

8447

ValaCCodeFunction* _tmp44_;

8448

ValaCCodeIdentifier* _tmp45_;

8449

ValaCCodeIdentifier* _tmp46_;

8450

ValaCCodeFunctionCall* _tmp47_;

8451

ValaCCodeFunction* _tmp48_;

8452

ValaCCodeFunction* _tmp49_;

8453

ValaCCodeIdentifier* _tmp50_;

8454

ValaCCodeIdentifier* _tmp51_;

8455

ValaCCodeUnaryExpression* _tmp52_;

8456

ValaCCodeUnaryExpression* _tmp53_;

8457

ValaCCodeIdentifier* _tmp54_;

8458

ValaCCodeIdentifier* _tmp55_;

8459

ValaCCodeFunctionCall* _tmp56_;

8460

ValaCCodeFunctionCall* _tmp57_;

8461

ValaCCodeFunctionCall* set_error;

8462

ValaCCodeFunctionCall* _tmp58_;

8463

ValaCCodeIdentifier* _tmp59_;

8464

ValaCCodeIdentifier* _tmp60_;

8465

ValaCCodeFunctionCall* _tmp61_;

8466

ValaCCodeIdentifier* _tmp62_;

8467

ValaCCodeIdentifier* _tmp63_;

8468

ValaCCodeFunctionCall* _tmp64_;

8469

ValaCCodeIdentifier* _tmp65_;

8470

ValaCCodeIdentifier* _tmp66_;

8471

ValaCCodeFunctionCall* _tmp67_;

8472

ValaCCodeConstant* _tmp68_;

8473

ValaCCodeConstant* _tmp69_;

8474

ValaCCodeFunction* _tmp70_;

8475

ValaCCodeFunction* _tmp71_;

8476

ValaCCodeFunctionCall* _tmp72_;

8477

ValaCCodeFunction* _tmp73_;

8478

ValaCCodeFunction* _tmp74_;

8479

ValaCCodeConstant* _tmp75_;

8480

ValaCCodeConstant* _tmp76_;

8481

ValaCCodeFunction* _tmp77_;

8482

ValaCCodeFunction* _tmp78_;

8483

ValaCCodeIdentifier* _tmp79_;

8484

ValaCCodeIdentifier* _tmp80_;

8485

ValaCCodeCastExpression* _tmp81_;

8486

ValaCCodeCastExpression* _tmp82_;

8487

ValaCCodeCastExpression* register_object;

8488

ValaCCodeCastExpression* _tmp83_;

8489

ValaCCodeFunctionCall* _tmp84_;

8490

ValaCCodeFunctionCall* ccall;

8491

ValaCCodeFunctionCall* _tmp85_;

8492

ValaCCodeIdentifier* _tmp86_;

8493

ValaCCodeIdentifier* _tmp87_;

8494

ValaCCodeFunctionCall* _tmp88_;

8495

ValaCCodeIdentifier* _tmp89_;

8496

ValaCCodeIdentifier* _tmp90_;

8497

ValaCCodeFunctionCall* _tmp91_;

8498

ValaCCodeIdentifier* _tmp92_;

8499

ValaCCodeIdentifier* _tmp93_;

8500

ValaCCodeFunctionCall* _tmp94_;

8501

ValaCCodeIdentifier* _tmp95_;

8502

ValaCCodeIdentifier* _tmp96_;

8503

ValaCCodeFunction* _tmp97_;

8504

ValaCCodeFunction* _tmp98_;

8505

ValaCCodeFunctionCall* _tmp99_;

8506

ValaCCodeFile* _tmp100_;

8507

ValaCCodeFunction* _tmp101_;

8508

ValaCCodeFile* _tmp102_;

8509

ValaCCodeFunction* _tmp103_;

8510

g_return_val_if_fail (self != NULL, NULL);

8511

_tmp0_ = g_strdup ("_vala_g_dbus_connection_register_object");

8512

register_object_func = _tmp0_;

8513

_tmp1_ = register_object_func;

8514

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

8515

if (!_tmp2_) {

8516

result = register_object_func;

8517

return result;

8518

}

8519

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

8520

vala_ccode_file_add_include (_tmp3_, "gio/gio.h", FALSE);

8521

_tmp4_ = register_object_func;

8522

_tmp5_ = vala_ccode_function_new (_tmp4_, "guint");

8523

function = _tmp5_;

8524

_tmp6_ = function;

8525

vala_ccode_function_set_modifiers (_tmp6_, VALA_CCODE_MODIFIERS_STATIC);

8526

_tmp7_ = function;

8527

_tmp8_ = vala_ccode_parameter_new ("type", "GType");

8528

_tmp9_ = _tmp8_;

8529

vala_ccode_function_add_parameter (_tmp7_, _tmp9_);

8530

_vala_ccode_node_unref0 (_tmp9_);

8531

_tmp10_ = function;

8532

_tmp11_ = vala_ccode_parameter_new ("object", "void*");

8533

_tmp12_ = _tmp11_;

8534

vala_ccode_function_add_parameter (_tmp10_, _tmp12_);

8535

_vala_ccode_node_unref0 (_tmp12_);

8536

_tmp13_ = function;

8537

_tmp14_ = vala_ccode_parameter_new ("connection", "GDBusConnection*");

8538

_tmp15_ = _tmp14_;

8539

vala_ccode_function_add_parameter (_tmp13_, _tmp15_);

8540

_vala_ccode_node_unref0 (_tmp15_);

8541

_tmp16_ = function;

8542

_tmp17_ = vala_ccode_parameter_new ("path", "const gchar*");

8543

_tmp18_ = _tmp17_;

8544

vala_ccode_function_add_parameter (_tmp16_, _tmp18_);

8545

_vala_ccode_node_unref0 (_tmp18_);

8546

_tmp19_ = function;

8547

_tmp20_ = vala_ccode_parameter_new ("error", "GError**");

8548

_tmp21_ = _tmp20_;

8549

vala_ccode_function_add_parameter (_tmp19_, _tmp21_);

8550

_vala_ccode_node_unref0 (_tmp21_);

8551

_tmp22_ = function;

8552

vala_ccode_base_module_push_function ((ValaCCodeBaseModule*) self, _tmp22_);

8553

_tmp23_ = vala_ccode_identifier_new ("g_quark_from_static_string");

8554

_tmp24_ = _tmp23_;

8555

_tmp25_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp24_);

8556

_tmp26_ = _tmp25_;

8557

_vala_ccode_node_unref0 (_tmp24_);

8558

quark = _tmp26_;

8559

_tmp27_ = quark;

8560

_tmp28_ = vala_ccode_constant_new ("\"vala-dbus-register-object\"");

8561

_tmp29_ = _tmp28_;

8562

vala_ccode_function_call_add_argument (_tmp27_, (ValaCCodeExpression*) _tmp29_);

8563

_vala_ccode_node_unref0 (_tmp29_);

8564

_tmp30_ = vala_ccode_identifier_new ("g_type_get_qdata");

8565

_tmp31_ = _tmp30_;

8566

_tmp32_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp31_);

8567

_tmp33_ = _tmp32_;

8568

_vala_ccode_node_unref0 (_tmp31_);

8569

get_qdata = _tmp33_;

8570

_tmp34_ = get_qdata;

8571

_tmp35_ = vala_ccode_identifier_new ("type");

8572

_tmp36_ = _tmp35_;

8573

vala_ccode_function_call_add_argument (_tmp34_, (ValaCCodeExpression*) _tmp36_);

8574

_vala_ccode_node_unref0 (_tmp36_);

8575

_tmp37_ = get_qdata;

8576

_tmp38_ = quark;

8577

vala_ccode_function_call_add_argument (_tmp37_, (ValaCCodeExpression*) _tmp38_);

8578

_tmp39_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

8579

_tmp40_ = _tmp39_;

8580

_tmp41_ = vala_ccode_variable_declarator_new ("*func", NULL, NULL);

8581

_tmp42_ = _tmp41_;

8582

vala_ccode_function_add_declaration (_tmp40_, "void", (ValaCCodeDeclarator*) _tmp42_, 0);

8583

_vala_ccode_node_unref0 (_tmp42_);

8584

_tmp43_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

8585

_tmp44_ = _tmp43_;

8586

_tmp45_ = vala_ccode_identifier_new ("func");

8587

_tmp46_ = _tmp45_;

8588

_tmp47_ = get_qdata;

8589

vala_ccode_function_add_assignment (_tmp44_, (ValaCCodeExpression*) _tmp46_, (ValaCCodeExpression*) _tmp47_);

8590

_vala_ccode_node_unref0 (_tmp46_);

8591

_tmp48_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

8592

_tmp49_ = _tmp48_;

8593

_tmp50_ = vala_ccode_identifier_new ("func");

8594

_tmp51_ = _tmp50_;

8595

_tmp52_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_LOGICAL_NEGATION, (ValaCCodeExpression*) _tmp51_);

8596

_tmp53_ = _tmp52_;

8597

vala_ccode_function_open_if (_tmp49_, (ValaCCodeExpression*) _tmp53_);

8598

_vala_ccode_node_unref0 (_tmp53_);

8599

_vala_ccode_node_unref0 (_tmp51_);

8600

_tmp54_ = vala_ccode_identifier_new ("g_set_error_literal");

8601

_tmp55_ = _tmp54_;

8602

_tmp56_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp55_);

8603

_tmp57_ = _tmp56_;

8604

_vala_ccode_node_unref0 (_tmp55_);

8605

set_error = _tmp57_;

8606

_tmp58_ = set_error;

8607

_tmp59_ = vala_ccode_identifier_new ("error");

8608

_tmp60_ = _tmp59_;

8609

vala_ccode_function_call_add_argument (_tmp58_, (ValaCCodeExpression*) _tmp60_);

8610

_vala_ccode_node_unref0 (_tmp60_);

8611

_tmp61_ = set_error;

8612

_tmp62_ = vala_ccode_identifier_new ("G_IO_ERROR");

8613

_tmp63_ = _tmp62_;

8614

vala_ccode_function_call_add_argument (_tmp61_, (ValaCCodeExpression*) _tmp63_);

8615

_vala_ccode_node_unref0 (_tmp63_);

8616

_tmp64_ = set_error;

8617

_tmp65_ = vala_ccode_identifier_new ("G_IO_ERROR_FAILED");

8618

_tmp66_ = _tmp65_;

8619

vala_ccode_function_call_add_argument (_tmp64_, (ValaCCodeExpression*) _tmp66_);

8620

_vala_ccode_node_unref0 (_tmp66_);

8621

_tmp67_ = set_error;

8622

_tmp68_ = vala_ccode_constant_new ("\"The specified type does not support D-Bus registration\"");

8623

_tmp69_ = _tmp68_;

8624

vala_ccode_function_call_add_argument (_tmp67_, (ValaCCodeExpression*) _tmp69_);

8625

_vala_ccode_node_unref0 (_tmp69_);

8626

_tmp70_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

8627

_tmp71_ = _tmp70_;

8628

_tmp72_ = set_error;

8629

vala_ccode_function_add_expression (_tmp71_, (ValaCCodeExpression*) _tmp72_);

8630

_tmp73_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

8631

_tmp74_ = _tmp73_;

8632

_tmp75_ = vala_ccode_constant_new ("0");

8633

_tmp76_ = _tmp75_;

8634

vala_ccode_function_add_return (_tmp74_, (ValaCCodeExpression*) _tmp76_);

8635

_vala_ccode_node_unref0 (_tmp76_);

8636

_tmp77_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

8637

_tmp78_ = _tmp77_;

8638

vala_ccode_function_close (_tmp78_);

8639

_tmp79_ = vala_ccode_identifier_new ("func");

8640

_tmp80_ = _tmp79_;

8641

_tmp81_ = vala_ccode_cast_expression_new ((ValaCCodeExpression*) _tmp80_, "guint (*) (void *, GDBusConnection *, const gchar *, GError **)");

8642

_tmp82_ = _tmp81_;

8643

_vala_ccode_node_unref0 (_tmp80_);

8644

register_object = _tmp82_;

8645

_tmp83_ = register_object;

8646

_tmp84_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp83_);

8647

ccall = _tmp84_;

8648

_tmp85_ = ccall;

8649

_tmp86_ = vala_ccode_identifier_new ("object");

8650

_tmp87_ = _tmp86_;

8651

vala_ccode_function_call_add_argument (_tmp85_, (ValaCCodeExpression*) _tmp87_);

8652

_vala_ccode_node_unref0 (_tmp87_);

8653

_tmp88_ = ccall;

8654

_tmp89_ = vala_ccode_identifier_new ("connection");

8655

_tmp90_ = _tmp89_;

8656

vala_ccode_function_call_add_argument (_tmp88_, (ValaCCodeExpression*) _tmp90_);

8657

_vala_ccode_node_unref0 (_tmp90_);

8658

_tmp91_ = ccall;

8659

_tmp92_ = vala_ccode_identifier_new ("path");

8660

_tmp93_ = _tmp92_;

8661

vala_ccode_function_call_add_argument (_tmp91_, (ValaCCodeExpression*) _tmp93_);

8662

_vala_ccode_node_unref0 (_tmp93_);

8663

_tmp94_ = ccall;

8664

_tmp95_ = vala_ccode_identifier_new ("error");

8665

_tmp96_ = _tmp95_;

8666

vala_ccode_function_call_add_argument (_tmp94_, (ValaCCodeExpression*) _tmp96_);

8667

_vala_ccode_node_unref0 (_tmp96_);

8668

_tmp97_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

8669

_tmp98_ = _tmp97_;

8670

_tmp99_ = ccall;

8671

vala_ccode_function_add_return (_tmp98_, (ValaCCodeExpression*) _tmp99_);

8672

vala_ccode_base_module_pop_function ((ValaCCodeBaseModule*) self);

8673

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

8674

_tmp101_ = function;

8675

vala_ccode_file_add_function_declaration (_tmp100_, _tmp101_);

8676

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

8677

_tmp103_ = function;

8678

vala_ccode_file_add_function (_tmp102_, _tmp103_);

8679

result = register_object_func;

8680

_vala_ccode_node_unref0 (ccall);

8681

_vala_ccode_node_unref0 (register_object);

8682

_vala_ccode_node_unref0 (set_error);

8683

_vala_ccode_node_unref0 (get_qdata);

8684

_vala_ccode_node_unref0 (quark);

8685

_vala_ccode_node_unref0 (function);

8686

return result;

8687

}

8688

8689

8690

static void vala_gd_bus_server_module_real_visit_method_call (ValaCodeVisitor* base, ValaMethodCall* expr) {

8691

ValaGDBusServerModule * self;

8692

ValaMethodCall* _tmp0_;

8693

ValaExpression* _tmp1_;

8694

ValaExpression* _tmp2_;

8695

ValaDataType* _tmp3_;

8696

ValaDataType* _tmp4_;

8697

ValaMethodType* _tmp5_;

8698

ValaMethodType* mtype;

8699

gboolean _tmp6_ = FALSE;

8700

ValaMethodType* _tmp7_;

8701

gboolean _tmp13_;

8702

ValaMethodCall* _tmp15_;

8703

ValaExpression* _tmp16_;

8704

ValaExpression* _tmp17_;

8705

ValaMemberAccess* _tmp18_;

8706

ValaMemberAccess* ma;

8707

ValaMemberAccess* _tmp19_;

8708

ValaList* _tmp20_ = NULL;

8709

ValaList* _tmp21_;

8710

gpointer _tmp22_ = NULL;

8711

ValaDataType* _tmp23_;

8712

ValaDataType* type_arg;

8713

ValaCCodeFunctionCall* cregister = NULL;

8714

ValaDataType* _tmp24_;

8715

ValaObjectType* _tmp25_;

8716

ValaObjectType* object_type;

8717

ValaObjectType* _tmp26_;

8718

ValaMethodCall* _tmp55_;

8719

ValaList* _tmp56_ = NULL;

8720

ValaList* args;

8721

ValaList* _tmp57_;

8722

gpointer _tmp58_ = NULL;

8723

ValaExpression* path_arg;

8724

ValaList* _tmp59_;

8725

gpointer _tmp60_ = NULL;

8726

ValaExpression* obj_arg;

8727

ValaCCodeFunctionCall* _tmp61_;

8728

ValaExpression* _tmp62_;

8729

ValaCCodeExpression* _tmp63_ = NULL;

8730

ValaCCodeExpression* _tmp64_;

8731

ValaCCodeFunctionCall* _tmp65_;

8732

ValaMemberAccess* _tmp66_;

8733

ValaExpression* _tmp67_;

8734

ValaExpression* _tmp68_;

8735

ValaCCodeExpression* _tmp69_ = NULL;

8736

ValaCCodeExpression* _tmp70_;

8737

ValaCCodeFunctionCall* _tmp71_;

8738

ValaExpression* _tmp72_;

8739

ValaCCodeExpression* _tmp73_ = NULL;

8740

ValaCCodeExpression* _tmp74_;

8741

ValaCCodeFunctionCall* _tmp75_;

8742

ValaCCodeExpression* _tmp76_ = NULL;

8743

ValaCCodeExpression* _tmp77_;

8744

ValaCCodeUnaryExpression* _tmp78_;

8745

ValaCCodeUnaryExpression* _tmp79_;

8746

ValaMethodCall* _tmp80_;

8747

ValaCodeNode* _tmp81_;

8748

ValaCodeNode* _tmp82_;

8749

self = (ValaGDBusServerModule*) base;

8750

g_return_if_fail (expr != NULL);

8751

_tmp0_ = expr;

8752

_tmp1_ = vala_method_call_get_call (_tmp0_);

8753

_tmp2_ = _tmp1_;

8754

_tmp3_ = vala_expression_get_value_type (_tmp2_);

8755

_tmp4_ = _tmp3_;

8756

_tmp5_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp4_, VALA_TYPE_METHOD_TYPE) ? ((ValaMethodType*) _tmp4_) : NULL);

8757

mtype = _tmp5_;

8758

_tmp7_ = mtype;

8759

if (_tmp7_ == NULL) {

8760

_tmp6_ = TRUE;

8761

} else {

8762

ValaMethodType* _tmp8_;

8763

ValaMethod* _tmp9_;

8764

ValaMethod* _tmp10_;

8765

gchar* _tmp11_ = NULL;

8766

gchar* _tmp12_;

8767

_tmp8_ = mtype;

8768

_tmp9_ = vala_method_type_get_method_symbol (_tmp8_);

8769

_tmp10_ = _tmp9_;

8770

_tmp11_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp10_);

8771

_tmp12_ = _tmp11_;

8772

_tmp6_ = g_strcmp0 (_tmp12_, "g_dbus_connection_register_object") != 0;

8773

_g_free0 (_tmp12_);

8774

}

8775

_tmp13_ = _tmp6_;

8776

if (_tmp13_) {

8777

ValaMethodCall* _tmp14_;

8778

_tmp14_ = expr;

8779

VALA_CODE_VISITOR_CLASS (vala_gd_bus_server_module_parent_class)->visit_method_call ((ValaCodeVisitor*) G_TYPE_CHECK_INSTANCE_CAST (self, VALA_TYPE_GD_BUS_CLIENT_MODULE, ValaGDBusClientModule), _tmp14_);

8780

_vala_code_node_unref0 (mtype);

8781

return;

8782

}

8783

_tmp15_ = expr;

8784

_tmp16_ = vala_method_call_get_call (_tmp15_);

8785

_tmp17_ = _tmp16_;

8786

_tmp18_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp17_, VALA_TYPE_MEMBER_ACCESS, ValaMemberAccess));

8787

ma = _tmp18_;

8788

_tmp19_ = ma;

8789

_tmp20_ = vala_member_access_get_type_arguments (_tmp19_);

8790

_tmp21_ = _tmp20_;

8791

_tmp22_ = vala_list_get (_tmp21_, 0);

8792

_tmp23_ = (ValaDataType*) _tmp22_;

8793

_vala_iterable_unref0 (_tmp21_);

8794

type_arg = _tmp23_;

8795

_tmp24_ = type_arg;

8796

_tmp25_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp24_, VALA_TYPE_OBJECT_TYPE) ? ((ValaObjectType*) _tmp24_) : NULL);

8797

object_type = _tmp25_;

8798

_tmp26_ = object_type;

8799

if (_tmp26_ != NULL) {

8800

ValaObjectType* _tmp27_;

8801

ValaObjectTypeSymbol* _tmp28_;

8802

ValaObjectTypeSymbol* _tmp29_;

8803

gchar* _tmp30_ = NULL;

8804

gchar* _tmp31_;

8805

gboolean _tmp32_;

8806

ValaObjectType* _tmp36_;

8807

ValaObjectTypeSymbol* _tmp37_;

8808

ValaObjectTypeSymbol* _tmp38_;

8809

gchar* _tmp39_ = NULL;

8810

gchar* _tmp40_;

8811

gchar* _tmp41_ = NULL;

8812

gchar* _tmp42_;

8813

ValaCCodeIdentifier* _tmp43_;

8814

ValaCCodeIdentifier* _tmp44_;

8815

ValaCCodeFunctionCall* _tmp45_;

8816

_tmp27_ = object_type;

8817

_tmp28_ = vala_object_type_get_type_symbol (_tmp27_);

8818

_tmp29_ = _tmp28_;

8819

_tmp30_ = vala_gd_bus_module_get_dbus_name ((ValaTypeSymbol*) _tmp29_);

8820

_tmp31_ = _tmp30_;

8821

_tmp32_ = _tmp31_ == NULL;

8822

_g_free0 (_tmp31_);

8823

if (_tmp32_) {

8824

ValaMethodCall* _tmp33_;

8825

ValaSourceReference* _tmp34_;

8826

ValaSourceReference* _tmp35_;

8827

_tmp33_ = expr;

8828

_tmp34_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp33_);

8829

_tmp35_ = _tmp34_;

8830

vala_report_error (_tmp35_, "DBusConnection.register_object requires type argument with [DBus (name" \

8831

" = ...)] attribute");

8832

_vala_code_node_unref0 (object_type);

8833

_vala_ccode_node_unref0 (cregister);

8834

_vala_code_node_unref0 (type_arg);

8835

_vala_code_node_unref0 (ma);

8836

_vala_code_node_unref0 (mtype);

8837

return;

8838

}

8839

_tmp36_ = object_type;

8840

_tmp37_ = vala_object_type_get_type_symbol (_tmp36_);

8841

_tmp38_ = _tmp37_;

8842

_tmp39_ = vala_ccode_base_module_get_ccode_lower_case_prefix ((ValaSymbol*) _tmp38_);

8843

_tmp40_ = _tmp39_;

8844

_tmp41_ = g_strdup_printf ("%sregister_object", _tmp40_);

8845

_tmp42_ = _tmp41_;

8846

_tmp43_ = vala_ccode_identifier_new (_tmp42_);

8847

_tmp44_ = _tmp43_;

8848

_tmp45_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp44_);

8849

_vala_ccode_node_unref0 (cregister);

8850

cregister = _tmp45_;

8851

_vala_ccode_node_unref0 (_tmp44_);

8852

_g_free0 (_tmp42_);

8853

_g_free0 (_tmp40_);

8854

} else {

8855

gchar* _tmp46_ = NULL;

8856

gchar* _tmp47_;

8857

ValaCCodeIdentifier* _tmp48_;

8858

ValaCCodeIdentifier* _tmp49_;

8859

ValaCCodeFunctionCall* _tmp50_;

8860

ValaCCodeFunctionCall* _tmp51_;

8861

ValaDataType* _tmp52_;

8862

ValaCCodeExpression* _tmp53_ = NULL;

8863

ValaCCodeExpression* _tmp54_;

8864

_tmp46_ = vala_gd_bus_server_module_generate_register_object_function (self);

8865

_tmp47_ = _tmp46_;

8866

_tmp48_ = vala_ccode_identifier_new (_tmp47_);

8867

_tmp49_ = _tmp48_;

8868

_tmp50_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp49_);

8869

_vala_ccode_node_unref0 (cregister);

8870

cregister = _tmp50_;

8871

_vala_ccode_node_unref0 (_tmp49_);

8872

_g_free0 (_tmp47_);

8873

_tmp51_ = cregister;

8874

_tmp52_ = type_arg;

8875

_tmp53_ = vala_ccode_base_module_get_type_id_expression ((ValaCCodeBaseModule*) self, _tmp52_, FALSE);

8876

_tmp54_ = _tmp53_;

8877

vala_ccode_function_call_add_argument (_tmp51_, _tmp54_);

8878

_vala_ccode_node_unref0 (_tmp54_);

8879

}

8880

_tmp55_ = expr;

8881

_tmp56_ = vala_method_call_get_argument_list (_tmp55_);

8882

args = _tmp56_;

8883

_tmp57_ = args;

8884

_tmp58_ = vala_list_get (_tmp57_, 0);

8885

path_arg = (ValaExpression*) _tmp58_;

8886

_tmp59_ = args;

8887

_tmp60_ = vala_list_get (_tmp59_, 1);

8888

obj_arg = (ValaExpression*) _tmp60_;

8889

vala_ccode_base_module_set_current_method_inner_error ((ValaCCodeBaseModule*) self, TRUE);

8890

_tmp61_ = cregister;

8891

_tmp62_ = obj_arg;

8892

_tmp63_ = vala_ccode_base_module_get_cvalue ((ValaCCodeBaseModule*) self, _tmp62_);

8893

_tmp64_ = _tmp63_;

8894

vala_ccode_function_call_add_argument (_tmp61_, _tmp64_);

8895

_vala_ccode_node_unref0 (_tmp64_);

8896

_tmp65_ = cregister;

8897

_tmp66_ = ma;

8898

_tmp67_ = vala_member_access_get_inner (_tmp66_);

8899

_tmp68_ = _tmp67_;

8900

_tmp69_ = vala_ccode_base_module_get_cvalue ((ValaCCodeBaseModule*) self, _tmp68_);

8901

_tmp70_ = _tmp69_;

8902

vala_ccode_function_call_add_argument (_tmp65_, _tmp70_);

8903

_vala_ccode_node_unref0 (_tmp70_);

8904

_tmp71_ = cregister;

8905

_tmp72_ = path_arg;

8906

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

8907

_tmp74_ = _tmp73_;

8908

vala_ccode_function_call_add_argument (_tmp71_, _tmp74_);

8909

_vala_ccode_node_unref0 (_tmp74_);

8910

_tmp75_ = cregister;

8911

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

8912

_tmp77_ = _tmp76_;

8913

_tmp78_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, _tmp77_);

8914

_tmp79_ = _tmp78_;

8915

vala_ccode_function_call_add_argument (_tmp75_, (ValaCCodeExpression*) _tmp79_);

8916

_vala_ccode_node_unref0 (_tmp79_);

8917

_vala_ccode_node_unref0 (_tmp77_);

8918

_tmp80_ = expr;

8919

_tmp81_ = vala_code_node_get_parent_node ((ValaCodeNode*) _tmp80_);

8920

_tmp82_ = _tmp81_;

8921

if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp82_, VALA_TYPE_EXPRESSION_STATEMENT)) {

8922

ValaCCodeFunction* _tmp83_;

8923

ValaCCodeFunction* _tmp84_;

8924

ValaCCodeFunctionCall* _tmp85_;

8925

_tmp83_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

8926

_tmp84_ = _tmp83_;

8927

_tmp85_ = cregister;

8928

vala_ccode_function_add_expression (_tmp84_, (ValaCCodeExpression*) _tmp85_);

8929

} else {

8930

ValaMethodCall* _tmp86_;

8931

ValaDataType* _tmp87_;

8932

ValaDataType* _tmp88_;

8933

ValaMethodCall* _tmp89_;

8934

ValaDataType* _tmp90_;

8935

ValaDataType* _tmp91_;

8936

gboolean _tmp92_;

8937

gboolean _tmp93_;

8938

ValaLocalVariable* _tmp94_ = NULL;

8939

ValaLocalVariable* temp_var;

8940

ValaLocalVariable* _tmp95_;

8941

const gchar* _tmp96_;

8942

const gchar* _tmp97_;

8943

ValaCCodeExpression* _tmp98_ = NULL;

8944

ValaCCodeExpression* temp_ref;

8945

ValaLocalVariable* _tmp99_;

8946

ValaCCodeFunction* _tmp100_;

8947

ValaCCodeFunction* _tmp101_;

8948

ValaCCodeExpression* _tmp102_;

8949

ValaCCodeFunctionCall* _tmp103_;

8950

ValaMethodCall* _tmp104_;

8951

ValaCCodeExpression* _tmp105_;

8952

_tmp86_ = expr;

8953

_tmp87_ = vala_expression_get_value_type ((ValaExpression*) _tmp86_);

8954

_tmp88_ = _tmp87_;

8955

_tmp89_ = expr;

8956

_tmp90_ = vala_expression_get_value_type ((ValaExpression*) _tmp89_);

8957

_tmp91_ = _tmp90_;

8958

_tmp92_ = vala_data_type_get_value_owned (_tmp91_);

8959

_tmp93_ = _tmp92_;

8960

_tmp94_ = vala_ccode_base_module_get_temp_variable ((ValaCCodeBaseModule*) self, _tmp88_, _tmp93_, NULL, TRUE);

8961

temp_var = _tmp94_;

8962

_tmp95_ = temp_var;

8963

_tmp96_ = vala_symbol_get_name ((ValaSymbol*) _tmp95_);

8964

_tmp97_ = _tmp96_;

8965

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

8966

temp_ref = _tmp98_;

8967

_tmp99_ = temp_var;

8968

vala_ccode_base_module_emit_temp_var ((ValaCCodeBaseModule*) self, _tmp99_);

8969

_tmp100_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

8970

_tmp101_ = _tmp100_;

8971

_tmp102_ = temp_ref;

8972

_tmp103_ = cregister;

8973

vala_ccode_function_add_assignment (_tmp101_, _tmp102_, (ValaCCodeExpression*) _tmp103_);

8974

_tmp104_ = expr;

8975

_tmp105_ = temp_ref;

8976

vala_ccode_base_module_set_cvalue ((ValaCCodeBaseModule*) self, (ValaExpression*) _tmp104_, _tmp105_);

8977

_vala_ccode_node_unref0 (temp_ref);

8978

_vala_code_node_unref0 (temp_var);

8979

}

8980

_vala_code_node_unref0 (obj_arg);

8981

_vala_code_node_unref0 (path_arg);

8982

_vala_iterable_unref0 (args);

8983

_vala_code_node_unref0 (object_type);

8984

_vala_ccode_node_unref0 (cregister);

8985

_vala_code_node_unref0 (type_arg);

8986

_vala_code_node_unref0 (ma);

8987

_vala_code_node_unref0 (mtype);

8988

}

8989

8990

8991

static void vala_gd_bus_server_module_real_generate_class_declaration (ValaCCodeBaseModule* base, ValaClass* cl, ValaCCodeFile* decl_space) {

8992

ValaGDBusServerModule * self;

8993

ValaClass* _tmp0_;

8994

ValaCCodeFile* _tmp1_;

8995

ValaClass* _tmp2_;

8996

ValaCCodeFile* _tmp3_;

8997

self = (ValaGDBusServerModule*) base;

8998

g_return_if_fail (cl != NULL);

8999

g_return_if_fail (decl_space != NULL);

9000

_tmp0_ = cl;

9001

_tmp1_ = decl_space;

9002

VALA_CCODE_BASE_MODULE_CLASS (vala_gd_bus_server_module_parent_class)->generate_class_declaration ((ValaCCodeBaseModule*) G_TYPE_CHECK_INSTANCE_CAST (self, VALA_TYPE_GD_BUS_CLIENT_MODULE, ValaGDBusClientModule), _tmp0_, _tmp1_);

9003

_tmp2_ = cl;

9004

_tmp3_ = decl_space;

9005

vala_gd_bus_server_module_generate_object_type_symbol_declaration (self, (ValaObjectTypeSymbol*) _tmp2_, _tmp3_);

9006

}

9007

9008

9009

static void vala_gd_bus_server_module_real_generate_interface_declaration (ValaCCodeBaseModule* base, ValaInterface* iface, ValaCCodeFile* decl_space) {

9010

ValaGDBusServerModule * self;

9011

ValaInterface* _tmp0_;

9012

ValaCCodeFile* _tmp1_;

9013

ValaInterface* _tmp2_;

9014

ValaCCodeFile* _tmp3_;

9015

self = (ValaGDBusServerModule*) base;

9016

g_return_if_fail (iface != NULL);

9017

g_return_if_fail (decl_space != NULL);

9018

_tmp0_ = iface;

9019

_tmp1_ = decl_space;

9020

VALA_CCODE_BASE_MODULE_CLASS (vala_gd_bus_server_module_parent_class)->generate_interface_declaration ((ValaCCodeBaseModule*) G_TYPE_CHECK_INSTANCE_CAST (self, VALA_TYPE_GD_BUS_CLIENT_MODULE, ValaGDBusClientModule), _tmp0_, _tmp1_);

9021

_tmp2_ = iface;

9022

_tmp3_ = decl_space;

9023

vala_gd_bus_server_module_generate_object_type_symbol_declaration (self, (ValaObjectTypeSymbol*) _tmp2_, _tmp3_);

9024

}

9025

9026

9027

static void vala_gd_bus_server_module_real_visit_class (ValaCodeVisitor* base, ValaClass* cl) {

9028

ValaGDBusServerModule * self;

9029

ValaClass* _tmp0_;

9030

ValaClass* _tmp1_;

9031

self = (ValaGDBusServerModule*) base;

9032

g_return_if_fail (cl != NULL);

9033

_tmp0_ = cl;

9034

VALA_CODE_VISITOR_CLASS (vala_gd_bus_server_module_parent_class)->visit_class ((ValaCodeVisitor*) G_TYPE_CHECK_INSTANCE_CAST (self, VALA_TYPE_GD_BUS_CLIENT_MODULE, ValaGDBusClientModule), _tmp0_);

9035

_tmp1_ = cl;

9036

vala_gd_bus_server_module_visit_object_type_symbol (self, (ValaObjectTypeSymbol*) _tmp1_);

9037

}

9038

9039

9040

static void vala_gd_bus_server_module_real_visit_interface (ValaCodeVisitor* base, ValaInterface* iface) {

9041

ValaGDBusServerModule * self;

9042

ValaInterface* _tmp0_;

9043

ValaInterface* _tmp1_;

9044

self = (ValaGDBusServerModule*) base;

9045

g_return_if_fail (iface != NULL);

9046

_tmp0_ = iface;

9047

VALA_CODE_VISITOR_CLASS (vala_gd_bus_server_module_parent_class)->visit_interface ((ValaCodeVisitor*) G_TYPE_CHECK_INSTANCE_CAST (self, VALA_TYPE_GD_BUS_CLIENT_MODULE, ValaGDBusClientModule), _tmp0_);

9048

_tmp1_ = iface;

9049

vala_gd_bus_server_module_visit_object_type_symbol (self, (ValaObjectTypeSymbol*) _tmp1_);

9050

}

9051

9052

9053

static void vala_gd_bus_server_module_generate_object_type_symbol_declaration (ValaGDBusServerModule* self, ValaObjectTypeSymbol* sym, ValaCCodeFile* decl_space) {

9054

ValaObjectTypeSymbol* _tmp0_;

9055

gchar* _tmp1_ = NULL;

9056

gchar* dbus_iface_name;

9057

const gchar* _tmp2_;

9058

ValaObjectTypeSymbol* _tmp3_;

9059

gchar* _tmp4_ = NULL;

9060

gchar* _tmp5_;

9061

gchar* _tmp6_ = NULL;

9062

gchar* _tmp7_;

9063

gchar* register_object_name;

9064

ValaCCodeFile* _tmp8_;

9065

ValaObjectTypeSymbol* _tmp9_;

9066

const gchar* _tmp10_;

9067

gboolean _tmp11_ = FALSE;

9068

ValaCCodeFile* _tmp12_;

9069

const gchar* _tmp13_;

9070

ValaCCodeFunction* _tmp14_;

9071

ValaCCodeFunction* cfunc;

9072

ValaCCodeFunction* _tmp15_;

9073

ValaCCodeParameter* _tmp16_;

9074

ValaCCodeParameter* _tmp17_;

9075

ValaCCodeFunction* _tmp18_;

9076

ValaCCodeParameter* _tmp19_;

9077

ValaCCodeParameter* _tmp20_;

9078

ValaCCodeFunction* _tmp21_;

9079

ValaCCodeParameter* _tmp22_;

9080

ValaCCodeParameter* _tmp23_;

9081

ValaCCodeFunction* _tmp24_;

9082

ValaCCodeParameter* _tmp25_;

9083

ValaCCodeParameter* _tmp26_;

9084

ValaObjectTypeSymbol* _tmp27_;

9085

gboolean _tmp28_ = FALSE;

9086

ValaCCodeFile* _tmp33_;

9087

ValaCCodeFunction* _tmp34_;

9088

g_return_if_fail (self != NULL);

9089

g_return_if_fail (sym != NULL);

9090

g_return_if_fail (decl_space != NULL);

9091

_tmp0_ = sym;

9092

_tmp1_ = vala_gd_bus_module_get_dbus_name ((ValaTypeSymbol*) _tmp0_);

9093

dbus_iface_name = _tmp1_;

9094

_tmp2_ = dbus_iface_name;

9095

if (_tmp2_ == NULL) {

9096

_g_free0 (dbus_iface_name);

9097

return;

9098

}

9099

_tmp3_ = sym;

9100

_tmp4_ = vala_ccode_base_module_get_ccode_lower_case_prefix ((ValaSymbol*) _tmp3_);

9101

_tmp5_ = _tmp4_;

9102

_tmp6_ = g_strdup_printf ("%sregister_object", _tmp5_);

9103

_tmp7_ = _tmp6_;

9104

_g_free0 (_tmp5_);

9105

register_object_name = _tmp7_;

9106

_tmp8_ = decl_space;

9107

_tmp9_ = sym;

9108

_tmp10_ = register_object_name;

9109

_tmp11_ = vala_ccode_base_module_add_symbol_declaration ((ValaCCodeBaseModule*) self, _tmp8_, (ValaSymbol*) _tmp9_, _tmp10_);

9110

if (_tmp11_) {

9111

_g_free0 (register_object_name);

9112

_g_free0 (dbus_iface_name);

9113

return;

9114

}

9115

_tmp12_ = decl_space;

9116

vala_ccode_file_add_include (_tmp12_, "gio/gio.h", FALSE);

9117

_tmp13_ = register_object_name;

9118

_tmp14_ = vala_ccode_function_new (_tmp13_, "guint");

9119

cfunc = _tmp14_;

9120

_tmp15_ = cfunc;

9121

_tmp16_ = vala_ccode_parameter_new ("object", "void*");

9122

_tmp17_ = _tmp16_;

9123

vala_ccode_function_add_parameter (_tmp15_, _tmp17_);

9124

_vala_ccode_node_unref0 (_tmp17_);

9125

_tmp18_ = cfunc;

9126

_tmp19_ = vala_ccode_parameter_new ("connection", "GDBusConnection*");

9127

_tmp20_ = _tmp19_;

9128

vala_ccode_function_add_parameter (_tmp18_, _tmp20_);

9129

_vala_ccode_node_unref0 (_tmp20_);

9130

_tmp21_ = cfunc;

9131

_tmp22_ = vala_ccode_parameter_new ("path", "const gchar*");

9132

_tmp23_ = _tmp22_;

9133

vala_ccode_function_add_parameter (_tmp21_, _tmp23_);

9134

_vala_ccode_node_unref0 (_tmp23_);

9135

_tmp24_ = cfunc;

9136

_tmp25_ = vala_ccode_parameter_new ("error", "GError**");

9137

_tmp26_ = _tmp25_;

9138

vala_ccode_function_add_parameter (_tmp24_, _tmp26_);

9139

_vala_ccode_node_unref0 (_tmp26_);

9140

_tmp27_ = sym;

9141

_tmp28_ = vala_symbol_is_private_symbol ((ValaSymbol*) _tmp27_);

9142

if (_tmp28_) {

9143

ValaCCodeFunction* _tmp29_;

9144

ValaCCodeFunction* _tmp30_;

9145

ValaCCodeModifiers _tmp31_;

9146

ValaCCodeModifiers _tmp32_;

9147

_tmp29_ = cfunc;

9148

_tmp30_ = cfunc;

9149

_tmp31_ = vala_ccode_function_get_modifiers (_tmp30_);

9150

_tmp32_ = _tmp31_;

9151

vala_ccode_function_set_modifiers (_tmp30_, _tmp32_ | VALA_CCODE_MODIFIERS_STATIC);

9152

}

9153

_tmp33_ = decl_space;

9154

_tmp34_ = cfunc;

9155

vala_ccode_file_add_function_declaration (_tmp33_, _tmp34_);

9156

_vala_ccode_node_unref0 (cfunc);

9157

_g_free0 (register_object_name);

9158

_g_free0 (dbus_iface_name);

9159

}

9160

9161

9162

static void vala_gd_bus_server_module_visit_object_type_symbol (ValaGDBusServerModule* self, ValaObjectTypeSymbol* sym) {

9163

ValaObjectTypeSymbol* _tmp0_;

9164

gchar* _tmp1_ = NULL;

9165

gchar* dbus_iface_name;

9166

const gchar* _tmp2_;

9167

ValaCCodeFile* _tmp3_;

9168

ValaObjectTypeSymbol* _tmp4_;

9169

gchar* _tmp5_ = NULL;

9170

gchar* _tmp6_;

9171

gchar* _tmp7_;

9172

gchar* _tmp8_;

9173

ValaCCodeFunction* _tmp9_;

9174

ValaCCodeFunction* _tmp10_;

9175

ValaCCodeFunction* cfunc;

9176

ValaCCodeFunction* _tmp11_;

9177

ValaCCodeParameter* _tmp12_;

9178

ValaCCodeParameter* _tmp13_;

9179

ValaCCodeFunction* _tmp14_;

9180

ValaCCodeParameter* _tmp15_;

9181

ValaCCodeParameter* _tmp16_;

9182

ValaCCodeFunction* _tmp17_;

9183

ValaCCodeParameter* _tmp18_;

9184

ValaCCodeParameter* _tmp19_;

9185

ValaCCodeFunction* _tmp20_;

9186

ValaCCodeParameter* _tmp21_;

9187

ValaCCodeParameter* _tmp22_;

9188

ValaObjectTypeSymbol* _tmp23_;

9189

gboolean _tmp24_ = FALSE;

9190

ValaCCodeFunction* _tmp29_;

9191

ValaCCodeFunction* _tmp30_;

9192

ValaCCodeFunction* _tmp31_;

9193

ValaCCodeVariableDeclarator* _tmp32_;

9194

ValaCCodeVariableDeclarator* _tmp33_;

9195

ValaCCodeFunction* _tmp34_;

9196

ValaCCodeFunction* _tmp35_;

9197

ValaCCodeVariableDeclarator* _tmp36_;

9198

ValaCCodeVariableDeclarator* _tmp37_;

9199

ValaCCodeIdentifier* _tmp38_;

9200

ValaCCodeIdentifier* _tmp39_;

9201

ValaCCodeFunctionCall* _tmp40_;

9202

ValaCCodeFunctionCall* _tmp41_;

9203

ValaCCodeFunctionCall* alloc_data;

9204

ValaCCodeFunctionCall* _tmp42_;

9205

ValaCCodeIdentifier* _tmp43_;

9206

ValaCCodeIdentifier* _tmp44_;

9207

ValaCCodeFunctionCall* _tmp45_;

9208

ValaCCodeConstant* _tmp46_;

9209

ValaCCodeConstant* _tmp47_;

9210

ValaCCodeFunction* _tmp48_;

9211

ValaCCodeFunction* _tmp49_;

9212

ValaCCodeIdentifier* _tmp50_;

9213

ValaCCodeIdentifier* _tmp51_;

9214

ValaCCodeFunctionCall* _tmp52_;

9215

ValaObjectTypeSymbol* _tmp53_;

9216

gchar* _tmp54_ = NULL;

9217

gchar* ref_function;

9218

gboolean _tmp55_ = FALSE;

9219

ValaObjectTypeSymbol* _tmp56_;

9220

gboolean _tmp58_;

9221

const gchar* _tmp67_;

9222

ValaCCodeIdentifier* _tmp68_;

9223

ValaCCodeIdentifier* _tmp69_;

9224

ValaCCodeFunctionCall* _tmp70_;

9225

ValaCCodeFunctionCall* _tmp71_;

9226

ValaCCodeFunctionCall* ref_object;

9227

ValaCCodeFunctionCall* _tmp72_;

9228

ValaCCodeIdentifier* _tmp73_;

9229

ValaCCodeIdentifier* _tmp74_;

9230

ValaCCodeFunction* _tmp75_;

9231

ValaCCodeFunction* _tmp76_;

9232

ValaCCodeIdentifier* _tmp77_;

9233

ValaCCodeIdentifier* _tmp78_;

9234

ValaCCodeConstant* _tmp79_;

9235

ValaCCodeConstant* _tmp80_;

9236

ValaCCodeElementAccess* _tmp81_;

9237

ValaCCodeElementAccess* _tmp82_;

9238

ValaCCodeFunctionCall* _tmp83_;

9239

ValaCCodeIdentifier* _tmp84_;

9240

ValaCCodeIdentifier* _tmp85_;

9241

ValaCCodeFunctionCall* _tmp86_;

9242

ValaCCodeFunctionCall* _tmp87_;

9243

ValaCCodeIdentifier* _tmp88_;

9244

ValaCCodeIdentifier* _tmp89_;

9245

ValaCCodeFunction* _tmp90_;

9246

ValaCCodeFunction* _tmp91_;

9247

ValaCCodeIdentifier* _tmp92_;

9248

ValaCCodeIdentifier* _tmp93_;

9249

ValaCCodeConstant* _tmp94_;

9250

ValaCCodeConstant* _tmp95_;

9251

ValaCCodeElementAccess* _tmp96_;

9252

ValaCCodeElementAccess* _tmp97_;

9253

ValaCCodeFunctionCall* _tmp98_;

9254

ValaCCodeIdentifier* _tmp99_;

9255

ValaCCodeIdentifier* _tmp100_;

9256

ValaCCodeFunctionCall* _tmp101_;

9257

ValaCCodeFunctionCall* _tmp102_;

9258

ValaCCodeFunctionCall* dup_path;

9259

ValaCCodeFunctionCall* _tmp103_;

9260

ValaCCodeIdentifier* _tmp104_;

9261

ValaCCodeIdentifier* _tmp105_;

9262

ValaCCodeFunction* _tmp106_;

9263

ValaCCodeFunction* _tmp107_;

9264

ValaCCodeIdentifier* _tmp108_;

9265

ValaCCodeIdentifier* _tmp109_;

9266

ValaCCodeConstant* _tmp110_;

9267

ValaCCodeConstant* _tmp111_;

9268

ValaCCodeElementAccess* _tmp112_;

9269

ValaCCodeElementAccess* _tmp113_;

9270

ValaCCodeFunctionCall* _tmp114_;

9271

ValaCCodeIdentifier* _tmp115_;

9272

ValaCCodeIdentifier* _tmp116_;

9273

ValaCCodeFunctionCall* _tmp117_;

9274

ValaCCodeFunctionCall* _tmp118_;

9275

ValaCCodeFunctionCall* cregister;

9276

ValaCCodeFunctionCall* _tmp119_;

9277

ValaCCodeIdentifier* _tmp120_;

9278

ValaCCodeIdentifier* _tmp121_;

9279

ValaCCodeFunctionCall* _tmp122_;

9280

ValaCCodeIdentifier* _tmp123_;

9281

ValaCCodeIdentifier* _tmp124_;

9282

ValaCCodeFunctionCall* _tmp125_;

9283

ValaObjectTypeSymbol* _tmp126_;

9284

ValaCCodeExpression* _tmp127_ = NULL;

9285

ValaCCodeExpression* _tmp128_;

9286

ValaCCodeUnaryExpression* _tmp129_;

9287

ValaCCodeUnaryExpression* _tmp130_;

9288

ValaCCodeCastExpression* _tmp131_;

9289

ValaCCodeCastExpression* _tmp132_;

9290

ValaCCodeFunctionCall* _tmp133_;

9291

ValaObjectTypeSymbol* _tmp134_;

9292

ValaCCodeExpression* _tmp135_ = NULL;

9293

ValaCCodeExpression* _tmp136_;

9294

ValaCCodeUnaryExpression* _tmp137_;

9295

ValaCCodeUnaryExpression* _tmp138_;

9296

ValaCCodeFunctionCall* _tmp139_;

9297

ValaCCodeIdentifier* _tmp140_;

9298

ValaCCodeIdentifier* _tmp141_;

9299

ValaCCodeFunctionCall* _tmp142_;

9300

ValaObjectTypeSymbol* _tmp143_;

9301

gchar* _tmp144_ = NULL;

9302

gchar* _tmp145_;

9303

gchar* _tmp146_;

9304

gchar* _tmp147_;

9305

gchar* _tmp148_;

9306

gchar* _tmp149_;

9307

ValaCCodeIdentifier* _tmp150_;

9308

ValaCCodeIdentifier* _tmp151_;

9309

ValaCCodeFunctionCall* _tmp152_;

9310

ValaCCodeIdentifier* _tmp153_;

9311

ValaCCodeIdentifier* _tmp154_;

9312

ValaCCodeFunction* _tmp155_;

9313

ValaCCodeFunction* _tmp156_;

9314

ValaCCodeIdentifier* _tmp157_;

9315

ValaCCodeIdentifier* _tmp158_;

9316

ValaCCodeFunctionCall* _tmp159_;

9317

ValaCCodeFunction* _tmp160_;

9318

ValaCCodeFunction* _tmp161_;

9319

ValaCCodeIdentifier* _tmp162_;

9320

ValaCCodeIdentifier* _tmp163_;

9321

ValaCCodeUnaryExpression* _tmp164_;

9322

ValaCCodeUnaryExpression* _tmp165_;

9323

ValaCCodeFunction* _tmp166_;

9324

ValaCCodeFunction* _tmp167_;

9325

ValaCCodeConstant* _tmp168_;

9326

ValaCCodeConstant* _tmp169_;

9327

ValaCCodeFunction* _tmp170_;

9328

ValaCCodeFunction* _tmp171_;

9329

ValaObjectTypeSymbol* _tmp172_;

9330

ValaCCodeFunction* _tmp173_;

9331

ValaCCodeFunction* _tmp174_;

9332

ValaCCodeIdentifier* _tmp175_;

9333

ValaCCodeIdentifier* _tmp176_;

9334

ValaCCodeFile* _tmp177_;

9335

ValaCCodeFunction* _tmp178_;

9336

ValaObjectTypeSymbol* _tmp179_;

9337

gchar* _tmp180_ = NULL;

9338

gchar* _tmp181_;

9339

gchar* _tmp182_;

9340

gchar* _tmp183_;

9341

gchar* _tmp184_;

9342

gchar* _tmp185_;

9343

ValaCCodeFunction* _tmp186_;

9344

ValaCCodeFunction* _tmp187_;

9345

ValaCCodeParameter* _tmp188_;

9346

ValaCCodeParameter* _tmp189_;

9347

ValaCCodeFunction* _tmp190_;

9348

ValaCCodeFunction* _tmp191_;

9349

ValaCCodeModifiers _tmp192_;

9350

ValaCCodeModifiers _tmp193_;

9351

ValaCCodeFunction* _tmp194_;

9352

ValaCCodeFunction* _tmp195_;

9353

ValaCCodeFunction* _tmp196_;

9354

ValaCCodeIdentifier* _tmp197_;

9355

ValaCCodeIdentifier* _tmp198_;

9356

ValaCCodeVariableDeclarator* _tmp199_;

9357

ValaCCodeVariableDeclarator* _tmp200_;

9358

ValaObjectTypeSymbol* _tmp201_;

9359

ValaObjectTypeSymbol* _tmp202_;

9360

gchar* _tmp203_ = NULL;

9361

gchar* _tmp204_;

9362

ValaCCodeIdentifier* _tmp205_;

9363

ValaCCodeIdentifier* _tmp206_;

9364

ValaCCodeFunctionCall* _tmp207_;

9365

ValaCCodeFunctionCall* _tmp208_;

9366

ValaCCodeFunctionCall* unref_object;

9367

ValaCCodeFunctionCall* _tmp209_;

9368

ValaCCodeIdentifier* _tmp210_;

9369

ValaCCodeIdentifier* _tmp211_;

9370

ValaCCodeConstant* _tmp212_;

9371

ValaCCodeConstant* _tmp213_;

9372

ValaCCodeElementAccess* _tmp214_;

9373

ValaCCodeElementAccess* _tmp215_;

9374

ValaCCodeFunction* _tmp216_;

9375

ValaCCodeFunction* _tmp217_;

9376

ValaCCodeFunctionCall* _tmp218_;

9377

ValaCCodeIdentifier* _tmp219_;

9378

ValaCCodeIdentifier* _tmp220_;

9379

ValaCCodeFunctionCall* _tmp221_;

9380

ValaCCodeFunctionCall* _tmp222_;

9381

ValaCCodeIdentifier* _tmp223_;

9382

ValaCCodeIdentifier* _tmp224_;

9383

ValaCCodeConstant* _tmp225_;

9384

ValaCCodeConstant* _tmp226_;

9385

ValaCCodeElementAccess* _tmp227_;

9386

ValaCCodeElementAccess* _tmp228_;

9387

ValaCCodeFunction* _tmp229_;

9388

ValaCCodeFunction* _tmp230_;

9389

ValaCCodeFunctionCall* _tmp231_;

9390

ValaCCodeIdentifier* _tmp232_;

9391

ValaCCodeIdentifier* _tmp233_;

9392

ValaCCodeFunctionCall* _tmp234_;

9393

ValaCCodeFunctionCall* _tmp235_;

9394

ValaCCodeFunctionCall* free_path;

9395

ValaCCodeFunctionCall* _tmp236_;

9396

ValaCCodeIdentifier* _tmp237_;

9397

ValaCCodeIdentifier* _tmp238_;

9398

ValaCCodeConstant* _tmp239_;

9399

ValaCCodeConstant* _tmp240_;

9400

ValaCCodeElementAccess* _tmp241_;

9401

ValaCCodeElementAccess* _tmp242_;

9402

ValaCCodeFunction* _tmp243_;

9403

ValaCCodeFunction* _tmp244_;

9404

ValaCCodeFunctionCall* _tmp245_;

9405

ValaCCodeIdentifier* _tmp246_;

9406

ValaCCodeIdentifier* _tmp247_;

9407

ValaCCodeFunctionCall* _tmp248_;

9408

ValaCCodeFunctionCall* _tmp249_;

9409

ValaCCodeFunctionCall* free_data;

9410

ValaCCodeFunctionCall* _tmp250_;

9411

ValaCCodeIdentifier* _tmp251_;

9412

ValaCCodeIdentifier* _tmp252_;

9413

ValaCCodeFunction* _tmp253_;

9414

ValaCCodeFunction* _tmp254_;

9415

ValaCCodeFunctionCall* _tmp255_;

9416

ValaCCodeFile* _tmp256_;

9417

ValaCCodeFunction* _tmp257_;

9418

ValaCCodeFile* _tmp258_;

9419

ValaCCodeFunction* _tmp259_;

9420

g_return_if_fail (self != NULL);

9421

g_return_if_fail (sym != NULL);

9422

_tmp0_ = sym;

9423

_tmp1_ = vala_gd_bus_module_get_dbus_name ((ValaTypeSymbol*) _tmp0_);

9424

dbus_iface_name = _tmp1_;

9425

_tmp2_ = dbus_iface_name;

9426

if (_tmp2_ == NULL) {

9427

_g_free0 (dbus_iface_name);

9428

return;

9429

}

9430

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

9431

vala_ccode_file_add_include (_tmp3_, "gio/gio.h", FALSE);

9432

_tmp4_ = sym;

9433

_tmp5_ = vala_ccode_base_module_get_ccode_lower_case_prefix ((ValaSymbol*) _tmp4_);

9434

_tmp6_ = _tmp5_;

9435

_tmp7_ = g_strconcat (_tmp6_, "register_object", NULL);

9436

_tmp8_ = _tmp7_;

9437

_tmp9_ = vala_ccode_function_new (_tmp8_, "guint");

9438

_tmp10_ = _tmp9_;

9439

_g_free0 (_tmp8_);

9440

_g_free0 (_tmp6_);

9441

cfunc = _tmp10_;

9442

_tmp11_ = cfunc;

9443

_tmp12_ = vala_ccode_parameter_new ("object", "gpointer");

9444

_tmp13_ = _tmp12_;

9445

vala_ccode_function_add_parameter (_tmp11_, _tmp13_);

9446

_vala_ccode_node_unref0 (_tmp13_);

9447

_tmp14_ = cfunc;

9448

_tmp15_ = vala_ccode_parameter_new ("connection", "GDBusConnection*");

9449

_tmp16_ = _tmp15_;

9450

vala_ccode_function_add_parameter (_tmp14_, _tmp16_);

9451

_vala_ccode_node_unref0 (_tmp16_);

9452

_tmp17_ = cfunc;

9453

_tmp18_ = vala_ccode_parameter_new ("path", "const gchar*");

9454

_tmp19_ = _tmp18_;

9455

vala_ccode_function_add_parameter (_tmp17_, _tmp19_);

9456

_vala_ccode_node_unref0 (_tmp19_);

9457

_tmp20_ = cfunc;

9458

_tmp21_ = vala_ccode_parameter_new ("error", "GError**");

9459

_tmp22_ = _tmp21_;

9460

vala_ccode_function_add_parameter (_tmp20_, _tmp22_);

9461

_vala_ccode_node_unref0 (_tmp22_);

9462

_tmp23_ = sym;

9463

_tmp24_ = vala_symbol_is_private_symbol ((ValaSymbol*) _tmp23_);

9464

if (_tmp24_) {

9465

ValaCCodeFunction* _tmp25_;

9466

ValaCCodeFunction* _tmp26_;

9467

ValaCCodeModifiers _tmp27_;

9468

ValaCCodeModifiers _tmp28_;

9469

_tmp25_ = cfunc;

9470

_tmp26_ = cfunc;

9471

_tmp27_ = vala_ccode_function_get_modifiers (_tmp26_);

9472

_tmp28_ = _tmp27_;

9473

vala_ccode_function_set_modifiers (_tmp26_, _tmp28_ | VALA_CCODE_MODIFIERS_STATIC);

9474

}

9475

_tmp29_ = cfunc;

9476

vala_ccode_base_module_push_function ((ValaCCodeBaseModule*) self, _tmp29_);

9477

_tmp30_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

9478

_tmp31_ = _tmp30_;

9479

_tmp32_ = vala_ccode_variable_declarator_new ("result", NULL, NULL);

9480

_tmp33_ = _tmp32_;

9481

vala_ccode_function_add_declaration (_tmp31_, "guint", (ValaCCodeDeclarator*) _tmp33_, 0);

9482

_vala_ccode_node_unref0 (_tmp33_);

9483

_tmp34_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

9484

_tmp35_ = _tmp34_;

9485

_tmp36_ = vala_ccode_variable_declarator_new ("*data", NULL, NULL);

9486

_tmp37_ = _tmp36_;

9487

vala_ccode_function_add_declaration (_tmp35_, "gpointer", (ValaCCodeDeclarator*) _tmp37_, 0);

9488

_vala_ccode_node_unref0 (_tmp37_);

9489

_tmp38_ = vala_ccode_identifier_new ("g_new");

9490

_tmp39_ = _tmp38_;

9491

_tmp40_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp39_);

9492

_tmp41_ = _tmp40_;

9493

_vala_ccode_node_unref0 (_tmp39_);

9494

alloc_data = _tmp41_;

9495

_tmp42_ = alloc_data;

9496

_tmp43_ = vala_ccode_identifier_new ("gpointer");

9497

_tmp44_ = _tmp43_;

9498

vala_ccode_function_call_add_argument (_tmp42_, (ValaCCodeExpression*) _tmp44_);

9499

_vala_ccode_node_unref0 (_tmp44_);

9500

_tmp45_ = alloc_data;

9501

_tmp46_ = vala_ccode_constant_new ("3");

9502

_tmp47_ = _tmp46_;

9503

vala_ccode_function_call_add_argument (_tmp45_, (ValaCCodeExpression*) _tmp47_);

9504

_vala_ccode_node_unref0 (_tmp47_);

9505

_tmp48_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

9506

_tmp49_ = _tmp48_;

9507

_tmp50_ = vala_ccode_identifier_new ("data");

9508

_tmp51_ = _tmp50_;

9509

_tmp52_ = alloc_data;

9510

vala_ccode_function_add_assignment (_tmp49_, (ValaCCodeExpression*) _tmp51_, (ValaCCodeExpression*) _tmp52_);

9511

_vala_ccode_node_unref0 (_tmp51_);

9512

_tmp53_ = sym;

9513

_tmp54_ = vala_ccode_base_module_get_ccode_ref_function ((ValaTypeSymbol*) _tmp53_);

9514

ref_function = _tmp54_;

9515

_tmp56_ = sym;

9516

if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp56_, VALA_TYPE_INTERFACE)) {

9517

const gchar* _tmp57_;

9518

_tmp57_ = ref_function;

9519

_tmp55_ = _tmp57_ == NULL;

9520

} else {

9521

_tmp55_ = FALSE;

9522

}

9523

_tmp58_ = _tmp55_;

9524

if (_tmp58_) {

9525

ValaObjectTypeSymbol* _tmp59_;

9526

ValaSourceReference* _tmp60_;

9527

ValaSourceReference* _tmp61_;

9528

ValaObjectTypeSymbol* _tmp62_;

9529

gchar* _tmp63_ = NULL;

9530

gchar* _tmp64_;

9531

gchar* _tmp65_ = NULL;

9532

gchar* _tmp66_;

9533

_tmp59_ = sym;

9534

_tmp60_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp59_);

9535

_tmp61_ = _tmp60_;

9536

_tmp62_ = sym;

9537

_tmp63_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp62_);

9538

_tmp64_ = _tmp63_;

9539

_tmp65_ = g_strdup_printf ("missing class prerequisite for interface `%s', add GLib.Object to inte" \

9540

"rface declaration if unsure", _tmp64_);

9541

_tmp66_ = _tmp65_;

9542

vala_report_error (_tmp61_, _tmp66_);

9543

_g_free0 (_tmp66_);

9544

_g_free0 (_tmp64_);

9545

_g_free0 (ref_function);

9546

_vala_ccode_node_unref0 (alloc_data);

9547

_vala_ccode_node_unref0 (cfunc);

9548

_g_free0 (dbus_iface_name);

9549

return;

9550

}

9551

_tmp67_ = ref_function;

9552

_tmp68_ = vala_ccode_identifier_new (_tmp67_);

9553

_tmp69_ = _tmp68_;

9554

_tmp70_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp69_);

9555

_tmp71_ = _tmp70_;

9556

_vala_ccode_node_unref0 (_tmp69_);

9557

ref_object = _tmp71_;

9558

_tmp72_ = ref_object;

9559

_tmp73_ = vala_ccode_identifier_new ("object");

9560

_tmp74_ = _tmp73_;

9561

vala_ccode_function_call_add_argument (_tmp72_, (ValaCCodeExpression*) _tmp74_);

9562

_vala_ccode_node_unref0 (_tmp74_);

9563

_tmp75_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

9564

_tmp76_ = _tmp75_;

9565

_tmp77_ = vala_ccode_identifier_new ("data");

9566

_tmp78_ = _tmp77_;

9567

_tmp79_ = vala_ccode_constant_new ("0");

9568

_tmp80_ = _tmp79_;

9569

_tmp81_ = vala_ccode_element_access_new ((ValaCCodeExpression*) _tmp78_, (ValaCCodeExpression*) _tmp80_);

9570

_tmp82_ = _tmp81_;

9571

_tmp83_ = ref_object;

9572

vala_ccode_function_add_assignment (_tmp76_, (ValaCCodeExpression*) _tmp82_, (ValaCCodeExpression*) _tmp83_);

9573

_vala_ccode_node_unref0 (_tmp82_);

9574

_vala_ccode_node_unref0 (_tmp80_);

9575

_vala_ccode_node_unref0 (_tmp78_);

9576

_tmp84_ = vala_ccode_identifier_new ("g_object_ref");

9577

_tmp85_ = _tmp84_;

9578

_tmp86_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp85_);

9579

_vala_ccode_node_unref0 (ref_object);

9580

ref_object = _tmp86_;

9581

_vala_ccode_node_unref0 (_tmp85_);

9582

_tmp87_ = ref_object;

9583

_tmp88_ = vala_ccode_identifier_new ("connection");

9584

_tmp89_ = _tmp88_;

9585

vala_ccode_function_call_add_argument (_tmp87_, (ValaCCodeExpression*) _tmp89_);

9586

_vala_ccode_node_unref0 (_tmp89_);

9587

_tmp90_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

9588

_tmp91_ = _tmp90_;

9589

_tmp92_ = vala_ccode_identifier_new ("data");

9590

_tmp93_ = _tmp92_;

9591

_tmp94_ = vala_ccode_constant_new ("1");

9592

_tmp95_ = _tmp94_;

9593

_tmp96_ = vala_ccode_element_access_new ((ValaCCodeExpression*) _tmp93_, (ValaCCodeExpression*) _tmp95_);

9594

_tmp97_ = _tmp96_;

9595

_tmp98_ = ref_object;

9596

vala_ccode_function_add_assignment (_tmp91_, (ValaCCodeExpression*) _tmp97_, (ValaCCodeExpression*) _tmp98_);

9597

_vala_ccode_node_unref0 (_tmp97_);

9598

_vala_ccode_node_unref0 (_tmp95_);

9599

_vala_ccode_node_unref0 (_tmp93_);

9600

_tmp99_ = vala_ccode_identifier_new ("g_strdup");

9601

_tmp100_ = _tmp99_;

9602

_tmp101_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp100_);

9603

_tmp102_ = _tmp101_;

9604

_vala_ccode_node_unref0 (_tmp100_);

9605

dup_path = _tmp102_;

9606

_tmp103_ = dup_path;

9607

_tmp104_ = vala_ccode_identifier_new ("path");

9608

_tmp105_ = _tmp104_;

9609

vala_ccode_function_call_add_argument (_tmp103_, (ValaCCodeExpression*) _tmp105_);

9610

_vala_ccode_node_unref0 (_tmp105_);

9611

_tmp106_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

9612

_tmp107_ = _tmp106_;

9613

_tmp108_ = vala_ccode_identifier_new ("data");

9614

_tmp109_ = _tmp108_;

9615

_tmp110_ = vala_ccode_constant_new ("2");

9616

_tmp111_ = _tmp110_;

9617

_tmp112_ = vala_ccode_element_access_new ((ValaCCodeExpression*) _tmp109_, (ValaCCodeExpression*) _tmp111_);

9618

_tmp113_ = _tmp112_;

9619

_tmp114_ = dup_path;

9620

vala_ccode_function_add_assignment (_tmp107_, (ValaCCodeExpression*) _tmp113_, (ValaCCodeExpression*) _tmp114_);

9621

_vala_ccode_node_unref0 (_tmp113_);

9622

_vala_ccode_node_unref0 (_tmp111_);

9623

_vala_ccode_node_unref0 (_tmp109_);

9624

_tmp115_ = vala_ccode_identifier_new ("g_dbus_connection_register_object");

9625

_tmp116_ = _tmp115_;

9626

_tmp117_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp116_);

9627

_tmp118_ = _tmp117_;

9628

_vala_ccode_node_unref0 (_tmp116_);

9629

cregister = _tmp118_;

9630

_tmp119_ = cregister;

9631

_tmp120_ = vala_ccode_identifier_new ("connection");

9632

_tmp121_ = _tmp120_;

9633

vala_ccode_function_call_add_argument (_tmp119_, (ValaCCodeExpression*) _tmp121_);

9634

_vala_ccode_node_unref0 (_tmp121_);

9635

_tmp122_ = cregister;

9636

_tmp123_ = vala_ccode_identifier_new ("path");

9637

_tmp124_ = _tmp123_;

9638

vala_ccode_function_call_add_argument (_tmp122_, (ValaCCodeExpression*) _tmp124_);

9639

_vala_ccode_node_unref0 (_tmp124_);

9640

_tmp125_ = cregister;

9641

_tmp126_ = sym;

9642

_tmp127_ = vala_gd_bus_server_module_get_interface_info (self, _tmp126_);

9643

_tmp128_ = _tmp127_;

9644

_tmp129_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, _tmp128_);

9645

_tmp130_ = _tmp129_;

9646

_tmp131_ = vala_ccode_cast_expression_new ((ValaCCodeExpression*) _tmp130_, "GDBusInterfaceInfo *");

9647

_tmp132_ = _tmp131_;

9648

vala_ccode_function_call_add_argument (_tmp125_, (ValaCCodeExpression*) _tmp132_);

9649

_vala_ccode_node_unref0 (_tmp132_);

9650

_vala_ccode_node_unref0 (_tmp130_);

9651

_vala_ccode_node_unref0 (_tmp128_);

9652

_tmp133_ = cregister;

9653

_tmp134_ = sym;

9654

_tmp135_ = vala_gd_bus_server_module_get_interface_vtable (self, _tmp134_);

9655

_tmp136_ = _tmp135_;

9656

_tmp137_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, _tmp136_);

9657

_tmp138_ = _tmp137_;

9658

vala_ccode_function_call_add_argument (_tmp133_, (ValaCCodeExpression*) _tmp138_);

9659

_vala_ccode_node_unref0 (_tmp138_);

9660

_vala_ccode_node_unref0 (_tmp136_);

9661

_tmp139_ = cregister;

9662

_tmp140_ = vala_ccode_identifier_new ("data");

9663

_tmp141_ = _tmp140_;

9664

vala_ccode_function_call_add_argument (_tmp139_, (ValaCCodeExpression*) _tmp141_);

9665

_vala_ccode_node_unref0 (_tmp141_);

9666

_tmp142_ = cregister;

9667

_tmp143_ = sym;

9668

_tmp144_ = vala_ccode_base_module_get_ccode_lower_case_prefix ((ValaSymbol*) _tmp143_);

9669

_tmp145_ = _tmp144_;

9670

_tmp146_ = g_strconcat ("_", _tmp145_, NULL);

9671

_tmp147_ = _tmp146_;

9672

_tmp148_ = g_strconcat (_tmp147_, "unregister_object", NULL);

9673

_tmp149_ = _tmp148_;

9674

_tmp150_ = vala_ccode_identifier_new (_tmp149_);

9675

_tmp151_ = _tmp150_;

9676

vala_ccode_function_call_add_argument (_tmp142_, (ValaCCodeExpression*) _tmp151_);

9677

_vala_ccode_node_unref0 (_tmp151_);

9678

_g_free0 (_tmp149_);

9679

_g_free0 (_tmp147_);

9680

_g_free0 (_tmp145_);

9681

_tmp152_ = cregister;

9682

_tmp153_ = vala_ccode_identifier_new ("error");

9683

_tmp154_ = _tmp153_;

9684

vala_ccode_function_call_add_argument (_tmp152_, (ValaCCodeExpression*) _tmp154_);

9685

_vala_ccode_node_unref0 (_tmp154_);

9686

_tmp155_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

9687

_tmp156_ = _tmp155_;

9688

_tmp157_ = vala_ccode_identifier_new ("result");

9689

_tmp158_ = _tmp157_;

9690

_tmp159_ = cregister;

9691

vala_ccode_function_add_assignment (_tmp156_, (ValaCCodeExpression*) _tmp158_, (ValaCCodeExpression*) _tmp159_);

9692

_vala_ccode_node_unref0 (_tmp158_);

9693

_tmp160_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

9694

_tmp161_ = _tmp160_;

9695

_tmp162_ = vala_ccode_identifier_new ("result");

9696

_tmp163_ = _tmp162_;

9697

_tmp164_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_LOGICAL_NEGATION, (ValaCCodeExpression*) _tmp163_);

9698

_tmp165_ = _tmp164_;

9699

vala_ccode_function_open_if (_tmp161_, (ValaCCodeExpression*) _tmp165_);

9700

_vala_ccode_node_unref0 (_tmp165_);

9701

_vala_ccode_node_unref0 (_tmp163_);

9702

_tmp166_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

9703

_tmp167_ = _tmp166_;

9704

_tmp168_ = vala_ccode_constant_new ("0");

9705

_tmp169_ = _tmp168_;

9706

vala_ccode_function_add_return (_tmp167_, (ValaCCodeExpression*) _tmp169_);

9707

_vala_ccode_node_unref0 (_tmp169_);

9708

_tmp170_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

9709

_tmp171_ = _tmp170_;

9710

vala_ccode_function_close (_tmp171_);

9711

_tmp172_ = sym;

9712

vala_gd_bus_server_module_handle_signals (self, _tmp172_, TRUE);

9713

_tmp173_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

9714

_tmp174_ = _tmp173_;

9715

_tmp175_ = vala_ccode_identifier_new ("result");

9716

_tmp176_ = _tmp175_;

9717

vala_ccode_function_add_return (_tmp174_, (ValaCCodeExpression*) _tmp176_);

9718

_vala_ccode_node_unref0 (_tmp176_);

9719

vala_ccode_base_module_pop_function ((ValaCCodeBaseModule*) self);

9720

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

9721

_tmp178_ = cfunc;

9722

vala_ccode_file_add_function (_tmp177_, _tmp178_);

9723

_tmp179_ = sym;

9724

_tmp180_ = vala_ccode_base_module_get_ccode_lower_case_prefix ((ValaSymbol*) _tmp179_);

9725

_tmp181_ = _tmp180_;

9726

_tmp182_ = g_strconcat ("_", _tmp181_, NULL);

9727

_tmp183_ = _tmp182_;

9728

_tmp184_ = g_strconcat (_tmp183_, "unregister_object", NULL);

9729

_tmp185_ = _tmp184_;

9730

_tmp186_ = vala_ccode_function_new (_tmp185_, "void");

9731

_vala_ccode_node_unref0 (cfunc);

9732

cfunc = _tmp186_;

9733

_g_free0 (_tmp185_);

9734

_g_free0 (_tmp183_);

9735

_g_free0 (_tmp181_);

9736

_tmp187_ = cfunc;

9737

_tmp188_ = vala_ccode_parameter_new ("user_data", "gpointer");

9738

_tmp189_ = _tmp188_;

9739

vala_ccode_function_add_parameter (_tmp187_, _tmp189_);

9740

_vala_ccode_node_unref0 (_tmp189_);

9741

_tmp190_ = cfunc;

9742

_tmp191_ = cfunc;

9743

_tmp192_ = vala_ccode_function_get_modifiers (_tmp191_);

9744

_tmp193_ = _tmp192_;

9745

vala_ccode_function_set_modifiers (_tmp191_, _tmp193_ | VALA_CCODE_MODIFIERS_STATIC);

9746

_tmp194_ = cfunc;

9747

vala_ccode_base_module_push_function ((ValaCCodeBaseModule*) self, _tmp194_);

9748

_tmp195_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

9749

_tmp196_ = _tmp195_;

9750

_tmp197_ = vala_ccode_identifier_new ("user_data");

9751

_tmp198_ = _tmp197_;

9752

_tmp199_ = vala_ccode_variable_declarator_new ("data", (ValaCCodeExpression*) _tmp198_, NULL);

9753

_tmp200_ = _tmp199_;

9754

vala_ccode_function_add_declaration (_tmp196_, "gpointer*", (ValaCCodeDeclarator*) _tmp200_, 0);

9755

_vala_ccode_node_unref0 (_tmp200_);

9756

_vala_ccode_node_unref0 (_tmp198_);

9757

_tmp201_ = sym;

9758

vala_gd_bus_server_module_handle_signals (self, _tmp201_, FALSE);

9759

_tmp202_ = sym;

9760

_tmp203_ = vala_ccode_base_module_get_ccode_unref_function (_tmp202_);

9761

_tmp204_ = _tmp203_;

9762

_tmp205_ = vala_ccode_identifier_new (_tmp204_);

9763

_tmp206_ = _tmp205_;

9764

_tmp207_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp206_);

9765

_tmp208_ = _tmp207_;

9766

_vala_ccode_node_unref0 (_tmp206_);

9767

_g_free0 (_tmp204_);

9768

unref_object = _tmp208_;

9769

_tmp209_ = unref_object;

9770

_tmp210_ = vala_ccode_identifier_new ("data");

9771

_tmp211_ = _tmp210_;

9772

_tmp212_ = vala_ccode_constant_new ("0");

9773

_tmp213_ = _tmp212_;

9774

_tmp214_ = vala_ccode_element_access_new ((ValaCCodeExpression*) _tmp211_, (ValaCCodeExpression*) _tmp213_);

9775

_tmp215_ = _tmp214_;

9776

vala_ccode_function_call_add_argument (_tmp209_, (ValaCCodeExpression*) _tmp215_);

9777

_vala_ccode_node_unref0 (_tmp215_);

9778

_vala_ccode_node_unref0 (_tmp213_);

9779

_vala_ccode_node_unref0 (_tmp211_);

9780

_tmp216_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

9781

_tmp217_ = _tmp216_;

9782

_tmp218_ = unref_object;

9783

vala_ccode_function_add_expression (_tmp217_, (ValaCCodeExpression*) _tmp218_);

9784

_tmp219_ = vala_ccode_identifier_new ("g_object_unref");

9785

_tmp220_ = _tmp219_;

9786

_tmp221_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp220_);

9787

_vala_ccode_node_unref0 (unref_object);

9788

unref_object = _tmp221_;

9789

_vala_ccode_node_unref0 (_tmp220_);

9790

_tmp222_ = unref_object;

9791

_tmp223_ = vala_ccode_identifier_new ("data");

9792

_tmp224_ = _tmp223_;

9793

_tmp225_ = vala_ccode_constant_new ("1");

9794

_tmp226_ = _tmp225_;

9795

_tmp227_ = vala_ccode_element_access_new ((ValaCCodeExpression*) _tmp224_, (ValaCCodeExpression*) _tmp226_);

9796

_tmp228_ = _tmp227_;

9797

vala_ccode_function_call_add_argument (_tmp222_, (ValaCCodeExpression*) _tmp228_);

9798

_vala_ccode_node_unref0 (_tmp228_);

9799

_vala_ccode_node_unref0 (_tmp226_);

9800

_vala_ccode_node_unref0 (_tmp224_);

9801

_tmp229_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

9802

_tmp230_ = _tmp229_;

9803

_tmp231_ = unref_object;

9804

vala_ccode_function_add_expression (_tmp230_, (ValaCCodeExpression*) _tmp231_);

9805

_tmp232_ = vala_ccode_identifier_new ("g_free");

9806

_tmp233_ = _tmp232_;

9807

_tmp234_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp233_);

9808

_tmp235_ = _tmp234_;

9809

_vala_ccode_node_unref0 (_tmp233_);

9810

free_path = _tmp235_;

9811

_tmp236_ = free_path;

9812

_tmp237_ = vala_ccode_identifier_new ("data");

9813

_tmp238_ = _tmp237_;

9814

_tmp239_ = vala_ccode_constant_new ("2");

9815

_tmp240_ = _tmp239_;

9816

_tmp241_ = vala_ccode_element_access_new ((ValaCCodeExpression*) _tmp238_, (ValaCCodeExpression*) _tmp240_);

9817

_tmp242_ = _tmp241_;

9818

vala_ccode_function_call_add_argument (_tmp236_, (ValaCCodeExpression*) _tmp242_);

9819

_vala_ccode_node_unref0 (_tmp242_);

9820

_vala_ccode_node_unref0 (_tmp240_);

9821

_vala_ccode_node_unref0 (_tmp238_);

9822

_tmp243_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

9823

_tmp244_ = _tmp243_;

9824

_tmp245_ = free_path;

9825

vala_ccode_function_add_expression (_tmp244_, (ValaCCodeExpression*) _tmp245_);

9826

_tmp246_ = vala_ccode_identifier_new ("g_free");

9827

_tmp247_ = _tmp246_;

9828

_tmp248_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp247_);

9829

_tmp249_ = _tmp248_;

9830

_vala_ccode_node_unref0 (_tmp247_);

9831

free_data = _tmp249_;

9832

_tmp250_ = free_data;

9833

_tmp251_ = vala_ccode_identifier_new ("data");

9834

_tmp252_ = _tmp251_;

9835

vala_ccode_function_call_add_argument (_tmp250_, (ValaCCodeExpression*) _tmp252_);

9836

_vala_ccode_node_unref0 (_tmp252_);

9837

_tmp253_ = vala_ccode_base_module_get_ccode ((ValaCCodeBaseModule*) self);

9838

_tmp254_ = _tmp253_;

9839

_tmp255_ = free_data;

9840

vala_ccode_function_add_expression (_tmp254_, (ValaCCodeExpression*) _tmp255_);

9841

vala_ccode_base_module_pop_function ((ValaCCodeBaseModule*) self);

9842

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

9843

_tmp257_ = cfunc;

9844

vala_ccode_file_add_function_declaration (_tmp256_, _tmp257_);

9845

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

9846

_tmp259_ = cfunc;

9847

vala_ccode_file_add_function (_tmp258_, _tmp259_);

9848

_vala_ccode_node_unref0 (free_data);

9849

_vala_ccode_node_unref0 (free_path);

9850

_vala_ccode_node_unref0 (unref_object);

9851

_vala_ccode_node_unref0 (cregister);

9852

_vala_ccode_node_unref0 (dup_path);

9853

_vala_ccode_node_unref0 (ref_object);

9854

_g_free0 (ref_function);

9855

_vala_ccode_node_unref0 (alloc_data);

9856

_vala_ccode_node_unref0 (cfunc);

9857

_g_free0 (dbus_iface_name);

9858

}

9859

9860

9861

static void vala_gd_bus_server_module_real_register_dbus_info (ValaCCodeBaseModule* base, ValaCCodeBlock* block, ValaObjectTypeSymbol* sym) {

9862

ValaGDBusServerModule * self;

9863

ValaObjectTypeSymbol* _tmp0_;

9864

gchar* _tmp1_ = NULL;

9865

gchar* dbus_iface_name;

9866

const gchar* _tmp2_;

9867

ValaCCodeBlock* _tmp3_;

9868

ValaObjectTypeSymbol* _tmp4_;

9869

ValaCCodeIdentifier* _tmp5_;

9870

ValaCCodeIdentifier* _tmp6_;

9871

ValaCCodeFunctionCall* _tmp7_;

9872

ValaCCodeFunctionCall* _tmp8_;

9873

ValaCCodeFunctionCall* quark;

9874

ValaCCodeFunctionCall* _tmp9_;

9875

ValaCCodeConstant* _tmp10_;

9876

ValaCCodeConstant* _tmp11_;

9877

ValaCCodeIdentifier* _tmp12_;

9878

ValaCCodeIdentifier* _tmp13_;

9879

ValaCCodeFunctionCall* _tmp14_;

9880

ValaCCodeFunctionCall* _tmp15_;

9881

ValaCCodeFunctionCall* set_qdata;

9882

ValaCCodeFunctionCall* _tmp16_;

9883

ValaObjectTypeSymbol* _tmp17_;

9884

gchar* _tmp18_ = NULL;

9885

gchar* _tmp19_;

9886

gchar* _tmp20_ = NULL;

9887

gchar* _tmp21_;

9888

ValaCCodeIdentifier* _tmp22_;

9889

ValaCCodeIdentifier* _tmp23_;

9890

ValaCCodeFunctionCall* _tmp24_;

9891

ValaCCodeFunctionCall* _tmp25_;

9892

ValaCCodeFunctionCall* _tmp26_;

9893

ValaObjectTypeSymbol* _tmp27_;

9894

gchar* _tmp28_ = NULL;

9895

gchar* _tmp29_;

9896

gchar* _tmp30_;

9897

gchar* _tmp31_;

9898

ValaCCodeIdentifier* _tmp32_;

9899

ValaCCodeIdentifier* _tmp33_;

9900

ValaCCodeCastExpression* _tmp34_;

9901

ValaCCodeCastExpression* _tmp35_;

9902

ValaCCodeBlock* _tmp36_;

9903

ValaCCodeFunctionCall* _tmp37_;

9904

ValaCCodeExpressionStatement* _tmp38_;

9905

ValaCCodeExpressionStatement* _tmp39_;

9906

self = (ValaGDBusServerModule*) base;

9907

g_return_if_fail (block != NULL);

9908

g_return_if_fail (sym != NULL);

9909

_tmp0_ = sym;

9910

_tmp1_ = vala_gd_bus_module_get_dbus_name ((ValaTypeSymbol*) _tmp0_);

9911

dbus_iface_name = _tmp1_;

9912

_tmp2_ = dbus_iface_name;

9913

if (_tmp2_ == NULL) {

9914

_g_free0 (dbus_iface_name);

9915

return;

9916

}

9917

_tmp3_ = block;

9918

_tmp4_ = sym;

9919

VALA_CCODE_BASE_MODULE_CLASS (vala_gd_bus_server_module_parent_class)->register_dbus_info ((ValaCCodeBaseModule*) G_TYPE_CHECK_INSTANCE_CAST (self, VALA_TYPE_GD_BUS_CLIENT_MODULE, ValaGDBusClientModule), _tmp3_, _tmp4_);

9920

_tmp5_ = vala_ccode_identifier_new ("g_quark_from_static_string");

9921

_tmp6_ = _tmp5_;

9922

_tmp7_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp6_);

9923

_tmp8_ = _tmp7_;

9924

_vala_ccode_node_unref0 (_tmp6_);

9925

quark = _tmp8_;

9926

_tmp9_ = quark;

9927

_tmp10_ = vala_ccode_constant_new ("\"vala-dbus-register-object\"");

9928

_tmp11_ = _tmp10_;

9929

vala_ccode_function_call_add_argument (_tmp9_, (ValaCCodeExpression*) _tmp11_);

9930

_vala_ccode_node_unref0 (_tmp11_);

9931

_tmp12_ = vala_ccode_identifier_new ("g_type_set_qdata");

9932

_tmp13_ = _tmp12_;

9933

_tmp14_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp13_);

9934

_tmp15_ = _tmp14_;

9935

_vala_ccode_node_unref0 (_tmp13_);

9936

set_qdata = _tmp15_;

9937

_tmp16_ = set_qdata;

9938

_tmp17_ = sym;

9939

_tmp18_ = vala_ccode_base_module_get_ccode_lower_case_name ((ValaCodeNode*) _tmp17_, NULL);

9940

_tmp19_ = _tmp18_;

9941

_tmp20_ = g_strdup_printf ("%s_type_id", _tmp19_);

9942

_tmp21_ = _tmp20_;

9943

_tmp22_ = vala_ccode_identifier_new (_tmp21_);

9944

_tmp23_ = _tmp22_;

9945

vala_ccode_function_call_add_argument (_tmp16_, (ValaCCodeExpression*) _tmp23_);

9946

_vala_ccode_node_unref0 (_tmp23_);

9947

_g_free0 (_tmp21_);

9948

_g_free0 (_tmp19_);

9949

_tmp24_ = set_qdata;

9950

_tmp25_ = quark;

9951

vala_ccode_function_call_add_argument (_tmp24_, (ValaCCodeExpression*) _tmp25_);

9952

_tmp26_ = set_qdata;

9953

_tmp27_ = sym;

9954

_tmp28_ = vala_ccode_base_module_get_ccode_lower_case_prefix ((ValaSymbol*) _tmp27_);

9955

_tmp29_ = _tmp28_;

9956

_tmp30_ = g_strconcat (_tmp29_, "register_object", NULL);

9957

_tmp31_ = _tmp30_;

9958

_tmp32_ = vala_ccode_identifier_new (_tmp31_);

9959

_tmp33_ = _tmp32_;

9960

_tmp34_ = vala_ccode_cast_expression_new ((ValaCCodeExpression*) _tmp33_, "void*");

9961

_tmp35_ = _tmp34_;

9962

vala_ccode_function_call_add_argument (_tmp26_, (ValaCCodeExpression*) _tmp35_);

9963

_vala_ccode_node_unref0 (_tmp35_);

9964

_vala_ccode_node_unref0 (_tmp33_);

9965

_g_free0 (_tmp31_);

9966

_g_free0 (_tmp29_);

9967

_tmp36_ = block;

9968

_tmp37_ = set_qdata;

9969

_tmp38_ = vala_ccode_expression_statement_new ((ValaCCodeExpression*) _tmp37_);

9970

_tmp39_ = _tmp38_;

9971

vala_ccode_block_add_statement (_tmp36_, (ValaCCodeNode*) _tmp39_);

9972

_vala_ccode_node_unref0 (_tmp39_);

9973

_vala_ccode_node_unref0 (set_qdata);

9974

_vala_ccode_node_unref0 (quark);

9975

_g_free0 (dbus_iface_name);

9976

}

9977

9978

9979

ValaGDBusServerModule* vala_gd_bus_server_module_construct (GType object_type) {

9980

ValaGDBusServerModule* self = NULL;

9981

self = (ValaGDBusServerModule*) vala_gd_bus_client_module_construct (object_type);

9982

return self;

9983

}

9984

9985

9986

ValaGDBusServerModule* vala_gd_bus_server_module_new (void) {

9987

return vala_gd_bus_server_module_construct (VALA_TYPE_GD_BUS_SERVER_MODULE);

9988

}

9989

9990

9991

static void vala_gd_bus_server_module_class_init (ValaGDBusServerModuleClass * klass) {

9992

vala_gd_bus_server_module_parent_class = g_type_class_peek_parent (klass);

9993

VALA_CODE_VISITOR_CLASS (klass)->visit_method_call = vala_gd_bus_server_module_real_visit_method_call;

9994

VALA_CCODE_BASE_MODULE_CLASS (klass)->generate_class_declaration = vala_gd_bus_server_module_real_generate_class_declaration;

9995

VALA_CCODE_BASE_MODULE_CLASS (klass)->generate_interface_declaration = vala_gd_bus_server_module_real_generate_interface_declaration;

9996

VALA_CODE_VISITOR_CLASS (klass)->visit_class = vala_gd_bus_server_module_real_visit_class;

9997

VALA_CODE_VISITOR_CLASS (klass)->visit_interface = vala_gd_bus_server_module_real_visit_interface;

9998

VALA_CCODE_BASE_MODULE_CLASS (klass)->register_dbus_info = vala_gd_bus_server_module_real_register_dbus_info;

9999

}

10000

10001

10002

static void vala_gd_bus_server_module_instance_init (ValaGDBusServerModule * self) {

10003

}

10004

10005

10006

GType vala_gd_bus_server_module_get_type (void) {

10007

static volatile gsize vala_gd_bus_server_module_type_id__volatile = 0;

10008

if (g_once_init_enter (&vala_gd_bus_server_module_type_id__volatile)) {

10009

static const GTypeInfo g_define_type_info = { sizeof (ValaGDBusServerModuleClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) vala_gd_bus_server_module_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ValaGDBusServerModule), 0, (GInstanceInitFunc) vala_gd_bus_server_module_instance_init, NULL };

10010

GType vala_gd_bus_server_module_type_id;

10011

vala_gd_bus_server_module_type_id = g_type_register_static (VALA_TYPE_GD_BUS_CLIENT_MODULE, "ValaGDBusServerModule", &g_define_type_info, 0);

10012

g_once_init_leave (&vala_gd_bus_server_module_type_id__volatile, vala_gd_bus_server_module_type_id);

10013

}

10014

return vala_gd_bus_server_module_type_id__volatile;

10015

}

10016

10017

10018

Older »