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

void vala_gir_writer_write_file (ValaGIRWriter* self, ValaCodeContext* context, const gchar* directory, const gchar* gir_namespace, const gchar* gir_version, const gchar* package);

161

static void vala_gir_writer_write_package (ValaGIRWriter* self, const gchar* package);

162

static void vala_gir_writer_write_doc (ValaGIRWriter* self, const gchar* comment);

163

static void vala_gir_writer_write_indent (ValaGIRWriter* self);

164

static void vala_gir_writer_write_c_includes (ValaGIRWriter* self, ValaNamespace* ns);

165

gchar* vala_ccode_base_module_get_ccode_header_filenames (ValaSymbol* sym);

166

static void vala_gir_writer_write_c_include (ValaGIRWriter* self, const gchar* name);

167

static void vala_gir_writer_real_visit_namespace (ValaCodeVisitor* base, ValaNamespace* ns);

168

gchar* vala_ccode_base_module_get_ccode_prefix (ValaSymbol* sym);

169

static void vala_gir_writer_write_annotations (ValaGIRWriter* self, ValaCodeNode* node);

170

static void vala_gir_writer_visit_deferred (ValaGIRWriter* self);

171

static void vala_gir_writer_write_symbol_attributes (ValaGIRWriter* self, ValaSymbol* symbol);

172

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

173

static gboolean vala_gir_writer_check_accessibility (ValaGIRWriter* self, ValaSymbol* sym);

174

static gchar* vala_gir_writer_get_gir_name (ValaGIRWriter* self, ValaSymbol* symbol);

175

static void vala_gir_writer_write_gtype_attributes (ValaGIRWriter* self, ValaTypeSymbol* symbol);

176

static gchar* vala_gir_writer_gi_type_name (ValaGIRWriter* self, ValaTypeSymbol* type_symbol);

177

gchar* vala_ccode_base_module_get_ccode_name (ValaCodeNode* node);

178

static void vala_gir_writer_write_ctype_attributes (ValaGIRWriter* self, ValaTypeSymbol* symbol, const gchar* suffix);

179

static void vala_gir_writer_do_write_signature (ValaGIRWriter* self, ValaMethod* m, const gchar* tag_name, gboolean instance, const gchar* name, const gchar* cname, ValaList* params, ValaDataType* return_type, gboolean can_fail, gboolean write_comment);

180

gchar* vala_ccode_base_module_get_ccode_finish_name (ValaMethod* m);

181

static void vala_gir_writer_write_signature (ValaGIRWriter* self, ValaMethod* m, const gchar* tag_name, gboolean write_doc, gboolean instance);

182

static void vala_gir_writer_real_visit_struct (ValaCodeVisitor* base, ValaStruct* st);

183

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

184

static void vala_gir_writer_real_visit_enum (ValaCodeVisitor* base, ValaEnum* en);

185

static void vala_gir_writer_real_visit_enum_value (ValaCodeVisitor* base, ValaEnumValue* ev);

186

static gchar* vala_gir_writer_literal_expression_to_value_string (ValaGIRWriter* self, ValaExpression* literal);

187

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

188

gchar* vala_ccode_base_module_get_ccode_lower_case_prefix (ValaSymbol* sym);

189

static void vala_gir_writer_real_visit_error_code (ValaCodeVisitor* base, ValaErrorCode* ecode);

190

static void vala_gir_writer_real_visit_constant (ValaCodeVisitor* base, ValaConstant* c);

191

static void vala_gir_writer_write_type (ValaGIRWriter* self, ValaDataType* type, gint index);

192

static void vala_gir_writer_real_visit_field (ValaCodeVisitor* base, ValaField* f);

193

static void vala_gir_writer_write_implicit_params (ValaGIRWriter* self, ValaDataType* type, gint* index, gboolean has_array_length, const gchar* name, ValaParameterDirection direction);

194

static void vala_gir_writer_write_param_or_return (ValaGIRWriter* self, ValaDataType* type, gboolean is_parameter, gint* index, gboolean has_array_length, const gchar* name, const gchar* comment, ValaParameterDirection direction, gboolean constructor, gboolean caller_allocates);

195

static void vala_gir_writer_skip_implicit_params (ValaGIRWriter* self, ValaDataType* type, gint* index, gboolean has_array_length);

196

static void vala_gir_writer_write_params_and_return (ValaGIRWriter* self, ValaList* params, ValaDataType* return_type, gboolean return_array_length, const gchar* return_comment, gboolean constructor, ValaDataType* instance_type, gboolean user_data);

197

gboolean vala_ccode_base_module_get_ccode_array_length (ValaCodeNode* node);

198

static void vala_gir_writer_real_visit_delegate (ValaCodeVisitor* base, ValaDelegate* cb);

199

static void vala_gir_writer_real_visit_method (ValaCodeVisitor* base, ValaMethod* m);

200

static gboolean vala_gir_writer_check_signature (ValaGIRWriter* self, ValaMethod* m);

201

static gboolean vala_gir_writer_check_type (ValaGIRWriter* self, ValaDataType* type);

202

ValaDataType* vala_ccode_base_module_get_data_type_for_symbol (ValaTypeSymbol* sym);

203

static void vala_gir_writer_real_visit_creation_method (ValaCodeVisitor* base, ValaCreationMethod* m);

204

static void vala_gir_writer_real_visit_property (ValaCodeVisitor* base, ValaProperty* prop);

205

static void vala_gir_writer_real_visit_signal (ValaCodeVisitor* base, ValaSignal* sig);

206

static gchar* vala_gir_writer_camel_case_to_canonical (ValaGIRWriter* self, const gchar* name);

207

static gchar* vala_gir_writer_get_full_gir_name (ValaGIRWriter* self, ValaSymbol* sym);

208

static void vala_gir_writer_gir_namespace_init (ValaGIRWriterGIRNamespace *self, const gchar* ns, const gchar* version);

209

ValaGIRWriter* vala_gir_writer_new (void);

210

ValaGIRWriter* vala_gir_writer_construct (GType object_type);

211

static void vala_gir_writer_finalize (ValaCodeVisitor* obj);

212

static void _vala_array_destroy (gpointer array, gint array_length, GDestroyNotify destroy_func);

213

static void _vala_array_free (gpointer array, gint array_length, GDestroyNotify destroy_func);

214

static gint _vala_array_length (gpointer array);

215

216

217

static gchar* vala_gir_writer_real_get_interface_comment (ValaGIRWriter* self, ValaInterface* iface) {

218

gchar* result = NULL;

219

g_return_val_if_fail (iface != NULL, NULL);

220

result = NULL;

221

return result;

222

}

223

224

225

gchar* vala_gir_writer_get_interface_comment (ValaGIRWriter* self, ValaInterface* iface) {

226

g_return_val_if_fail (self != NULL, NULL);

227

return VALA_GIR_WRITER_GET_CLASS (self)->get_interface_comment (self, iface);

228

}

229

230

231

static gchar* vala_gir_writer_real_get_struct_comment (ValaGIRWriter* self, ValaStruct* st) {

232

gchar* result = NULL;

233

g_return_val_if_fail (st != NULL, NULL);

234

result = NULL;

235

return result;

236

}

237

238

239

gchar* vala_gir_writer_get_struct_comment (ValaGIRWriter* self, ValaStruct* st) {

240

g_return_val_if_fail (self != NULL, NULL);

241

return VALA_GIR_WRITER_GET_CLASS (self)->get_struct_comment (self, st);

242

}

243

244

245

static gchar* vala_gir_writer_real_get_enum_comment (ValaGIRWriter* self, ValaEnum* en) {

246

gchar* result = NULL;

247

g_return_val_if_fail (en != NULL, NULL);

248

result = NULL;

249

return result;

250

}

251

252

253

gchar* vala_gir_writer_get_enum_comment (ValaGIRWriter* self, ValaEnum* en) {

254

g_return_val_if_fail (self != NULL, NULL);

255

return VALA_GIR_WRITER_GET_CLASS (self)->get_enum_comment (self, en);

256

}

257

258

259

static gchar* vala_gir_writer_real_get_class_comment (ValaGIRWriter* self, ValaClass* c) {

260

gchar* result = NULL;

261

g_return_val_if_fail (c != NULL, NULL);

262

result = NULL;

263

return result;

264

}

265

266

267

gchar* vala_gir_writer_get_class_comment (ValaGIRWriter* self, ValaClass* c) {

268

g_return_val_if_fail (self != NULL, NULL);

269

return VALA_GIR_WRITER_GET_CLASS (self)->get_class_comment (self, c);

270

}

271

272

273

static gchar* vala_gir_writer_real_get_error_code_comment (ValaGIRWriter* self, ValaErrorCode* ecode) {

274

gchar* result = NULL;

275

g_return_val_if_fail (ecode != NULL, NULL);

276

result = NULL;

277

return result;

278

}

279

280

281

gchar* vala_gir_writer_get_error_code_comment (ValaGIRWriter* self, ValaErrorCode* ecode) {

282

g_return_val_if_fail (self != NULL, NULL);

283

return VALA_GIR_WRITER_GET_CLASS (self)->get_error_code_comment (self, ecode);

284

}

285

286

287

static gchar* vala_gir_writer_real_get_enum_value_comment (ValaGIRWriter* self, ValaEnumValue* ev) {

288

gchar* result = NULL;

289

g_return_val_if_fail (ev != NULL, NULL);

290

result = NULL;

291

return result;

292

}

293

294

295

gchar* vala_gir_writer_get_enum_value_comment (ValaGIRWriter* self, ValaEnumValue* ev) {

296

g_return_val_if_fail (self != NULL, NULL);

297

return VALA_GIR_WRITER_GET_CLASS (self)->get_enum_value_comment (self, ev);

298

}

299

300

301

static gchar* vala_gir_writer_real_get_constant_comment (ValaGIRWriter* self, ValaConstant* c) {

302

gchar* result = NULL;

303

g_return_val_if_fail (c != NULL, NULL);

304

result = NULL;

305

return result;

306

}

307

308

309

gchar* vala_gir_writer_get_constant_comment (ValaGIRWriter* self, ValaConstant* c) {

310

g_return_val_if_fail (self != NULL, NULL);

311

return VALA_GIR_WRITER_GET_CLASS (self)->get_constant_comment (self, c);

312

}

313

314

315

static gchar* vala_gir_writer_real_get_error_domain_comment (ValaGIRWriter* self, ValaErrorDomain* edomain) {

316

gchar* result = NULL;

317

g_return_val_if_fail (edomain != NULL, NULL);

318

result = NULL;

319

return result;

320

}

321

322

323

gchar* vala_gir_writer_get_error_domain_comment (ValaGIRWriter* self, ValaErrorDomain* edomain) {

324

g_return_val_if_fail (self != NULL, NULL);

325

return VALA_GIR_WRITER_GET_CLASS (self)->get_error_domain_comment (self, edomain);

326

}

327

328

329

static gchar* vala_gir_writer_real_get_field_comment (ValaGIRWriter* self, ValaField* f) {

330

gchar* result = NULL;

331

g_return_val_if_fail (f != NULL, NULL);

332

result = NULL;

333

return result;

334

}

335

336

337

gchar* vala_gir_writer_get_field_comment (ValaGIRWriter* self, ValaField* f) {

338

g_return_val_if_fail (self != NULL, NULL);

339

return VALA_GIR_WRITER_GET_CLASS (self)->get_field_comment (self, f);

340

}

341

342

343

static gchar* vala_gir_writer_real_get_delegate_comment (ValaGIRWriter* self, ValaDelegate* cb) {

344

gchar* result = NULL;

345

g_return_val_if_fail (cb != NULL, NULL);

346

result = NULL;

347

return result;

348

}

349

350

351

gchar* vala_gir_writer_get_delegate_comment (ValaGIRWriter* self, ValaDelegate* cb) {

352

g_return_val_if_fail (self != NULL, NULL);

353

return VALA_GIR_WRITER_GET_CLASS (self)->get_delegate_comment (self, cb);

354

}

355

356

357

static gchar* vala_gir_writer_real_get_method_comment (ValaGIRWriter* self, ValaMethod* m) {

358

gchar* result = NULL;

359

g_return_val_if_fail (m != NULL, NULL);

360

result = NULL;

361

return result;

362

}

363

364

365

gchar* vala_gir_writer_get_method_comment (ValaGIRWriter* self, ValaMethod* m) {

366

g_return_val_if_fail (self != NULL, NULL);

367

return VALA_GIR_WRITER_GET_CLASS (self)->get_method_comment (self, m);

368

}

369

370

371

static gchar* vala_gir_writer_real_get_property_comment (ValaGIRWriter* self, ValaProperty* prop) {

372

gchar* result = NULL;

373

g_return_val_if_fail (prop != NULL, NULL);

374

result = NULL;

375

return result;

376

}

377

378

379

gchar* vala_gir_writer_get_property_comment (ValaGIRWriter* self, ValaProperty* prop) {

380

g_return_val_if_fail (self != NULL, NULL);

381

return VALA_GIR_WRITER_GET_CLASS (self)->get_property_comment (self, prop);

382

}

383

384

385

static gchar* vala_gir_writer_real_get_delegate_return_comment (ValaGIRWriter* self, ValaDelegate* cb) {

386

gchar* result = NULL;

387

g_return_val_if_fail (cb != NULL, NULL);

388

result = NULL;

389

return result;

390

}

391

392

393

gchar* vala_gir_writer_get_delegate_return_comment (ValaGIRWriter* self, ValaDelegate* cb) {

394

g_return_val_if_fail (self != NULL, NULL);

395

return VALA_GIR_WRITER_GET_CLASS (self)->get_delegate_return_comment (self, cb);

396

}

397

398

399

static gchar* vala_gir_writer_real_get_signal_return_comment (ValaGIRWriter* self, ValaSignal* sig) {

400

gchar* result = NULL;

401

g_return_val_if_fail (sig != NULL, NULL);

402

result = NULL;

403

return result;

404

}

405

406

407

gchar* vala_gir_writer_get_signal_return_comment (ValaGIRWriter* self, ValaSignal* sig) {

408

g_return_val_if_fail (self != NULL, NULL);

409

return VALA_GIR_WRITER_GET_CLASS (self)->get_signal_return_comment (self, sig);

410

}

411

412

413

static gchar* vala_gir_writer_real_get_method_return_comment (ValaGIRWriter* self, ValaMethod* m) {

414

gchar* result = NULL;

415

g_return_val_if_fail (m != NULL, NULL);

416

result = NULL;

417

return result;

418

}

419

420

421

gchar* vala_gir_writer_get_method_return_comment (ValaGIRWriter* self, ValaMethod* m) {

422

g_return_val_if_fail (self != NULL, NULL);

423

return VALA_GIR_WRITER_GET_CLASS (self)->get_method_return_comment (self, m);

424

}

425

426

427

static gchar* vala_gir_writer_real_get_signal_comment (ValaGIRWriter* self, ValaSignal* sig) {

428

gchar* result = NULL;

429

g_return_val_if_fail (sig != NULL, NULL);

430

result = NULL;

431

return result;

432

}

433

434

435

gchar* vala_gir_writer_get_signal_comment (ValaGIRWriter* self, ValaSignal* sig) {

436

g_return_val_if_fail (self != NULL, NULL);

437

return VALA_GIR_WRITER_GET_CLASS (self)->get_signal_comment (self, sig);

438

}

439

440

441

static gchar* vala_gir_writer_real_get_parameter_comment (ValaGIRWriter* self, ValaParameter* param) {

442

gchar* result = NULL;

443

g_return_val_if_fail (param != NULL, NULL);

444

result = NULL;

445

return result;

446

}

447

448

449

gchar* vala_gir_writer_get_parameter_comment (ValaGIRWriter* self, ValaParameter* param) {

450

g_return_val_if_fail (self != NULL, NULL);

451

return VALA_GIR_WRITER_GET_CLASS (self)->get_parameter_comment (self, param);

452

}

453

454

455

static gpointer _vala_iterable_ref0 (gpointer self) {

456

return self ? vala_iterable_ref (self) : NULL;

457

}

458

459

460

void vala_gir_writer_write_includes (ValaGIRWriter* self) {

461

g_return_if_fail (self != NULL);

462

{

463

ValaArrayList* _tmp0_;

464

ValaArrayList* _tmp1_;

465

ValaArrayList* _i_list;

466

ValaArrayList* _tmp2_;

467

gint _tmp3_;

468

gint _tmp4_;

469

gint _i_size;

470

gint _i_index;

471

_tmp0_ = self->priv->externals;

472

_tmp1_ = _vala_iterable_ref0 (_tmp0_);

473

_i_list = _tmp1_;

474

_tmp2_ = _i_list;

475

_tmp3_ = vala_collection_get_size ((ValaCollection*) _tmp2_);

476

_tmp4_ = _tmp3_;

477

_i_size = _tmp4_;

478

_i_index = -1;

479

while (TRUE) {

480

gint _tmp5_;

481

gint _tmp6_;

482

gint _tmp7_;

483

ValaArrayList* _tmp8_;

484

gint _tmp9_;

485

gpointer _tmp10_ = NULL;

486

ValaGIRWriterGIRNamespace* i;

487

ValaGIRWriterGIRNamespace* _tmp11_;

488

const gchar* _tmp12_;

489

const gchar* _tmp13_;

490

_tmp5_ = _i_index;

491

_i_index = _tmp5_ + 1;

492

_tmp6_ = _i_index;

493

_tmp7_ = _i_size;

494

if (!(_tmp6_ < _tmp7_)) {

495

break;

496

}

497

_tmp8_ = _i_list;

498

_tmp9_ = _i_index;

499

_tmp10_ = vala_list_get ((ValaList*) _tmp8_, _tmp9_);

500

i = (ValaGIRWriterGIRNamespace*) _tmp10_;

501

_tmp11_ = i;

502

_tmp12_ = (*_tmp11_).ns;

503

_tmp13_ = self->priv->gir_namespace;

504

if (g_strcmp0 (_tmp12_, _tmp13_) != 0) {

505

FILE* _tmp14_;

506

ValaGIRWriterGIRNamespace* _tmp15_;

507

const gchar* _tmp16_;

508

ValaGIRWriterGIRNamespace* _tmp17_;

509

const gchar* _tmp18_;

510

vala_gir_writer_write_indent_stream (self);

511

_tmp14_ = self->priv->stream;

512

_tmp15_ = i;

513

_tmp16_ = (*_tmp15_).ns;

514

_tmp17_ = i;

515

_tmp18_ = (*_tmp17_).version;

516

fprintf (_tmp14_, "<include name=\"%s\" version=\"%s\"/>\n", _tmp16_, _tmp18_);

517

}

518

_vala_gir_writer_gir_namespace_free0 (i);

519

}

520

_vala_iterable_unref0 (_i_list);

521

}

522

}

523

524

525

/**

526

* Writes the public interface of the specified code context into the

527

* specified file.

528

529

* @param context a code context

530

* @param filename a relative or absolute filename

531

532

static gpointer _vala_code_context_ref0 (gpointer self) {

533

return self ? vala_code_context_ref (self) : NULL;

534

}

535

536

537

static gpointer _vala_code_node_ref0 (gpointer self) {

538

return self ? vala_code_node_ref (self) : NULL;

539

}

540

541

542

void vala_gir_writer_write_file (ValaGIRWriter* self, ValaCodeContext* context, const gchar* directory, const gchar* gir_namespace, const gchar* gir_version, const gchar* package) {

543

ValaCodeContext* _tmp0_;

544

ValaCodeContext* _tmp1_;

545

const gchar* _tmp2_;

546

gchar* _tmp3_;

547

const gchar* _tmp4_;

548

gchar* _tmp5_;

549

const gchar* _tmp6_;

550

gchar* _tmp7_;

551

ValaCodeContext* _tmp8_;

552

ValaNamespace* _tmp9_;

553

ValaNamespace* _tmp10_;

554

ValaNamespace* _tmp11_;

555

ValaNamespace* root_symbol;

556

ValaNamespace* _tmp12_;

557

ValaScope* _tmp13_;

558

ValaScope* _tmp14_;

559

ValaSymbol* _tmp15_ = NULL;

560

ValaSymbol* glib_ns;

561

ValaSymbol* _tmp16_;

562

ValaScope* _tmp17_;

563

ValaScope* _tmp18_;

564

ValaSymbol* _tmp19_ = NULL;

565

ValaSymbol* _tmp20_;

566

ValaScope* _tmp21_;

567

ValaScope* _tmp22_;

568

ValaSymbol* _tmp23_ = NULL;

569

const gchar* _tmp24_;

570

ValaCodeContext* _tmp25_;

571

gint _tmp26_;

572

GString* _tmp27_;

573

const gchar* _tmp28_;

574

const gchar* _tmp29_;

575

const gchar* _tmp30_;

576

gchar* _tmp31_ = NULL;

577

gchar* filename;

578

const gchar* _tmp32_;

579

FILE* _tmp33_ = NULL;

580

FILE* _tmp34_;

581

FILE* _tmp38_;

582

FILE* _tmp39_;

583

FILE* _tmp40_;

584

FILE* _tmp41_;

585

FILE* _tmp42_;

586

FILE* _tmp43_;

587

gint _tmp44_;

588

gint _tmp45_;

589

FILE* _tmp46_;

590

GString* _tmp47_;

591

const gchar* _tmp48_;

592

ValaHashSet* _tmp84_;

593

gint _tmp85_;

594

gint _tmp86_;

595

g_return_if_fail (self != NULL);

596

g_return_if_fail (context != NULL);

597

g_return_if_fail (directory != NULL);

598

g_return_if_fail (gir_namespace != NULL);

599

g_return_if_fail (gir_version != NULL);

600

g_return_if_fail (package != NULL);

601

_tmp0_ = context;

602

_tmp1_ = _vala_code_context_ref0 (_tmp0_);

603

_vala_code_context_unref0 (self->priv->context);

604

self->priv->context = _tmp1_;

605

_tmp2_ = directory;

606

_tmp3_ = g_strdup (_tmp2_);

607

_g_free0 (self->priv->directory);

608

self->priv->directory = _tmp3_;

609

_tmp4_ = gir_namespace;

610

_tmp5_ = g_strdup (_tmp4_);

611

_g_free0 (self->priv->gir_namespace);

612

self->priv->gir_namespace = _tmp5_;

613

_tmp6_ = gir_version;

614

_tmp7_ = g_strdup (_tmp6_);

615

_g_free0 (self->priv->gir_version);

616

self->priv->gir_version = _tmp7_;

617

_tmp8_ = context;

618

_tmp9_ = vala_code_context_get_root (_tmp8_);

619

_tmp10_ = _tmp9_;

620

_tmp11_ = _vala_code_node_ref0 (_tmp10_);

621

root_symbol = _tmp11_;

622

_tmp12_ = root_symbol;

623

_tmp13_ = vala_symbol_get_scope ((ValaSymbol*) _tmp12_);

624

_tmp14_ = _tmp13_;

625

_tmp15_ = vala_scope_lookup (_tmp14_, "GLib");

626

glib_ns = _tmp15_;

627

_tmp16_ = glib_ns;

628

_tmp17_ = vala_symbol_get_scope (_tmp16_);

629

_tmp18_ = _tmp17_;

630

_tmp19_ = vala_scope_lookup (_tmp18_, "Object");

631

_vala_code_node_unref0 (self->priv->gobject_type);

632

self->priv->gobject_type = G_TYPE_CHECK_INSTANCE_CAST (_tmp19_, VALA_TYPE_TYPESYMBOL, ValaTypeSymbol);

633

_tmp20_ = glib_ns;

634

_tmp21_ = vala_symbol_get_scope (_tmp20_);

635

_tmp22_ = _tmp21_;

636

_tmp23_ = vala_scope_lookup (_tmp22_, "InitiallyUnowned");

637

_vala_code_node_unref0 (self->priv->ginitiallyunowned_type);

638

self->priv->ginitiallyunowned_type = G_TYPE_CHECK_INSTANCE_CAST (_tmp23_, VALA_TYPE_TYPESYMBOL, ValaTypeSymbol);

639

_tmp24_ = package;

640

vala_gir_writer_write_package (self, _tmp24_);

641

_tmp25_ = context;

642

vala_code_context_accept (_tmp25_, (ValaCodeVisitor*) self);

643

_tmp26_ = self->priv->indent;

644

self->priv->indent = _tmp26_ - 1;

645

_tmp27_ = self->priv->buffer;

646

g_string_append_printf (_tmp27_, "</repository>\n");

647

_tmp28_ = directory;

648

_tmp29_ = gir_namespace;

649

_tmp30_ = gir_version;

650

_tmp31_ = g_strdup_printf ("%s%c%s-%s.gir", _tmp28_, (gint) G_DIR_SEPARATOR, _tmp29_, _tmp30_);

651

filename = _tmp31_;

652

_tmp32_ = filename;

653

_tmp33_ = g_fopen (_tmp32_, "w");

654

_fclose0 (self->priv->stream);

655

self->priv->stream = _tmp33_;

656

_tmp34_ = self->priv->stream;

657

if (_tmp34_ == NULL) {

658

const gchar* _tmp35_;

659

gchar* _tmp36_ = NULL;

660

gchar* _tmp37_;

661

_tmp35_ = filename;

662

_tmp36_ = g_strdup_printf ("unable to open `%s' for writing", _tmp35_);

663

_tmp37_ = _tmp36_;

664

vala_report_error (NULL, _tmp37_);

665

_g_free0 (_tmp37_);

666

_g_free0 (filename);

667

_vala_code_node_unref0 (glib_ns);

668

_vala_code_node_unref0 (root_symbol);

669

return;

670

}

671

_tmp38_ = self->priv->stream;

672

fprintf (_tmp38_, "<?xml version=\"1.0\"?>\n");

673

_tmp39_ = self->priv->stream;

674

fprintf (_tmp39_, "<repository version=\"1.2\"");

675

_tmp40_ = self->priv->stream;

676

fprintf (_tmp40_, " xmlns=\"http://www.gtk.org/introspection/core/1.0\"");

677

_tmp41_ = self->priv->stream;

678

fprintf (_tmp41_, " xmlns:c=\"http://www.gtk.org/introspection/c/1.0\"");

679

_tmp42_ = self->priv->stream;

680

fprintf (_tmp42_, " xmlns:glib=\"http://www.gtk.org/introspection/glib/1.0\"");

681

_tmp43_ = self->priv->stream;

682

fprintf (_tmp43_, ">\n");

683

_tmp44_ = self->priv->indent;

684

self->priv->indent = _tmp44_ + 1;

685

vala_gir_writer_write_includes (self);

686

_tmp45_ = self->priv->indent;

687

self->priv->indent = _tmp45_ - 1;

688

_tmp46_ = self->priv->stream;

689

_tmp47_ = self->priv->buffer;

690

_tmp48_ = _tmp47_->str;

691

fputs (_tmp48_, _tmp46_);

692

_fclose0 (self->priv->stream);

693

self->priv->stream = NULL;

694

{

695

ValaHashSet* _tmp49_;

696

ValaIterator* _tmp50_ = NULL;

697

ValaIterator* _ns_it;

698

_tmp49_ = self->priv->unannotated_namespaces;

699

_tmp50_ = vala_iterable_iterator ((ValaIterable*) _tmp49_);

700

_ns_it = _tmp50_;

701

while (TRUE) {

702

ValaIterator* _tmp51_;

703

gboolean _tmp52_ = FALSE;

704

ValaIterator* _tmp53_;

705

gpointer _tmp54_ = NULL;

706

ValaNamespace* ns;

707

ValaHashSet* _tmp55_;

708

ValaNamespace* _tmp56_;

709

gboolean _tmp57_ = FALSE;

710

_tmp51_ = _ns_it;

711

_tmp52_ = vala_iterator_next (_tmp51_);

712

if (!_tmp52_) {

713

break;

714

}

715

_tmp53_ = _ns_it;

716

_tmp54_ = vala_iterator_get (_tmp53_);

717

ns = (ValaNamespace*) _tmp54_;

718

_tmp55_ = self->priv->our_namespaces;

719

_tmp56_ = ns;

720

_tmp57_ = vala_collection_contains ((ValaCollection*) _tmp55_, _tmp56_);

721

if (!_tmp57_) {

722

ValaNamespace* _tmp58_;

723

ValaSourceReference* _tmp59_;

724

ValaSourceReference* _tmp60_;

725

ValaNamespace* _tmp61_;

726

const gchar* _tmp62_;

727

const gchar* _tmp63_;

728

gchar* _tmp64_ = NULL;

729

gchar* _tmp65_;

730

_tmp58_ = ns;

731

_tmp59_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp58_);

732

_tmp60_ = _tmp59_;

733

_tmp61_ = ns;

734

_tmp62_ = vala_symbol_get_name ((ValaSymbol*) _tmp61_);

735

_tmp63_ = _tmp62_;

736

_tmp64_ = g_strdup_printf ("Namespace %s does not have a GIR namespace and version annotation", _tmp63_);

737

_tmp65_ = _tmp64_;

738

vala_report_warning (_tmp60_, _tmp65_);

739

_g_free0 (_tmp65_);

740

}

741

_vala_code_node_unref0 (ns);

742

}

743

_vala_iterator_unref0 (_ns_it);

744

}

745

{

746

ValaHashSet* _tmp66_;

747

ValaIterator* _tmp67_ = NULL;

748

ValaIterator* _ns_it;

749

_tmp66_ = self->priv->our_namespaces;

750

_tmp67_ = vala_iterable_iterator ((ValaIterable*) _tmp66_);

751

_ns_it = _tmp67_;

752

while (TRUE) {

753

ValaIterator* _tmp68_;

754

gboolean _tmp69_ = FALSE;

755

ValaIterator* _tmp70_;

756

gpointer _tmp71_ = NULL;

757

ValaNamespace* ns;

758

ValaNamespace* _tmp72_;

759

ValaSourceReference* _tmp73_;

760

ValaSourceReference* _tmp74_;

761

ValaSourceFile* _tmp75_;

762

ValaSourceFile* _tmp76_;

763

const gchar* _tmp77_;

764

ValaNamespace* _tmp78_;

765

ValaSourceReference* _tmp79_;

766

ValaSourceReference* _tmp80_;

767

ValaSourceFile* _tmp81_;

768

ValaSourceFile* _tmp82_;

769

const gchar* _tmp83_;

770

_tmp68_ = _ns_it;

771

_tmp69_ = vala_iterator_next (_tmp68_);

772

if (!_tmp69_) {

773

break;

774

}

775

_tmp70_ = _ns_it;

776

_tmp71_ = vala_iterator_get (_tmp70_);

777

ns = (ValaNamespace*) _tmp71_;

778

_tmp72_ = ns;

779

_tmp73_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp72_);

780

_tmp74_ = _tmp73_;

781

_tmp75_ = vala_source_reference_get_file (_tmp74_);

782

_tmp76_ = _tmp75_;

783

_tmp77_ = gir_namespace;

784

vala_source_file_set_gir_namespace (_tmp76_, _tmp77_);

785

_tmp78_ = ns;

786

_tmp79_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp78_);

787

_tmp80_ = _tmp79_;

788

_tmp81_ = vala_source_reference_get_file (_tmp80_);

789

_tmp82_ = _tmp81_;

790

_tmp83_ = gir_version;

791

vala_source_file_set_gir_version (_tmp82_, _tmp83_);

792

_vala_code_node_unref0 (ns);

793

}

794

_vala_iterator_unref0 (_ns_it);

795

}

796

_tmp84_ = self->priv->our_namespaces;

797

_tmp85_ = vala_collection_get_size ((ValaCollection*) _tmp84_);

798

_tmp86_ = _tmp85_;

799

if (_tmp86_ == 0) {

800

vala_report_error (NULL, "No suitable namespace found to export for GIR");

801

}

802

_g_free0 (filename);

803

_vala_code_node_unref0 (glib_ns);

804

_vala_code_node_unref0 (root_symbol);

805

}

806

807

808

static void vala_gir_writer_write_doc (ValaGIRWriter* self, const gchar* comment) {

809

const gchar* _tmp0_;

810

g_return_if_fail (self != NULL);

811

_tmp0_ = comment;

812

if (_tmp0_ != NULL) {

813

GString* _tmp1_;

814

GString* _tmp2_;

815

const gchar* _tmp3_;

816

GString* _tmp4_;

817

vala_gir_writer_write_indent (self);

818

_tmp1_ = self->priv->buffer;

819

g_string_append (_tmp1_, "<doc xml:whitespace=\"preserve\">");

820

_tmp2_ = self->priv->buffer;

821

_tmp3_ = comment;

822

g_string_append (_tmp2_, _tmp3_);

823

_tmp4_ = self->priv->buffer;

824

g_string_append (_tmp4_, "</doc>\n");

825

}

826

}

827

828

829

static void vala_gir_writer_write_package (ValaGIRWriter* self, const gchar* package) {

830

GString* _tmp0_;

831

const gchar* _tmp1_;

832

g_return_if_fail (self != NULL);

833

g_return_if_fail (package != NULL);

834

vala_gir_writer_write_indent (self);

835

_tmp0_ = self->priv->buffer;

836

_tmp1_ = package;

837

g_string_append_printf (_tmp0_, "<package name=\"%s\"/>\n", _tmp1_);

838

}

839

840

841

static void vala_gir_writer_write_c_includes (ValaGIRWriter* self, ValaNamespace* ns) {

842

GHashFunc _tmp0_;

843

GEqualFunc _tmp1_;

844

ValaHashSet* _tmp2_;

845

ValaSet* header_filenames;

846

ValaNamespace* _tmp3_;

847

gchar* _tmp4_ = NULL;

848

gchar* _tmp5_;

849

gchar** _tmp6_;

850

gchar** _tmp7_ = NULL;

851

gchar** _tmp8_;

852

gint _tmp8__length1;

853

g_return_if_fail (self != NULL);

854

g_return_if_fail (ns != NULL);

855

_tmp0_ = g_str_hash;

856

_tmp1_ = g_str_equal;

857

_tmp2_ = vala_hash_set_new (G_TYPE_STRING, (GBoxedCopyFunc) g_strdup, g_free, _tmp0_, _tmp1_);

858

header_filenames = (ValaSet*) _tmp2_;

859

_tmp3_ = ns;

860

_tmp4_ = vala_ccode_base_module_get_ccode_header_filenames ((ValaSymbol*) _tmp3_);

861

_tmp5_ = _tmp4_;

862

_tmp7_ = _tmp6_ = g_strsplit (_tmp5_, ",", 0);

863

_tmp8_ = _tmp7_;

864

_tmp8__length1 = _vala_array_length (_tmp6_);

865

_g_free0 (_tmp5_);

866

{

867

gchar** c_header_filename_collection = NULL;

868

gint c_header_filename_collection_length1 = 0;

869

gint _c_header_filename_collection_size_ = 0;

870

gint c_header_filename_it = 0;

871

c_header_filename_collection = _tmp8_;

872

c_header_filename_collection_length1 = _tmp8__length1;

873

for (c_header_filename_it = 0; c_header_filename_it < _tmp8__length1; c_header_filename_it = c_header_filename_it + 1) {

874

gchar* _tmp9_;

875

gchar* c_header_filename = NULL;

876

_tmp9_ = g_strdup (c_header_filename_collection[c_header_filename_it]);

877

c_header_filename = _tmp9_;

878

{

879

ValaSet* _tmp10_;

880

const gchar* _tmp11_;

881

_tmp10_ = header_filenames;

882

_tmp11_ = c_header_filename;

883

vala_collection_add ((ValaCollection*) _tmp10_, _tmp11_);

884

_g_free0 (c_header_filename);

885

}

886

}

887

c_header_filename_collection = (_vala_array_free (c_header_filename_collection, c_header_filename_collection_length1, (GDestroyNotify) g_free), NULL);

888

}

889

{

890

ValaNamespace* _tmp12_;

891

ValaScope* _tmp13_;

892

ValaScope* _tmp14_;

893

ValaMap* _tmp15_ = NULL;

894

ValaMap* _tmp16_;

895

ValaCollection* _tmp17_ = NULL;

896

ValaCollection* _tmp18_;

897

ValaIterator* _tmp19_ = NULL;

898

ValaIterator* _tmp20_;

899

ValaIterator* _symbol_it;

900

_tmp12_ = ns;

901

_tmp13_ = vala_symbol_get_scope ((ValaSymbol*) _tmp12_);

902

_tmp14_ = _tmp13_;

903

_tmp15_ = vala_scope_get_symbol_table (_tmp14_);

904

_tmp16_ = _tmp15_;

905

_tmp17_ = vala_map_get_values (_tmp16_);

906

_tmp18_ = _tmp17_;

907

_tmp19_ = vala_iterable_iterator ((ValaIterable*) _tmp18_);

908

_tmp20_ = _tmp19_;

909

_vala_iterable_unref0 (_tmp18_);

910

_vala_map_unref0 (_tmp16_);

911

_symbol_it = _tmp20_;

912

while (TRUE) {

913

ValaIterator* _tmp21_;

914

gboolean _tmp22_ = FALSE;

915

ValaIterator* _tmp23_;

916

gpointer _tmp24_ = NULL;

917

ValaSymbol* symbol;

918

ValaSymbol* _tmp25_;

919

gchar* _tmp26_ = NULL;

920

gchar* _tmp27_;

921

gchar** _tmp28_;

922

gchar** _tmp29_ = NULL;

923

gchar** _tmp30_;

924

gint _tmp30__length1;

925

_tmp21_ = _symbol_it;

926

_tmp22_ = vala_iterator_next (_tmp21_);

927

if (!_tmp22_) {

928

break;

929

}

930

_tmp23_ = _symbol_it;

931

_tmp24_ = vala_iterator_get (_tmp23_);

932

symbol = (ValaSymbol*) _tmp24_;

933

_tmp25_ = symbol;

934

_tmp26_ = vala_ccode_base_module_get_ccode_header_filenames (_tmp25_);

935

_tmp27_ = _tmp26_;

936

_tmp29_ = _tmp28_ = g_strsplit (_tmp27_, ",", 0);

937

_tmp30_ = _tmp29_;

938

_tmp30__length1 = _vala_array_length (_tmp28_);

939

_g_free0 (_tmp27_);

940

{

941

gchar** c_header_filename_collection = NULL;

942

gint c_header_filename_collection_length1 = 0;

943

gint _c_header_filename_collection_size_ = 0;

944

gint c_header_filename_it = 0;

945

c_header_filename_collection = _tmp30_;

946

c_header_filename_collection_length1 = _tmp30__length1;

947

for (c_header_filename_it = 0; c_header_filename_it < _tmp30__length1; c_header_filename_it = c_header_filename_it + 1) {

948

gchar* _tmp31_;

949

gchar* c_header_filename = NULL;

950

_tmp31_ = g_strdup (c_header_filename_collection[c_header_filename_it]);

951

c_header_filename = _tmp31_;

952

{

953

ValaSet* _tmp32_;

954

const gchar* _tmp33_;

955

_tmp32_ = header_filenames;

956

_tmp33_ = c_header_filename;

957

vala_collection_add ((ValaCollection*) _tmp32_, _tmp33_);

958

_g_free0 (c_header_filename);

959

}

960

}

961

c_header_filename_collection = (_vala_array_free (c_header_filename_collection, c_header_filename_collection_length1, (GDestroyNotify) g_free), NULL);

962

}

963

_vala_code_node_unref0 (symbol);

964

}

965

_vala_iterator_unref0 (_symbol_it);

966

}

967

{

968

ValaSet* _tmp34_;

969

ValaIterator* _tmp35_ = NULL;

970

ValaIterator* _c_header_filename_it;

971

_tmp34_ = header_filenames;

972

_tmp35_ = vala_iterable_iterator ((ValaIterable*) _tmp34_);

973

_c_header_filename_it = _tmp35_;

974

while (TRUE) {

975

ValaIterator* _tmp36_;

976

gboolean _tmp37_ = FALSE;

977

ValaIterator* _tmp38_;

978

gpointer _tmp39_ = NULL;

979

gchar* c_header_filename;

980

const gchar* _tmp40_;

981

_tmp36_ = _c_header_filename_it;

982

_tmp37_ = vala_iterator_next (_tmp36_);

983

if (!_tmp37_) {

984

break;

985

}

986

_tmp38_ = _c_header_filename_it;

987

_tmp39_ = vala_iterator_get (_tmp38_);

988

c_header_filename = (gchar*) _tmp39_;

989

_tmp40_ = c_header_filename;

990

vala_gir_writer_write_c_include (self, _tmp40_);

991

_g_free0 (c_header_filename);

992

}

993

_vala_iterator_unref0 (_c_header_filename_it);

994

}

995

_vala_iterable_unref0 (header_filenames);

996

}

997

998

999

static void vala_gir_writer_write_c_include (ValaGIRWriter* self, const gchar* name) {

1000

GString* _tmp0_;

1001

const gchar* _tmp1_;

1002

g_return_if_fail (self != NULL);

1003

g_return_if_fail (name != NULL);

1004

vala_gir_writer_write_indent (self);

1005

_tmp0_ = self->priv->buffer;

1006

_tmp1_ = name;

1007

g_string_append_printf (_tmp0_, "<c:include name=\"%s\"/>\n", _tmp1_);

1008

}

1009

1010

1011

static void vala_gir_writer_real_visit_namespace (ValaCodeVisitor* base, ValaNamespace* ns) {

1012

ValaGIRWriter * self;

1013

ValaNamespace* _tmp0_;

1014

gboolean _tmp1_;

1015

gboolean _tmp2_;

1016

ValaNamespace* _tmp3_;

1017

const gchar* _tmp4_;

1018

const gchar* _tmp5_;

1019

ValaNamespace* _tmp10_;

1020

ValaSymbol* _tmp11_;

1021

ValaSymbol* _tmp12_;

1022

const gchar* _tmp13_;

1023

const gchar* _tmp14_;

1024

ValaNamespace* _tmp16_;

1025

GString* _tmp17_;

1026

const gchar* _tmp18_;

1027

const gchar* _tmp19_;

1028

ValaNamespace* _tmp20_;

1029

gchar* _tmp21_ = NULL;

1030

gchar* cprefix;

1031

const gchar* _tmp22_;

1032

GString* _tmp25_;

1033

gint _tmp26_;

1034

ValaNamespace* _tmp27_;

1035

ValaArrayList* _tmp28_;

1036

ValaNamespace* _tmp29_;

1037

ValaNamespace* _tmp30_;

1038

ValaArrayList* _tmp31_;

1039

gint _tmp32_;

1040

GString* _tmp33_;

1041

ValaHashSet* _tmp34_;

1042

ValaNamespace* _tmp35_;

1043

self = (ValaGIRWriter*) base;

1044

g_return_if_fail (ns != NULL);

1045

_tmp0_ = ns;

1046

_tmp1_ = vala_symbol_get_external_package ((ValaSymbol*) _tmp0_);

1047

_tmp2_ = _tmp1_;

1048

if (_tmp2_) {

1049

return;

1050

}

1051

_tmp3_ = ns;

1052

_tmp4_ = vala_symbol_get_name ((ValaSymbol*) _tmp3_);

1053

_tmp5_ = _tmp4_;

1054

if (_tmp5_ == NULL) {

1055

ValaArrayList* _tmp6_;

1056

ValaNamespace* _tmp7_;

1057

ValaNamespace* _tmp8_;

1058

ValaArrayList* _tmp9_;

1059

_tmp6_ = self->priv->hierarchy;

1060

_tmp7_ = ns;

1061

vala_list_insert ((ValaList*) _tmp6_, 0, (ValaSymbol*) _tmp7_);

1062

_tmp8_ = ns;

1063

vala_code_node_accept_children ((ValaCodeNode*) _tmp8_, (ValaCodeVisitor*) self);

1064

_tmp9_ = self->priv->hierarchy;

1065

vala_list_remove_at ((ValaList*) _tmp9_, 0);

1066

return;

1067

}

1068

_tmp10_ = ns;

1069

_tmp11_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp10_);

1070

_tmp12_ = _tmp11_;

1071

_tmp13_ = vala_symbol_get_name (_tmp12_);

1072

_tmp14_ = _tmp13_;

1073

if (_tmp14_ != NULL) {

1074

ValaNamespace* _tmp15_;

1075

_tmp15_ = ns;

1076

vala_code_node_accept_children ((ValaCodeNode*) _tmp15_, (ValaCodeVisitor*) self);

1077

return;

1078

}

1079

_tmp16_ = ns;

1080

vala_gir_writer_write_c_includes (self, _tmp16_);

1081

vala_gir_writer_write_indent (self);

1082

_tmp17_ = self->priv->buffer;

1083

_tmp18_ = self->priv->gir_namespace;

1084

_tmp19_ = self->priv->gir_version;

1085

g_string_append_printf (_tmp17_, "<namespace name=\"%s\" version=\"%s\"", _tmp18_, _tmp19_);

1086

_tmp20_ = ns;

1087

_tmp21_ = vala_ccode_base_module_get_ccode_prefix ((ValaSymbol*) _tmp20_);

1088

cprefix = _tmp21_;

1089

_tmp22_ = cprefix;

1090

if (_tmp22_ != NULL) {

1091

GString* _tmp23_;

1092

const gchar* _tmp24_;

1093

_tmp23_ = self->priv->buffer;

1094

_tmp24_ = cprefix;

1095

g_string_append_printf (_tmp23_, " c:prefix=\"%s\"", _tmp24_);

1096

}

1097

_tmp25_ = self->priv->buffer;

1098

g_string_append_printf (_tmp25_, ">\n");

1099

_tmp26_ = self->priv->indent;

1100

self->priv->indent = _tmp26_ + 1;

1101

_tmp27_ = ns;

1102

vala_gir_writer_write_annotations (self, (ValaCodeNode*) _tmp27_);

1103

_tmp28_ = self->priv->hierarchy;

1104

_tmp29_ = ns;

1105

vala_list_insert ((ValaList*) _tmp28_, 0, (ValaSymbol*) _tmp29_);

1106

_tmp30_ = ns;

1107

vala_code_node_accept_children ((ValaCodeNode*) _tmp30_, (ValaCodeVisitor*) self);

1108

_tmp31_ = self->priv->hierarchy;

1109

vala_list_remove_at ((ValaList*) _tmp31_, 0);

1110

_tmp32_ = self->priv->indent;

1111

self->priv->indent = _tmp32_ - 1;

1112

vala_gir_writer_write_indent (self);

1113

_tmp33_ = self->priv->buffer;

1114

g_string_append_printf (_tmp33_, "</namespace>\n");

1115

_tmp34_ = self->priv->our_namespaces;

1116

_tmp35_ = ns;

1117

vala_collection_add ((ValaCollection*) _tmp34_, _tmp35_);

1118

vala_gir_writer_visit_deferred (self);

1119

_g_free0 (cprefix);

1120

}

1121

1122

1123

static void vala_gir_writer_write_symbol_attributes (ValaGIRWriter* self, ValaSymbol* symbol) {

1124

ValaSymbol* _tmp0_;

1125

gboolean _tmp1_;

1126

gboolean _tmp2_;

1127

g_return_if_fail (self != NULL);

1128

g_return_if_fail (symbol != NULL);

1129

_tmp0_ = symbol;

1130

_tmp1_ = vala_symbol_get_deprecated (_tmp0_);

1131

_tmp2_ = _tmp1_;

1132

if (_tmp2_) {

1133

gchar* _tmp3_ = NULL;

1134

ValaSymbol* _tmp4_;

1135

gchar* _tmp5_;

1136

gchar* _tmp6_;

1137

gchar* _tmp7_;

1138

gboolean _tmp8_;

1139

GString* _tmp15_;

1140

const gchar* _tmp16_;

1141

ValaSymbol* _tmp17_;

1142

gchar* _tmp18_;

1143

gchar* _tmp19_;

1144

gchar* _tmp20_;

1145

gboolean _tmp21_;

1146

_tmp4_ = symbol;

1147

_tmp5_ = vala_symbol_get_replacement (_tmp4_);

1148

_tmp6_ = _tmp5_;

1149

_tmp7_ = _tmp6_;

1150

_tmp8_ = _tmp7_ == NULL;

1151

_g_free0 (_tmp7_);

1152

if (_tmp8_) {

1153

gchar* _tmp9_;

1154

_tmp9_ = g_strdup ("");

1155

_g_free0 (_tmp3_);

1156

_tmp3_ = _tmp9_;

1157

} else {

1158

ValaSymbol* _tmp10_;

1159

gchar* _tmp11_;

1160

gchar* _tmp12_;

1161

gchar* _tmp13_;

1162

gchar* _tmp14_ = NULL;

1163

_tmp10_ = symbol;

1164

_tmp11_ = vala_symbol_get_replacement (_tmp10_);

1165

_tmp12_ = _tmp11_;

1166

_tmp13_ = _tmp12_;

1167

_tmp14_ = g_strdup_printf ("Use %s", _tmp13_);

1168

_g_free0 (_tmp3_);

1169

_tmp3_ = _tmp14_;

1170

_g_free0 (_tmp13_);

1171

}

1172

_tmp15_ = self->priv->buffer;

1173

_tmp16_ = _tmp3_;

1174

g_string_append_printf (_tmp15_, " deprecated=\"%s\"", _tmp16_);

1175

_tmp17_ = symbol;

1176

_tmp18_ = vala_symbol_get_deprecated_since (_tmp17_);

1177

_tmp19_ = _tmp18_;

1178

_tmp20_ = _tmp19_;

1179

_tmp21_ = _tmp20_ != NULL;

1180

_g_free0 (_tmp20_);

1181

if (_tmp21_) {

1182

GString* _tmp22_;

1183

ValaSymbol* _tmp23_;

1184

gchar* _tmp24_;

1185

gchar* _tmp25_;

1186

gchar* _tmp26_;

1187

_tmp22_ = self->priv->buffer;

1188

_tmp23_ = symbol;

1189

_tmp24_ = vala_symbol_get_deprecated_since (_tmp23_);

1190

_tmp25_ = _tmp24_;

1191

_tmp26_ = _tmp25_;

1192

g_string_append_printf (_tmp22_, " deprecated-version=\"%s\"", _tmp26_);

1193

_g_free0 (_tmp26_);

1194

}

1195

_g_free0 (_tmp3_);

1196

}

1197

}

1198

1199

1200

static glong string_strnlen (gchar* str, glong maxlen) {

1201

glong result = 0L;

1202

gchar* _tmp0_;

1203

glong _tmp1_;

1204

gchar* _tmp2_ = NULL;

1205

gchar* end;

1206

gchar* _tmp3_;

1207

_tmp0_ = str;

1208

_tmp1_ = maxlen;

1209

_tmp2_ = memchr (_tmp0_, 0, (gsize) _tmp1_);

1210

end = _tmp2_;

1211

_tmp3_ = end;

1212

if (_tmp3_ == NULL) {

1213

glong _tmp4_;

1214

_tmp4_ = maxlen;

1215

result = _tmp4_;

1216

return result;

1217

} else {

1218

gchar* _tmp5_;

1219

gchar* _tmp6_;

1220

_tmp5_ = end;

1221

_tmp6_ = str;

1222

result = (glong) (_tmp5_ - _tmp6_);

1223

return result;

1224

}

1225

}

1226

1227

1228

static gchar* string_substring (const gchar* self, glong offset, glong len) {

1229

gchar* result = NULL;

1230

glong string_length = 0L;

1231

gboolean _tmp0_ = FALSE;

1232

glong _tmp1_;

1233

gboolean _tmp3_;

1234

glong _tmp9_;

1235

glong _tmp15_;

1236

glong _tmp18_;

1237

glong _tmp19_;

1238

glong _tmp20_;

1239

glong _tmp21_;

1240

glong _tmp22_;

1241

gchar* _tmp23_ = NULL;

1242

g_return_val_if_fail (self != NULL, NULL);

1243

_tmp1_ = offset;

1244

if (_tmp1_ >= ((glong) 0)) {

1245

glong _tmp2_;

1246

_tmp2_ = len;

1247

_tmp0_ = _tmp2_ >= ((glong) 0);

1248

} else {

1249

_tmp0_ = FALSE;

1250

}

1251

_tmp3_ = _tmp0_;

1252

if (_tmp3_) {

1253

glong _tmp4_;

1254

glong _tmp5_;

1255

glong _tmp6_ = 0L;

1256

_tmp4_ = offset;

1257

_tmp5_ = len;

1258

_tmp6_ = string_strnlen ((gchar*) self, _tmp4_ + _tmp5_);

1259

string_length = _tmp6_;

1260

} else {

1261

gint _tmp7_;

1262

gint _tmp8_;

1263

_tmp7_ = strlen (self);

1264

_tmp8_ = _tmp7_;

1265

string_length = (glong) _tmp8_;

1266

}

1267

_tmp9_ = offset;

1268

if (_tmp9_ < ((glong) 0)) {

1269

glong _tmp10_;

1270

glong _tmp11_;

1271

glong _tmp12_;

1272

_tmp10_ = string_length;

1273

_tmp11_ = offset;

1274

offset = _tmp10_ + _tmp11_;

1275

_tmp12_ = offset;

1276

g_return_val_if_fail (_tmp12_ >= ((glong) 0), NULL);

1277

} else {

1278

glong _tmp13_;

1279

glong _tmp14_;

1280

_tmp13_ = offset;

1281

_tmp14_ = string_length;

1282

g_return_val_if_fail (_tmp13_ <= _tmp14_, NULL);

1283

}

1284

_tmp15_ = len;

1285

if (_tmp15_ < ((glong) 0)) {

1286

glong _tmp16_;

1287

glong _tmp17_;

1288

_tmp16_ = string_length;

1289

_tmp17_ = offset;

1290

len = _tmp16_ - _tmp17_;

1291

}

1292

_tmp18_ = offset;

1293

_tmp19_ = len;

1294

_tmp20_ = string_length;

1295

g_return_val_if_fail ((_tmp18_ + _tmp19_) <= _tmp20_, NULL);

1296

_tmp21_ = offset;

1297

_tmp22_ = len;

1298

_tmp23_ = g_strndup (((gchar*) self) + _tmp21_, (gsize) _tmp22_);

1299

result = _tmp23_;

1300

return result;

1301

}

1302

1303

1304

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

1305

ValaGIRWriter * self;

1306

ValaClass* _tmp0_;

1307

gboolean _tmp1_;

1308

gboolean _tmp2_;

1309

ValaClass* _tmp3_;

1310

gboolean _tmp4_ = FALSE;

1311

ValaArrayList* _tmp5_;

1312

gpointer _tmp6_ = NULL;

1313

ValaSymbol* _tmp7_;

1314

gboolean _tmp8_;

1315

ValaClass* _tmp11_;

1316

ValaTypeSymbol* _tmp12_;

1317

gboolean _tmp13_ = FALSE;

1318

self = (ValaGIRWriter*) base;

1319

g_return_if_fail (cl != NULL);

1320

_tmp0_ = cl;

1321

_tmp1_ = vala_symbol_get_external_package ((ValaSymbol*) _tmp0_);

1322

_tmp2_ = _tmp1_;

1323

if (_tmp2_) {

1324

return;

1325

}

1326

_tmp3_ = cl;

1327

_tmp4_ = vala_gir_writer_check_accessibility (self, (ValaSymbol*) _tmp3_);

1328

if (!_tmp4_) {

1329

return;

1330

}

1331

_tmp5_ = self->priv->hierarchy;

1332

_tmp6_ = vala_list_get ((ValaList*) _tmp5_, 0);

1333

_tmp7_ = (ValaSymbol*) _tmp6_;

1334

_tmp8_ = !G_TYPE_CHECK_INSTANCE_TYPE (_tmp7_, VALA_TYPE_NAMESPACE);

1335

_vala_code_node_unref0 (_tmp7_);

1336

if (_tmp8_) {

1337

ValaArrayList* _tmp9_;

1338

ValaClass* _tmp10_;

1339

_tmp9_ = self->priv->deferred;

1340

_tmp10_ = cl;

1341

vala_collection_add ((ValaCollection*) _tmp9_, (ValaCodeNode*) _tmp10_);

1342

return;

1343

}

1344

_tmp11_ = cl;

1345

_tmp12_ = self->priv->gobject_type;

1346

_tmp13_ = vala_typesymbol_is_subtype_of ((ValaTypeSymbol*) _tmp11_, _tmp12_);

1347

if (_tmp13_) {

1348

ValaClass* _tmp14_;

1349

gchar* _tmp15_ = NULL;

1350

gchar* _tmp16_;

1351

gchar* _tmp17_;

1352

gchar* _tmp18_;

1353

gchar* gtype_struct_name;

1354

GString* _tmp19_;

1355

ValaClass* _tmp20_;

1356

gchar* _tmp21_ = NULL;

1357

gchar* _tmp22_;

1358

ValaClass* _tmp23_;

1359

GString* _tmp24_;

1360

const gchar* _tmp25_;

1361

GString* _tmp26_;

1362

ValaClass* _tmp27_;

1363

ValaClass* _tmp28_;

1364

ValaClass* _tmp29_;

1365

gchar* _tmp30_ = NULL;

1366

gchar* _tmp31_;

1367

ValaClass* _tmp32_;

1368

gboolean _tmp33_;

1369

gboolean _tmp34_;

1370

ValaClass* _tmp36_;

1371

GString* _tmp37_;

1372

gint _tmp38_;

1373

ValaClass* _tmp39_;

1374

gchar* _tmp40_ = NULL;

1375

gchar* _tmp41_;

1376

ValaClass* _tmp64_;

1377

GString* _tmp65_;

1378

gint _tmp66_;

1379

GString* _tmp67_;

1380

ValaClass* _tmp68_;

1381

ValaClass* _tmp69_;

1382

ValaClass* _tmp70_;

1383

gchar* _tmp71_ = NULL;

1384

gchar* _tmp72_;

1385

ValaClass* _tmp73_;

1386

ValaClass* _tmp74_;

1387

ValaClass* _tmp75_;

1388

gchar* _tmp76_ = NULL;

1389

gchar* _tmp77_;

1390

gint _tmp78_;

1391

GString* _tmp79_;

1392

GString* _tmp80_;

1393

gint _tmp81_;

1394

GString* _tmp82_;

1395

ValaClass* _tmp83_;

1396

const gchar* _tmp84_;

1397

const gchar* _tmp85_;

1398

ValaClass* _tmp86_;

1399

gchar* _tmp87_ = NULL;

1400

gchar* _tmp88_;

1401

gint _tmp89_;

1402

GString* _tmp90_;

1403

ValaArrayList* _tmp91_;

1404

ValaClass* _tmp92_;

1405

ValaClass* _tmp93_;

1406

ValaArrayList* _tmp94_;

1407

gint _tmp95_;

1408

GString* _tmp96_;

1409

GString* _tmp97_;

1410

const gchar* _tmp98_;

1411

ValaClass* _tmp99_;

1412

GString* _tmp100_;

1413

ValaClass* _tmp101_;

1414

const gchar* _tmp102_;

1415

const gchar* _tmp103_;

1416

GString* _tmp104_;

1417

gint _tmp105_;

1418

GString* _tmp106_;

1419

gint _tmp107_;

1420

GString* _tmp108_;

1421

ValaClass* _tmp109_;

1422

ValaClass* _tmp110_;

1423

ValaClass* _tmp111_;

1424

gchar* _tmp112_ = NULL;

1425

gchar* _tmp113_;

1426

ValaClass* _tmp114_;

1427

ValaClass* _tmp115_;

1428

ValaClass* _tmp116_;

1429

gchar* _tmp117_ = NULL;

1430

gchar* _tmp118_;

1431

gint _tmp119_;

1432

GString* _tmp120_;

1433

gint _tmp243_;

1434

GString* _tmp244_;

1435

GString* _tmp245_;

1436

ValaClass* _tmp246_;

1437

const gchar* _tmp247_;

1438

const gchar* _tmp248_;

1439

ValaClass* _tmp249_;

1440

gchar* _tmp250_ = NULL;

1441

gchar* _tmp251_;

1442

_tmp14_ = cl;

1443

_tmp15_ = vala_gir_writer_get_gir_name (self, (ValaSymbol*) _tmp14_);

1444

_tmp16_ = _tmp15_;

1445

_tmp17_ = g_strconcat (_tmp16_, "Class", NULL);

1446

_tmp18_ = _tmp17_;

1447

_g_free0 (_tmp16_);

1448

gtype_struct_name = _tmp18_;

1449

vala_gir_writer_write_indent (self);

1450

_tmp19_ = self->priv->buffer;

1451

_tmp20_ = cl;

1452

_tmp21_ = vala_gir_writer_get_gir_name (self, (ValaSymbol*) _tmp20_);

1453

_tmp22_ = _tmp21_;

1454

g_string_append_printf (_tmp19_, "<class name=\"%s\"", _tmp22_);

1455

_g_free0 (_tmp22_);

1456

_tmp23_ = cl;

1457

vala_gir_writer_write_gtype_attributes (self, (ValaTypeSymbol*) _tmp23_);

1458

_tmp24_ = self->priv->buffer;

1459

_tmp25_ = gtype_struct_name;

1460

g_string_append_printf (_tmp24_, " glib:type-struct=\"%s\"", _tmp25_);

1461

_tmp26_ = self->priv->buffer;

1462

_tmp27_ = cl;

1463

_tmp28_ = vala_class_get_base_class (_tmp27_);

1464

_tmp29_ = _tmp28_;

1465

_tmp30_ = vala_gir_writer_gi_type_name (self, (ValaTypeSymbol*) _tmp29_);

1466

_tmp31_ = _tmp30_;

1467

g_string_append_printf (_tmp26_, " parent=\"%s\"", _tmp31_);

1468

_g_free0 (_tmp31_);

1469

_tmp32_ = cl;

1470

_tmp33_ = vala_class_get_is_abstract (_tmp32_);

1471

_tmp34_ = _tmp33_;

1472

if (_tmp34_) {

1473

GString* _tmp35_;

1474

_tmp35_ = self->priv->buffer;

1475

g_string_append_printf (_tmp35_, " abstract=\"1\"");

1476

}

1477

_tmp36_ = cl;

1478

vala_gir_writer_write_symbol_attributes (self, (ValaSymbol*) _tmp36_);

1479

_tmp37_ = self->priv->buffer;

1480

g_string_append_printf (_tmp37_, ">\n");

1481

_tmp38_ = self->priv->indent;

1482

self->priv->indent = _tmp38_ + 1;

1483

_tmp39_ = cl;

1484

_tmp40_ = vala_gir_writer_get_class_comment (self, _tmp39_);

1485

_tmp41_ = _tmp40_;

1486

vala_gir_writer_write_doc (self, _tmp41_);

1487

_g_free0 (_tmp41_);

1488

{

1489

ValaClass* _tmp42_;

1490

ValaList* _tmp43_ = NULL;

1491

ValaList* _base_type_list;

1492

ValaList* _tmp44_;

1493

gint _tmp45_;

1494

gint _tmp46_;

1495

gint _base_type_size;

1496

gint _base_type_index;

1497

_tmp42_ = cl;

1498

_tmp43_ = vala_class_get_base_types (_tmp42_);

1499

_base_type_list = _tmp43_;

1500

_tmp44_ = _base_type_list;

1501

_tmp45_ = vala_collection_get_size ((ValaCollection*) _tmp44_);

1502

_tmp46_ = _tmp45_;

1503

_base_type_size = _tmp46_;

1504

_base_type_index = -1;

1505

while (TRUE) {

1506

gint _tmp47_;

1507

gint _tmp48_;

1508

gint _tmp49_;

1509

ValaList* _tmp50_;

1510

gint _tmp51_;

1511

gpointer _tmp52_ = NULL;

1512

ValaDataType* base_type;

1513

ValaDataType* _tmp53_;

1514

ValaObjectType* _tmp54_;

1515

ValaObjectType* object_type;

1516

ValaObjectType* _tmp55_;

1517

ValaObjectTypeSymbol* _tmp56_;

1518

ValaObjectTypeSymbol* _tmp57_;

1519

_tmp47_ = _base_type_index;

1520

_base_type_index = _tmp47_ + 1;

1521

_tmp48_ = _base_type_index;

1522

_tmp49_ = _base_type_size;

1523

if (!(_tmp48_ < _tmp49_)) {

1524

break;

1525

}

1526

_tmp50_ = _base_type_list;

1527

_tmp51_ = _base_type_index;

1528

_tmp52_ = vala_list_get (_tmp50_, _tmp51_);

1529

base_type = (ValaDataType*) _tmp52_;

1530

_tmp53_ = base_type;

1531

_tmp54_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp53_, VALA_TYPE_OBJECT_TYPE, ValaObjectType));

1532

object_type = _tmp54_;

1533

_tmp55_ = object_type;

1534

_tmp56_ = vala_object_type_get_type_symbol (_tmp55_);

1535

_tmp57_ = _tmp56_;

1536

if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp57_, VALA_TYPE_INTERFACE)) {

1537

GString* _tmp58_;

1538

ValaObjectType* _tmp59_;

1539

ValaObjectTypeSymbol* _tmp60_;

1540

ValaObjectTypeSymbol* _tmp61_;

1541

gchar* _tmp62_ = NULL;

1542

gchar* _tmp63_;

1543

vala_gir_writer_write_indent (self);

1544

_tmp58_ = self->priv->buffer;

1545

_tmp59_ = object_type;

1546

_tmp60_ = vala_object_type_get_type_symbol (_tmp59_);

1547

_tmp61_ = _tmp60_;

1548

_tmp62_ = vala_gir_writer_gi_type_name (self, (ValaTypeSymbol*) _tmp61_);

1549

_tmp63_ = _tmp62_;

1550

g_string_append_printf (_tmp58_, "<implements name=\"%s\"/>\n", _tmp63_);

1551

_g_free0 (_tmp63_);

1552

}

1553

_vala_code_node_unref0 (object_type);

1554

_vala_code_node_unref0 (base_type);

1555

}

1556

_vala_iterable_unref0 (_base_type_list);

1557

}

1558

_tmp64_ = cl;

1559

vala_gir_writer_write_annotations (self, (ValaCodeNode*) _tmp64_);

1560

vala_gir_writer_write_indent (self);

1561

_tmp65_ = self->priv->buffer;

1562

g_string_append_printf (_tmp65_, "<field name=\"parent_instance\">\n");

1563

_tmp66_ = self->priv->indent;

1564

self->priv->indent = _tmp66_ + 1;

1565

vala_gir_writer_write_indent (self);

1566

_tmp67_ = self->priv->buffer;

1567

_tmp68_ = cl;

1568

_tmp69_ = vala_class_get_base_class (_tmp68_);

1569

_tmp70_ = _tmp69_;

1570

_tmp71_ = vala_gir_writer_gi_type_name (self, (ValaTypeSymbol*) _tmp70_);

1571

_tmp72_ = _tmp71_;

1572

_tmp73_ = cl;

1573

_tmp74_ = vala_class_get_base_class (_tmp73_);

1574

_tmp75_ = _tmp74_;

1575

_tmp76_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp75_);

1576

_tmp77_ = _tmp76_;

1577

g_string_append_printf (_tmp67_, "<type name=\"%s\" c:type=\"%s\"/>\n", _tmp72_, _tmp77_);

1578

_g_free0 (_tmp77_);

1579

_g_free0 (_tmp72_);

1580

_tmp78_ = self->priv->indent;

1581

self->priv->indent = _tmp78_ - 1;

1582

vala_gir_writer_write_indent (self);

1583

_tmp79_ = self->priv->buffer;

1584

g_string_append_printf (_tmp79_, "</field>\n");

1585

vala_gir_writer_write_indent (self);

1586

_tmp80_ = self->priv->buffer;

1587

g_string_append_printf (_tmp80_, "<field name=\"priv\">\n");

1588

_tmp81_ = self->priv->indent;

1589

self->priv->indent = _tmp81_ + 1;

1590

vala_gir_writer_write_indent (self);

1591

_tmp82_ = self->priv->buffer;

1592

_tmp83_ = cl;

1593

_tmp84_ = vala_symbol_get_name ((ValaSymbol*) _tmp83_);

1594

_tmp85_ = _tmp84_;

1595

_tmp86_ = cl;

1596

_tmp87_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp86_);

1597

_tmp88_ = _tmp87_;

1598

g_string_append_printf (_tmp82_, "<type name=\"%sPrivate\" c:type=\"%sPrivate*\"/>\n", _tmp85_, _tmp88_);

1599

_g_free0 (_tmp88_);

1600

_tmp89_ = self->priv->indent;

1601

self->priv->indent = _tmp89_ - 1;

1602

vala_gir_writer_write_indent (self);

1603

_tmp90_ = self->priv->buffer;

1604

g_string_append_printf (_tmp90_, "</field>\n");

1605

_tmp91_ = self->priv->hierarchy;

1606

_tmp92_ = cl;

1607

vala_list_insert ((ValaList*) _tmp91_, 0, (ValaSymbol*) _tmp92_);

1608

_tmp93_ = cl;

1609

vala_code_node_accept_children ((ValaCodeNode*) _tmp93_, (ValaCodeVisitor*) self);

1610

_tmp94_ = self->priv->hierarchy;

1611

vala_list_remove_at ((ValaList*) _tmp94_, 0);

1612

_tmp95_ = self->priv->indent;

1613

self->priv->indent = _tmp95_ - 1;

1614

vala_gir_writer_write_indent (self);

1615

_tmp96_ = self->priv->buffer;

1616

g_string_append_printf (_tmp96_, "</class>\n");

1617

vala_gir_writer_write_indent (self);

1618

_tmp97_ = self->priv->buffer;

1619

_tmp98_ = gtype_struct_name;

1620

g_string_append_printf (_tmp97_, "<record name=\"%s\"", _tmp98_);

1621

_tmp99_ = cl;

1622

vala_gir_writer_write_ctype_attributes (self, (ValaTypeSymbol*) _tmp99_, "Class");

1623

_tmp100_ = self->priv->buffer;

1624

_tmp101_ = cl;

1625

_tmp102_ = vala_symbol_get_name ((ValaSymbol*) _tmp101_);

1626

_tmp103_ = _tmp102_;

1627

g_string_append_printf (_tmp100_, " glib:is-gtype-struct-for=\"%s\"", _tmp103_);

1628

_tmp104_ = self->priv->buffer;

1629

g_string_append_printf (_tmp104_, ">\n");

1630

_tmp105_ = self->priv->indent;

1631

self->priv->indent = _tmp105_ + 1;

1632

vala_gir_writer_write_indent (self);

1633

_tmp106_ = self->priv->buffer;

1634

g_string_append_printf (_tmp106_, "<field name=\"parent_class\">\n");

1635

_tmp107_ = self->priv->indent;

1636

self->priv->indent = _tmp107_ + 1;

1637

vala_gir_writer_write_indent (self);

1638

_tmp108_ = self->priv->buffer;

1639

_tmp109_ = cl;

1640

_tmp110_ = vala_class_get_base_class (_tmp109_);

1641

_tmp111_ = _tmp110_;

1642

_tmp112_ = vala_gir_writer_gi_type_name (self, (ValaTypeSymbol*) _tmp111_);

1643

_tmp113_ = _tmp112_;

1644

_tmp114_ = cl;

1645

_tmp115_ = vala_class_get_base_class (_tmp114_);

1646

_tmp116_ = _tmp115_;

1647

_tmp117_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp116_);

1648

_tmp118_ = _tmp117_;

1649

g_string_append_printf (_tmp108_, "<type name=\"%sClass\" c:type=\"%sClass\"/>\n", _tmp113_, _tmp118_);

1650

_g_free0 (_tmp118_);

1651

_g_free0 (_tmp113_);

1652

_tmp119_ = self->priv->indent;

1653

self->priv->indent = _tmp119_ - 1;

1654

vala_gir_writer_write_indent (self);

1655

_tmp120_ = self->priv->buffer;

1656

g_string_append_printf (_tmp120_, "</field>\n");

1657

{

1658

ValaClass* _tmp121_;

1659

ValaList* _tmp122_ = NULL;

1660

ValaList* _m_list;

1661

ValaList* _tmp123_;

1662

gint _tmp124_;

1663

gint _tmp125_;

1664

gint _m_size;

1665

gint _m_index;

1666

_tmp121_ = cl;

1667

_tmp122_ = vala_object_type_symbol_get_methods ((ValaObjectTypeSymbol*) _tmp121_);

1668

_m_list = _tmp122_;

1669

_tmp123_ = _m_list;

1670

_tmp124_ = vala_collection_get_size ((ValaCollection*) _tmp123_);

1671

_tmp125_ = _tmp124_;

1672

_m_size = _tmp125_;

1673

_m_index = -1;

1674

while (TRUE) {

1675

gint _tmp126_;

1676

gint _tmp127_;

1677

gint _tmp128_;

1678

ValaList* _tmp129_;

1679

gint _tmp130_;

1680

gpointer _tmp131_ = NULL;

1681

ValaMethod* m;

1682

gboolean _tmp132_ = FALSE;

1683

ValaMethod* _tmp133_;

1684

gboolean _tmp134_;

1685

gboolean _tmp135_;

1686

gboolean _tmp139_;

1687

_tmp126_ = _m_index;

1688

_m_index = _tmp126_ + 1;

1689

_tmp127_ = _m_index;

1690

_tmp128_ = _m_size;

1691

if (!(_tmp127_ < _tmp128_)) {

1692

break;

1693

}

1694

_tmp129_ = _m_list;

1695

_tmp130_ = _m_index;

1696

_tmp131_ = vala_list_get (_tmp129_, _tmp130_);

1697

m = (ValaMethod*) _tmp131_;

1698

_tmp133_ = m;

1699

_tmp134_ = vala_method_get_is_abstract (_tmp133_);

1700

_tmp135_ = _tmp134_;

1701

if (_tmp135_) {

1702

_tmp132_ = TRUE;

1703

} else {

1704

ValaMethod* _tmp136_;

1705

gboolean _tmp137_;

1706

gboolean _tmp138_;

1707

_tmp136_ = m;

1708

_tmp137_ = vala_method_get_is_virtual (_tmp136_);

1709

_tmp138_ = _tmp137_;

1710

_tmp132_ = _tmp138_;

1711

}

1712

_tmp139_ = _tmp132_;

1713

if (_tmp139_) {

1714

ValaMethod* _tmp140_;

1715

gboolean _tmp141_;

1716

gboolean _tmp142_;

1717

vala_gir_writer_write_indent (self);

1718

_tmp140_ = m;

1719

_tmp141_ = vala_method_get_coroutine (_tmp140_);

1720

_tmp142_ = _tmp141_;

1721

if (_tmp142_) {

1722

ValaMethod* _tmp143_;

1723

const gchar* _tmp144_;

1724

const gchar* _tmp145_;

1725

gchar* _tmp146_;

1726

gchar* finish_name;

1727

const gchar* _tmp147_;

1728

gboolean _tmp148_ = FALSE;

1729

const gchar* _tmp156_;

1730

gchar* _tmp157_;

1731

GString* _tmp158_;

1732

ValaMethod* _tmp159_;

1733

const gchar* _tmp160_;

1734

const gchar* _tmp161_;

1735

gint _tmp162_;

1736

ValaMethod* _tmp163_;

1737

ValaMethod* _tmp164_;

1738

const gchar* _tmp165_;

1739

const gchar* _tmp166_;

1740

ValaMethod* _tmp167_;

1741

gchar* _tmp168_ = NULL;

1742

gchar* _tmp169_;

1743

ValaMethod* _tmp170_;

1744

ValaList* _tmp171_ = NULL;

1745

ValaList* _tmp172_;

1746

ValaVoidType* _tmp173_;

1747

ValaVoidType* _tmp174_;

1748

gint _tmp175_;

1749

GString* _tmp176_;

1750

GString* _tmp177_;

1751

const gchar* _tmp178_;

1752

gint _tmp179_;

1753

ValaMethod* _tmp180_;

1754

const gchar* _tmp181_;

1755

ValaMethod* _tmp182_;

1756

gchar* _tmp183_ = NULL;

1757

gchar* _tmp184_;

1758

ValaMethod* _tmp185_;

1759

ValaList* _tmp186_ = NULL;

1760

ValaList* _tmp187_;

1761

ValaMethod* _tmp188_;

1762

ValaDataType* _tmp189_;

1763

ValaDataType* _tmp190_;

1764

ValaMethod* _tmp191_;

1765

gboolean _tmp192_;

1766

gboolean _tmp193_;

1767

gint _tmp194_;

1768

GString* _tmp195_;

1769

_tmp143_ = m;

1770

_tmp144_ = vala_symbol_get_name ((ValaSymbol*) _tmp143_);

1771

_tmp145_ = _tmp144_;

1772

_tmp146_ = g_strdup (_tmp145_);

1773

finish_name = _tmp146_;

1774

_tmp147_ = finish_name;

1775

_tmp148_ = g_str_has_suffix (_tmp147_, "_async");

1776

if (_tmp148_) {

1777

const gchar* _tmp149_;

1778

const gchar* _tmp150_;

1779

gint _tmp151_;

1780

gint _tmp152_;

1781

gint _tmp153_;

1782

gint _tmp154_;

1783

gchar* _tmp155_ = NULL;

1784

_tmp149_ = finish_name;

1785

_tmp150_ = finish_name;

1786

_tmp151_ = strlen (_tmp150_);

1787

_tmp152_ = _tmp151_;

1788

_tmp153_ = strlen ("_async");

1789

_tmp154_ = _tmp153_;

1790

_tmp155_ = string_substring (_tmp149_, (glong) 0, (glong) (_tmp152_ - _tmp154_));

1791

_g_free0 (finish_name);

1792

finish_name = _tmp155_;

1793

}

1794

_tmp156_ = finish_name;

1795

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

1796

_g_free0 (finish_name);

1797

finish_name = _tmp157_;

1798

vala_gir_writer_write_indent (self);

1799

_tmp158_ = self->priv->buffer;

1800

_tmp159_ = m;

1801

_tmp160_ = vala_symbol_get_name ((ValaSymbol*) _tmp159_);

1802

_tmp161_ = _tmp160_;

1803

g_string_append_printf (_tmp158_, "<field name=\"%s\">\n", _tmp161_);

1804

_tmp162_ = self->priv->indent;

1805

self->priv->indent = _tmp162_ + 1;

1806

_tmp163_ = m;

1807

_tmp164_ = m;

1808

_tmp165_ = vala_symbol_get_name ((ValaSymbol*) _tmp164_);

1809

_tmp166_ = _tmp165_;

1810

_tmp167_ = m;

1811

_tmp168_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp167_);

1812

_tmp169_ = _tmp168_;

1813

_tmp170_ = m;

1814

_tmp171_ = vala_method_get_async_begin_parameters (_tmp170_);

1815

_tmp172_ = _tmp171_;

1816

_tmp173_ = vala_void_type_new (NULL);

1817

_tmp174_ = _tmp173_;

1818

vala_gir_writer_do_write_signature (self, _tmp163_, "callback", TRUE, _tmp166_, _tmp169_, _tmp172_, (ValaDataType*) _tmp174_, FALSE, FALSE);

1819

_vala_code_node_unref0 (_tmp174_);

1820

_vala_iterable_unref0 (_tmp172_);

1821

_g_free0 (_tmp169_);

1822

_tmp175_ = self->priv->indent;

1823

self->priv->indent = _tmp175_ - 1;

1824

vala_gir_writer_write_indent (self);

1825

_tmp176_ = self->priv->buffer;

1826

g_string_append_printf (_tmp176_, "</field>\n");

1827

vala_gir_writer_write_indent (self);

1828

_tmp177_ = self->priv->buffer;

1829

_tmp178_ = finish_name;

1830

g_string_append_printf (_tmp177_, "<field name=\"%s\">\n", _tmp178_);

1831

_tmp179_ = self->priv->indent;

1832

self->priv->indent = _tmp179_ + 1;

1833

_tmp180_ = m;

1834

_tmp181_ = finish_name;

1835

_tmp182_ = m;

1836

_tmp183_ = vala_ccode_base_module_get_ccode_finish_name (_tmp182_);

1837

_tmp184_ = _tmp183_;

1838

_tmp185_ = m;

1839

_tmp186_ = vala_method_get_async_end_parameters (_tmp185_);

1840

_tmp187_ = _tmp186_;

1841

_tmp188_ = m;

1842

_tmp189_ = vala_method_get_return_type (_tmp188_);

1843

_tmp190_ = _tmp189_;

1844

_tmp191_ = m;

1845

_tmp192_ = vala_code_node_get_tree_can_fail ((ValaCodeNode*) _tmp191_);

1846

_tmp193_ = _tmp192_;

1847

vala_gir_writer_do_write_signature (self, _tmp180_, "callback", TRUE, _tmp181_, _tmp184_, _tmp187_, _tmp190_, _tmp193_, FALSE);

1848

_vala_iterable_unref0 (_tmp187_);

1849

_g_free0 (_tmp184_);

1850

_tmp194_ = self->priv->indent;

1851

self->priv->indent = _tmp194_ - 1;

1852

vala_gir_writer_write_indent (self);

1853

_tmp195_ = self->priv->buffer;

1854

g_string_append_printf (_tmp195_, "</field>\n");

1855

_g_free0 (finish_name);

1856

} else {

1857

GString* _tmp196_;

1858

ValaMethod* _tmp197_;

1859

const gchar* _tmp198_;

1860

const gchar* _tmp199_;

1861

gint _tmp200_;

1862

ValaMethod* _tmp201_;

1863

ValaMethod* _tmp202_;

1864

const gchar* _tmp203_;

1865

const gchar* _tmp204_;

1866

ValaMethod* _tmp205_;

1867

gchar* _tmp206_ = NULL;

1868

gchar* _tmp207_;

1869

ValaMethod* _tmp208_;

1870

ValaList* _tmp209_ = NULL;

1871

ValaList* _tmp210_;

1872

ValaMethod* _tmp211_;

1873

ValaDataType* _tmp212_;

1874

ValaDataType* _tmp213_;

1875

ValaMethod* _tmp214_;

1876

gboolean _tmp215_;

1877

gboolean _tmp216_;

1878

gint _tmp217_;

1879

GString* _tmp218_;

1880

vala_gir_writer_write_indent (self);

1881

_tmp196_ = self->priv->buffer;

1882

_tmp197_ = m;

1883

_tmp198_ = vala_symbol_get_name ((ValaSymbol*) _tmp197_);

1884

_tmp199_ = _tmp198_;

1885

g_string_append_printf (_tmp196_, "<field name=\"%s\">\n", _tmp199_);

1886

_tmp200_ = self->priv->indent;

1887

self->priv->indent = _tmp200_ + 1;

1888

_tmp201_ = m;

1889

_tmp202_ = m;

1890

_tmp203_ = vala_symbol_get_name ((ValaSymbol*) _tmp202_);

1891

_tmp204_ = _tmp203_;

1892

_tmp205_ = m;

1893

_tmp206_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp205_);

1894

_tmp207_ = _tmp206_;

1895

_tmp208_ = m;

1896

_tmp209_ = vala_method_get_parameters (_tmp208_);

1897

_tmp210_ = _tmp209_;

1898

_tmp211_ = m;

1899

_tmp212_ = vala_method_get_return_type (_tmp211_);

1900

_tmp213_ = _tmp212_;

1901

_tmp214_ = m;

1902

_tmp215_ = vala_code_node_get_tree_can_fail ((ValaCodeNode*) _tmp214_);

1903

_tmp216_ = _tmp215_;

1904

vala_gir_writer_do_write_signature (self, _tmp201_, "callback", TRUE, _tmp204_, _tmp207_, _tmp210_, _tmp213_, _tmp216_, FALSE);

1905

_vala_iterable_unref0 (_tmp210_);

1906

_g_free0 (_tmp207_);

1907

_tmp217_ = self->priv->indent;

1908

self->priv->indent = _tmp217_ - 1;

1909

vala_gir_writer_write_indent (self);

1910

_tmp218_ = self->priv->buffer;

1911

g_string_append_printf (_tmp218_, "</field>\n");

1912

}

1913

}

1914

_vala_code_node_unref0 (m);

1915

}

1916

_vala_iterable_unref0 (_m_list);

1917

}

1918

{

1919

ValaClass* _tmp219_;

1920

ValaList* _tmp220_ = NULL;

1921

ValaList* _sig_list;

1922

ValaList* _tmp221_;

1923

gint _tmp222_;

1924

gint _tmp223_;

1925

gint _sig_size;

1926

gint _sig_index;

1927

_tmp219_ = cl;

1928

_tmp220_ = vala_object_type_symbol_get_signals ((ValaObjectTypeSymbol*) _tmp219_);

1929

_sig_list = _tmp220_;

1930

_tmp221_ = _sig_list;

1931

_tmp222_ = vala_collection_get_size ((ValaCollection*) _tmp221_);

1932

_tmp223_ = _tmp222_;

1933

_sig_size = _tmp223_;

1934

_sig_index = -1;

1935

while (TRUE) {

1936

gint _tmp224_;

1937

gint _tmp225_;

1938

gint _tmp226_;

1939

ValaList* _tmp227_;

1940

gint _tmp228_;

1941

gpointer _tmp229_ = NULL;

1942

ValaSignal* sig;

1943

ValaSignal* _tmp230_;

1944

ValaMethod* _tmp231_;

1945

ValaMethod* _tmp232_;

1946

_tmp224_ = _sig_index;

1947

_sig_index = _tmp224_ + 1;

1948

_tmp225_ = _sig_index;

1949

_tmp226_ = _sig_size;

1950

if (!(_tmp225_ < _tmp226_)) {

1951

break;

1952

}

1953

_tmp227_ = _sig_list;

1954

_tmp228_ = _sig_index;

1955

_tmp229_ = vala_list_get (_tmp227_, _tmp228_);

1956

sig = (ValaSignal*) _tmp229_;

1957

_tmp230_ = sig;

1958

_tmp231_ = vala_signal_get_default_handler (_tmp230_);

1959

_tmp232_ = _tmp231_;

1960

if (_tmp232_ != NULL) {

1961

GString* _tmp233_;

1962

ValaSignal* _tmp234_;

1963

const gchar* _tmp235_;

1964

const gchar* _tmp236_;

1965

gint _tmp237_;

1966

ValaSignal* _tmp238_;

1967

ValaMethod* _tmp239_;

1968

ValaMethod* _tmp240_;

1969

gint _tmp241_;

1970

GString* _tmp242_;

1971

vala_gir_writer_write_indent (self);

1972

_tmp233_ = self->priv->buffer;

1973

_tmp234_ = sig;

1974

_tmp235_ = vala_symbol_get_name ((ValaSymbol*) _tmp234_);

1975

_tmp236_ = _tmp235_;

1976

g_string_append_printf (_tmp233_, "<field name=\"%s\">\n", _tmp236_);

1977

_tmp237_ = self->priv->indent;

1978

self->priv->indent = _tmp237_ + 1;

1979

_tmp238_ = sig;

1980

_tmp239_ = vala_signal_get_default_handler (_tmp238_);

1981

_tmp240_ = _tmp239_;

1982

vala_gir_writer_write_signature (self, _tmp240_, "callback", FALSE, TRUE);

1983

_tmp241_ = self->priv->indent;

1984

self->priv->indent = _tmp241_ - 1;

1985

vala_gir_writer_write_indent (self);

1986

_tmp242_ = self->priv->buffer;

1987

g_string_append_printf (_tmp242_, "</field>\n");

1988

}

1989

_vala_code_node_unref0 (sig);

1990

}

1991

_vala_iterable_unref0 (_sig_list);

1992

}

1993

_tmp243_ = self->priv->indent;

1994

self->priv->indent = _tmp243_ - 1;

1995

vala_gir_writer_write_indent (self);

1996

_tmp244_ = self->priv->buffer;

1997

g_string_append_printf (_tmp244_, "</record>\n");

1998

vala_gir_writer_write_indent (self);

1999

_tmp245_ = self->priv->buffer;

2000

_tmp246_ = cl;

2001

_tmp247_ = vala_symbol_get_name ((ValaSymbol*) _tmp246_);

2002

_tmp248_ = _tmp247_;

2003

_tmp249_ = cl;

2004

_tmp250_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp249_);

2005

_tmp251_ = _tmp250_;

2006

g_string_append_printf (_tmp245_, "<record name=\"%sPrivate\" c:type=\"%sPrivate\" disguised=\"1\"/>\n", _tmp248_, _tmp251_);

2007

_g_free0 (_tmp251_);

2008

_g_free0 (gtype_struct_name);

2009

} else {

2010

GString* _tmp252_;

2011

ValaClass* _tmp253_;

2012

gchar* _tmp254_ = NULL;

2013

gchar* _tmp255_;

2014

ValaClass* _tmp256_;

2015

GString* _tmp257_;

2016

gint _tmp258_;

2017

ValaClass* _tmp259_;

2018

gchar* _tmp260_ = NULL;

2019

gchar* _tmp261_;

2020

ValaClass* _tmp262_;

2021

ValaArrayList* _tmp263_;

2022

ValaClass* _tmp264_;

2023

ValaClass* _tmp265_;

2024

ValaArrayList* _tmp266_;

2025

gint _tmp267_;

2026

GString* _tmp268_;

2027

vala_gir_writer_write_indent (self);

2028

_tmp252_ = self->priv->buffer;

2029

_tmp253_ = cl;

2030

_tmp254_ = vala_gir_writer_get_gir_name (self, (ValaSymbol*) _tmp253_);

2031

_tmp255_ = _tmp254_;

2032

g_string_append_printf (_tmp252_, "<record name=\"%s\"", _tmp255_);

2033

_g_free0 (_tmp255_);

2034

_tmp256_ = cl;

2035

vala_gir_writer_write_symbol_attributes (self, (ValaSymbol*) _tmp256_);

2036

_tmp257_ = self->priv->buffer;

2037

g_string_append_printf (_tmp257_, ">\n");

2038

_tmp258_ = self->priv->indent;

2039

self->priv->indent = _tmp258_ + 1;

2040

_tmp259_ = cl;

2041

_tmp260_ = vala_gir_writer_get_class_comment (self, _tmp259_);

2042

_tmp261_ = _tmp260_;

2043

vala_gir_writer_write_doc (self, _tmp261_);

2044

_g_free0 (_tmp261_);

2045

_tmp262_ = cl;

2046

vala_gir_writer_write_annotations (self, (ValaCodeNode*) _tmp262_);

2047

_tmp263_ = self->priv->hierarchy;

2048

_tmp264_ = cl;

2049

vala_list_insert ((ValaList*) _tmp263_, 0, (ValaSymbol*) _tmp264_);

2050

_tmp265_ = cl;

2051

vala_code_node_accept_children ((ValaCodeNode*) _tmp265_, (ValaCodeVisitor*) self);

2052

_tmp266_ = self->priv->hierarchy;

2053

vala_list_remove_at ((ValaList*) _tmp266_, 0);

2054

_tmp267_ = self->priv->indent;

2055

self->priv->indent = _tmp267_ - 1;

2056

vala_gir_writer_write_indent (self);

2057

_tmp268_ = self->priv->buffer;

2058

g_string_append_printf (_tmp268_, "</record>\n");

2059

}

2060

vala_gir_writer_visit_deferred (self);

2061

}

2062

2063

2064

static void vala_gir_writer_real_visit_struct (ValaCodeVisitor* base, ValaStruct* st) {

2065

ValaGIRWriter * self;

2066

ValaStruct* _tmp0_;

2067

gboolean _tmp1_;

2068

gboolean _tmp2_;

2069

ValaStruct* _tmp3_;

2070

gboolean _tmp4_ = FALSE;

2071

ValaArrayList* _tmp5_;

2072

gpointer _tmp6_ = NULL;

2073

ValaSymbol* _tmp7_;

2074

gboolean _tmp8_;

2075

GString* _tmp11_;

2076

ValaStruct* _tmp12_;

2077

gchar* _tmp13_ = NULL;

2078

gchar* _tmp14_;

2079

ValaStruct* _tmp15_;

2080

GString* _tmp16_;

2081

gint _tmp17_;

2082

ValaStruct* _tmp18_;

2083

gchar* _tmp19_ = NULL;

2084

gchar* _tmp20_;

2085

ValaStruct* _tmp21_;

2086

ValaArrayList* _tmp22_;

2087

ValaStruct* _tmp23_;

2088

ValaStruct* _tmp24_;

2089

ValaArrayList* _tmp25_;

2090

gint _tmp26_;

2091

GString* _tmp27_;

2092

self = (ValaGIRWriter*) base;

2093

g_return_if_fail (st != NULL);

2094

_tmp0_ = st;

2095

_tmp1_ = vala_symbol_get_external_package ((ValaSymbol*) _tmp0_);

2096

_tmp2_ = _tmp1_;

2097

if (_tmp2_) {

2098

return;

2099

}

2100

_tmp3_ = st;

2101

_tmp4_ = vala_gir_writer_check_accessibility (self, (ValaSymbol*) _tmp3_);

2102

if (!_tmp4_) {

2103

return;

2104

}

2105

_tmp5_ = self->priv->hierarchy;

2106

_tmp6_ = vala_list_get ((ValaList*) _tmp5_, 0);

2107

_tmp7_ = (ValaSymbol*) _tmp6_;

2108

_tmp8_ = !G_TYPE_CHECK_INSTANCE_TYPE (_tmp7_, VALA_TYPE_NAMESPACE);

2109

_vala_code_node_unref0 (_tmp7_);

2110

if (_tmp8_) {

2111

ValaArrayList* _tmp9_;

2112

ValaStruct* _tmp10_;

2113

_tmp9_ = self->priv->deferred;

2114

_tmp10_ = st;

2115

vala_collection_add ((ValaCollection*) _tmp9_, (ValaCodeNode*) _tmp10_);

2116

return;

2117

}

2118

vala_gir_writer_write_indent (self);

2119

_tmp11_ = self->priv->buffer;

2120

_tmp12_ = st;

2121

_tmp13_ = vala_gir_writer_get_gir_name (self, (ValaSymbol*) _tmp12_);

2122

_tmp14_ = _tmp13_;

2123

g_string_append_printf (_tmp11_, "<record name=\"%s\"", _tmp14_);

2124

_g_free0 (_tmp14_);

2125

_tmp15_ = st;

2126

vala_gir_writer_write_symbol_attributes (self, (ValaSymbol*) _tmp15_);

2127

_tmp16_ = self->priv->buffer;

2128

g_string_append_printf (_tmp16_, ">\n");

2129

_tmp17_ = self->priv->indent;

2130

self->priv->indent = _tmp17_ + 1;

2131

_tmp18_ = st;

2132

_tmp19_ = vala_gir_writer_get_struct_comment (self, _tmp18_);

2133

_tmp20_ = _tmp19_;

2134

vala_gir_writer_write_doc (self, _tmp20_);

2135

_g_free0 (_tmp20_);

2136

_tmp21_ = st;

2137

vala_gir_writer_write_annotations (self, (ValaCodeNode*) _tmp21_);

2138

_tmp22_ = self->priv->hierarchy;

2139

_tmp23_ = st;

2140

vala_list_insert ((ValaList*) _tmp22_, 0, (ValaSymbol*) _tmp23_);

2141

_tmp24_ = st;

2142

vala_code_node_accept_children ((ValaCodeNode*) _tmp24_, (ValaCodeVisitor*) self);

2143

_tmp25_ = self->priv->hierarchy;

2144

vala_list_remove_at ((ValaList*) _tmp25_, 0);

2145

_tmp26_ = self->priv->indent;

2146

self->priv->indent = _tmp26_ - 1;

2147

vala_gir_writer_write_indent (self);

2148

_tmp27_ = self->priv->buffer;

2149

g_string_append_printf (_tmp27_, "</record>\n");

2150

vala_gir_writer_visit_deferred (self);

2151

}

2152

2153

2154

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

2155

ValaGIRWriter * self;

2156

ValaInterface* _tmp0_;

2157

gboolean _tmp1_;

2158

gboolean _tmp2_;

2159

ValaInterface* _tmp3_;

2160

gboolean _tmp4_ = FALSE;

2161

ValaArrayList* _tmp5_;

2162

gpointer _tmp6_ = NULL;

2163

ValaSymbol* _tmp7_;

2164

gboolean _tmp8_;

2165

ValaInterface* _tmp11_;

2166

const gchar* _tmp12_;

2167

const gchar* _tmp13_;

2168

gchar* _tmp14_;

2169

gchar* gtype_struct_name;

2170

GString* _tmp15_;

2171

ValaInterface* _tmp16_;

2172

gchar* _tmp17_ = NULL;

2173

gchar* _tmp18_;

2174

ValaInterface* _tmp19_;

2175

GString* _tmp20_;

2176

const gchar* _tmp21_;

2177

ValaInterface* _tmp22_;

2178

GString* _tmp23_;

2179

gint _tmp24_;

2180

ValaInterface* _tmp25_;

2181

gchar* _tmp26_ = NULL;

2182

gchar* _tmp27_;

2183

ValaInterface* _tmp28_;

2184

ValaList* _tmp29_ = NULL;

2185

ValaList* _tmp30_;

2186

gint _tmp31_;

2187

gint _tmp32_;

2188

gboolean _tmp33_;

2189

ValaInterface* _tmp51_;

2190

ValaArrayList* _tmp52_;

2191

ValaInterface* _tmp53_;

2192

ValaInterface* _tmp54_;

2193

ValaArrayList* _tmp55_;

2194

gint _tmp56_;

2195

GString* _tmp57_;

2196

GString* _tmp58_;

2197

const gchar* _tmp59_;

2198

ValaInterface* _tmp60_;

2199

GString* _tmp61_;

2200

ValaInterface* _tmp62_;

2201

const gchar* _tmp63_;

2202

const gchar* _tmp64_;

2203

GString* _tmp65_;

2204

gint _tmp66_;

2205

GString* _tmp67_;

2206

gint _tmp68_;

2207

GString* _tmp69_;

2208

gint _tmp70_;

2209

GString* _tmp71_;

2210

gint _tmp170_;

2211

GString* _tmp171_;

2212

self = (ValaGIRWriter*) base;

2213

g_return_if_fail (iface != NULL);

2214

_tmp0_ = iface;

2215

_tmp1_ = vala_symbol_get_external_package ((ValaSymbol*) _tmp0_);

2216

_tmp2_ = _tmp1_;

2217

if (_tmp2_) {

2218

return;

2219

}

2220

_tmp3_ = iface;

2221

_tmp4_ = vala_gir_writer_check_accessibility (self, (ValaSymbol*) _tmp3_);

2222

if (!_tmp4_) {

2223

return;

2224

}

2225

_tmp5_ = self->priv->hierarchy;

2226

_tmp6_ = vala_list_get ((ValaList*) _tmp5_, 0);

2227

_tmp7_ = (ValaSymbol*) _tmp6_;

2228

_tmp8_ = !G_TYPE_CHECK_INSTANCE_TYPE (_tmp7_, VALA_TYPE_NAMESPACE);

2229

_vala_code_node_unref0 (_tmp7_);

2230

if (_tmp8_) {

2231

ValaArrayList* _tmp9_;

2232

ValaInterface* _tmp10_;

2233

_tmp9_ = self->priv->deferred;

2234

_tmp10_ = iface;

2235

vala_collection_add ((ValaCollection*) _tmp9_, (ValaCodeNode*) _tmp10_);

2236

return;

2237

}

2238

_tmp11_ = iface;

2239

_tmp12_ = vala_symbol_get_name ((ValaSymbol*) _tmp11_);

2240

_tmp13_ = _tmp12_;

2241

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

2242

gtype_struct_name = _tmp14_;

2243

vala_gir_writer_write_indent (self);

2244

_tmp15_ = self->priv->buffer;

2245

_tmp16_ = iface;

2246

_tmp17_ = vala_gir_writer_get_gir_name (self, (ValaSymbol*) _tmp16_);

2247

_tmp18_ = _tmp17_;

2248

g_string_append_printf (_tmp15_, "<interface name=\"%s\"", _tmp18_);

2249

_g_free0 (_tmp18_);

2250

_tmp19_ = iface;

2251

vala_gir_writer_write_gtype_attributes (self, (ValaTypeSymbol*) _tmp19_);

2252

_tmp20_ = self->priv->buffer;

2253

_tmp21_ = gtype_struct_name;

2254

g_string_append_printf (_tmp20_, " glib:type-struct=\"%s\"", _tmp21_);

2255

_tmp22_ = iface;

2256

vala_gir_writer_write_symbol_attributes (self, (ValaSymbol*) _tmp22_);

2257

_tmp23_ = self->priv->buffer;

2258

g_string_append_printf (_tmp23_, ">\n");

2259

_tmp24_ = self->priv->indent;

2260

self->priv->indent = _tmp24_ + 1;

2261

_tmp25_ = iface;

2262

_tmp26_ = vala_gir_writer_get_interface_comment (self, _tmp25_);

2263

_tmp27_ = _tmp26_;

2264

vala_gir_writer_write_doc (self, _tmp27_);

2265

_g_free0 (_tmp27_);

2266

_tmp28_ = iface;

2267

_tmp29_ = vala_interface_get_prerequisites (_tmp28_);

2268

_tmp30_ = _tmp29_;

2269

_tmp31_ = vala_collection_get_size ((ValaCollection*) _tmp30_);

2270

_tmp32_ = _tmp31_;

2271

_tmp33_ = _tmp32_ > 0;

2272

_vala_iterable_unref0 (_tmp30_);

2273

if (_tmp33_) {

2274

{

2275

ValaInterface* _tmp34_;

2276

ValaList* _tmp35_ = NULL;

2277

ValaList* _base_type_list;

2278

ValaList* _tmp36_;

2279

gint _tmp37_;

2280

gint _tmp38_;

2281

gint _base_type_size;

2282

gint _base_type_index;

2283

_tmp34_ = iface;

2284

_tmp35_ = vala_interface_get_prerequisites (_tmp34_);

2285

_base_type_list = _tmp35_;

2286

_tmp36_ = _base_type_list;

2287

_tmp37_ = vala_collection_get_size ((ValaCollection*) _tmp36_);

2288

_tmp38_ = _tmp37_;

2289

_base_type_size = _tmp38_;

2290

_base_type_index = -1;

2291

while (TRUE) {

2292

gint _tmp39_;

2293

gint _tmp40_;

2294

gint _tmp41_;

2295

ValaList* _tmp42_;

2296

gint _tmp43_;

2297

gpointer _tmp44_ = NULL;

2298

ValaDataType* base_type;

2299

GString* _tmp45_;

2300

ValaDataType* _tmp46_;

2301

ValaObjectTypeSymbol* _tmp47_;

2302

ValaObjectTypeSymbol* _tmp48_;

2303

gchar* _tmp49_ = NULL;

2304

gchar* _tmp50_;

2305

_tmp39_ = _base_type_index;

2306

_base_type_index = _tmp39_ + 1;

2307

_tmp40_ = _base_type_index;

2308

_tmp41_ = _base_type_size;

2309

if (!(_tmp40_ < _tmp41_)) {

2310

break;

2311

}

2312

_tmp42_ = _base_type_list;

2313

_tmp43_ = _base_type_index;

2314

_tmp44_ = vala_list_get (_tmp42_, _tmp43_);

2315

base_type = (ValaDataType*) _tmp44_;

2316

vala_gir_writer_write_indent (self);

2317

_tmp45_ = self->priv->buffer;

2318

_tmp46_ = base_type;

2319

_tmp47_ = vala_object_type_get_type_symbol (G_TYPE_CHECK_INSTANCE_CAST (_tmp46_, VALA_TYPE_OBJECT_TYPE, ValaObjectType));

2320

_tmp48_ = _tmp47_;

2321

_tmp49_ = vala_gir_writer_gi_type_name (self, (ValaTypeSymbol*) _tmp48_);

2322

_tmp50_ = _tmp49_;

2323

g_string_append_printf (_tmp45_, "<prerequisite name=\"%s\"/>\n", _tmp50_);

2324

_g_free0 (_tmp50_);

2325

_vala_code_node_unref0 (base_type);

2326

}

2327

_vala_iterable_unref0 (_base_type_list);

2328

}

2329

}

2330

_tmp51_ = iface;

2331

vala_gir_writer_write_annotations (self, (ValaCodeNode*) _tmp51_);

2332

_tmp52_ = self->priv->hierarchy;

2333

_tmp53_ = iface;

2334

vala_list_insert ((ValaList*) _tmp52_, 0, (ValaSymbol*) _tmp53_);

2335

_tmp54_ = iface;

2336

vala_code_node_accept_children ((ValaCodeNode*) _tmp54_, (ValaCodeVisitor*) self);

2337

_tmp55_ = self->priv->hierarchy;

2338

vala_list_remove_at ((ValaList*) _tmp55_, 0);

2339

_tmp56_ = self->priv->indent;

2340

self->priv->indent = _tmp56_ - 1;

2341

vala_gir_writer_write_indent (self);

2342

_tmp57_ = self->priv->buffer;

2343

g_string_append_printf (_tmp57_, "</interface>\n");

2344

vala_gir_writer_write_indent (self);

2345

_tmp58_ = self->priv->buffer;

2346

_tmp59_ = gtype_struct_name;

2347

g_string_append_printf (_tmp58_, "<record name=\"%s\"", _tmp59_);

2348

_tmp60_ = iface;

2349

vala_gir_writer_write_ctype_attributes (self, (ValaTypeSymbol*) _tmp60_, "Iface");

2350

_tmp61_ = self->priv->buffer;

2351

_tmp62_ = iface;

2352

_tmp63_ = vala_symbol_get_name ((ValaSymbol*) _tmp62_);

2353

_tmp64_ = _tmp63_;

2354

g_string_append_printf (_tmp61_, " glib:is-gtype-struct-for=\"%s\"", _tmp64_);

2355

_tmp65_ = self->priv->buffer;

2356

g_string_append_printf (_tmp65_, ">\n");

2357

_tmp66_ = self->priv->indent;

2358

self->priv->indent = _tmp66_ + 1;

2359

vala_gir_writer_write_indent (self);

2360

_tmp67_ = self->priv->buffer;

2361

g_string_append_printf (_tmp67_, "<field name=\"parent_iface\">\n");

2362

_tmp68_ = self->priv->indent;

2363

self->priv->indent = _tmp68_ + 1;

2364

vala_gir_writer_write_indent (self);

2365

_tmp69_ = self->priv->buffer;

2366

g_string_append_printf (_tmp69_, "<type name=\"GObject.TypeInterface\" c:type=\"GTypeInterface\"/>\n");

2367

_tmp70_ = self->priv->indent;

2368

self->priv->indent = _tmp70_ - 1;

2369

vala_gir_writer_write_indent (self);

2370

_tmp71_ = self->priv->buffer;

2371

g_string_append_printf (_tmp71_, "</field>\n");

2372

{

2373

ValaInterface* _tmp72_;

2374

ValaList* _tmp73_ = NULL;

2375

ValaList* _m_list;

2376

ValaList* _tmp74_;

2377

gint _tmp75_;

2378

gint _tmp76_;

2379

gint _m_size;

2380

gint _m_index;

2381

_tmp72_ = iface;

2382

_tmp73_ = vala_object_type_symbol_get_methods ((ValaObjectTypeSymbol*) _tmp72_);

2383

_m_list = _tmp73_;

2384

_tmp74_ = _m_list;

2385

_tmp75_ = vala_collection_get_size ((ValaCollection*) _tmp74_);

2386

_tmp76_ = _tmp75_;

2387

_m_size = _tmp76_;

2388

_m_index = -1;

2389

while (TRUE) {

2390

gint _tmp77_;

2391

gint _tmp78_;

2392

gint _tmp79_;

2393

ValaList* _tmp80_;

2394

gint _tmp81_;

2395

gpointer _tmp82_ = NULL;

2396

ValaMethod* m;

2397

gboolean _tmp83_ = FALSE;

2398

ValaMethod* _tmp84_;

2399

gboolean _tmp85_;

2400

gboolean _tmp86_;

2401

gboolean _tmp90_;

2402

_tmp77_ = _m_index;

2403

_m_index = _tmp77_ + 1;

2404

_tmp78_ = _m_index;

2405

_tmp79_ = _m_size;

2406

if (!(_tmp78_ < _tmp79_)) {

2407

break;

2408

}

2409

_tmp80_ = _m_list;

2410

_tmp81_ = _m_index;

2411

_tmp82_ = vala_list_get (_tmp80_, _tmp81_);

2412

m = (ValaMethod*) _tmp82_;

2413

_tmp84_ = m;

2414

_tmp85_ = vala_method_get_is_abstract (_tmp84_);

2415

_tmp86_ = _tmp85_;

2416

if (_tmp86_) {

2417

_tmp83_ = TRUE;

2418

} else {

2419

ValaMethod* _tmp87_;

2420

gboolean _tmp88_;

2421

gboolean _tmp89_;

2422

_tmp87_ = m;

2423

_tmp88_ = vala_method_get_is_virtual (_tmp87_);

2424

_tmp89_ = _tmp88_;

2425

_tmp83_ = _tmp89_;

2426

}

2427

_tmp90_ = _tmp83_;

2428

if (_tmp90_) {

2429

ValaMethod* _tmp91_;

2430

gboolean _tmp92_;

2431

gboolean _tmp93_;

2432

_tmp91_ = m;

2433

_tmp92_ = vala_method_get_coroutine (_tmp91_);

2434

_tmp93_ = _tmp92_;

2435

if (_tmp93_) {

2436

ValaMethod* _tmp94_;

2437

const gchar* _tmp95_;

2438

const gchar* _tmp96_;

2439

gchar* _tmp97_;

2440

gchar* finish_name;

2441

const gchar* _tmp98_;

2442

gboolean _tmp99_ = FALSE;

2443

const gchar* _tmp107_;

2444

gchar* _tmp108_;

2445

GString* _tmp109_;

2446

ValaMethod* _tmp110_;

2447

const gchar* _tmp111_;

2448

const gchar* _tmp112_;

2449

gint _tmp113_;

2450

ValaMethod* _tmp114_;

2451

ValaMethod* _tmp115_;

2452

const gchar* _tmp116_;

2453

const gchar* _tmp117_;

2454

ValaMethod* _tmp118_;

2455

gchar* _tmp119_ = NULL;

2456

gchar* _tmp120_;

2457

ValaMethod* _tmp121_;

2458

ValaList* _tmp122_ = NULL;

2459

ValaList* _tmp123_;

2460

ValaVoidType* _tmp124_;

2461

ValaVoidType* _tmp125_;

2462

gint _tmp126_;

2463

GString* _tmp127_;

2464

GString* _tmp128_;

2465

const gchar* _tmp129_;

2466

gint _tmp130_;

2467

ValaMethod* _tmp131_;

2468

const gchar* _tmp132_;

2469

ValaMethod* _tmp133_;

2470

gchar* _tmp134_ = NULL;

2471

gchar* _tmp135_;

2472

ValaMethod* _tmp136_;

2473

ValaList* _tmp137_ = NULL;

2474

ValaList* _tmp138_;

2475

ValaMethod* _tmp139_;

2476

ValaDataType* _tmp140_;

2477

ValaDataType* _tmp141_;

2478

ValaMethod* _tmp142_;

2479

gboolean _tmp143_;

2480

gboolean _tmp144_;

2481

gint _tmp145_;

2482

GString* _tmp146_;

2483

_tmp94_ = m;

2484

_tmp95_ = vala_symbol_get_name ((ValaSymbol*) _tmp94_);

2485

_tmp96_ = _tmp95_;

2486

_tmp97_ = g_strdup (_tmp96_);

2487

finish_name = _tmp97_;

2488

_tmp98_ = finish_name;

2489

_tmp99_ = g_str_has_suffix (_tmp98_, "_async");

2490

if (_tmp99_) {

2491

const gchar* _tmp100_;

2492

const gchar* _tmp101_;

2493

gint _tmp102_;

2494

gint _tmp103_;

2495

gint _tmp104_;

2496

gint _tmp105_;

2497

gchar* _tmp106_ = NULL;

2498

_tmp100_ = finish_name;

2499

_tmp101_ = finish_name;

2500

_tmp102_ = strlen (_tmp101_);

2501

_tmp103_ = _tmp102_;

2502

_tmp104_ = strlen ("_async");

2503

_tmp105_ = _tmp104_;

2504

_tmp106_ = string_substring (_tmp100_, (glong) 0, (glong) (_tmp103_ - _tmp105_));

2505

_g_free0 (finish_name);

2506

finish_name = _tmp106_;

2507

}

2508

_tmp107_ = finish_name;

2509

_tmp108_ = g_strconcat (_tmp107_, "_finish", NULL);

2510

_g_free0 (finish_name);

2511

finish_name = _tmp108_;

2512

vala_gir_writer_write_indent (self);

2513

_tmp109_ = self->priv->buffer;

2514

_tmp110_ = m;

2515

_tmp111_ = vala_symbol_get_name ((ValaSymbol*) _tmp110_);

2516

_tmp112_ = _tmp111_;

2517

g_string_append_printf (_tmp109_, "<field name=\"%s\">\n", _tmp112_);

2518

_tmp113_ = self->priv->indent;

2519

self->priv->indent = _tmp113_ + 1;

2520

_tmp114_ = m;

2521

_tmp115_ = m;

2522

_tmp116_ = vala_symbol_get_name ((ValaSymbol*) _tmp115_);

2523

_tmp117_ = _tmp116_;

2524

_tmp118_ = m;

2525

_tmp119_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp118_);

2526

_tmp120_ = _tmp119_;

2527

_tmp121_ = m;

2528

_tmp122_ = vala_method_get_async_begin_parameters (_tmp121_);

2529

_tmp123_ = _tmp122_;

2530

_tmp124_ = vala_void_type_new (NULL);

2531

_tmp125_ = _tmp124_;

2532

vala_gir_writer_do_write_signature (self, _tmp114_, "callback", TRUE, _tmp117_, _tmp120_, _tmp123_, (ValaDataType*) _tmp125_, FALSE, FALSE);

2533

_vala_code_node_unref0 (_tmp125_);

2534

_vala_iterable_unref0 (_tmp123_);

2535

_g_free0 (_tmp120_);

2536

_tmp126_ = self->priv->indent;

2537

self->priv->indent = _tmp126_ - 1;

2538

vala_gir_writer_write_indent (self);

2539

_tmp127_ = self->priv->buffer;

2540

g_string_append_printf (_tmp127_, "</field>\n");

2541

vala_gir_writer_write_indent (self);

2542

_tmp128_ = self->priv->buffer;

2543

_tmp129_ = finish_name;

2544

g_string_append_printf (_tmp128_, "<field name=\"%s\">\n", _tmp129_);

2545

_tmp130_ = self->priv->indent;

2546

self->priv->indent = _tmp130_ + 1;

2547

_tmp131_ = m;

2548

_tmp132_ = finish_name;

2549

_tmp133_ = m;

2550

_tmp134_ = vala_ccode_base_module_get_ccode_finish_name (_tmp133_);

2551

_tmp135_ = _tmp134_;

2552

_tmp136_ = m;

2553

_tmp137_ = vala_method_get_async_end_parameters (_tmp136_);

2554

_tmp138_ = _tmp137_;

2555

_tmp139_ = m;

2556

_tmp140_ = vala_method_get_return_type (_tmp139_);

2557

_tmp141_ = _tmp140_;

2558

_tmp142_ = m;

2559

_tmp143_ = vala_code_node_get_tree_can_fail ((ValaCodeNode*) _tmp142_);

2560

_tmp144_ = _tmp143_;

2561

vala_gir_writer_do_write_signature (self, _tmp131_, "callback", TRUE, _tmp132_, _tmp135_, _tmp138_, _tmp141_, _tmp144_, FALSE);

2562

_vala_iterable_unref0 (_tmp138_);

2563

_g_free0 (_tmp135_);

2564

_tmp145_ = self->priv->indent;

2565

self->priv->indent = _tmp145_ - 1;

2566

vala_gir_writer_write_indent (self);

2567

_tmp146_ = self->priv->buffer;

2568

g_string_append_printf (_tmp146_, "</field>\n");

2569

_g_free0 (finish_name);

2570

} else {

2571

GString* _tmp147_;

2572

ValaMethod* _tmp148_;

2573

const gchar* _tmp149_;

2574

const gchar* _tmp150_;

2575

gint _tmp151_;

2576

ValaMethod* _tmp152_;

2577

ValaMethod* _tmp153_;

2578

const gchar* _tmp154_;

2579

const gchar* _tmp155_;

2580

ValaMethod* _tmp156_;

2581

gchar* _tmp157_ = NULL;

2582

gchar* _tmp158_;

2583

ValaMethod* _tmp159_;

2584

ValaList* _tmp160_ = NULL;

2585

ValaList* _tmp161_;

2586

ValaMethod* _tmp162_;

2587

ValaDataType* _tmp163_;

2588

ValaDataType* _tmp164_;

2589

ValaMethod* _tmp165_;

2590

gboolean _tmp166_;

2591

gboolean _tmp167_;

2592

gint _tmp168_;

2593

GString* _tmp169_;

2594

vala_gir_writer_write_indent (self);

2595

_tmp147_ = self->priv->buffer;

2596

_tmp148_ = m;

2597

_tmp149_ = vala_symbol_get_name ((ValaSymbol*) _tmp148_);

2598

_tmp150_ = _tmp149_;

2599

g_string_append_printf (_tmp147_, "<field name=\"%s\">\n", _tmp150_);

2600

_tmp151_ = self->priv->indent;

2601

self->priv->indent = _tmp151_ + 1;

2602

_tmp152_ = m;

2603

_tmp153_ = m;

2604

_tmp154_ = vala_symbol_get_name ((ValaSymbol*) _tmp153_);

2605

_tmp155_ = _tmp154_;

2606

_tmp156_ = m;

2607

_tmp157_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp156_);

2608

_tmp158_ = _tmp157_;

2609

_tmp159_ = m;

2610

_tmp160_ = vala_method_get_parameters (_tmp159_);

2611

_tmp161_ = _tmp160_;

2612

_tmp162_ = m;

2613

_tmp163_ = vala_method_get_return_type (_tmp162_);

2614

_tmp164_ = _tmp163_;

2615

_tmp165_ = m;

2616

_tmp166_ = vala_code_node_get_tree_can_fail ((ValaCodeNode*) _tmp165_);

2617

_tmp167_ = _tmp166_;

2618

vala_gir_writer_do_write_signature (self, _tmp152_, "callback", TRUE, _tmp155_, _tmp158_, _tmp161_, _tmp164_, _tmp167_, FALSE);

2619

_vala_iterable_unref0 (_tmp161_);

2620

_g_free0 (_tmp158_);

2621

_tmp168_ = self->priv->indent;

2622

self->priv->indent = _tmp168_ - 1;

2623

vala_gir_writer_write_indent (self);

2624

_tmp169_ = self->priv->buffer;

2625

g_string_append_printf (_tmp169_, "</field>\n");

2626

}

2627

}

2628

_vala_code_node_unref0 (m);

2629

}

2630

_vala_iterable_unref0 (_m_list);

2631

}

2632

_tmp170_ = self->priv->indent;

2633

self->priv->indent = _tmp170_ - 1;

2634

vala_gir_writer_write_indent (self);

2635

_tmp171_ = self->priv->buffer;

2636

g_string_append_printf (_tmp171_, "</record>\n");

2637

vala_gir_writer_visit_deferred (self);

2638

_g_free0 (gtype_struct_name);

2639

}

2640

2641

2642

static void vala_gir_writer_visit_deferred (ValaGIRWriter* self) {

2643

ValaArrayList* _tmp0_;

2644

ValaArrayList* _tmp1_;

2645

ValaArrayList* nodes;

2646

GEqualFunc _tmp2_;

2647

ValaArrayList* _tmp3_;

2648

g_return_if_fail (self != NULL);

2649

_tmp0_ = self->priv->deferred;

2650

_tmp1_ = _vala_iterable_ref0 (_tmp0_);

2651

nodes = _tmp1_;

2652

_tmp2_ = g_direct_equal;

2653

_tmp3_ = vala_array_list_new (VALA_TYPE_CODE_NODE, (GBoxedCopyFunc) vala_code_node_ref, vala_code_node_unref, _tmp2_);

2654

_vala_iterable_unref0 (self->priv->deferred);

2655

self->priv->deferred = _tmp3_;

2656

{

2657

ValaArrayList* _tmp4_;

2658

ValaArrayList* _tmp5_;

2659

ValaArrayList* _node_list;

2660

ValaArrayList* _tmp6_;

2661

gint _tmp7_;

2662

gint _tmp8_;

2663

gint _node_size;

2664

gint _node_index;

2665

_tmp4_ = nodes;

2666

_tmp5_ = _vala_iterable_ref0 (_tmp4_);

2667

_node_list = _tmp5_;

2668

_tmp6_ = _node_list;

2669

_tmp7_ = vala_collection_get_size ((ValaCollection*) _tmp6_);

2670

_tmp8_ = _tmp7_;

2671

_node_size = _tmp8_;

2672

_node_index = -1;

2673

while (TRUE) {

2674

gint _tmp9_;

2675

gint _tmp10_;

2676

gint _tmp11_;

2677

ValaArrayList* _tmp12_;

2678

gint _tmp13_;

2679

gpointer _tmp14_ = NULL;

2680

ValaCodeNode* node;

2681

ValaCodeNode* _tmp15_;

2682

_tmp9_ = _node_index;

2683

_node_index = _tmp9_ + 1;

2684

_tmp10_ = _node_index;

2685

_tmp11_ = _node_size;

2686

if (!(_tmp10_ < _tmp11_)) {

2687

break;

2688

}

2689

_tmp12_ = _node_list;

2690

_tmp13_ = _node_index;

2691

_tmp14_ = vala_list_get ((ValaList*) _tmp12_, _tmp13_);

2692

node = (ValaCodeNode*) _tmp14_;

2693

_tmp15_ = node;

2694

vala_code_node_accept (_tmp15_, (ValaCodeVisitor*) self);

2695

_vala_code_node_unref0 (node);

2696

}

2697

_vala_iterable_unref0 (_node_list);

2698

}

2699

_vala_iterable_unref0 (nodes);

2700

}

2701

2702

2703

static gchar* vala_gir_writer_get_gir_name (ValaGIRWriter* self, ValaSymbol* symbol) {

2704

gchar* result = NULL;

2705

gchar* gir_name;

2706

ValaArrayList* _tmp0_;

2707

gpointer _tmp1_ = NULL;

2708

ValaSymbol* h0;

2709

g_return_val_if_fail (self != NULL, NULL);

2710

g_return_val_if_fail (symbol != NULL, NULL);

2711

gir_name = NULL;

2712

_tmp0_ = self->priv->hierarchy;

2713

_tmp1_ = vala_list_get ((ValaList*) _tmp0_, 0);

2714

h0 = (ValaSymbol*) _tmp1_;

2715

{

2716

ValaSymbol* _tmp2_;

2717

ValaSymbol* _tmp3_;

2718

ValaSymbol* cur_sym;

2719

_tmp2_ = symbol;

2720

_tmp3_ = _vala_code_node_ref0 (_tmp2_);

2721

cur_sym = _tmp3_;

2722

{

2723

gboolean _tmp4_;

2724

_tmp4_ = TRUE;

2725

while (TRUE) {

2726

gboolean _tmp5_;

2727

ValaSymbol* _tmp10_;

2728

ValaSymbol* _tmp11_;

2729

ValaSymbol* _tmp12_;

2730

ValaSymbol* _tmp13_;

2731

gchar* _tmp14_ = NULL;

2732

gchar* cur_name;

2733

const gchar* _tmp15_;

2734

const gchar* _tmp20_;

2735

const gchar* _tmp21_;

2736

gchar* _tmp22_ = NULL;

2737

_tmp5_ = _tmp4_;

2738

if (!_tmp5_) {

2739

ValaSymbol* _tmp6_;

2740

ValaSymbol* _tmp7_;

2741

ValaSymbol* _tmp8_;

2742

ValaSymbol* _tmp9_;

2743

_tmp6_ = cur_sym;

2744

_tmp7_ = vala_symbol_get_parent_symbol (_tmp6_);

2745

_tmp8_ = _tmp7_;

2746

_tmp9_ = _vala_code_node_ref0 (_tmp8_);

2747

_vala_code_node_unref0 (cur_sym);

2748

cur_sym = _tmp9_;

2749

}

2750

_tmp4_ = FALSE;

2751

_tmp10_ = cur_sym;

2752

if (!(_tmp10_ != NULL)) {

2753

break;

2754

}

2755

_tmp11_ = cur_sym;

2756

_tmp12_ = h0;

2757

if (_tmp11_ == _tmp12_) {

2758

break;

2759

}

2760

_tmp13_ = cur_sym;

2761

_tmp14_ = vala_code_node_get_attribute_string ((ValaCodeNode*) _tmp13_, "GIR", "name");

2762

cur_name = _tmp14_;

2763

_tmp15_ = cur_name;

2764

if (_tmp15_ == NULL) {

2765

ValaSymbol* _tmp16_;

2766

const gchar* _tmp17_;

2767

const gchar* _tmp18_;

2768

gchar* _tmp19_;

2769

_tmp16_ = cur_sym;

2770

_tmp17_ = vala_symbol_get_name (_tmp16_);

2771

_tmp18_ = _tmp17_;

2772

_tmp19_ = g_strdup (_tmp18_);

2773

_g_free0 (cur_name);

2774

cur_name = _tmp19_;

2775

}

2776

_tmp20_ = cur_name;

2777

_tmp21_ = gir_name;

2778

_tmp22_ = g_strconcat (_tmp20_, _tmp21_, NULL);

2779

_g_free0 (gir_name);

2780

gir_name = _tmp22_;

2781

_g_free0 (cur_name);

2782

}

2783

}

2784

_vala_code_node_unref0 (cur_sym);

2785

}

2786

result = gir_name;

2787

_vala_code_node_unref0 (h0);

2788

return result;

2789

}

2790

2791

2792

static void vala_gir_writer_real_visit_enum (ValaCodeVisitor* base, ValaEnum* en) {

2793

ValaGIRWriter * self;

2794

ValaEnum* _tmp0_;

2795

gboolean _tmp1_;

2796

gboolean _tmp2_;

2797

ValaEnum* _tmp3_;

2798

gboolean _tmp4_ = FALSE;

2799

ValaArrayList* _tmp5_;

2800

gpointer _tmp6_ = NULL;

2801

ValaSymbol* _tmp7_;

2802

gboolean _tmp8_;

2803

const gchar* _tmp11_ = NULL;

2804

ValaEnum* _tmp12_;

2805

gboolean _tmp13_;

2806

gboolean _tmp14_;

2807

const gchar* _tmp15_;

2808

gchar* _tmp16_;

2809

gchar* element_name;

2810

GString* _tmp17_;

2811

const gchar* _tmp18_;

2812

ValaEnum* _tmp19_;

2813

gchar* _tmp20_ = NULL;

2814

gchar* _tmp21_;

2815

ValaEnum* _tmp22_;

2816

ValaEnum* _tmp23_;

2817

GString* _tmp24_;

2818

gint _tmp25_;

2819

ValaEnum* _tmp26_;

2820

gchar* _tmp27_ = NULL;

2821

gchar* _tmp28_;

2822

ValaEnum* _tmp29_;

2823

ValaArrayList* _tmp30_;

2824

ValaEnum* _tmp31_;

2825

ValaEnum* _tmp32_;

2826

ValaArrayList* _tmp33_;

2827

gint _tmp34_;

2828

GString* _tmp35_;

2829

const gchar* _tmp36_;

2830

self = (ValaGIRWriter*) base;

2831

g_return_if_fail (en != NULL);

2832

_tmp0_ = en;

2833

_tmp1_ = vala_symbol_get_external_package ((ValaSymbol*) _tmp0_);

2834

_tmp2_ = _tmp1_;

2835

if (_tmp2_) {

2836

return;

2837

}

2838

_tmp3_ = en;

2839

_tmp4_ = vala_gir_writer_check_accessibility (self, (ValaSymbol*) _tmp3_);

2840

if (!_tmp4_) {

2841

return;

2842

}

2843

_tmp5_ = self->priv->hierarchy;

2844

_tmp6_ = vala_list_get ((ValaList*) _tmp5_, 0);

2845

_tmp7_ = (ValaSymbol*) _tmp6_;

2846

_tmp8_ = !G_TYPE_CHECK_INSTANCE_TYPE (_tmp7_, VALA_TYPE_NAMESPACE);

2847

_vala_code_node_unref0 (_tmp7_);

2848

if (_tmp8_) {

2849

ValaArrayList* _tmp9_;

2850

ValaEnum* _tmp10_;

2851

_tmp9_ = self->priv->deferred;

2852

_tmp10_ = en;

2853

vala_collection_add ((ValaCollection*) _tmp9_, (ValaCodeNode*) _tmp10_);

2854

return;

2855

}

2856

_tmp12_ = en;

2857

_tmp13_ = vala_enum_get_is_flags (_tmp12_);

2858

_tmp14_ = _tmp13_;

2859

if (_tmp14_) {

2860

_tmp11_ = "bitfield";

2861

} else {

2862

_tmp11_ = "enumeration";

2863

}

2864

_tmp15_ = _tmp11_;

2865

_tmp16_ = g_strdup (_tmp15_);

2866

element_name = _tmp16_;

2867

vala_gir_writer_write_indent (self);

2868

_tmp17_ = self->priv->buffer;

2869

_tmp18_ = element_name;

2870

_tmp19_ = en;

2871

_tmp20_ = vala_gir_writer_get_gir_name (self, (ValaSymbol*) _tmp19_);

2872

_tmp21_ = _tmp20_;

2873

g_string_append_printf (_tmp17_, "<%s name=\"%s\"", _tmp18_, _tmp21_);

2874

_g_free0 (_tmp21_);

2875

_tmp22_ = en;

2876

vala_gir_writer_write_gtype_attributes (self, (ValaTypeSymbol*) _tmp22_);

2877

_tmp23_ = en;

2878

vala_gir_writer_write_symbol_attributes (self, (ValaSymbol*) _tmp23_);

2879

_tmp24_ = self->priv->buffer;

2880

g_string_append_printf (_tmp24_, ">\n");

2881

_tmp25_ = self->priv->indent;

2882

self->priv->indent = _tmp25_ + 1;

2883

_tmp26_ = en;

2884

_tmp27_ = vala_gir_writer_get_enum_comment (self, _tmp26_);

2885

_tmp28_ = _tmp27_;

2886

vala_gir_writer_write_doc (self, _tmp28_);

2887

_g_free0 (_tmp28_);

2888

_tmp29_ = en;

2889

vala_gir_writer_write_annotations (self, (ValaCodeNode*) _tmp29_);

2890

self->priv->enum_value = 0;

2891

_tmp30_ = self->priv->hierarchy;

2892

_tmp31_ = en;

2893

vala_list_insert ((ValaList*) _tmp30_, 0, (ValaSymbol*) _tmp31_);

2894

_tmp32_ = en;

2895

vala_code_node_accept_children ((ValaCodeNode*) _tmp32_, (ValaCodeVisitor*) self);

2896

_tmp33_ = self->priv->hierarchy;

2897

vala_list_remove_at ((ValaList*) _tmp33_, 0);

2898

_tmp34_ = self->priv->indent;

2899

self->priv->indent = _tmp34_ - 1;

2900

vala_gir_writer_write_indent (self);

2901

_tmp35_ = self->priv->buffer;

2902

_tmp36_ = element_name;

2903

g_string_append_printf (_tmp35_, "</%s>\n", _tmp36_);

2904

vala_gir_writer_visit_deferred (self);

2905

_g_free0 (element_name);

2906

}

2907

2908

2909

static void vala_gir_writer_real_visit_enum_value (ValaCodeVisitor* base, ValaEnumValue* ev) {

2910

ValaGIRWriter * self;

2911

ValaArrayList* _tmp0_;

2912

gpointer _tmp1_ = NULL;

2913

ValaEnum* en;

2914

GString* _tmp2_;

2915

ValaEnumValue* _tmp3_;

2916

const gchar* _tmp4_;

2917

const gchar* _tmp5_;

2918

gchar* _tmp6_ = NULL;

2919

gchar* _tmp7_;

2920

ValaEnumValue* _tmp8_;

2921

gchar* _tmp9_ = NULL;

2922

gchar* _tmp10_;

2923

ValaEnumValue* _tmp11_;

2924

ValaExpression* _tmp12_;

2925

ValaExpression* _tmp13_;

2926

ValaEnumValue* _tmp27_;

2927

ValaEnumValue* _tmp28_;

2928

gchar* _tmp29_ = NULL;

2929

gchar* comment;

2930

const gchar* _tmp30_;

2931

self = (ValaGIRWriter*) base;

2932

g_return_if_fail (ev != NULL);

2933

vala_gir_writer_write_indent (self);

2934

_tmp0_ = self->priv->hierarchy;

2935

_tmp1_ = vala_list_get ((ValaList*) _tmp0_, 0);

2936

en = G_TYPE_CHECK_INSTANCE_CAST ((ValaSymbol*) _tmp1_, VALA_TYPE_ENUM, ValaEnum);

2937

_tmp2_ = self->priv->buffer;

2938

_tmp3_ = ev;

2939

_tmp4_ = vala_symbol_get_name ((ValaSymbol*) _tmp3_);

2940

_tmp5_ = _tmp4_;

2941

_tmp6_ = g_utf8_strdown (_tmp5_, (gssize) (-1));

2942

_tmp7_ = _tmp6_;

2943

_tmp8_ = ev;

2944

_tmp9_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp8_);

2945

_tmp10_ = _tmp9_;

2946

g_string_append_printf (_tmp2_, "<member name=\"%s\" c:identifier=\"%s\"", _tmp7_, _tmp10_);

2947

_g_free0 (_tmp10_);

2948

_g_free0 (_tmp7_);

2949

_tmp11_ = ev;

2950

_tmp12_ = vala_constant_get_value ((ValaConstant*) _tmp11_);

2951

_tmp13_ = _tmp12_;

2952

if (_tmp13_ != NULL) {

2953

ValaEnumValue* _tmp14_;

2954

ValaExpression* _tmp15_;

2955

ValaExpression* _tmp16_;

2956

gchar* _tmp17_ = NULL;

2957

gchar* value;

2958

GString* _tmp18_;

2959

const gchar* _tmp19_;

2960

_tmp14_ = ev;

2961

_tmp15_ = vala_constant_get_value ((ValaConstant*) _tmp14_);

2962

_tmp16_ = _tmp15_;

2963

_tmp17_ = vala_gir_writer_literal_expression_to_value_string (self, _tmp16_);

2964

value = _tmp17_;

2965

_tmp18_ = self->priv->buffer;

2966

_tmp19_ = value;

2967

g_string_append_printf (_tmp18_, " value=\"%s\"", _tmp19_);

2968

_g_free0 (value);

2969

} else {

2970

ValaEnum* _tmp20_;

2971

gboolean _tmp21_;

2972

gboolean _tmp22_;

2973

_tmp20_ = en;

2974

_tmp21_ = vala_enum_get_is_flags (_tmp20_);

2975

_tmp22_ = _tmp21_;

2976

if (_tmp22_) {

2977

GString* _tmp23_;

2978

gint _tmp24_;

2979

_tmp23_ = self->priv->buffer;

2980

_tmp24_ = self->priv->enum_value;

2981

self->priv->enum_value = _tmp24_ + 1;

2982

g_string_append_printf (_tmp23_, " value=\"%d\"", 1 << _tmp24_);

2983

} else {

2984

GString* _tmp25_;

2985

gint _tmp26_;

2986

_tmp25_ = self->priv->buffer;

2987

_tmp26_ = self->priv->enum_value;

2988

self->priv->enum_value = _tmp26_ + 1;

2989

g_string_append_printf (_tmp25_, " value=\"%d\"", _tmp26_);

2990

}

2991

}

2992

_tmp27_ = ev;

2993

vala_gir_writer_write_symbol_attributes (self, (ValaSymbol*) _tmp27_);

2994

_tmp28_ = ev;

2995

_tmp29_ = vala_gir_writer_get_enum_value_comment (self, _tmp28_);

2996

comment = _tmp29_;

2997

_tmp30_ = comment;

2998

if (_tmp30_ == NULL) {

2999

GString* _tmp31_;

3000

_tmp31_ = self->priv->buffer;

3001

g_string_append_printf (_tmp31_, "/>\n");

3002

} else {

3003

GString* _tmp32_;

3004

gint _tmp33_;

3005

const gchar* _tmp34_;

3006

gint _tmp35_;

3007

GString* _tmp36_;

3008

_tmp32_ = self->priv->buffer;

3009

g_string_append_printf (_tmp32_, ">\n");

3010

_tmp33_ = self->priv->indent;

3011

self->priv->indent = _tmp33_ + 1;

3012

_tmp34_ = comment;

3013

vala_gir_writer_write_doc (self, _tmp34_);

3014

_tmp35_ = self->priv->indent;

3015

self->priv->indent = _tmp35_ - 1;

3016

vala_gir_writer_write_indent (self);

3017

_tmp36_ = self->priv->buffer;

3018

g_string_append_printf (_tmp36_, "</member>\n");

3019

}

3020

_g_free0 (comment);

3021

_vala_code_node_unref0 (en);

3022

}

3023

3024

3025

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

3026

ValaGIRWriter * self;

3027

ValaErrorDomain* _tmp0_;

3028

gboolean _tmp1_;

3029

gboolean _tmp2_;

3030

ValaErrorDomain* _tmp3_;

3031

gboolean _tmp4_ = FALSE;

3032

GString* _tmp5_;

3033

ValaErrorDomain* _tmp6_;

3034

const gchar* _tmp7_;

3035

const gchar* _tmp8_;

3036

GString* _tmp9_;

3037

ValaErrorDomain* _tmp10_;

3038

gchar* _tmp11_ = NULL;

3039

gchar* _tmp12_;

3040

GString* _tmp13_;

3041

ValaErrorDomain* _tmp14_;

3042

const gchar* _tmp15_;

3043

const gchar* _tmp16_;

3044

ValaErrorDomain* _tmp17_;

3045

GString* _tmp18_;

3046

ValaErrorDomain* _tmp19_;

3047

GString* _tmp20_;

3048

GString* _tmp21_;

3049

ValaErrorDomain* _tmp22_;

3050

const gchar* _tmp23_;

3051

const gchar* _tmp24_;

3052

ValaErrorDomain* _tmp25_;

3053

GString* _tmp26_;

3054

gint _tmp27_;

3055

ValaErrorDomain* _tmp28_;

3056

gchar* _tmp29_ = NULL;

3057

gchar* _tmp30_;

3058

ValaArrayList* _tmp31_;

3059

ValaErrorDomain* _tmp32_;

3060

ValaErrorDomain* _tmp33_;

3061

ValaArrayList* _tmp34_;

3062

gint _tmp35_;

3063

GString* _tmp36_;

3064

self = (ValaGIRWriter*) base;

3065

g_return_if_fail (edomain != NULL);

3066

_tmp0_ = edomain;

3067

_tmp1_ = vala_symbol_get_external_package ((ValaSymbol*) _tmp0_);

3068

_tmp2_ = _tmp1_;

3069

if (_tmp2_) {

3070

return;

3071

}

3072

_tmp3_ = edomain;

3073

_tmp4_ = vala_gir_writer_check_accessibility (self, (ValaSymbol*) _tmp3_);

3074

if (!_tmp4_) {

3075

return;

3076

}

3077

vala_gir_writer_write_indent (self);

3078

_tmp5_ = self->priv->buffer;

3079

_tmp6_ = edomain;

3080

_tmp7_ = vala_symbol_get_name ((ValaSymbol*) _tmp6_);

3081

_tmp8_ = _tmp7_;

3082

g_string_append_printf (_tmp5_, "<errordomain name=\"%s\"", _tmp8_);

3083

_tmp9_ = self->priv->buffer;

3084

_tmp10_ = edomain;

3085

_tmp11_ = vala_ccode_base_module_get_ccode_lower_case_prefix ((ValaSymbol*) _tmp10_);

3086

_tmp12_ = _tmp11_;

3087

g_string_append_printf (_tmp9_, " get-quark=\"%squark\"", _tmp12_);

3088

_g_free0 (_tmp12_);

3089

_tmp13_ = self->priv->buffer;

3090

_tmp14_ = edomain;

3091

_tmp15_ = vala_symbol_get_name ((ValaSymbol*) _tmp14_);

3092

_tmp16_ = _tmp15_;

3093

g_string_append_printf (_tmp13_, " codes=\"%s\"", _tmp16_);

3094

_tmp17_ = edomain;

3095

vala_gir_writer_write_symbol_attributes (self, (ValaSymbol*) _tmp17_);

3096

_tmp18_ = self->priv->buffer;

3097

g_string_append_printf (_tmp18_, ">\n");

3098

_tmp19_ = edomain;

3099

vala_gir_writer_write_annotations (self, (ValaCodeNode*) _tmp19_);

3100

_tmp20_ = self->priv->buffer;

3101

g_string_append_printf (_tmp20_, "</errordomain>\n");

3102

vala_gir_writer_write_indent (self);

3103

_tmp21_ = self->priv->buffer;

3104

_tmp22_ = edomain;

3105

_tmp23_ = vala_symbol_get_name ((ValaSymbol*) _tmp22_);

3106

_tmp24_ = _tmp23_;

3107

g_string_append_printf (_tmp21_, "<enumeration name=\"%s\"", _tmp24_);

3108

_tmp25_ = edomain;

3109

vala_gir_writer_write_ctype_attributes (self, (ValaTypeSymbol*) _tmp25_, "");

3110

_tmp26_ = self->priv->buffer;

3111

g_string_append_printf (_tmp26_, ">\n");

3112

_tmp27_ = self->priv->indent;

3113

self->priv->indent = _tmp27_ + 1;

3114

_tmp28_ = edomain;

3115

_tmp29_ = vala_gir_writer_get_error_domain_comment (self, _tmp28_);

3116

_tmp30_ = _tmp29_;

3117

vala_gir_writer_write_doc (self, _tmp30_);

3118

_g_free0 (_tmp30_);

3119

self->priv->enum_value = 0;

3120

_tmp31_ = self->priv->hierarchy;

3121

_tmp32_ = edomain;

3122

vala_list_insert ((ValaList*) _tmp31_, 0, (ValaSymbol*) _tmp32_);

3123

_tmp33_ = edomain;

3124

vala_code_node_accept_children ((ValaCodeNode*) _tmp33_, (ValaCodeVisitor*) self);

3125

_tmp34_ = self->priv->hierarchy;

3126

vala_list_remove_at ((ValaList*) _tmp34_, 0);

3127

_tmp35_ = self->priv->indent;

3128

self->priv->indent = _tmp35_ - 1;

3129

vala_gir_writer_write_indent (self);

3130

_tmp36_ = self->priv->buffer;

3131

g_string_append_printf (_tmp36_, "</enumeration>\n");

3132

vala_gir_writer_visit_deferred (self);

3133

}

3134

3135

3136

static void vala_gir_writer_real_visit_error_code (ValaCodeVisitor* base, ValaErrorCode* ecode) {

3137

ValaGIRWriter * self;

3138

GString* _tmp0_;

3139

ValaErrorCode* _tmp1_;

3140

const gchar* _tmp2_;

3141

const gchar* _tmp3_;

3142

gchar* _tmp4_ = NULL;

3143

gchar* _tmp5_;

3144

ValaErrorCode* _tmp6_;

3145

gchar* _tmp7_ = NULL;

3146

gchar* _tmp8_;

3147

ValaErrorCode* _tmp9_;

3148

ValaExpression* _tmp10_;

3149

ValaExpression* _tmp11_;

3150

ValaErrorCode* _tmp20_;

3151

ValaErrorCode* _tmp21_;

3152

gchar* _tmp22_ = NULL;

3153

gchar* comment;

3154

const gchar* _tmp23_;

3155

self = (ValaGIRWriter*) base;

3156

g_return_if_fail (ecode != NULL);

3157

vala_gir_writer_write_indent (self);

3158

_tmp0_ = self->priv->buffer;

3159

_tmp1_ = ecode;

3160

_tmp2_ = vala_symbol_get_name ((ValaSymbol*) _tmp1_);

3161

_tmp3_ = _tmp2_;

3162

_tmp4_ = g_utf8_strdown (_tmp3_, (gssize) (-1));

3163

_tmp5_ = _tmp4_;

3164

_tmp6_ = ecode;

3165

_tmp7_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp6_);

3166

_tmp8_ = _tmp7_;

3167

g_string_append_printf (_tmp0_, "<member name=\"%s\" c:identifier=\"%s\"", _tmp5_, _tmp8_);

3168

_g_free0 (_tmp8_);

3169

_g_free0 (_tmp5_);

3170

_tmp9_ = ecode;

3171

_tmp10_ = vala_error_code_get_value (_tmp9_);

3172

_tmp11_ = _tmp10_;

3173

if (_tmp11_ != NULL) {

3174

ValaErrorCode* _tmp12_;

3175

ValaExpression* _tmp13_;

3176

ValaExpression* _tmp14_;

3177

gchar* _tmp15_ = NULL;

3178

gchar* value;

3179

GString* _tmp16_;

3180

const gchar* _tmp17_;

3181

_tmp12_ = ecode;

3182

_tmp13_ = vala_error_code_get_value (_tmp12_);

3183

_tmp14_ = _tmp13_;

3184

_tmp15_ = vala_gir_writer_literal_expression_to_value_string (self, _tmp14_);

3185

value = _tmp15_;

3186

_tmp16_ = self->priv->buffer;

3187

_tmp17_ = value;

3188

g_string_append_printf (_tmp16_, " value=\"%s\"", _tmp17_);

3189

_g_free0 (value);

3190

} else {

3191

GString* _tmp18_;

3192

gint _tmp19_;

3193

_tmp18_ = self->priv->buffer;

3194

_tmp19_ = self->priv->enum_value;

3195

self->priv->enum_value = _tmp19_ + 1;

3196

g_string_append_printf (_tmp18_, " value=\"%d\"", _tmp19_);

3197

}

3198

_tmp20_ = ecode;

3199

vala_gir_writer_write_symbol_attributes (self, (ValaSymbol*) _tmp20_);

3200

_tmp21_ = ecode;

3201

_tmp22_ = vala_gir_writer_get_error_code_comment (self, _tmp21_);

3202

comment = _tmp22_;

3203

_tmp23_ = comment;

3204

if (_tmp23_ == NULL) {

3205

GString* _tmp24_;

3206

_tmp24_ = self->priv->buffer;

3207

g_string_append_printf (_tmp24_, "/>\n");

3208

} else {

3209

GString* _tmp25_;

3210

gint _tmp26_;

3211

const gchar* _tmp27_;

3212

gint _tmp28_;

3213

GString* _tmp29_;

3214

_tmp25_ = self->priv->buffer;

3215

g_string_append_printf (_tmp25_, ">\n");

3216

_tmp26_ = self->priv->indent;

3217

self->priv->indent = _tmp26_ + 1;

3218

_tmp27_ = comment;

3219

vala_gir_writer_write_doc (self, _tmp27_);

3220

_tmp28_ = self->priv->indent;

3221

self->priv->indent = _tmp28_ - 1;

3222

vala_gir_writer_write_indent (self);

3223

_tmp29_ = self->priv->buffer;

3224

g_string_append_printf (_tmp29_, "</member>\n");

3225

}

3226

_g_free0 (comment);

3227

}

3228

3229

3230

static void vala_gir_writer_real_visit_constant (ValaCodeVisitor* base, ValaConstant* c) {

3231

ValaGIRWriter * self;

3232

ValaConstant* _tmp0_;

3233

gboolean _tmp1_;

3234

gboolean _tmp2_;

3235

ValaConstant* _tmp3_;

3236

gboolean _tmp4_ = FALSE;

3237

ValaConstant* _tmp5_;

3238

ValaExpression* _tmp6_;

3239

ValaExpression* _tmp7_;

3240

ValaExpression* _tmp8_;

3241

ValaExpression* initializer;

3242

ValaExpression* _tmp9_;

3243

gchar* _tmp10_ = NULL;

3244

gchar* value;

3245

GString* _tmp11_;

3246

ValaConstant* _tmp12_;

3247

const gchar* _tmp13_;

3248

const gchar* _tmp14_;

3249

ValaConstant* _tmp15_;

3250

gchar* _tmp16_ = NULL;

3251

gchar* _tmp17_;

3252

GString* _tmp18_;

3253

const gchar* _tmp19_;

3254

ValaConstant* _tmp20_;

3255

GString* _tmp21_;

3256

gint _tmp22_;

3257

ValaConstant* _tmp23_;

3258

gchar* _tmp24_ = NULL;

3259

gchar* _tmp25_;

3260

ValaExpression* _tmp26_;

3261

ValaDataType* _tmp27_;

3262

ValaDataType* _tmp28_;

3263

gint _tmp29_;

3264

GString* _tmp30_;

3265

self = (ValaGIRWriter*) base;

3266

g_return_if_fail (c != NULL);

3267

_tmp0_ = c;

3268

_tmp1_ = vala_symbol_get_external_package ((ValaSymbol*) _tmp0_);

3269

_tmp2_ = _tmp1_;

3270

if (_tmp2_) {

3271

return;

3272

}

3273

_tmp3_ = c;

3274

_tmp4_ = vala_gir_writer_check_accessibility (self, (ValaSymbol*) _tmp3_);

3275

if (!_tmp4_) {

3276

return;

3277

}

3278

_tmp5_ = c;

3279

_tmp6_ = vala_constant_get_value (_tmp5_);

3280

_tmp7_ = _tmp6_;

3281

_tmp8_ = _vala_code_node_ref0 (_tmp7_);

3282

initializer = _tmp8_;

3283

_tmp9_ = initializer;

3284

_tmp10_ = vala_gir_writer_literal_expression_to_value_string (self, _tmp9_);

3285

value = _tmp10_;

3286

vala_gir_writer_write_indent (self);

3287

_tmp11_ = self->priv->buffer;

3288

_tmp12_ = c;

3289

_tmp13_ = vala_symbol_get_name ((ValaSymbol*) _tmp12_);

3290

_tmp14_ = _tmp13_;

3291

_tmp15_ = c;

3292

_tmp16_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp15_);

3293

_tmp17_ = _tmp16_;

3294

g_string_append_printf (_tmp11_, "<constant name=\"%s\" c:identifier=\"%s\"", _tmp14_, _tmp17_);

3295

_g_free0 (_tmp17_);

3296

_tmp18_ = self->priv->buffer;

3297

_tmp19_ = value;

3298

g_string_append_printf (_tmp18_, " value=\"%s\"", _tmp19_);

3299

_tmp20_ = c;

3300

vala_gir_writer_write_symbol_attributes (self, (ValaSymbol*) _tmp20_);

3301

_tmp21_ = self->priv->buffer;

3302

g_string_append_printf (_tmp21_, ">\n");

3303

_tmp22_ = self->priv->indent;

3304

self->priv->indent = _tmp22_ + 1;

3305

_tmp23_ = c;

3306

_tmp24_ = vala_gir_writer_get_constant_comment (self, _tmp23_);

3307

_tmp25_ = _tmp24_;

3308

vala_gir_writer_write_doc (self, _tmp25_);

3309

_g_free0 (_tmp25_);

3310

_tmp26_ = initializer;

3311

_tmp27_ = vala_expression_get_value_type (_tmp26_);

3312

_tmp28_ = _tmp27_;

3313

vala_gir_writer_write_type (self, _tmp28_, -1);

3314

_tmp29_ = self->priv->indent;

3315

self->priv->indent = _tmp29_ - 1;

3316

vala_gir_writer_write_indent (self);

3317

_tmp30_ = self->priv->buffer;

3318

g_string_append_printf (_tmp30_, "</constant>\n");

3319

_g_free0 (value);

3320

_vala_code_node_unref0 (initializer);

3321

}

3322

3323

3324

static void vala_gir_writer_real_visit_field (ValaCodeVisitor* base, ValaField* f) {

3325

ValaGIRWriter * self;

3326

ValaField* _tmp0_;

3327

gboolean _tmp1_;

3328

gboolean _tmp2_;

3329

ValaField* _tmp3_;

3330

gboolean _tmp4_ = FALSE;

3331

GString* _tmp5_;

3332

ValaField* _tmp6_;

3333

gchar* _tmp7_ = NULL;

3334

gchar* _tmp8_;

3335

ValaField* _tmp9_;

3336

ValaDataType* _tmp10_;

3337

ValaDataType* _tmp11_;

3338

gboolean _tmp12_;

3339

gboolean _tmp13_;

3340

ValaField* _tmp15_;

3341

GString* _tmp16_;

3342

gint _tmp17_;

3343

ValaField* _tmp18_;

3344

gchar* _tmp19_ = NULL;

3345

gchar* _tmp20_;

3346

ValaField* _tmp21_;

3347

ValaField* _tmp22_;

3348

ValaDataType* _tmp23_;

3349

ValaDataType* _tmp24_;

3350

gint _tmp25_;

3351

GString* _tmp26_;

3352

self = (ValaGIRWriter*) base;

3353

g_return_if_fail (f != NULL);

3354

_tmp0_ = f;

3355

_tmp1_ = vala_symbol_get_external_package ((ValaSymbol*) _tmp0_);

3356

_tmp2_ = _tmp1_;

3357

if (_tmp2_) {

3358

return;

3359

}

3360

_tmp3_ = f;

3361

_tmp4_ = vala_gir_writer_check_accessibility (self, (ValaSymbol*) _tmp3_);

3362

if (!_tmp4_) {

3363

return;

3364

}

3365

vala_gir_writer_write_indent (self);

3366

_tmp5_ = self->priv->buffer;

3367

_tmp6_ = f;

3368

_tmp7_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp6_);

3369

_tmp8_ = _tmp7_;

3370

g_string_append_printf (_tmp5_, "<field name=\"%s\"", _tmp8_);

3371

_g_free0 (_tmp8_);

3372

_tmp9_ = f;

3373

_tmp10_ = vala_variable_get_variable_type ((ValaVariable*) _tmp9_);

3374

_tmp11_ = _tmp10_;

3375

_tmp12_ = vala_data_type_get_nullable (_tmp11_);

3376

_tmp13_ = _tmp12_;

3377

if (_tmp13_) {

3378

GString* _tmp14_;

3379

_tmp14_ = self->priv->buffer;

3380

g_string_append_printf (_tmp14_, " allow-none=\"1\"");

3381

}

3382

_tmp15_ = f;

3383

vala_gir_writer_write_symbol_attributes (self, (ValaSymbol*) _tmp15_);

3384

_tmp16_ = self->priv->buffer;

3385

g_string_append_printf (_tmp16_, ">\n");

3386

_tmp17_ = self->priv->indent;

3387

self->priv->indent = _tmp17_ + 1;

3388

_tmp18_ = f;

3389

_tmp19_ = vala_gir_writer_get_field_comment (self, _tmp18_);

3390

_tmp20_ = _tmp19_;

3391

vala_gir_writer_write_doc (self, _tmp20_);

3392

_g_free0 (_tmp20_);

3393

_tmp21_ = f;

3394

vala_gir_writer_write_annotations (self, (ValaCodeNode*) _tmp21_);

3395

_tmp22_ = f;

3396

_tmp23_ = vala_variable_get_variable_type ((ValaVariable*) _tmp22_);

3397

_tmp24_ = _tmp23_;

3398

vala_gir_writer_write_type (self, _tmp24_, -1);

3399

_tmp25_ = self->priv->indent;

3400

self->priv->indent = _tmp25_ - 1;

3401

vala_gir_writer_write_indent (self);

3402

_tmp26_ = self->priv->buffer;

3403

g_string_append_printf (_tmp26_, "</field>\n");

3404

}

3405

3406

3407

static void vala_gir_writer_write_implicit_params (ValaGIRWriter* self, ValaDataType* type, gint* index, gboolean has_array_length, const gchar* name, ValaParameterDirection direction) {

3408

gboolean _tmp0_ = FALSE;

3409

ValaDataType* _tmp1_;

3410

gboolean _tmp3_;

3411

g_return_if_fail (self != NULL);

3412

g_return_if_fail (type != NULL);

3413

g_return_if_fail (name != NULL);

3414

_tmp1_ = type;

3415

if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp1_, VALA_TYPE_ARRAY_TYPE)) {

3416

gboolean _tmp2_;

3417

_tmp2_ = has_array_length;

3418

_tmp0_ = _tmp2_;

3419

} else {

3420

_tmp0_ = FALSE;

3421

}

3422

_tmp3_ = _tmp0_;

3423

if (_tmp3_) {

3424

ValaCodeContext* _tmp4_ = NULL;

3425

ValaCodeContext* _tmp5_;

3426

ValaNamespace* _tmp6_;

3427

ValaNamespace* _tmp7_;

3428

ValaScope* _tmp8_;

3429

ValaScope* _tmp9_;

3430

ValaSymbol* _tmp10_ = NULL;

3431

ValaStruct* _tmp11_;

3432

ValaStruct* _tmp12_;

3433

ValaIntegerType* _tmp13_;

3434

ValaIntegerType* _tmp14_;

3435

ValaIntegerType* int_type;

3436

ValaIntegerType* _tmp15_;

3437

gboolean _tmp16_;

3438

const gchar* _tmp17_;

3439

gchar* _tmp18_ = NULL;

3440

gchar* _tmp19_;

3441

ValaParameterDirection _tmp20_;

3442

_tmp4_ = vala_code_context_get ();

3443

_tmp5_ = _tmp4_;

3444

_tmp6_ = vala_code_context_get_root (_tmp5_);

3445

_tmp7_ = _tmp6_;

3446

_tmp8_ = vala_symbol_get_scope ((ValaSymbol*) _tmp7_);

3447

_tmp9_ = _tmp8_;

3448

_tmp10_ = vala_scope_lookup (_tmp9_, "int");

3449

_tmp11_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp10_, VALA_TYPE_STRUCT) ? ((ValaStruct*) _tmp10_) : NULL;

3450

if (_tmp11_ == NULL) {

3451

_vala_code_node_unref0 (_tmp10_);

3452

}

3453

_tmp12_ = _tmp11_;

3454

_tmp13_ = vala_integer_type_new (_tmp12_, NULL, NULL);

3455

_tmp14_ = _tmp13_;

3456

_vala_code_node_unref0 (_tmp12_);

3457

_vala_code_context_unref0 (_tmp5_);

3458

int_type = _tmp14_;

3459

_tmp15_ = int_type;

3460

_tmp16_ = has_array_length;

3461

_tmp17_ = name;

3462

_tmp18_ = g_strdup_printf ("%s_length1", _tmp17_);

3463

_tmp19_ = _tmp18_;

3464

_tmp20_ = direction;

3465

vala_gir_writer_write_param_or_return (self, (ValaDataType*) _tmp15_, TRUE, index, _tmp16_, _tmp19_, NULL, _tmp20_, FALSE, FALSE);

3466

_g_free0 (_tmp19_);

3467

_vala_code_node_unref0 (int_type);

3468

} else {

3469

ValaDataType* _tmp21_;

3470

_tmp21_ = type;

3471

if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp21_, VALA_TYPE_DELEGATE_TYPE)) {

3472

ValaVoidType* _tmp22_;

3473

ValaVoidType* _tmp23_;

3474

ValaPointerType* _tmp24_;

3475

ValaPointerType* _tmp25_;

3476

ValaPointerType* data_type;

3477

ValaPointerType* _tmp26_;

3478

const gchar* _tmp27_;

3479

gchar* _tmp28_ = NULL;

3480

gchar* _tmp29_;

3481

ValaParameterDirection _tmp30_;

3482

ValaDataType* _tmp31_;

3483

gboolean _tmp32_;

3484

gboolean _tmp33_;

3485

_tmp22_ = vala_void_type_new (NULL);

3486

_tmp23_ = _tmp22_;

3487

_tmp24_ = vala_pointer_type_new ((ValaDataType*) _tmp23_, NULL);

3488

_tmp25_ = _tmp24_;

3489

_vala_code_node_unref0 (_tmp23_);

3490

data_type = _tmp25_;

3491

_tmp26_ = data_type;

3492

_tmp27_ = name;

3493

_tmp28_ = g_strdup_printf ("%s_target", _tmp27_);

3494

_tmp29_ = _tmp28_;

3495

_tmp30_ = direction;

3496

vala_gir_writer_write_param_or_return (self, (ValaDataType*) _tmp26_, TRUE, index, FALSE, _tmp29_, NULL, _tmp30_, FALSE, FALSE);

3497

_g_free0 (_tmp29_);

3498

_tmp31_ = type;

3499

_tmp32_ = vala_data_type_get_value_owned (_tmp31_);

3500

_tmp33_ = _tmp32_;

3501

if (_tmp33_) {

3502

ValaCodeContext* _tmp34_ = NULL;

3503

ValaCodeContext* _tmp35_;

3504

ValaNamespace* _tmp36_;

3505

ValaNamespace* _tmp37_;

3506

ValaScope* _tmp38_;

3507

ValaScope* _tmp39_;

3508

ValaSymbol* _tmp40_ = NULL;

3509

ValaSymbol* _tmp41_;

3510

ValaScope* _tmp42_;

3511

ValaScope* _tmp43_;

3512

ValaSymbol* _tmp44_ = NULL;

3513

ValaDelegate* _tmp45_;

3514

ValaDelegate* _tmp46_;

3515

ValaDelegateType* _tmp47_;

3516

ValaDelegateType* _tmp48_;

3517

ValaDelegateType* notify_type;

3518

ValaDelegateType* _tmp49_;

3519

const gchar* _tmp50_;

3520

gchar* _tmp51_ = NULL;

3521

gchar* _tmp52_;

3522

ValaParameterDirection _tmp53_;

3523

_tmp34_ = vala_code_context_get ();

3524

_tmp35_ = _tmp34_;

3525

_tmp36_ = vala_code_context_get_root (_tmp35_);

3526

_tmp37_ = _tmp36_;

3527

_tmp38_ = vala_symbol_get_scope ((ValaSymbol*) _tmp37_);

3528

_tmp39_ = _tmp38_;

3529

_tmp40_ = vala_scope_lookup (_tmp39_, "GLib");

3530

_tmp41_ = _tmp40_;

3531

_tmp42_ = vala_symbol_get_scope (_tmp41_);

3532

_tmp43_ = _tmp42_;

3533

_tmp44_ = vala_scope_lookup (_tmp43_, "DestroyNotify");

3534

_tmp45_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp44_, VALA_TYPE_DELEGATE) ? ((ValaDelegate*) _tmp44_) : NULL;

3535

if (_tmp45_ == NULL) {

3536

_vala_code_node_unref0 (_tmp44_);

3537

}

3538

_tmp46_ = _tmp45_;

3539

_tmp47_ = vala_delegate_type_new (_tmp46_);

3540

_tmp48_ = _tmp47_;

3541

_vala_code_node_unref0 (_tmp46_);

3542

_vala_code_node_unref0 (_tmp41_);

3543

_vala_code_context_unref0 (_tmp35_);

3544

notify_type = _tmp48_;

3545

_tmp49_ = notify_type;

3546

_tmp50_ = name;

3547

_tmp51_ = g_strdup_printf ("%s_target_destroy_notify", _tmp50_);

3548

_tmp52_ = _tmp51_;

3549

_tmp53_ = direction;

3550

vala_gir_writer_write_param_or_return (self, (ValaDataType*) _tmp49_, TRUE, index, FALSE, _tmp52_, NULL, _tmp53_, FALSE, FALSE);

3551

_g_free0 (_tmp52_);

3552

_vala_code_node_unref0 (notify_type);

3553

}

3554

_vala_code_node_unref0 (data_type);

3555

}

3556

}

3557

}

3558

3559

3560

static void vala_gir_writer_skip_implicit_params (ValaGIRWriter* self, ValaDataType* type, gint* index, gboolean has_array_length) {

3561

gboolean _tmp0_ = FALSE;

3562

ValaDataType* _tmp1_;

3563

gboolean _tmp3_;

3564

g_return_if_fail (self != NULL);

3565

g_return_if_fail (type != NULL);

3566

_tmp1_ = type;

3567

if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp1_, VALA_TYPE_ARRAY_TYPE)) {

3568

gboolean _tmp2_;

3569

_tmp2_ = has_array_length;

3570

_tmp0_ = _tmp2_;

3571

} else {

3572

_tmp0_ = FALSE;

3573

}

3574

_tmp3_ = _tmp0_;

3575

if (_tmp3_) {

3576

gint _tmp4_;

3577

_tmp4_ = *index;

3578

*index = _tmp4_ + 1;

3579

} else {

3580

ValaDataType* _tmp5_;

3581

_tmp5_ = type;

3582

if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp5_, VALA_TYPE_DELEGATE_TYPE)) {

3583

gint _tmp6_;

3584

ValaDataType* _tmp7_;

3585

gboolean _tmp8_;

3586

gboolean _tmp9_;

3587

_tmp6_ = *index;

3588

*index = _tmp6_ + 1;

3589

_tmp7_ = type;

3590

_tmp8_ = vala_data_type_get_value_owned (_tmp7_);

3591

_tmp9_ = _tmp8_;

3592

if (_tmp9_) {

3593

gint _tmp10_;

3594

_tmp10_ = *index;

3595

*index = _tmp10_ + 1;

3596

}

3597

}

3598

}

3599

}

3600

3601

3602

3603

gint last_index;

3604

gboolean _tmp0_ = FALSE;

3605

ValaDataType* _tmp1_;

3606

gboolean _tmp4_;

3607

gboolean ret_is_struct;

3608

gboolean _tmp5_ = FALSE;

3609

gboolean _tmp6_ = FALSE;

3610

gboolean _tmp7_ = FALSE;

3611

gboolean _tmp8_ = FALSE;

3612

ValaList* _tmp9_;

3613

gint _tmp10_;

3614

gint _tmp11_;

3615

gboolean _tmp13_;

3616

gboolean _tmp18_;

3617

gboolean _tmp20_;

3618

gboolean _tmp22_;

3619

gboolean _tmp47_ = FALSE;

3620

ValaDataType* _tmp48_;

3621

gboolean _tmp50_;

3622

gboolean _tmp59_ = FALSE;

3623

gboolean _tmp60_ = FALSE;

3624

gboolean _tmp61_ = FALSE;

3625

gboolean _tmp62_ = FALSE;

3626

ValaList* _tmp63_;

3627

gint _tmp64_;

3628

gint _tmp65_;

3629

gboolean _tmp67_;

3630

gboolean _tmp72_;

3631

gboolean _tmp74_;

3632

gboolean _tmp76_;

3633

g_return_if_fail (self != NULL);

3634

g_return_if_fail (params != NULL);

3635

last_index = 0;

3636

_tmp1_ = return_type;

3637

if (_tmp1_ != NULL) {

3638

ValaDataType* _tmp2_;

3639

gboolean _tmp3_ = FALSE;

3640

_tmp2_ = return_type;

3641

_tmp3_ = vala_data_type_is_real_non_null_struct_type (_tmp2_);

3642

_tmp0_ = _tmp3_;

3643

} else {

3644

_tmp0_ = FALSE;

3645

}

3646

_tmp4_ = _tmp0_;

3647

ret_is_struct = _tmp4_;

3648

_tmp9_ = params;

3649

_tmp10_ = vala_collection_get_size ((ValaCollection*) _tmp9_);

3650

_tmp11_ = _tmp10_;

3651

if (_tmp11_ != 0) {

3652

_tmp8_ = TRUE;

3653

} else {

3654

ValaDataType* _tmp12_;

3655

_tmp12_ = instance_type;

3656

_tmp8_ = _tmp12_ != NULL;

3657

}

3658

_tmp13_ = _tmp8_;

3659

if (_tmp13_) {

3660

_tmp7_ = TRUE;

3661

} else {

3662

gboolean _tmp14_ = FALSE;

3663

ValaDataType* _tmp15_;

3664

gboolean _tmp17_;

3665

_tmp15_ = return_type;

3666

if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp15_, VALA_TYPE_ARRAY_TYPE)) {

3667

gboolean _tmp16_;

3668

_tmp16_ = return_array_length;

3669

_tmp14_ = _tmp16_;

3670

} else {

3671

_tmp14_ = FALSE;

3672

}

3673

_tmp17_ = _tmp14_;

3674

_tmp7_ = _tmp17_;

3675

}

3676

_tmp18_ = _tmp7_;

3677

if (_tmp18_) {

3678

_tmp6_ = TRUE;

3679

} else {

3680

ValaDataType* _tmp19_;

3681

_tmp19_ = return_type;

3682

_tmp6_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp19_, VALA_TYPE_DELEGATE_TYPE);

3683

}

3684

_tmp20_ = _tmp6_;

3685

if (_tmp20_) {

3686

_tmp5_ = TRUE;

3687

} else {

3688

gboolean _tmp21_;

3689

_tmp21_ = ret_is_struct;

3690

_tmp5_ = _tmp21_;

3691

}

3692

_tmp22_ = _tmp5_;

3693

if (_tmp22_) {

3694

gint index;

3695

ValaDataType* _tmp23_;

3696

gboolean _tmp42_;

3697

gint _tmp46_;

3698

index = 0;

3699

_tmp23_ = instance_type;

3700

if (_tmp23_ != NULL) {

3701

gint _tmp24_;

3702

_tmp24_ = index;

3703

index = _tmp24_ + 1;

3704

}

3705

{

3706

ValaList* _tmp25_;

3707

ValaList* _tmp26_;

3708

ValaList* _param_list;

3709

ValaList* _tmp27_;

3710

gint _tmp28_;

3711

gint _tmp29_;

3712

gint _param_size;

3713

gint _param_index;

3714

_tmp25_ = params;

3715

_tmp26_ = _vala_iterable_ref0 (_tmp25_);

3716

_param_list = _tmp26_;

3717

_tmp27_ = _param_list;

3718

_tmp28_ = vala_collection_get_size ((ValaCollection*) _tmp27_);

3719

_tmp29_ = _tmp28_;

3720

_param_size = _tmp29_;

3721

_param_index = -1;

3722

while (TRUE) {

3723

gint _tmp30_;

3724

gint _tmp31_;

3725

gint _tmp32_;

3726

ValaList* _tmp33_;

3727

gint _tmp34_;

3728

gpointer _tmp35_ = NULL;

3729

ValaParameter* param;

3730

gint _tmp36_;

3731

ValaParameter* _tmp37_;

3732

ValaDataType* _tmp38_;

3733

ValaDataType* _tmp39_;

3734

ValaParameter* _tmp40_;

3735

gboolean _tmp41_ = FALSE;

3736

_tmp30_ = _param_index;

3737

_param_index = _tmp30_ + 1;

3738

_tmp31_ = _param_index;

3739

_tmp32_ = _param_size;

3740

if (!(_tmp31_ < _tmp32_)) {

3741

break;

3742

}

3743

_tmp33_ = _param_list;

3744

_tmp34_ = _param_index;

3745

_tmp35_ = vala_list_get (_tmp33_, _tmp34_);

3746

param = (ValaParameter*) _tmp35_;

3747

_tmp36_ = index;

3748

index = _tmp36_ + 1;

3749

_tmp37_ = param;

3750

_tmp38_ = vala_variable_get_variable_type ((ValaVariable*) _tmp37_);

3751

_tmp39_ = _tmp38_;

3752

_tmp40_ = param;

3753

_tmp41_ = vala_ccode_base_module_get_ccode_array_length ((ValaCodeNode*) _tmp40_);

3754

vala_gir_writer_skip_implicit_params (self, _tmp39_, &index, _tmp41_);

3755

_vala_code_node_unref0 (param);

3756

}

3757

_vala_iterable_unref0 (_param_list);

3758

}

3759

_tmp42_ = ret_is_struct;

3760

if (_tmp42_) {

3761

gint _tmp43_;

3762

_tmp43_ = index;

3763

index = _tmp43_ + 1;

3764

} else {

3765

ValaDataType* _tmp44_;

3766

gboolean _tmp45_;

3767

_tmp44_ = return_type;

3768

_tmp45_ = return_array_length;

3769

vala_gir_writer_skip_implicit_params (self, _tmp44_, &index, _tmp45_);

3770

}

3771

_tmp46_ = index;

3772

last_index = _tmp46_ - 1;

3773

}

3774

_tmp48_ = return_type;

3775

if (_tmp48_ != NULL) {

3776

gboolean _tmp49_;

3777

_tmp49_ = ret_is_struct;

3778

_tmp47_ = !_tmp49_;

3779

} else {

3780

_tmp47_ = FALSE;

3781

}

3782

_tmp50_ = _tmp47_;

3783

if (_tmp50_) {

3784

ValaDataType* _tmp51_;

3785

gboolean _tmp52_;

3786

const gchar* _tmp53_;

3787

gboolean _tmp54_;

3788

_tmp51_ = return_type;

3789

_tmp52_ = return_array_length;

3790

_tmp53_ = return_comment;

3791

_tmp54_ = constructor;

3792

vala_gir_writer_write_param_or_return (self, _tmp51_, FALSE, &last_index, _tmp52_, NULL, _tmp53_, VALA_PARAMETER_DIRECTION_IN, _tmp54_, FALSE);

3793

} else {

3794

gboolean _tmp55_;

3795

_tmp55_ = ret_is_struct;

3796

if (_tmp55_) {

3797

ValaVoidType* _tmp56_;

3798

ValaVoidType* _tmp57_;

3799

const gchar* _tmp58_;

3800

_tmp56_ = vala_void_type_new (NULL);

3801

_tmp57_ = _tmp56_;

3802

_tmp58_ = return_comment;

3803

vala_gir_writer_write_param_or_return (self, (ValaDataType*) _tmp57_, FALSE, &last_index, FALSE, NULL, _tmp58_, VALA_PARAMETER_DIRECTION_IN, FALSE, FALSE);

3804

_vala_code_node_unref0 (_tmp57_);

3805

}

3806

}

3807

_tmp63_ = params;

3808

_tmp64_ = vala_collection_get_size ((ValaCollection*) _tmp63_);

3809

_tmp65_ = _tmp64_;

3810

if (_tmp65_ != 0) {

3811

_tmp62_ = TRUE;

3812

} else {

3813

ValaDataType* _tmp66_;

3814

_tmp66_ = instance_type;

3815

_tmp62_ = _tmp66_ != NULL;

3816

}

3817

_tmp67_ = _tmp62_;

3818

if (_tmp67_) {

3819

_tmp61_ = TRUE;

3820

} else {

3821

gboolean _tmp68_ = FALSE;

3822

ValaDataType* _tmp69_;

3823

gboolean _tmp71_;

3824

_tmp69_ = return_type;

3825

if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp69_, VALA_TYPE_ARRAY_TYPE)) {

3826

gboolean _tmp70_;

3827

_tmp70_ = return_array_length;

3828

_tmp68_ = _tmp70_;

3829

} else {

3830

_tmp68_ = FALSE;

3831

}

3832

_tmp71_ = _tmp68_;

3833

_tmp61_ = _tmp71_;

3834

}

3835

_tmp72_ = _tmp61_;

3836

if (_tmp72_) {

3837

_tmp60_ = TRUE;

3838

} else {

3839

ValaDataType* _tmp73_;

3840

_tmp73_ = return_type;

3841

_tmp60_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp73_, VALA_TYPE_DELEGATE_TYPE);

3842

}

3843

_tmp74_ = _tmp60_;

3844

if (_tmp74_) {

3845

_tmp59_ = TRUE;

3846

} else {

3847

gboolean _tmp75_;

3848

_tmp75_ = ret_is_struct;

3849

_tmp59_ = _tmp75_;

3850

}

3851

_tmp76_ = _tmp59_;

3852

if (_tmp76_) {

3853

GString* _tmp77_;

3854

gint _tmp78_;

3855

gint index;

3856

ValaDataType* _tmp79_;

3857

gboolean _tmp117_;

3858

gboolean _tmp123_;

3859

gint _tmp130_;

3860

GString* _tmp131_;

3861

vala_gir_writer_write_indent (self);

3862

_tmp77_ = self->priv->buffer;

3863

g_string_append_printf (_tmp77_, "<parameters>\n");

3864

_tmp78_ = self->priv->indent;

3865

self->priv->indent = _tmp78_ + 1;

3866

index = 0;

3867

_tmp79_ = instance_type;

3868

if (_tmp79_ != NULL) {

3869

ValaDataType* _tmp80_;

3870

_tmp80_ = instance_type;

3871

vala_gir_writer_write_param_or_return (self, _tmp80_, TRUE, &index, FALSE, "self", NULL, VALA_PARAMETER_DIRECTION_IN, FALSE, FALSE);

3872

}

3873

{

3874

ValaList* _tmp81_;

3875

ValaList* _tmp82_;

3876

ValaList* _param_list;

3877

ValaList* _tmp83_;

3878

gint _tmp84_;

3879

gint _tmp85_;

3880

gint _param_size;

3881

gint _param_index;

3882

_tmp81_ = params;

3883

_tmp82_ = _vala_iterable_ref0 (_tmp81_);

3884

_param_list = _tmp82_;

3885

_tmp83_ = _param_list;

3886

_tmp84_ = vala_collection_get_size ((ValaCollection*) _tmp83_);

3887

_tmp85_ = _tmp84_;

3888

_param_size = _tmp85_;

3889

_param_index = -1;

3890

while (TRUE) {

3891

gint _tmp86_;

3892

gint _tmp87_;

3893

gint _tmp88_;

3894

ValaList* _tmp89_;

3895

gint _tmp90_;

3896

gpointer _tmp91_ = NULL;

3897

ValaParameter* param;

3898

ValaParameter* _tmp92_;

3899

ValaDataType* _tmp93_;

3900

ValaDataType* _tmp94_;

3901

ValaParameter* _tmp95_;

3902

gboolean _tmp96_ = FALSE;

3903

ValaParameter* _tmp97_;

3904

const gchar* _tmp98_;

3905

const gchar* _tmp99_;

3906

ValaParameter* _tmp100_;

3907

gchar* _tmp101_ = NULL;

3908

gchar* _tmp102_;

3909

ValaParameter* _tmp103_;

3910

ValaParameterDirection _tmp104_;

3911

ValaParameterDirection _tmp105_;

3912

ValaParameter* _tmp106_;

3913

ValaDataType* _tmp107_;

3914

ValaDataType* _tmp108_;

3915

ValaParameter* _tmp109_;

3916

gboolean _tmp110_ = FALSE;

3917

ValaParameter* _tmp111_;

3918

const gchar* _tmp112_;

3919

const gchar* _tmp113_;

3920

ValaParameter* _tmp114_;

3921

ValaParameterDirection _tmp115_;

3922

ValaParameterDirection _tmp116_;

3923

_tmp86_ = _param_index;

3924

_param_index = _tmp86_ + 1;

3925

_tmp87_ = _param_index;

3926

_tmp88_ = _param_size;

3927

if (!(_tmp87_ < _tmp88_)) {

3928

break;

3929

}

3930

_tmp89_ = _param_list;

3931

_tmp90_ = _param_index;

3932

_tmp91_ = vala_list_get (_tmp89_, _tmp90_);

3933

param = (ValaParameter*) _tmp91_;

3934

_tmp92_ = param;

3935

_tmp93_ = vala_variable_get_variable_type ((ValaVariable*) _tmp92_);

3936

_tmp94_ = _tmp93_;

3937

_tmp95_ = param;

3938

_tmp96_ = vala_ccode_base_module_get_ccode_array_length ((ValaCodeNode*) _tmp95_);

3939

_tmp97_ = param;

3940

_tmp98_ = vala_symbol_get_name ((ValaSymbol*) _tmp97_);

3941

_tmp99_ = _tmp98_;

3942

_tmp100_ = param;

3943

_tmp101_ = vala_gir_writer_get_parameter_comment (self, _tmp100_);

3944

_tmp102_ = _tmp101_;

3945

_tmp103_ = param;

3946

_tmp104_ = vala_parameter_get_direction (_tmp103_);

3947

_tmp105_ = _tmp104_;

3948

vala_gir_writer_write_param_or_return (self, _tmp94_, TRUE, &index, _tmp96_, _tmp99_, _tmp102_, _tmp105_, FALSE, FALSE);

3949

_g_free0 (_tmp102_);

3950

_tmp106_ = param;

3951

_tmp107_ = vala_variable_get_variable_type ((ValaVariable*) _tmp106_);

3952

_tmp108_ = _tmp107_;

3953

_tmp109_ = param;

3954

_tmp110_ = vala_ccode_base_module_get_ccode_array_length ((ValaCodeNode*) _tmp109_);

3955

_tmp111_ = param;

3956

_tmp112_ = vala_symbol_get_name ((ValaSymbol*) _tmp111_);

3957

_tmp113_ = _tmp112_;

3958

_tmp114_ = param;

3959

_tmp115_ = vala_parameter_get_direction (_tmp114_);

3960

_tmp116_ = _tmp115_;

3961

vala_gir_writer_write_implicit_params (self, _tmp108_, &index, _tmp110_, _tmp113_, _tmp116_);

3962

_vala_code_node_unref0 (param);

3963

}

3964

_vala_iterable_unref0 (_param_list);

3965

}

3966

_tmp117_ = ret_is_struct;

3967

if (_tmp117_) {

3968

ValaDataType* _tmp118_;

3969

const gchar* _tmp119_;

3970

gboolean _tmp120_;

3971

_tmp118_ = return_type;

3972

_tmp119_ = return_comment;

3973

_tmp120_ = constructor;

3974

vala_gir_writer_write_param_or_return (self, _tmp118_, TRUE, &index, FALSE, "result", _tmp119_, VALA_PARAMETER_DIRECTION_OUT, _tmp120_, TRUE);

3975

} else {

3976

ValaDataType* _tmp121_;

3977

gboolean _tmp122_;

3978

_tmp121_ = return_type;

3979

_tmp122_ = return_array_length;

3980

vala_gir_writer_write_implicit_params (self, _tmp121_, &index, _tmp122_, "result", VALA_PARAMETER_DIRECTION_OUT);

3981

}

3982

_tmp123_ = user_data;

3983

if (_tmp123_) {

3984

GString* _tmp124_;

3985

gint _tmp125_;

3986

gint _tmp126_;

3987

GString* _tmp127_;

3988

gint _tmp128_;

3989

GString* _tmp129_;

3990

vala_gir_writer_write_indent (self);

3991

_tmp124_ = self->priv->buffer;

3992

_tmp125_ = index;

3993

g_string_append_printf (_tmp124_, "<parameter name=\"user_data\" transfer-ownership=\"none\" closure=\"%d" \

3994

"\">\n", _tmp125_);

3995

_tmp126_ = self->priv->indent;

3996

self->priv->indent = _tmp126_ + 1;

3997

vala_gir_writer_write_indent (self);

3998

_tmp127_ = self->priv->buffer;

3999

g_string_append_printf (_tmp127_, "<type name=\"gpointer\" c:type=\"void*\"/>\n");

4000

_tmp128_ = self->priv->indent;

4001

self->priv->indent = _tmp128_ - 1;

4002

vala_gir_writer_write_indent (self);

4003

_tmp129_ = self->priv->buffer;

4004

g_string_append_printf (_tmp129_, "</parameter>\n");

4005

}

4006

_tmp130_ = self->priv->indent;

4007

self->priv->indent = _tmp130_ - 1;

4008

vala_gir_writer_write_indent (self);

4009

_tmp131_ = self->priv->buffer;

4010

g_string_append_printf (_tmp131_, "</parameters>\n");

4011

}

4012

}

4013

4014

4015

static void vala_gir_writer_real_visit_delegate (ValaCodeVisitor* base, ValaDelegate* cb) {

4016

ValaGIRWriter * self;

4017

ValaDelegate* _tmp0_;

4018

gboolean _tmp1_;

4019

gboolean _tmp2_;

4020

ValaDelegate* _tmp3_;

4021

gboolean _tmp4_ = FALSE;

4022

GString* _tmp5_;

4023

ValaDelegate* _tmp6_;

4024

const gchar* _tmp7_;

4025

const gchar* _tmp8_;

4026

GString* _tmp9_;

4027

ValaDelegate* _tmp10_;

4028

gchar* _tmp11_ = NULL;

4029

gchar* _tmp12_;

4030

ValaDelegate* _tmp13_;

4031

gboolean _tmp14_;

4032

gboolean _tmp15_;

4033

ValaDelegate* _tmp17_;

4034

GString* _tmp18_;

4035

gint _tmp19_;

4036

ValaDelegate* _tmp20_;

4037

gchar* _tmp21_ = NULL;

4038

gchar* _tmp22_;

4039

ValaDelegate* _tmp23_;

4040

ValaDelegate* _tmp24_;

4041

ValaList* _tmp25_ = NULL;

4042

ValaList* _tmp26_;

4043

ValaDelegate* _tmp27_;

4044

ValaDataType* _tmp28_;

4045

ValaDataType* _tmp29_;

4046

ValaDelegate* _tmp30_;

4047

gboolean _tmp31_ = FALSE;

4048

ValaDelegate* _tmp32_;

4049

gchar* _tmp33_ = NULL;

4050

gchar* _tmp34_;

4051

ValaDelegate* _tmp35_;

4052

gboolean _tmp36_;

4053

gboolean _tmp37_;

4054

gint _tmp38_;

4055

GString* _tmp39_;

4056

self = (ValaGIRWriter*) base;

4057

g_return_if_fail (cb != NULL);

4058

_tmp0_ = cb;

4059

_tmp1_ = vala_symbol_get_external_package ((ValaSymbol*) _tmp0_);

4060

_tmp2_ = _tmp1_;

4061

if (_tmp2_) {

4062

return;

4063

}

4064

_tmp3_ = cb;

4065

_tmp4_ = vala_gir_writer_check_accessibility (self, (ValaSymbol*) _tmp3_);

4066

if (!_tmp4_) {

4067

return;

4068

}

4069

vala_gir_writer_write_indent (self);

4070

_tmp5_ = self->priv->buffer;

4071

_tmp6_ = cb;

4072

_tmp7_ = vala_symbol_get_name ((ValaSymbol*) _tmp6_);

4073

_tmp8_ = _tmp7_;

4074

g_string_append_printf (_tmp5_, "<callback name=\"%s\"", _tmp8_);

4075

_tmp9_ = self->priv->buffer;

4076

_tmp10_ = cb;

4077

_tmp11_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp10_);

4078

_tmp12_ = _tmp11_;

4079

g_string_append_printf (_tmp9_, " c:type=\"%s\"", _tmp12_);

4080

_g_free0 (_tmp12_);

4081

_tmp13_ = cb;

4082

_tmp14_ = vala_code_node_get_tree_can_fail ((ValaCodeNode*) _tmp13_);

4083

_tmp15_ = _tmp14_;

4084

if (_tmp15_) {

4085

GString* _tmp16_;

4086

_tmp16_ = self->priv->buffer;

4087

g_string_append_printf (_tmp16_, " throws=\"1\"");

4088

}

4089

_tmp17_ = cb;

4090

vala_gir_writer_write_symbol_attributes (self, (ValaSymbol*) _tmp17_);

4091

_tmp18_ = self->priv->buffer;

4092

g_string_append_printf (_tmp18_, ">\n");

4093

_tmp19_ = self->priv->indent;

4094

self->priv->indent = _tmp19_ + 1;

4095

_tmp20_ = cb;

4096

_tmp21_ = vala_gir_writer_get_delegate_comment (self, _tmp20_);

4097

_tmp22_ = _tmp21_;

4098

vala_gir_writer_write_doc (self, _tmp22_);

4099

_g_free0 (_tmp22_);

4100

_tmp23_ = cb;

4101

vala_gir_writer_write_annotations (self, (ValaCodeNode*) _tmp23_);

4102

_tmp24_ = cb;

4103

_tmp25_ = vala_delegate_get_parameters (_tmp24_);

4104

_tmp26_ = _tmp25_;

4105

_tmp27_ = cb;

4106

_tmp28_ = vala_delegate_get_return_type (_tmp27_);

4107

_tmp29_ = _tmp28_;

4108

_tmp30_ = cb;

4109

_tmp31_ = vala_ccode_base_module_get_ccode_array_length ((ValaCodeNode*) _tmp30_);

4110

_tmp32_ = cb;

4111

_tmp33_ = vala_gir_writer_get_delegate_return_comment (self, _tmp32_);

4112

_tmp34_ = _tmp33_;

4113

_tmp35_ = cb;

4114

_tmp36_ = vala_delegate_get_has_target (_tmp35_);

4115

_tmp37_ = _tmp36_;

4116

vala_gir_writer_write_params_and_return (self, _tmp26_, _tmp29_, _tmp31_, _tmp34_, FALSE, NULL, _tmp37_);

4117

_g_free0 (_tmp34_);

4118

_vala_iterable_unref0 (_tmp26_);

4119

_tmp38_ = self->priv->indent;

4120

self->priv->indent = _tmp38_ - 1;

4121

vala_gir_writer_write_indent (self);

4122

_tmp39_ = self->priv->buffer;

4123

g_string_append_printf (_tmp39_, "</callback>\n");

4124

}

4125

4126

4127

static void vala_gir_writer_real_visit_method (ValaCodeVisitor* base, ValaMethod* m) {

4128

ValaGIRWriter * self;

4129

ValaMethod* _tmp0_;

4130

gboolean _tmp1_;

4131

gboolean _tmp2_;

4132

gboolean _tmp3_ = FALSE;

4133

gboolean _tmp4_ = FALSE;

4134

ValaMethod* _tmp5_;

4135

gboolean _tmp6_ = FALSE;

4136

gboolean _tmp10_;

4137

gboolean _tmp24_;

4138

ValaMethod* _tmp25_;

4139

gboolean _tmp26_ = FALSE;

4140

gchar* _tmp27_;

4141

gchar* tag_name;

4142

ValaArrayList* _tmp28_;

4143

gpointer _tmp29_ = NULL;

4144

ValaSymbol* parent;

4145

ValaSymbol* _tmp30_;

4146

gboolean _tmp33_ = FALSE;

4147

gboolean _tmp34_ = FALSE;

4148

ValaSymbol* _tmp35_;

4149

gboolean _tmp39_;

4150

gboolean _tmp44_;

4151

ValaMethod* _tmp46_;

4152

const gchar* _tmp47_;

4153

gboolean _tmp48_ = FALSE;

4154

ValaMethod* _tmp49_;

4155

gboolean _tmp50_;

4156

gboolean _tmp51_;

4157

gboolean _tmp55_;

4158

self = (ValaGIRWriter*) base;

4159

g_return_if_fail (m != NULL);

4160

_tmp0_ = m;

4161

_tmp1_ = vala_symbol_get_external_package ((ValaSymbol*) _tmp0_);

4162

_tmp2_ = _tmp1_;

4163

if (_tmp2_) {

4164

return;

4165

}

4166

_tmp5_ = m;

4167

_tmp6_ = vala_gir_writer_check_accessibility (self, (ValaSymbol*) _tmp5_);

4168

if (!_tmp6_) {

4169

_tmp4_ = TRUE;

4170

} else {

4171

ValaMethod* _tmp7_;

4172

gboolean _tmp8_;

4173

gboolean _tmp9_;

4174

_tmp7_ = m;

4175

_tmp8_ = vala_method_get_overrides (_tmp7_);

4176

_tmp9_ = _tmp8_;

4177

_tmp4_ = _tmp9_;

4178

}

4179

_tmp10_ = _tmp4_;

4180

if (_tmp10_) {

4181

_tmp3_ = TRUE;

4182

} else {

4183

gboolean _tmp11_ = FALSE;

4184

gboolean _tmp12_ = FALSE;

4185

ValaMethod* _tmp13_;

4186

ValaMethod* _tmp14_;

4187

ValaMethod* _tmp15_;

4188

gboolean _tmp19_;

4189

gboolean _tmp23_;

4190

_tmp13_ = m;

4191

_tmp14_ = vala_method_get_base_interface_method (_tmp13_);

4192

_tmp15_ = _tmp14_;

4193

if (_tmp15_ != NULL) {

4194

ValaMethod* _tmp16_;

4195

gboolean _tmp17_;

4196

gboolean _tmp18_;

4197

_tmp16_ = m;

4198

_tmp17_ = vala_method_get_is_abstract (_tmp16_);

4199

_tmp18_ = _tmp17_;

4200

_tmp12_ = !_tmp18_;

4201

} else {

4202

_tmp12_ = FALSE;

4203

}

4204

_tmp19_ = _tmp12_;

4205

if (_tmp19_) {

4206

ValaMethod* _tmp20_;

4207

gboolean _tmp21_;

4208

gboolean _tmp22_;

4209

_tmp20_ = m;

4210

_tmp21_ = vala_method_get_is_virtual (_tmp20_);

4211

_tmp22_ = _tmp21_;

4212

_tmp11_ = !_tmp22_;

4213

} else {

4214

_tmp11_ = FALSE;

4215

}

4216

_tmp23_ = _tmp11_;

4217

_tmp3_ = _tmp23_;

4218

}

4219

_tmp24_ = _tmp3_;

4220

if (_tmp24_) {

4221

return;

4222

}

4223

_tmp25_ = m;

4224

_tmp26_ = vala_gir_writer_check_signature (self, _tmp25_);

4225

if (!_tmp26_) {

4226

return;

4227

}

4228

_tmp27_ = g_strdup ("method");

4229

tag_name = _tmp27_;

4230

_tmp28_ = self->priv->hierarchy;

4231

_tmp29_ = vala_list_get ((ValaList*) _tmp28_, 0);

4232

parent = (ValaSymbol*) _tmp29_;

4233

_tmp30_ = parent;

4234

if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp30_, VALA_TYPE_ENUM)) {

4235

ValaArrayList* _tmp31_;

4236

ValaMethod* _tmp32_;

4237

_tmp31_ = self->priv->deferred;

4238

_tmp32_ = m;

4239

vala_collection_add ((ValaCollection*) _tmp31_, (ValaCodeNode*) _tmp32_);

4240

_vala_code_node_unref0 (parent);

4241

_g_free0 (tag_name);

4242

return;

4243

}

4244

_tmp35_ = parent;

4245

if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp35_, VALA_TYPE_NAMESPACE)) {

4246

_tmp34_ = TRUE;

4247

} else {

4248

ValaMethod* _tmp36_;

4249

ValaMemberBinding _tmp37_;

4250

ValaMemberBinding _tmp38_;

4251

_tmp36_ = m;

4252

_tmp37_ = vala_method_get_binding (_tmp36_);

4253

_tmp38_ = _tmp37_;

4254

_tmp34_ = _tmp38_ == VALA_MEMBER_BINDING_STATIC;

4255

}

4256

_tmp39_ = _tmp34_;

4257

if (_tmp39_) {

4258

_tmp33_ = TRUE;

4259

} else {

4260

ValaSymbol* _tmp40_;

4261

ValaMethod* _tmp41_;

4262

ValaSymbol* _tmp42_;

4263

ValaSymbol* _tmp43_;

4264

_tmp40_ = parent;

4265

_tmp41_ = m;

4266

_tmp42_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp41_);

4267

_tmp43_ = _tmp42_;

4268

_tmp33_ = _tmp40_ != _tmp43_;

4269

}

4270

_tmp44_ = _tmp33_;

4271

if (_tmp44_) {

4272

gchar* _tmp45_;

4273

_tmp45_ = g_strdup ("function");

4274

_g_free0 (tag_name);

4275

tag_name = _tmp45_;

4276

}

4277

_tmp46_ = m;

4278

_tmp47_ = tag_name;

4279

vala_gir_writer_write_signature (self, _tmp46_, _tmp47_, TRUE, FALSE);

4280

_tmp49_ = m;

4281

_tmp50_ = vala_method_get_is_abstract (_tmp49_);

4282

_tmp51_ = _tmp50_;

4283

if (_tmp51_) {

4284

_tmp48_ = TRUE;

4285

} else {

4286

ValaMethod* _tmp52_;

4287

gboolean _tmp53_;

4288

gboolean _tmp54_;

4289

_tmp52_ = m;

4290

_tmp53_ = vala_method_get_is_virtual (_tmp52_);

4291

_tmp54_ = _tmp53_;

4292

_tmp48_ = _tmp54_;

4293

}

4294

_tmp55_ = _tmp48_;

4295

if (_tmp55_) {

4296

ValaMethod* _tmp56_;

4297

_tmp56_ = m;

4298

vala_gir_writer_write_signature (self, _tmp56_, "virtual-method", TRUE, FALSE);

4299

}

4300

_vala_code_node_unref0 (parent);

4301

_g_free0 (tag_name);

4302

}

4303

4304

4305

static gboolean vala_gir_writer_check_type (ValaGIRWriter* self, ValaDataType* type) {

4306

gboolean result = FALSE;

4307

ValaDataType* _tmp0_;

4308

gchar* _tmp1_ = NULL;

4309

gchar* _tmp2_;

4310

gboolean _tmp3_;

4311

g_return_val_if_fail (self != NULL, FALSE);

4312

g_return_val_if_fail (type != NULL, FALSE);

4313

_tmp0_ = type;

4314

_tmp1_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp0_);

4315

_tmp2_ = _tmp1_;

4316

_tmp3_ = g_strcmp0 (_tmp2_, "va_list") == 0;

4317

_g_free0 (_tmp2_);

4318

if (_tmp3_) {

4319

result = FALSE;

4320

return result;

4321

}

4322

result = TRUE;

4323

return result;

4324

}

4325

4326

4327

static gboolean vala_gir_writer_check_signature (ValaGIRWriter* self, ValaMethod* m) {

4328

gboolean result = FALSE;

4329

ValaMethod* _tmp0_;

4330

ValaDataType* _tmp1_;

4331

ValaDataType* _tmp2_;

4332

gboolean _tmp3_ = FALSE;

4333

g_return_val_if_fail (self != NULL, FALSE);

4334

g_return_val_if_fail (m != NULL, FALSE);

4335

_tmp0_ = m;

4336

_tmp1_ = vala_method_get_return_type (_tmp0_);

4337

_tmp2_ = _tmp1_;

4338

_tmp3_ = vala_gir_writer_check_type (self, _tmp2_);

4339

if (!_tmp3_) {

4340

result = FALSE;

4341

return result;

4342

}

4343

{

4344

ValaMethod* _tmp4_;

4345

ValaList* _tmp5_ = NULL;

4346

ValaList* _param_list;

4347

ValaList* _tmp6_;

4348

gint _tmp7_;

4349

gint _tmp8_;

4350

gint _param_size;

4351

gint _param_index;

4352

_tmp4_ = m;

4353

_tmp5_ = vala_method_get_parameters (_tmp4_);

4354

_param_list = _tmp5_;

4355

_tmp6_ = _param_list;

4356

_tmp7_ = vala_collection_get_size ((ValaCollection*) _tmp6_);

4357

_tmp8_ = _tmp7_;

4358

_param_size = _tmp8_;

4359

_param_index = -1;

4360

while (TRUE) {

4361

gint _tmp9_;

4362

gint _tmp10_;

4363

gint _tmp11_;

4364

ValaList* _tmp12_;

4365

gint _tmp13_;

4366

gpointer _tmp14_ = NULL;

4367

ValaParameter* param;

4368

gboolean _tmp15_ = FALSE;

4369

ValaParameter* _tmp16_;

4370

ValaDataType* _tmp17_;

4371

ValaDataType* _tmp18_;

4372

gboolean _tmp23_;

4373

_tmp9_ = _param_index;

4374

_param_index = _tmp9_ + 1;

4375

_tmp10_ = _param_index;

4376

_tmp11_ = _param_size;

4377

if (!(_tmp10_ < _tmp11_)) {

4378

break;

4379

}

4380

_tmp12_ = _param_list;

4381

_tmp13_ = _param_index;

4382

_tmp14_ = vala_list_get (_tmp12_, _tmp13_);

4383

param = (ValaParameter*) _tmp14_;

4384

_tmp16_ = param;

4385

_tmp17_ = vala_variable_get_variable_type ((ValaVariable*) _tmp16_);

4386

_tmp18_ = _tmp17_;

4387

if (_tmp18_ == NULL) {

4388

_tmp15_ = TRUE;

4389

} else {

4390

ValaParameter* _tmp19_;

4391

ValaDataType* _tmp20_;

4392

ValaDataType* _tmp21_;

4393

gboolean _tmp22_ = FALSE;

4394

_tmp19_ = param;

4395

_tmp20_ = vala_variable_get_variable_type ((ValaVariable*) _tmp19_);

4396

_tmp21_ = _tmp20_;

4397

_tmp22_ = vala_gir_writer_check_type (self, _tmp21_);

4398

_tmp15_ = !_tmp22_;

4399

}

4400

_tmp23_ = _tmp15_;

4401

if (_tmp23_) {

4402

result = FALSE;

4403

_vala_code_node_unref0 (param);

4404

_vala_iterable_unref0 (_param_list);

4405

return result;

4406

}

4407

_vala_code_node_unref0 (param);

4408

}

4409

_vala_iterable_unref0 (_param_list);

4410

}

4411

result = TRUE;

4412

return result;

4413

}

4414

4415

4416

static void vala_gir_writer_write_signature (ValaGIRWriter* self, ValaMethod* m, const gchar* tag_name, gboolean write_doc, gboolean instance) {

4417

ValaArrayList* _tmp0_;

4418

gpointer _tmp1_ = NULL;

4419

ValaSymbol* parent;

4420

gchar* name = NULL;

4421

ValaMethod* _tmp2_;

4422

ValaSymbol* _tmp3_;

4423

ValaSymbol* _tmp4_;

4424

ValaSymbol* _tmp5_;

4425

ValaMethod* _tmp22_;

4426

gboolean _tmp23_;

4427

gboolean _tmp24_;

4428

g_return_if_fail (self != NULL);

4429

g_return_if_fail (m != NULL);

4430

g_return_if_fail (tag_name != NULL);

4431

_tmp0_ = self->priv->hierarchy;

4432

_tmp1_ = vala_list_get ((ValaList*) _tmp0_, 0);

4433

parent = (ValaSymbol*) _tmp1_;

4434

_tmp2_ = m;

4435

_tmp3_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp2_);

4436

_tmp4_ = _tmp3_;

4437

_tmp5_ = parent;

4438

if (_tmp4_ != _tmp5_) {

4439

ValaMethod* _tmp6_;

4440

gchar* _tmp7_ = NULL;

4441

ValaSymbol* _tmp8_;

4442

gchar* _tmp9_ = NULL;

4443

gchar* parent_prefix;

4444

const gchar* _tmp10_;

4445

const gchar* _tmp11_;

4446

gboolean _tmp12_ = FALSE;

4447

instance = FALSE;

4448

_tmp6_ = m;

4449

_tmp7_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp6_);

4450

_g_free0 (name);

4451

name = _tmp7_;

4452

_tmp8_ = parent;

4453

_tmp9_ = vala_ccode_base_module_get_ccode_lower_case_prefix (_tmp8_);

4454

parent_prefix = _tmp9_;

4455

_tmp10_ = name;

4456

_tmp11_ = parent_prefix;

4457

_tmp12_ = g_str_has_prefix (_tmp10_, _tmp11_);

4458

if (_tmp12_) {

4459

const gchar* _tmp13_;

4460

const gchar* _tmp14_;

4461

gint _tmp15_;

4462

gint _tmp16_;

4463

gchar* _tmp17_ = NULL;

4464

_tmp13_ = name;

4465

_tmp14_ = parent_prefix;

4466

_tmp15_ = strlen (_tmp14_);

4467

_tmp16_ = _tmp15_;

4468

_tmp17_ = string_substring (_tmp13_, (glong) _tmp16_, (glong) (-1));

4469

_g_free0 (name);

4470

name = _tmp17_;

4471

}

4472

_g_free0 (parent_prefix);

4473

} else {

4474

ValaMethod* _tmp18_;

4475

const gchar* _tmp19_;

4476

const gchar* _tmp20_;

4477

gchar* _tmp21_;

4478

_tmp18_ = m;

4479

_tmp19_ = vala_symbol_get_name ((ValaSymbol*) _tmp18_);

4480

_tmp20_ = _tmp19_;

4481

_tmp21_ = g_strdup (_tmp20_);

4482

_g_free0 (name);

4483

name = _tmp21_;

4484

}

4485

_tmp22_ = m;

4486

_tmp23_ = vala_method_get_coroutine (_tmp22_);

4487

_tmp24_ = _tmp23_;

4488

if (_tmp24_) {

4489

const gchar* _tmp25_;

4490

gchar* _tmp26_;

4491

gchar* finish_name;

4492

const gchar* _tmp27_;

4493

gboolean _tmp28_ = FALSE;

4494

const gchar* _tmp36_;

4495

gchar* _tmp37_;

4496

ValaMethod* _tmp38_;

4497

const gchar* _tmp39_;

4498

gboolean _tmp40_;

4499

const gchar* _tmp41_;

4500

ValaMethod* _tmp42_;

4501

gchar* _tmp43_ = NULL;

4502

gchar* _tmp44_;

4503

ValaMethod* _tmp45_;

4504

ValaList* _tmp46_ = NULL;

4505

ValaList* _tmp47_;

4506

ValaVoidType* _tmp48_;

4507

ValaVoidType* _tmp49_;

4508

ValaMethod* _tmp50_;

4509

const gchar* _tmp51_;

4510

gboolean _tmp52_;

4511

const gchar* _tmp53_;

4512

ValaMethod* _tmp54_;

4513

gchar* _tmp55_ = NULL;

4514

gchar* _tmp56_;

4515

ValaMethod* _tmp57_;

4516

ValaList* _tmp58_ = NULL;

4517

ValaList* _tmp59_;

4518

ValaMethod* _tmp60_;

4519

ValaDataType* _tmp61_;

4520

ValaDataType* _tmp62_;

4521

ValaMethod* _tmp63_;

4522

gboolean _tmp64_;

4523

gboolean _tmp65_;

4524

_tmp25_ = name;

4525

_tmp26_ = g_strdup (_tmp25_);

4526

finish_name = _tmp26_;

4527

_tmp27_ = finish_name;

4528

_tmp28_ = g_str_has_suffix (_tmp27_, "_async");

4529

if (_tmp28_) {

4530

const gchar* _tmp29_;

4531

const gchar* _tmp30_;

4532

gint _tmp31_;

4533

gint _tmp32_;

4534

gint _tmp33_;

4535

gint _tmp34_;

4536

gchar* _tmp35_ = NULL;

4537

_tmp29_ = finish_name;

4538

_tmp30_ = finish_name;

4539

_tmp31_ = strlen (_tmp30_);

4540

_tmp32_ = _tmp31_;

4541

_tmp33_ = strlen ("_async");

4542

_tmp34_ = _tmp33_;

4543

_tmp35_ = string_substring (_tmp29_, (glong) 0, (glong) (_tmp32_ - _tmp34_));

4544

_g_free0 (finish_name);

4545

finish_name = _tmp35_;

4546

}

4547

_tmp36_ = finish_name;

4548

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

4549

_g_free0 (finish_name);

4550

finish_name = _tmp37_;

4551

_tmp38_ = m;

4552

_tmp39_ = tag_name;

4553

_tmp40_ = instance;

4554

_tmp41_ = name;

4555

_tmp42_ = m;

4556

_tmp43_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp42_);

4557

_tmp44_ = _tmp43_;

4558

_tmp45_ = m;

4559

_tmp46_ = vala_method_get_async_begin_parameters (_tmp45_);

4560

_tmp47_ = _tmp46_;

4561

_tmp48_ = vala_void_type_new (NULL);

4562

_tmp49_ = _tmp48_;

4563

vala_gir_writer_do_write_signature (self, _tmp38_, _tmp39_, _tmp40_, _tmp41_, _tmp44_, _tmp47_, (ValaDataType*) _tmp49_, FALSE, TRUE);

4564

_vala_code_node_unref0 (_tmp49_);

4565

_vala_iterable_unref0 (_tmp47_);

4566

_g_free0 (_tmp44_);

4567

_tmp50_ = m;

4568

_tmp51_ = tag_name;

4569

_tmp52_ = instance;

4570

_tmp53_ = finish_name;

4571

_tmp54_ = m;

4572

_tmp55_ = vala_ccode_base_module_get_ccode_finish_name (_tmp54_);

4573

_tmp56_ = _tmp55_;

4574

_tmp57_ = m;

4575

_tmp58_ = vala_method_get_async_end_parameters (_tmp57_);

4576

_tmp59_ = _tmp58_;

4577

_tmp60_ = m;

4578

_tmp61_ = vala_method_get_return_type (_tmp60_);

4579

_tmp62_ = _tmp61_;

4580

_tmp63_ = m;

4581

_tmp64_ = vala_code_node_get_tree_can_fail ((ValaCodeNode*) _tmp63_);

4582

_tmp65_ = _tmp64_;

4583

vala_gir_writer_do_write_signature (self, _tmp50_, _tmp51_, _tmp52_, _tmp53_, _tmp56_, _tmp59_, _tmp62_, _tmp65_, FALSE);

4584

_vala_iterable_unref0 (_tmp59_);

4585

_g_free0 (_tmp56_);

4586

_g_free0 (finish_name);

4587

} else {

4588

ValaMethod* _tmp66_;

4589

const gchar* _tmp67_;

4590

gboolean _tmp68_;

4591

const gchar* _tmp69_;

4592

ValaMethod* _tmp70_;

4593

gchar* _tmp71_ = NULL;

4594

gchar* _tmp72_;

4595

ValaMethod* _tmp73_;

4596

ValaList* _tmp74_ = NULL;

4597

ValaList* _tmp75_;

4598

ValaMethod* _tmp76_;

4599

ValaDataType* _tmp77_;

4600

ValaDataType* _tmp78_;

4601

ValaMethod* _tmp79_;

4602

gboolean _tmp80_;

4603

gboolean _tmp81_;

4604

_tmp66_ = m;

4605

_tmp67_ = tag_name;

4606

_tmp68_ = instance;

4607

_tmp69_ = name;

4608

_tmp70_ = m;

4609

_tmp71_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp70_);

4610

_tmp72_ = _tmp71_;

4611

_tmp73_ = m;

4612

_tmp74_ = vala_method_get_parameters (_tmp73_);

4613

_tmp75_ = _tmp74_;

4614

_tmp76_ = m;

4615

_tmp77_ = vala_method_get_return_type (_tmp76_);

4616

_tmp78_ = _tmp77_;

4617

_tmp79_ = m;

4618

_tmp80_ = vala_code_node_get_tree_can_fail ((ValaCodeNode*) _tmp79_);

4619

_tmp81_ = _tmp80_;

4620

vala_gir_writer_do_write_signature (self, _tmp66_, _tmp67_, _tmp68_, _tmp69_, _tmp72_, _tmp75_, _tmp78_, _tmp81_, TRUE);

4621

_vala_iterable_unref0 (_tmp75_);

4622

_g_free0 (_tmp72_);

4623

}

4624

_g_free0 (name);

4625

_vala_code_node_unref0 (parent);

4626

}

4627

4628

4629

4630

GString* _tmp0_;

4631

const gchar* _tmp1_;

4632

const gchar* _tmp2_;

4633

const gchar* _tmp3_;

4634

gboolean _tmp11_;

4635

ValaMethod* _tmp13_;

4636

GString* _tmp14_;

4637

gint _tmp15_;

4638

gchar* return_comment;

4639

gboolean _tmp16_;

4640

ValaMethod* _tmp22_;

4641

ValaDataType* instance_type;

4642

gboolean _tmp23_;

4643

ValaList* _tmp28_;

4644

ValaDataType* _tmp29_;

4645

ValaMethod* _tmp30_;

4646

gboolean _tmp31_ = FALSE;

4647

const gchar* _tmp32_;

4648

ValaDataType* _tmp33_;

4649

gint _tmp34_;

4650

GString* _tmp35_;

4651

const gchar* _tmp36_;

4652

g_return_if_fail (self != NULL);

4653

g_return_if_fail (m != NULL);

4654

g_return_if_fail (tag_name != NULL);

4655

g_return_if_fail (name != NULL);

4656

g_return_if_fail (cname != NULL);

4657

g_return_if_fail (params != NULL);

4658

g_return_if_fail (return_type != NULL);

4659

vala_gir_writer_write_indent (self);

4660

_tmp0_ = self->priv->buffer;

4661

_tmp1_ = tag_name;

4662

_tmp2_ = name;

4663

g_string_append_printf (_tmp0_, "<%s name=\"%s\"", _tmp1_, _tmp2_);

4664

_tmp3_ = tag_name;

4665

if (g_strcmp0 (_tmp3_, "virtual-method") == 0) {

4666

GString* _tmp4_;

4667

const gchar* _tmp5_;

4668

_tmp4_ = self->priv->buffer;

4669

_tmp5_ = name;

4670

g_string_append_printf (_tmp4_, " invoker=\"%s\"", _tmp5_);

4671

} else {

4672

const gchar* _tmp6_;

4673

_tmp6_ = tag_name;

4674

if (g_strcmp0 (_tmp6_, "callback") == 0) {

4675

GString* _tmp7_;

4676

const gchar* _tmp8_;

4677

_tmp7_ = self->priv->buffer;

4678

_tmp8_ = name;

4679

g_string_append_printf (_tmp7_, " c:type=\"%s\"", _tmp8_);

4680

} else {

4681

GString* _tmp9_;

4682

const gchar* _tmp10_;

4683

_tmp9_ = self->priv->buffer;

4684

_tmp10_ = cname;

4685

g_string_append_printf (_tmp9_, " c:identifier=\"%s\"", _tmp10_);

4686

}

4687

}

4688

_tmp11_ = can_fail;

4689

if (_tmp11_) {

4690

GString* _tmp12_;

4691

_tmp12_ = self->priv->buffer;

4692

g_string_append_printf (_tmp12_, " throws=\"1\"");

4693

}

4694

_tmp13_ = m;

4695

vala_gir_writer_write_symbol_attributes (self, (ValaSymbol*) _tmp13_);

4696

_tmp14_ = self->priv->buffer;

4697

g_string_append_printf (_tmp14_, ">\n");

4698

_tmp15_ = self->priv->indent;

4699

self->priv->indent = _tmp15_ + 1;

4700

return_comment = NULL;

4701

_tmp16_ = write_comment;

4702

if (_tmp16_) {

4703

ValaMethod* _tmp17_;

4704

gchar* _tmp18_ = NULL;

4705

ValaMethod* _tmp19_;

4706

gchar* _tmp20_ = NULL;

4707

gchar* _tmp21_;

4708

_tmp17_ = m;

4709

_tmp18_ = vala_gir_writer_get_method_return_comment (self, _tmp17_);

4710

_g_free0 (return_comment);

4711

return_comment = _tmp18_;

4712

_tmp19_ = m;

4713

_tmp20_ = vala_gir_writer_get_method_comment (self, _tmp19_);

4714

_tmp21_ = _tmp20_;

4715

vala_gir_writer_write_doc (self, _tmp21_);

4716

_g_free0 (_tmp21_);

4717

}

4718

_tmp22_ = m;

4719

vala_gir_writer_write_annotations (self, (ValaCodeNode*) _tmp22_);

4720

instance_type = NULL;

4721

_tmp23_ = instance;

4722

if (_tmp23_) {

4723

ValaMethod* _tmp24_;

4724

ValaSymbol* _tmp25_;

4725

ValaSymbol* _tmp26_;

4726

ValaDataType* _tmp27_ = NULL;

4727

_tmp24_ = m;

4728

_tmp25_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp24_);

4729

_tmp26_ = _tmp25_;

4730

_tmp27_ = vala_ccode_base_module_get_data_type_for_symbol (G_TYPE_CHECK_INSTANCE_CAST (_tmp26_, VALA_TYPE_TYPESYMBOL, ValaTypeSymbol));

4731

_vala_code_node_unref0 (instance_type);

4732

instance_type = _tmp27_;

4733

}

4734

_tmp28_ = params;

4735

_tmp29_ = return_type;

4736

_tmp30_ = m;

4737

_tmp31_ = vala_ccode_base_module_get_ccode_array_length ((ValaCodeNode*) _tmp30_);

4738

_tmp32_ = return_comment;

4739

_tmp33_ = instance_type;

4740

vala_gir_writer_write_params_and_return (self, _tmp28_, _tmp29_, _tmp31_, _tmp32_, FALSE, _tmp33_, FALSE);

4741

_tmp34_ = self->priv->indent;

4742

self->priv->indent = _tmp34_ - 1;

4743

vala_gir_writer_write_indent (self);

4744

_tmp35_ = self->priv->buffer;

4745

_tmp36_ = tag_name;

4746

g_string_append_printf (_tmp35_, "</%s>\n", _tmp36_);

4747

_vala_code_node_unref0 (instance_type);

4748

_g_free0 (return_comment);

4749

}

4750

4751

4752

static void vala_gir_writer_real_visit_creation_method (ValaCodeVisitor* base, ValaCreationMethod* m) {

4753

ValaGIRWriter * self;

4754

ValaCreationMethod* _tmp0_;

4755

gboolean _tmp1_;

4756

gboolean _tmp2_;

4757

ValaCreationMethod* _tmp3_;

4758

gboolean _tmp4_ = FALSE;

4759

gboolean _tmp5_ = FALSE;

4760

ValaCreationMethod* _tmp6_;

4761

ValaSymbol* _tmp7_;

4762

ValaSymbol* _tmp8_;

4763

gboolean _tmp14_;

4764

ValaCreationMethod* _tmp15_;

4765

ValaSymbol* _tmp16_;

4766

ValaSymbol* _tmp17_;

4767

gboolean is_struct;

4768

const gchar* _tmp18_ = NULL;

4769

gboolean _tmp19_;

4770

const gchar* _tmp20_;

4771

gchar* _tmp21_;

4772

gchar* tag_name;

4773

gboolean _tmp22_ = FALSE;

4774

gboolean _tmp23_ = FALSE;

4775

ValaCreationMethod* _tmp24_;

4776

ValaSymbol* _tmp25_;

4777

ValaSymbol* _tmp26_;

4778

gboolean _tmp33_;

4779

gboolean _tmp45_;

4780

ValaCreationMethod* _tmp64_;

4781

gboolean _tmp65_;

4782

gboolean _tmp66_;

4783

GString* _tmp68_;

4784

gint _tmp69_;

4785

ValaCreationMethod* _tmp70_;

4786

gchar* _tmp71_ = NULL;

4787

gchar* _tmp72_;

4788

ValaCreationMethod* _tmp73_;

4789

ValaCreationMethod* _tmp74_;

4790

ValaSymbol* _tmp75_;

4791

ValaSymbol* _tmp76_;

4792

ValaDataType* _tmp77_ = NULL;

4793

ValaDataType* datatype;

4794

ValaCreationMethod* _tmp78_;

4795

ValaList* _tmp79_ = NULL;

4796

ValaList* _tmp80_;

4797

ValaDataType* _tmp81_;

4798

ValaCreationMethod* _tmp82_;

4799

gchar* _tmp83_ = NULL;

4800

gchar* _tmp84_;

4801

gint _tmp85_;

4802

GString* _tmp86_;

4803

const gchar* _tmp87_;

4804

self = (ValaGIRWriter*) base;

4805

g_return_if_fail (m != NULL);

4806

_tmp0_ = m;

4807

_tmp1_ = vala_symbol_get_external_package ((ValaSymbol*) _tmp0_);

4808

_tmp2_ = _tmp1_;

4809

if (_tmp2_) {

4810

return;

4811

}

4812

_tmp3_ = m;

4813

_tmp4_ = vala_gir_writer_check_accessibility (self, (ValaSymbol*) _tmp3_);

4814

if (!_tmp4_) {

4815

return;

4816

}

4817

_tmp6_ = m;

4818

_tmp7_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp6_);

4819

_tmp8_ = _tmp7_;

4820

if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp8_, VALA_TYPE_CLASS)) {

4821

ValaCreationMethod* _tmp9_;

4822

ValaSymbol* _tmp10_;

4823

ValaSymbol* _tmp11_;

4824

gboolean _tmp12_;

4825

gboolean _tmp13_;

4826

_tmp9_ = m;

4827

_tmp10_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp9_);

4828

_tmp11_ = _tmp10_;

4829

_tmp12_ = vala_class_get_is_abstract (G_TYPE_CHECK_INSTANCE_CAST (_tmp11_, VALA_TYPE_CLASS, ValaClass));

4830

_tmp13_ = _tmp12_;

4831

_tmp5_ = _tmp13_;

4832

} else {

4833

_tmp5_ = FALSE;

4834

}

4835

_tmp14_ = _tmp5_;

4836

if (_tmp14_) {

4837

return;

4838

}

4839

vala_gir_writer_write_indent (self);

4840

_tmp15_ = m;

4841

_tmp16_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp15_);

4842

_tmp17_ = _tmp16_;

4843

is_struct = G_TYPE_CHECK_INSTANCE_TYPE (_tmp17_, VALA_TYPE_STRUCT);

4844

_tmp19_ = is_struct;

4845

if (_tmp19_) {

4846

_tmp18_ = "function";

4847

} else {

4848

_tmp18_ = "constructor";

4849

}

4850

_tmp20_ = _tmp18_;

4851

_tmp21_ = g_strdup (_tmp20_);

4852

tag_name = _tmp21_;

4853

_tmp24_ = m;

4854

_tmp25_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp24_);

4855

_tmp26_ = _tmp25_;

4856

if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp26_, VALA_TYPE_CLASS)) {

4857

ValaCreationMethod* _tmp27_;

4858

ValaCreationMethod* _tmp28_;

4859

ValaSymbol* _tmp29_;

4860

ValaSymbol* _tmp30_;

4861

ValaMethod* _tmp31_;

4862

ValaMethod* _tmp32_;

4863

_tmp27_ = m;

4864

_tmp28_ = m;

4865

_tmp29_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp28_);

4866

_tmp30_ = _tmp29_;

4867

_tmp31_ = vala_class_get_default_construction_method (G_TYPE_CHECK_INSTANCE_CAST (_tmp30_, VALA_TYPE_CLASS, ValaClass));

4868

_tmp32_ = _tmp31_;

4869

_tmp23_ = G_TYPE_CHECK_INSTANCE_CAST (_tmp27_, VALA_TYPE_METHOD, ValaMethod) == _tmp32_;

4870

} else {

4871

_tmp23_ = FALSE;

4872

}

4873

_tmp33_ = _tmp23_;

4874

if (_tmp33_) {

4875

_tmp22_ = TRUE;

4876

} else {

4877

gboolean _tmp34_ = FALSE;

4878

ValaCreationMethod* _tmp35_;

4879

ValaSymbol* _tmp36_;

4880

ValaSymbol* _tmp37_;

4881

gboolean _tmp44_;

4882

_tmp35_ = m;

4883

_tmp36_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp35_);

4884

_tmp37_ = _tmp36_;

4885

if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp37_, VALA_TYPE_STRUCT)) {

4886

ValaCreationMethod* _tmp38_;

4887

ValaCreationMethod* _tmp39_;

4888

ValaSymbol* _tmp40_;

4889

ValaSymbol* _tmp41_;

4890

ValaMethod* _tmp42_;

4891

ValaMethod* _tmp43_;

4892

_tmp38_ = m;

4893

_tmp39_ = m;

4894

_tmp40_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp39_);

4895

_tmp41_ = _tmp40_;

4896

_tmp42_ = vala_struct_get_default_construction_method (G_TYPE_CHECK_INSTANCE_CAST (_tmp41_, VALA_TYPE_STRUCT, ValaStruct));

4897

_tmp43_ = _tmp42_;

4898

_tmp34_ = G_TYPE_CHECK_INSTANCE_CAST (_tmp38_, VALA_TYPE_METHOD, ValaMethod) == _tmp43_;

4899

} else {

4900

_tmp34_ = FALSE;

4901

}

4902

_tmp44_ = _tmp34_;

4903

_tmp22_ = _tmp44_;

4904

}

4905

_tmp45_ = _tmp22_;

4906

if (_tmp45_) {

4907

const gchar* _tmp46_ = NULL;

4908

gboolean _tmp47_;

4909

const gchar* _tmp48_;

4910

gchar* _tmp49_;

4911

gchar* m_name;

4912

GString* _tmp50_;

4913

const gchar* _tmp51_;

4914

const gchar* _tmp52_;

4915

ValaCreationMethod* _tmp53_;

4916

gchar* _tmp54_ = NULL;

4917

gchar* _tmp55_;

4918

_tmp47_ = is_struct;

4919

if (_tmp47_) {

4920

_tmp46_ = "init";

4921

} else {

4922

_tmp46_ = "new";

4923

}

4924

_tmp48_ = _tmp46_;

4925

_tmp49_ = g_strdup (_tmp48_);

4926

m_name = _tmp49_;

4927

_tmp50_ = self->priv->buffer;

4928

_tmp51_ = tag_name;

4929

_tmp52_ = m_name;

4930

_tmp53_ = m;

4931

_tmp54_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp53_);

4932

_tmp55_ = _tmp54_;

4933

g_string_append_printf (_tmp50_, "<%s name=\"%s\" c:identifier=\"%s\"", _tmp51_, _tmp52_, _tmp55_);

4934

_g_free0 (_tmp55_);

4935

_g_free0 (m_name);

4936

} else {

4937

GString* _tmp56_;

4938

const gchar* _tmp57_;

4939

ValaCreationMethod* _tmp58_;

4940

const gchar* _tmp59_;

4941

const gchar* _tmp60_;

4942

ValaCreationMethod* _tmp61_;

4943

gchar* _tmp62_ = NULL;

4944

gchar* _tmp63_;

4945

_tmp56_ = self->priv->buffer;

4946

_tmp57_ = tag_name;

4947

_tmp58_ = m;

4948

_tmp59_ = vala_symbol_get_name ((ValaSymbol*) _tmp58_);

4949

_tmp60_ = _tmp59_;

4950

_tmp61_ = m;

4951

_tmp62_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp61_);

4952

_tmp63_ = _tmp62_;

4953

g_string_append_printf (_tmp56_, "<%s name=\"%s\" c:identifier=\"%s\"", _tmp57_, _tmp60_, _tmp63_);

4954

_g_free0 (_tmp63_);

4955

}

4956

_tmp64_ = m;

4957

_tmp65_ = vala_code_node_get_tree_can_fail ((ValaCodeNode*) _tmp64_);

4958

_tmp66_ = _tmp65_;

4959

if (_tmp66_) {

4960

GString* _tmp67_;

4961

_tmp67_ = self->priv->buffer;

4962

g_string_append_printf (_tmp67_, " throws=\"1\"");

4963

}

4964

_tmp68_ = self->priv->buffer;

4965

g_string_append_printf (_tmp68_, ">\n");

4966

_tmp69_ = self->priv->indent;

4967

self->priv->indent = _tmp69_ + 1;

4968

_tmp70_ = m;

4969

_tmp71_ = vala_gir_writer_get_method_comment (self, (ValaMethod*) _tmp70_);

4970

_tmp72_ = _tmp71_;

4971

vala_gir_writer_write_doc (self, _tmp72_);

4972

_g_free0 (_tmp72_);

4973

_tmp73_ = m;

4974

vala_gir_writer_write_annotations (self, (ValaCodeNode*) _tmp73_);

4975

_tmp74_ = m;

4976

_tmp75_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp74_);

4977

_tmp76_ = _tmp75_;

4978

_tmp77_ = vala_ccode_base_module_get_data_type_for_symbol (G_TYPE_CHECK_INSTANCE_CAST (_tmp76_, VALA_TYPE_TYPESYMBOL, ValaTypeSymbol));

4979

datatype = _tmp77_;

4980

_tmp78_ = m;

4981

_tmp79_ = vala_method_get_parameters ((ValaMethod*) _tmp78_);

4982

_tmp80_ = _tmp79_;

4983

_tmp81_ = datatype;

4984

_tmp82_ = m;

4985

_tmp83_ = vala_gir_writer_get_method_return_comment (self, (ValaMethod*) _tmp82_);

4986

_tmp84_ = _tmp83_;

4987

vala_gir_writer_write_params_and_return (self, _tmp80_, _tmp81_, FALSE, _tmp84_, TRUE, NULL, FALSE);

4988

_g_free0 (_tmp84_);

4989

_vala_iterable_unref0 (_tmp80_);

4990

_tmp85_ = self->priv->indent;

4991

self->priv->indent = _tmp85_ - 1;

4992

vala_gir_writer_write_indent (self);

4993

_tmp86_ = self->priv->buffer;

4994

_tmp87_ = tag_name;

4995

g_string_append_printf (_tmp86_, "</%s>\n", _tmp87_);

4996

_vala_code_node_unref0 (datatype);

4997

_g_free0 (tag_name);

4998

}

4999

5000

5001

static gchar* string_replace (const gchar* self, const gchar* old, const gchar* replacement) {

5002

gchar* result = NULL;

5003

GError * _inner_error_ = NULL;

5004

g_return_val_if_fail (self != NULL, NULL);

5005

g_return_val_if_fail (old != NULL, NULL);

5006

g_return_val_if_fail (replacement != NULL, NULL);

5007

{

5008

const gchar* _tmp0_;

5009

gchar* _tmp1_ = NULL;

5010

gchar* _tmp2_;

5011

GRegex* _tmp3_;

5012

GRegex* _tmp4_;

5013

GRegex* regex;

5014

GRegex* _tmp5_;

5015

const gchar* _tmp6_;

5016

gchar* _tmp7_ = NULL;

5017

gchar* _tmp8_;

5018

_tmp0_ = old;

5019

_tmp1_ = g_regex_escape_string (_tmp0_, -1);

5020

_tmp2_ = _tmp1_;

5021

_tmp3_ = g_regex_new (_tmp2_, 0, 0, &_inner_error_);

5022

_tmp4_ = _tmp3_;

5023

_g_free0 (_tmp2_);

5024

regex = _tmp4_;

5025

if (_inner_error_ != NULL) {

5026

if (_inner_error_->domain == G_REGEX_ERROR) {

5027

goto __catch5_g_regex_error;

5028

}

5029

g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);

5030

g_clear_error (&_inner_error_);

5031

return NULL;

5032

}

5033

_tmp5_ = regex;

5034

_tmp6_ = replacement;

5035

_tmp7_ = g_regex_replace_literal (_tmp5_, self, (gssize) (-1), 0, _tmp6_, 0, &_inner_error_);

5036

_tmp8_ = _tmp7_;

5037

if (_inner_error_ != NULL) {

5038

_g_regex_unref0 (regex);

5039

if (_inner_error_->domain == G_REGEX_ERROR) {

5040

goto __catch5_g_regex_error;

5041

}

5042

_g_regex_unref0 (regex);

5043

g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);

5044

g_clear_error (&_inner_error_);

5045

return NULL;

5046

}

5047

result = _tmp8_;

5048

_g_regex_unref0 (regex);

5049

return result;

5050

}

5051

goto __finally5;

5052

__catch5_g_regex_error:

5053

{

5054

GError* e = NULL;

5055

e = _inner_error_;

5056

_inner_error_ = NULL;

5057

g_assert_not_reached ();

5058

_g_error_free0 (e);

5059

}

5060

__finally5:

5061

if (_inner_error_ != NULL) {

5062

g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);

5063

g_clear_error (&_inner_error_);

5064

return NULL;

5065

}

5066

}

5067

5068

5069

static void vala_gir_writer_real_visit_property (ValaCodeVisitor* base, ValaProperty* prop) {

5070

ValaGIRWriter * self;

5071

gboolean _tmp0_ = FALSE;

5072

gboolean _tmp1_ = FALSE;

5073

ValaProperty* _tmp2_;

5074

gboolean _tmp3_ = FALSE;

5075

gboolean _tmp7_;

5076

gboolean _tmp21_;

5077

GString* _tmp22_;

5078

ValaProperty* _tmp23_;

5079

const gchar* _tmp24_;

5080

const gchar* _tmp25_;

5081

gchar* _tmp26_ = NULL;

5082

gchar* _tmp27_;

5083

ValaProperty* _tmp28_;

5084

ValaPropertyAccessor* _tmp29_;

5085

ValaPropertyAccessor* _tmp30_;

5086

ValaProperty* _tmp32_;

5087

ValaPropertyAccessor* _tmp33_;

5088

ValaPropertyAccessor* _tmp34_;

5089

ValaProperty* _tmp48_;

5090

GString* _tmp49_;

5091

gint _tmp50_;

5092

ValaProperty* _tmp51_;

5093

gchar* _tmp52_ = NULL;

5094

gchar* _tmp53_;

5095

ValaProperty* _tmp54_;

5096

ValaProperty* _tmp55_;

5097

ValaDataType* _tmp56_;

5098

ValaDataType* _tmp57_;

5099

gint _tmp58_;

5100

GString* _tmp59_;

5101

self = (ValaGIRWriter*) base;

5102

g_return_if_fail (prop != NULL);

5103

_tmp2_ = prop;

5104

_tmp3_ = vala_gir_writer_check_accessibility (self, (ValaSymbol*) _tmp2_);

5105

if (!_tmp3_) {

5106

_tmp1_ = TRUE;

5107

} else {

5108

ValaProperty* _tmp4_;

5109

gboolean _tmp5_;

5110

gboolean _tmp6_;

5111

_tmp4_ = prop;

5112

_tmp5_ = vala_property_get_overrides (_tmp4_);

5113

_tmp6_ = _tmp5_;

5114

_tmp1_ = _tmp6_;

5115

}

5116

_tmp7_ = _tmp1_;

5117

if (_tmp7_) {

5118

_tmp0_ = TRUE;

5119

} else {

5120

gboolean _tmp8_ = FALSE;

5121

gboolean _tmp9_ = FALSE;

5122

ValaProperty* _tmp10_;

5123

ValaProperty* _tmp11_;

5124

ValaProperty* _tmp12_;

5125

gboolean _tmp16_;

5126

gboolean _tmp20_;

5127

_tmp10_ = prop;

5128

_tmp11_ = vala_property_get_base_interface_property (_tmp10_);

5129

_tmp12_ = _tmp11_;

5130

if (_tmp12_ != NULL) {

5131

ValaProperty* _tmp13_;

5132

gboolean _tmp14_;

5133

gboolean _tmp15_;

5134

_tmp13_ = prop;

5135

_tmp14_ = vala_property_get_is_abstract (_tmp13_);

5136

_tmp15_ = _tmp14_;

5137

_tmp9_ = !_tmp15_;

5138

} else {

5139

_tmp9_ = FALSE;

5140

}

5141

_tmp16_ = _tmp9_;

5142

if (_tmp16_) {

5143

ValaProperty* _tmp17_;

5144

gboolean _tmp18_;

5145

gboolean _tmp19_;

5146

_tmp17_ = prop;

5147

_tmp18_ = vala_property_get_is_virtual (_tmp17_);

5148

_tmp19_ = _tmp18_;

5149

_tmp8_ = !_tmp19_;

5150

} else {

5151

_tmp8_ = FALSE;

5152

}

5153

_tmp20_ = _tmp8_;

5154

_tmp0_ = _tmp20_;

5155

}

5156

_tmp21_ = _tmp0_;

5157

if (_tmp21_) {

5158

return;

5159

}

5160

vala_gir_writer_write_indent (self);

5161

_tmp22_ = self->priv->buffer;

5162

_tmp23_ = prop;

5163

_tmp24_ = vala_symbol_get_name ((ValaSymbol*) _tmp23_);

5164

_tmp25_ = _tmp24_;

5165

_tmp26_ = string_replace (_tmp25_, "_", "-");

5166

_tmp27_ = _tmp26_;

5167

g_string_append_printf (_tmp22_, "<property name=\"%s\"", _tmp27_);

5168

_g_free0 (_tmp27_);

5169

_tmp28_ = prop;

5170

_tmp29_ = vala_property_get_get_accessor (_tmp28_);

5171

_tmp30_ = _tmp29_;

5172

if (_tmp30_ == NULL) {

5173

GString* _tmp31_;

5174

_tmp31_ = self->priv->buffer;

5175

g_string_append_printf (_tmp31_, " readable=\"0\"");

5176

}

5177

_tmp32_ = prop;

5178

_tmp33_ = vala_property_get_set_accessor (_tmp32_);

5179

_tmp34_ = _tmp33_;

5180

if (_tmp34_ != NULL) {

5181

GString* _tmp35_;

5182

ValaProperty* _tmp36_;

5183

ValaPropertyAccessor* _tmp37_;

5184

ValaPropertyAccessor* _tmp38_;

5185

gboolean _tmp39_;

5186

gboolean _tmp40_;

5187

_tmp35_ = self->priv->buffer;

5188

g_string_append_printf (_tmp35_, " writable=\"1\"");

5189

_tmp36_ = prop;

5190

_tmp37_ = vala_property_get_set_accessor (_tmp36_);

5191

_tmp38_ = _tmp37_;

5192

_tmp39_ = vala_property_accessor_get_construction (_tmp38_);

5193

_tmp40_ = _tmp39_;

5194

if (_tmp40_) {

5195

ValaProperty* _tmp41_;

5196

ValaPropertyAccessor* _tmp42_;

5197

ValaPropertyAccessor* _tmp43_;

5198

gboolean _tmp44_;

5199

gboolean _tmp45_;

5200

_tmp41_ = prop;

5201

_tmp42_ = vala_property_get_set_accessor (_tmp41_);

5202

_tmp43_ = _tmp42_;

5203

_tmp44_ = vala_property_accessor_get_writable (_tmp43_);

5204

_tmp45_ = _tmp44_;

5205

if (!_tmp45_) {

5206

GString* _tmp46_;

5207

_tmp46_ = self->priv->buffer;

5208

g_string_append_printf (_tmp46_, " construct-only=\"1\"");

5209

} else {

5210

GString* _tmp47_;

5211

_tmp47_ = self->priv->buffer;

5212

g_string_append_printf (_tmp47_, " construct=\"1\"");

5213

}

5214

}

5215

}

5216

_tmp48_ = prop;

5217

vala_gir_writer_write_symbol_attributes (self, (ValaSymbol*) _tmp48_);

5218

_tmp49_ = self->priv->buffer;

5219

g_string_append_printf (_tmp49_, ">\n");

5220

_tmp50_ = self->priv->indent;

5221

self->priv->indent = _tmp50_ + 1;

5222

_tmp51_ = prop;

5223

_tmp52_ = vala_gir_writer_get_property_comment (self, _tmp51_);

5224

_tmp53_ = _tmp52_;

5225

vala_gir_writer_write_doc (self, _tmp53_);

5226

_g_free0 (_tmp53_);

5227

_tmp54_ = prop;

5228

vala_gir_writer_write_annotations (self, (ValaCodeNode*) _tmp54_);

5229

_tmp55_ = prop;

5230

_tmp56_ = vala_property_get_property_type (_tmp55_);

5231

_tmp57_ = _tmp56_;

5232

vala_gir_writer_write_type (self, _tmp57_, -1);

5233

_tmp58_ = self->priv->indent;

5234

self->priv->indent = _tmp58_ - 1;

5235

vala_gir_writer_write_indent (self);

5236

_tmp59_ = self->priv->buffer;

5237

g_string_append_printf (_tmp59_, "</property>\n");

5238

}

5239

5240

5241

static void vala_gir_writer_real_visit_signal (ValaCodeVisitor* base, ValaSignal* sig) {

5242

ValaGIRWriter * self;

5243

ValaSignal* _tmp0_;

5244

gboolean _tmp1_ = FALSE;

5245

GString* _tmp2_;

5246

ValaSignal* _tmp3_;

5247

gchar* _tmp4_ = NULL;

5248

gchar* _tmp5_;

5249

ValaSignal* _tmp6_;

5250

GString* _tmp7_;

5251

gint _tmp8_;

5252

ValaSignal* _tmp9_;

5253

gchar* _tmp10_ = NULL;

5254

gchar* _tmp11_;

5255

ValaSignal* _tmp12_;

5256

ValaSignal* _tmp13_;

5257

ValaList* _tmp14_ = NULL;

5258

ValaList* _tmp15_;

5259

ValaSignal* _tmp16_;

5260

ValaDataType* _tmp17_;

5261

ValaDataType* _tmp18_;

5262

ValaSignal* _tmp19_;

5263

gchar* _tmp20_ = NULL;

5264

gchar* _tmp21_;

5265

gint _tmp22_;

5266

GString* _tmp23_;

5267

self = (ValaGIRWriter*) base;

5268

g_return_if_fail (sig != NULL);

5269

_tmp0_ = sig;

5270

_tmp1_ = vala_gir_writer_check_accessibility (self, (ValaSymbol*) _tmp0_);

5271

if (!_tmp1_) {

5272

return;

5273

}

5274

vala_gir_writer_write_indent (self);

5275

_tmp2_ = self->priv->buffer;

5276

_tmp3_ = sig;

5277

_tmp4_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp3_);

5278

_tmp5_ = _tmp4_;

5279

g_string_append_printf (_tmp2_, "<glib:signal name=\"%s\"", _tmp5_);

5280

_g_free0 (_tmp5_);

5281

_tmp6_ = sig;

5282

vala_gir_writer_write_symbol_attributes (self, (ValaSymbol*) _tmp6_);

5283

_tmp7_ = self->priv->buffer;

5284

g_string_append_printf (_tmp7_, ">\n");

5285

_tmp8_ = self->priv->indent;

5286

self->priv->indent = _tmp8_ + 1;

5287

_tmp9_ = sig;

5288

_tmp10_ = vala_gir_writer_get_signal_comment (self, _tmp9_);

5289

_tmp11_ = _tmp10_;

5290

vala_gir_writer_write_doc (self, _tmp11_);

5291

_g_free0 (_tmp11_);

5292

_tmp12_ = sig;

5293

vala_gir_writer_write_annotations (self, (ValaCodeNode*) _tmp12_);

5294

_tmp13_ = sig;

5295

_tmp14_ = vala_signal_get_parameters (_tmp13_);

5296

_tmp15_ = _tmp14_;

5297

_tmp16_ = sig;

5298

_tmp17_ = vala_signal_get_return_type (_tmp16_);

5299

_tmp18_ = _tmp17_;

5300

_tmp19_ = sig;

5301

_tmp20_ = vala_gir_writer_get_signal_return_comment (self, _tmp19_);

5302

_tmp21_ = _tmp20_;

5303

vala_gir_writer_write_params_and_return (self, _tmp15_, _tmp18_, FALSE, _tmp21_, FALSE, NULL, FALSE);

5304

_g_free0 (_tmp21_);

5305

_vala_iterable_unref0 (_tmp15_);

5306

_tmp22_ = self->priv->indent;

5307

self->priv->indent = _tmp22_ - 1;

5308

vala_gir_writer_write_indent (self);

5309

_tmp23_ = self->priv->buffer;

5310

g_string_append_printf (_tmp23_, "</glib:signal>\n");

5311

}

5312

5313

5314

static void vala_gir_writer_write_indent (ValaGIRWriter* self) {

5315

gint i = 0;

5316

g_return_if_fail (self != NULL);

5317

{

5318

gboolean _tmp0_;

5319

i = 0;

5320

_tmp0_ = TRUE;

5321

while (TRUE) {

5322

gboolean _tmp1_;

5323

gint _tmp3_;

5324

gint _tmp4_;

5325

GString* _tmp5_;

5326

_tmp1_ = _tmp0_;

5327

if (!_tmp1_) {

5328

gint _tmp2_;

5329

_tmp2_ = i;

5330

i = _tmp2_ + 1;

5331

}

5332

_tmp0_ = FALSE;

5333

_tmp3_ = i;

5334

_tmp4_ = self->priv->indent;

5335

if (!(_tmp3_ < _tmp4_)) {

5336

break;

5337

}

5338

_tmp5_ = self->priv->buffer;

5339

g_string_append_c (_tmp5_, '\t');

5340

}

5341

}

5342

}

5343

5344

5345

static void vala_gir_writer_write_indent_stream (ValaGIRWriter* self) {

5346

gint i = 0;

5347

g_return_if_fail (self != NULL);

5348

{

5349

gboolean _tmp0_;

5350

i = 0;

5351

_tmp0_ = TRUE;

5352

while (TRUE) {

5353

gboolean _tmp1_;

5354

gint _tmp3_;

5355

gint _tmp4_;

5356

FILE* _tmp5_;

5357

_tmp1_ = _tmp0_;

5358

if (!_tmp1_) {

5359

gint _tmp2_;

5360

_tmp2_ = i;

5361

i = _tmp2_ + 1;

5362

}

5363

_tmp0_ = FALSE;

5364

_tmp3_ = i;

5365

_tmp4_ = self->priv->indent;

5366

if (!(_tmp3_ < _tmp4_)) {

5367

break;

5368

}

5369

_tmp5_ = self->priv->stream;

5370

fputc ('\t', _tmp5_);

5371

}

5372

}

5373

}

5374

5375

5376

5377

const gchar* _tmp0_ = NULL;

5378

gboolean _tmp1_;

5379

const gchar* _tmp2_;

5380

gchar* _tmp3_;

5381

gchar* tag;

5382

GString* _tmp4_;

5383

const gchar* _tmp5_;

5384

const gchar* _tmp6_;

5385

ValaParameterDirection _tmp9_;

5386

ValaDataType* _tmp13_;

5387

ValaDelegateType* _tmp14_;

5388

ValaDelegateType* delegate_type;

5389

gboolean _tmp15_ = FALSE;

5390

gboolean _tmp16_ = FALSE;

5391

ValaDataType* _tmp17_;

5392

gboolean _tmp18_;

5393

gboolean _tmp19_;

5394

gboolean _tmp21_;

5395

gboolean _tmp30_;

5396

gboolean _tmp33_;

5397

ValaDataType* _tmp35_;

5398

gboolean _tmp36_;

5399

gboolean _tmp37_;

5400

gboolean _tmp39_ = FALSE;

5401

ValaDelegateType* _tmp40_;

5402

gboolean _tmp46_;

5403

GString* _tmp69_;

5404

gint _tmp70_;

5405

const gchar* _tmp71_;

5406

gint length_param_index;

5407

gboolean _tmp72_;

5408

ValaDataType* _tmp78_;

5409

gint _tmp79_;

5410

gint _tmp80_;

5411

GString* _tmp81_;

5412

const gchar* _tmp82_;

5413

gint _tmp83_;

5414

g_return_if_fail (self != NULL);

5415

g_return_if_fail (type != NULL);

5416

vala_gir_writer_write_indent (self);

5417

_tmp1_ = is_parameter;

5418

if (_tmp1_) {

5419

_tmp0_ = "parameter";

5420

} else {

5421

_tmp0_ = "return-value";

5422

}

5423

_tmp2_ = _tmp0_;

5424

_tmp3_ = g_strdup (_tmp2_);

5425

tag = _tmp3_;

5426

_tmp4_ = self->priv->buffer;

5427

_tmp5_ = tag;

5428

g_string_append_printf (_tmp4_, "<%s", _tmp5_);

5429

_tmp6_ = name;

5430

if (_tmp6_ != NULL) {

5431

GString* _tmp7_;

5432

const gchar* _tmp8_;

5433

_tmp7_ = self->priv->buffer;

5434

_tmp8_ = name;

5435

g_string_append_printf (_tmp7_, " name=\"%s\"", _tmp8_);

5436

}

5437

_tmp9_ = direction;

5438

if (_tmp9_ == VALA_PARAMETER_DIRECTION_REF) {

5439

GString* _tmp10_;

5440

_tmp10_ = self->priv->buffer;

5441

g_string_append_printf (_tmp10_, " direction=\"inout\"");

5442

} else {

5443

ValaParameterDirection _tmp11_;

5444

_tmp11_ = direction;

5445

if (_tmp11_ == VALA_PARAMETER_DIRECTION_OUT) {

5446

GString* _tmp12_;

5447

_tmp12_ = self->priv->buffer;

5448

g_string_append_printf (_tmp12_, " direction=\"out\"");

5449

}

5450

}

5451

_tmp13_ = type;

5452

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

5453

delegate_type = _tmp14_;

5454

_tmp17_ = type;

5455

_tmp18_ = vala_data_type_get_value_owned (_tmp17_);

5456

_tmp19_ = _tmp18_;

5457

if (_tmp19_) {

5458

ValaDelegateType* _tmp20_;

5459

_tmp20_ = delegate_type;

5460

_tmp16_ = _tmp20_ == NULL;

5461

} else {

5462

_tmp16_ = FALSE;

5463

}

5464

_tmp21_ = _tmp16_;

5465

if (_tmp21_) {

5466

_tmp15_ = TRUE;

5467

} else {

5468

gboolean _tmp22_ = FALSE;

5469

gboolean _tmp23_;

5470

gboolean _tmp29_;

5471

_tmp23_ = constructor;

5472

if (_tmp23_) {

5473

ValaDataType* _tmp24_;

5474

ValaTypeSymbol* _tmp25_;

5475

ValaTypeSymbol* _tmp26_;

5476

ValaTypeSymbol* _tmp27_;

5477

gboolean _tmp28_ = FALSE;

5478

_tmp24_ = type;

5479

_tmp25_ = vala_data_type_get_data_type (_tmp24_);

5480

_tmp26_ = _tmp25_;

5481

_tmp27_ = self->priv->ginitiallyunowned_type;

5482

_tmp28_ = vala_typesymbol_is_subtype_of (_tmp26_, _tmp27_);

5483

_tmp22_ = !_tmp28_;

5484

} else {

5485

_tmp22_ = FALSE;

5486

}

5487

_tmp29_ = _tmp22_;

5488

_tmp15_ = _tmp29_;

5489

}

5490

_tmp30_ = _tmp15_;

5491

if (_tmp30_) {

5492

GString* _tmp31_;

5493

_tmp31_ = self->priv->buffer;

5494

g_string_append_printf (_tmp31_, " transfer-ownership=\"full\"");

5495

} else {

5496

GString* _tmp32_;

5497

_tmp32_ = self->priv->buffer;

5498

g_string_append_printf (_tmp32_, " transfer-ownership=\"none\"");

5499

}

5500

_tmp33_ = caller_allocates;

5501

if (_tmp33_) {

5502

GString* _tmp34_;

5503

_tmp34_ = self->priv->buffer;

5504

g_string_append_printf (_tmp34_, " caller-allocates=\"1\"");

5505

}

5506

_tmp35_ = type;

5507

_tmp36_ = vala_data_type_get_nullable (_tmp35_);

5508

_tmp37_ = _tmp36_;

5509

if (_tmp37_) {

5510

GString* _tmp38_;

5511

_tmp38_ = self->priv->buffer;

5512

g_string_append_printf (_tmp38_, " allow-none=\"1\"");

5513

}

5514

_tmp40_ = delegate_type;

5515

if (_tmp40_ != NULL) {

5516

ValaDelegateType* _tmp41_;

5517

ValaDelegate* _tmp42_;

5518

ValaDelegate* _tmp43_;

5519

gboolean _tmp44_;

5520

gboolean _tmp45_;

5521

_tmp41_ = delegate_type;

5522

_tmp42_ = vala_delegate_type_get_delegate_symbol (_tmp41_);

5523

_tmp43_ = _tmp42_;

5524

_tmp44_ = vala_delegate_get_has_target (_tmp43_);

5525

_tmp45_ = _tmp44_;

5526

_tmp39_ = _tmp45_;

5527

} else {

5528

_tmp39_ = FALSE;

5529

}

5530

_tmp46_ = _tmp39_;

5531

if (_tmp46_) {

5532

gint _tmp47_ = 0;

5533

gboolean _tmp48_;

5534

gint _tmp57_;

5535

gint closure_index;

5536

GString* _tmp58_;

5537

gint _tmp59_;

5538

ValaDataType* _tmp60_;

5539

gboolean _tmp61_;

5540

gboolean _tmp62_;

5541

ValaDelegateType* _tmp65_;

5542

gboolean _tmp66_;

5543

gboolean _tmp67_;

5544

_tmp48_ = is_parameter;

5545

if (_tmp48_) {

5546

gint _tmp49_;

5547

_tmp49_ = *index;

5548

_tmp47_ = _tmp49_ + 1;

5549

} else {

5550

gint _tmp50_ = 0;

5551

ValaDataType* _tmp51_;

5552

gboolean _tmp52_;

5553

gboolean _tmp53_;

5554

gint _tmp56_;

5555

_tmp51_ = type;

5556

_tmp52_ = vala_data_type_get_value_owned (_tmp51_);

5557

_tmp53_ = _tmp52_;

5558

if (_tmp53_) {

5559

gint _tmp54_;

5560

_tmp54_ = *index;

5561

_tmp50_ = _tmp54_ - 1;

5562

} else {

5563

gint _tmp55_;

5564

_tmp55_ = *index;

5565

_tmp50_ = _tmp55_;

5566

}

5567

_tmp56_ = _tmp50_;

5568

_tmp47_ = _tmp56_;

5569

}

5570

_tmp57_ = _tmp47_;

5571

closure_index = _tmp57_;

5572

_tmp58_ = self->priv->buffer;

5573

_tmp59_ = closure_index;

5574

g_string_append_printf (_tmp58_, " closure=\"%i\"", _tmp59_);

5575

_tmp60_ = type;

5576

_tmp61_ = vala_data_type_get_value_owned (_tmp60_);

5577

_tmp62_ = _tmp61_;

5578

if (_tmp62_) {

5579

GString* _tmp63_;

5580

gint _tmp64_;

5581

_tmp63_ = self->priv->buffer;

5582

_tmp64_ = closure_index;

5583

g_string_append_printf (_tmp63_, " destroy=\"%i\"", _tmp64_ + 1);

5584

}

5585

_tmp65_ = delegate_type;

5586

_tmp66_ = vala_delegate_type_get_is_called_once (_tmp65_);

5587

_tmp67_ = _tmp66_;

5588

if (_tmp67_) {

5589

GString* _tmp68_;

5590

_tmp68_ = self->priv->buffer;

5591

g_string_append (_tmp68_, " scope=\"async\"");

5592

}

5593

}

5594

_tmp69_ = self->priv->buffer;

5595

g_string_append_printf (_tmp69_, ">\n");

5596

_tmp70_ = self->priv->indent;

5597

self->priv->indent = _tmp70_ + 1;

5598

_tmp71_ = comment;

5599

vala_gir_writer_write_doc (self, _tmp71_);

5600

length_param_index = -1;

5601

_tmp72_ = has_array_length;

5602

if (_tmp72_) {

5603

gint _tmp73_ = 0;

5604

gboolean _tmp74_;

5605

gint _tmp77_;

5606

_tmp74_ = is_parameter;

5607

if (_tmp74_) {

5608

gint _tmp75_;

5609

_tmp75_ = *index;

5610

_tmp73_ = _tmp75_ + 1;

5611

} else {

5612

gint _tmp76_;

5613

_tmp76_ = *index;

5614

_tmp73_ = _tmp76_;

5615

}

5616

_tmp77_ = _tmp73_;

5617

length_param_index = _tmp77_;

5618

}

5619

_tmp78_ = type;

5620

_tmp79_ = length_param_index;

5621

vala_gir_writer_write_type (self, _tmp78_, _tmp79_);

5622

_tmp80_ = self->priv->indent;

5623

self->priv->indent = _tmp80_ - 1;

5624

vala_gir_writer_write_indent (self);

5625

_tmp81_ = self->priv->buffer;

5626

_tmp82_ = tag;

5627

g_string_append_printf (_tmp81_, "</%s>\n", _tmp82_);

5628

_tmp83_ = *index;

5629

*index = _tmp83_ + 1;

5630

_vala_code_node_unref0 (delegate_type);

5631

_g_free0 (tag);

5632

}

5633

5634

5635

static void vala_gir_writer_write_ctype_attributes (ValaGIRWriter* self, ValaTypeSymbol* symbol, const gchar* suffix) {

5636

GString* _tmp0_;

5637

ValaTypeSymbol* _tmp1_;

5638

gchar* _tmp2_ = NULL;

5639

gchar* _tmp3_;

5640

const gchar* _tmp4_;

5641

g_return_if_fail (self != NULL);

5642

g_return_if_fail (symbol != NULL);

5643

g_return_if_fail (suffix != NULL);

5644

_tmp0_ = self->priv->buffer;

5645

_tmp1_ = symbol;

5646

_tmp2_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp1_);

5647

_tmp3_ = _tmp2_;

5648

_tmp4_ = suffix;

5649

g_string_append_printf (_tmp0_, " c:type=\"%s%s\"", _tmp3_, _tmp4_);

5650

_g_free0 (_tmp3_);

5651

}

5652

5653

5654

static void vala_gir_writer_write_gtype_attributes (ValaGIRWriter* self, ValaTypeSymbol* symbol) {

5655

ValaTypeSymbol* _tmp0_;

5656

GString* _tmp1_;

5657

ValaTypeSymbol* _tmp2_;

5658

gchar* _tmp3_ = NULL;

5659

gchar* _tmp4_;

5660

GString* _tmp5_;

5661

ValaTypeSymbol* _tmp6_;

5662

gchar* _tmp7_ = NULL;

5663

gchar* _tmp8_;

5664

g_return_if_fail (self != NULL);

5665

g_return_if_fail (symbol != NULL);

5666

_tmp0_ = symbol;

5667

vala_gir_writer_write_ctype_attributes (self, _tmp0_, "");

5668

_tmp1_ = self->priv->buffer;

5669

_tmp2_ = symbol;

5670

_tmp3_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp2_);

5671

_tmp4_ = _tmp3_;

5672

g_string_append_printf (_tmp1_, " glib:type-name=\"%s\"", _tmp4_);

5673

_g_free0 (_tmp4_);

5674

_tmp5_ = self->priv->buffer;

5675

_tmp6_ = symbol;

5676

_tmp7_ = vala_ccode_base_module_get_ccode_lower_case_prefix ((ValaSymbol*) _tmp6_);

5677

_tmp8_ = _tmp7_;

5678

g_string_append_printf (_tmp5_, " glib:get-type=\"%sget_type\"", _tmp8_);

5679

_g_free0 (_tmp8_);

5680

}

5681

5682

5683

static void vala_gir_writer_write_type (ValaGIRWriter* self, ValaDataType* type, gint index) {

5684

ValaDataType* _tmp0_;

5685

g_return_if_fail (self != NULL);

5686

g_return_if_fail (type != NULL);

5687

_tmp0_ = type;

5688

if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp0_, VALA_TYPE_ARRAY_TYPE)) {

5689

ValaDataType* _tmp1_;

5690

ValaArrayType* _tmp2_;

5691

ValaArrayType* array_type;

5692

GString* _tmp3_;

5693

ValaArrayType* _tmp4_;

5694

gboolean _tmp5_;

5695

gboolean _tmp6_;

5696

GString* _tmp14_;

5697

gint _tmp15_;

5698

ValaArrayType* _tmp16_;

5699

ValaDataType* _tmp17_;

5700

ValaDataType* _tmp18_;

5701

gint _tmp19_;

5702

GString* _tmp20_;

5703

_tmp1_ = type;

5704

_tmp2_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp1_, VALA_TYPE_ARRAY_TYPE, ValaArrayType));

5705

array_type = _tmp2_;

5706

vala_gir_writer_write_indent (self);

5707

_tmp3_ = self->priv->buffer;

5708

g_string_append_printf (_tmp3_, "<array");

5709

_tmp4_ = array_type;

5710

_tmp5_ = vala_array_type_get_fixed_length (_tmp4_);

5711

_tmp6_ = _tmp5_;

5712

if (_tmp6_) {

5713

GString* _tmp7_;

5714

ValaArrayType* _tmp8_;

5715

gint _tmp9_;

5716

gint _tmp10_;

5717

_tmp7_ = self->priv->buffer;

5718

_tmp8_ = array_type;

5719

_tmp9_ = vala_array_type_get_length (_tmp8_);

5720

_tmp10_ = _tmp9_;

5721

g_string_append_printf (_tmp7_, " fixed-size=\"%i\"", _tmp10_);

5722

} else {

5723

gint _tmp11_;

5724

_tmp11_ = index;

5725

if (_tmp11_ != (-1)) {

5726

GString* _tmp12_;

5727

gint _tmp13_;

5728

_tmp12_ = self->priv->buffer;

5729

_tmp13_ = index;

5730

g_string_append_printf (_tmp12_, " length=\"%i\"", _tmp13_);

5731

}

5732

}

5733

_tmp14_ = self->priv->buffer;

5734

g_string_append_printf (_tmp14_, ">\n");

5735

_tmp15_ = self->priv->indent;

5736

self->priv->indent = _tmp15_ + 1;

5737

_tmp16_ = array_type;

5738

_tmp17_ = vala_array_type_get_element_type (_tmp16_);

5739

_tmp18_ = _tmp17_;

5740

vala_gir_writer_write_type (self, _tmp18_, -1);

5741

_tmp19_ = self->priv->indent;

5742

self->priv->indent = _tmp19_ - 1;

5743

vala_gir_writer_write_indent (self);

5744

_tmp20_ = self->priv->buffer;

5745

g_string_append_printf (_tmp20_, "</array>\n");

5746

_vala_code_node_unref0 (array_type);

5747

} else {

5748

ValaDataType* _tmp21_;

5749

_tmp21_ = type;

5750

if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp21_, VALA_TYPE_VOID_TYPE)) {

5751

GString* _tmp22_;

5752

vala_gir_writer_write_indent (self);

5753

_tmp22_ = self->priv->buffer;

5754

g_string_append_printf (_tmp22_, "<type name=\"none\"/>\n");

5755

} else {

5756

ValaDataType* _tmp23_;

5757

_tmp23_ = type;

5758

if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp23_, VALA_TYPE_POINTER_TYPE)) {

5759

GString* _tmp24_;

5760

ValaDataType* _tmp25_;

5761

gchar* _tmp26_ = NULL;

5762

gchar* _tmp27_;

5763

vala_gir_writer_write_indent (self);

5764

_tmp24_ = self->priv->buffer;

5765

_tmp25_ = type;

5766

_tmp26_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp25_);

5767

_tmp27_ = _tmp26_;

5768

g_string_append_printf (_tmp24_, "<type name=\"gpointer\" c:type=\"%s\"/>\n", _tmp27_);

5769

_g_free0 (_tmp27_);

5770

} else {

5771

ValaDataType* _tmp28_;

5772

ValaTypeSymbol* _tmp29_;

5773

ValaTypeSymbol* _tmp30_;

5774

_tmp28_ = type;

5775

_tmp29_ = vala_data_type_get_data_type (_tmp28_);

5776

_tmp30_ = _tmp29_;

5777

if (_tmp30_ != NULL) {

5778

ValaDataType* _tmp31_;

5779

ValaTypeSymbol* _tmp32_;

5780

ValaTypeSymbol* _tmp33_;

5781

gchar* _tmp34_ = NULL;

5782

gchar* type_name;

5783

gboolean is_array;

5784

gboolean _tmp35_ = FALSE;

5785

const gchar* _tmp36_;

5786

gboolean _tmp38_;

5787

const gchar* _tmp39_ = NULL;

5788

gboolean _tmp40_;

5789

GString* _tmp41_;

5790

const gchar* _tmp42_;

5791

ValaDataType* _tmp43_;

5792

ValaTypeSymbol* _tmp44_;

5793

ValaTypeSymbol* _tmp45_;

5794

gchar* _tmp46_ = NULL;

5795

gchar* _tmp47_;

5796

ValaDataType* _tmp48_;

5797

gchar* _tmp49_ = NULL;

5798

gchar* _tmp50_;

5799

ValaDataType* _tmp51_;

5800

ValaList* _tmp52_ = NULL;

5801

ValaList* type_arguments;

5802

ValaList* _tmp53_;

5803

gint _tmp54_;

5804

gint _tmp55_;

5805

vala_gir_writer_write_indent (self);

5806

_tmp31_ = type;

5807

_tmp32_ = vala_data_type_get_data_type (_tmp31_);

5808

_tmp33_ = _tmp32_;

5809

_tmp34_ = vala_gir_writer_gi_type_name (self, _tmp33_);

5810

type_name = _tmp34_;

5811

is_array = FALSE;

5812

_tmp36_ = type_name;

5813

if (g_strcmp0 (_tmp36_, "GLib.Array") == 0) {

5814

_tmp35_ = TRUE;

5815

} else {

5816

const gchar* _tmp37_;

5817

_tmp37_ = type_name;

5818

_tmp35_ = g_strcmp0 (_tmp37_, "GLib.PtrArray") == 0;

5819

}

5820

_tmp38_ = _tmp35_;

5821

if (_tmp38_) {

5822

is_array = TRUE;

5823

}

5824

_tmp40_ = is_array;

5825

if (_tmp40_) {

5826

_tmp39_ = "array";

5827

} else {

5828

_tmp39_ = "type";

5829

}

5830

_tmp41_ = self->priv->buffer;

5831

_tmp42_ = _tmp39_;

5832

_tmp43_ = type;

5833

_tmp44_ = vala_data_type_get_data_type (_tmp43_);

5834

_tmp45_ = _tmp44_;

5835

_tmp46_ = vala_gir_writer_gi_type_name (self, _tmp45_);

5836

_tmp47_ = _tmp46_;

5837

_tmp48_ = type;

5838

_tmp49_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp48_);

5839

_tmp50_ = _tmp49_;

5840

g_string_append_printf (_tmp41_, "<%s name=\"%s\" c:type=\"%s\"", _tmp42_, _tmp47_, _tmp50_);

5841

_g_free0 (_tmp50_);

5842

_g_free0 (_tmp47_);

5843

_tmp51_ = type;

5844

_tmp52_ = vala_data_type_get_type_arguments (_tmp51_);

5845

type_arguments = _tmp52_;

5846

_tmp53_ = type_arguments;

5847

_tmp54_ = vala_collection_get_size ((ValaCollection*) _tmp53_);

5848

_tmp55_ = _tmp54_;

5849

if (_tmp55_ == 0) {

5850

GString* _tmp56_;

5851

_tmp56_ = self->priv->buffer;

5852

g_string_append_printf (_tmp56_, "/>\n");

5853

} else {

5854

GString* _tmp57_;

5855

gint _tmp58_;

5856

gint _tmp71_;

5857

const gchar* _tmp72_ = NULL;

5858

gboolean _tmp73_;

5859

GString* _tmp74_;

5860

const gchar* _tmp75_;

5861

_tmp57_ = self->priv->buffer;

5862

g_string_append_printf (_tmp57_, ">\n");

5863

_tmp58_ = self->priv->indent;

5864

self->priv->indent = _tmp58_ + 1;

5865

{

5866

ValaList* _tmp59_;

5867

ValaList* _tmp60_;

5868

ValaList* _type_argument_list;

5869

ValaList* _tmp61_;

5870

gint _tmp62_;

5871

gint _tmp63_;

5872

gint _type_argument_size;

5873

gint _type_argument_index;

5874

_tmp59_ = type_arguments;

5875

_tmp60_ = _vala_iterable_ref0 (_tmp59_);

5876

_type_argument_list = _tmp60_;

5877

_tmp61_ = _type_argument_list;

5878

_tmp62_ = vala_collection_get_size ((ValaCollection*) _tmp61_);

5879

_tmp63_ = _tmp62_;

5880

_type_argument_size = _tmp63_;

5881

_type_argument_index = -1;

5882

while (TRUE) {

5883

gint _tmp64_;

5884

gint _tmp65_;

5885

gint _tmp66_;

5886

ValaList* _tmp67_;

5887

gint _tmp68_;

5888

gpointer _tmp69_ = NULL;

5889

ValaDataType* type_argument;

5890

ValaDataType* _tmp70_;

5891

_tmp64_ = _type_argument_index;

5892

_type_argument_index = _tmp64_ + 1;

5893

_tmp65_ = _type_argument_index;

5894

_tmp66_ = _type_argument_size;

5895

if (!(_tmp65_ < _tmp66_)) {

5896

break;

5897

}

5898

_tmp67_ = _type_argument_list;

5899

_tmp68_ = _type_argument_index;

5900

_tmp69_ = vala_list_get (_tmp67_, _tmp68_);

5901

type_argument = (ValaDataType*) _tmp69_;

5902

_tmp70_ = type_argument;

5903

vala_gir_writer_write_type (self, _tmp70_, -1);

5904

_vala_code_node_unref0 (type_argument);

5905

}

5906

_vala_iterable_unref0 (_type_argument_list);

5907

}

5908

_tmp71_ = self->priv->indent;

5909

self->priv->indent = _tmp71_ - 1;

5910

vala_gir_writer_write_indent (self);

5911

_tmp73_ = is_array;

5912

if (_tmp73_) {

5913

_tmp72_ = "array";

5914

} else {

5915

_tmp72_ = "type";

5916

}

5917

_tmp74_ = self->priv->buffer;

5918

_tmp75_ = _tmp72_;

5919

g_string_append_printf (_tmp74_, "</%s>\n", _tmp75_);

5920

}

5921

_vala_iterable_unref0 (type_arguments);

5922

_g_free0 (type_name);

5923

} else {

5924

ValaDataType* _tmp76_;

5925

_tmp76_ = type;

5926

if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp76_, VALA_TYPE_DELEGATE_TYPE)) {

5927

ValaDataType* _tmp77_;

5928

ValaDelegateType* _tmp78_;

5929

ValaDelegateType* deleg_type;

5930

GString* _tmp79_;

5931

ValaDelegateType* _tmp80_;

5932

ValaDelegate* _tmp81_;

5933

ValaDelegate* _tmp82_;

5934

gchar* _tmp83_ = NULL;

5935

gchar* _tmp84_;

5936

ValaDataType* _tmp85_;

5937

gchar* _tmp86_ = NULL;

5938

gchar* _tmp87_;

5939

_tmp77_ = type;

5940

_tmp78_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp77_, VALA_TYPE_DELEGATE_TYPE, ValaDelegateType));

5941

deleg_type = _tmp78_;

5942

vala_gir_writer_write_indent (self);

5943

_tmp79_ = self->priv->buffer;

5944

_tmp80_ = deleg_type;

5945

_tmp81_ = vala_delegate_type_get_delegate_symbol (_tmp80_);

5946

_tmp82_ = _tmp81_;

5947

_tmp83_ = vala_gir_writer_gi_type_name (self, (ValaTypeSymbol*) _tmp82_);

5948

_tmp84_ = _tmp83_;

5949

_tmp85_ = type;

5950

_tmp86_ = vala_ccode_base_module_get_ccode_name ((ValaCodeNode*) _tmp85_);

5951

_tmp87_ = _tmp86_;

5952

g_string_append_printf (_tmp79_, "<type name=\"%s\" c:type=\"%s\"/>\n", _tmp84_, _tmp87_);

5953

_g_free0 (_tmp87_);

5954

_g_free0 (_tmp84_);

5955

_vala_code_node_unref0 (deleg_type);

5956

} else {

5957

ValaDataType* _tmp88_;

5958

_tmp88_ = type;

5959

if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp88_, VALA_TYPE_GENERIC_TYPE)) {

5960

GString* _tmp89_;

5961

vala_gir_writer_write_indent (self);

5962

_tmp89_ = self->priv->buffer;

5963

g_string_append (_tmp89_, "<type name=\"gpointer\" c:type=\"gpointer\"/>\n");

5964

} else {

5965

GString* _tmp90_;

5966

ValaDataType* _tmp91_;

5967

gchar* _tmp92_ = NULL;

5968

gchar* _tmp93_;

5969

vala_gir_writer_write_indent (self);

5970

_tmp90_ = self->priv->buffer;

5971

_tmp91_ = type;

5972

_tmp92_ = vala_code_node_to_string ((ValaCodeNode*) _tmp91_);

5973

_tmp93_ = _tmp92_;

5974

g_string_append_printf (_tmp90_, "<type name=\"%s\"/>\n", _tmp93_);

5975

_g_free0 (_tmp93_);

5976

}

5977

}

5978

}

5979

}

5980

}

5981

}

5982

}

5983

5984

5985

static void vala_gir_writer_write_annotations (ValaGIRWriter* self, ValaCodeNode* node) {

5986

ValaCodeNode* _tmp0_;

5987

GList* _tmp1_;

5988

g_return_if_fail (self != NULL);

5989

g_return_if_fail (node != NULL);

5990

_tmp0_ = node;

5991

_tmp1_ = _tmp0_->attributes;

5992

{

5993

GList* attr_collection = NULL;

5994

GList* attr_it = NULL;

5995

attr_collection = _tmp1_;

5996

for (attr_it = attr_collection; attr_it != NULL; attr_it = attr_it->next) {

5997

ValaAttribute* _tmp2_;

5998

ValaAttribute* attr = NULL;

5999

_tmp2_ = _vala_code_node_ref0 ((ValaAttribute*) attr_it->data);

6000

attr = _tmp2_;

6001

{

6002

ValaAttribute* _tmp3_;

6003

const gchar* _tmp4_;

6004

const gchar* _tmp5_;

6005

gchar* _tmp6_ = NULL;

6006

gchar* name;

6007

_tmp3_ = attr;

6008

_tmp4_ = vala_attribute_get_name (_tmp3_);

6009

_tmp5_ = _tmp4_;

6010

_tmp6_ = vala_gir_writer_camel_case_to_canonical (self, _tmp5_);

6011

name = _tmp6_;

6012

{

6013

ValaAttribute* _tmp7_;

6014

ValaMap* _tmp8_;

6015

ValaSet* _tmp9_ = NULL;

6016

ValaSet* _tmp10_;

6017

ValaIterator* _tmp11_ = NULL;

6018

ValaIterator* _tmp12_;

6019

ValaIterator* _arg_name_it;

6020

_tmp7_ = attr;

6021

_tmp8_ = _tmp7_->args;

6022

_tmp9_ = vala_map_get_keys (_tmp8_);

6023

_tmp10_ = _tmp9_;

6024

_tmp11_ = vala_iterable_iterator ((ValaIterable*) _tmp10_);

6025

_tmp12_ = _tmp11_;

6026

_vala_iterable_unref0 (_tmp10_);

6027

_arg_name_it = _tmp12_;

6028

while (TRUE) {

6029

ValaIterator* _tmp13_;

6030

gboolean _tmp14_ = FALSE;

6031

ValaIterator* _tmp15_;

6032

gpointer _tmp16_ = NULL;

6033

gchar* arg_name;

6034

ValaAttribute* _tmp17_;

6035

ValaMap* _tmp18_;

6036

const gchar* _tmp19_;

6037

gpointer _tmp20_ = NULL;

6038

gchar* value;

6039

const gchar* _tmp21_;

6040

gboolean _tmp22_ = FALSE;

6041

GString* _tmp26_;

6042

const gchar* _tmp27_;

6043

const gchar* _tmp28_;

6044

gchar* _tmp29_ = NULL;

6045

gchar* _tmp30_;

6046

const gchar* _tmp31_;

6047

_tmp13_ = _arg_name_it;

6048

_tmp14_ = vala_iterator_next (_tmp13_);

6049

if (!_tmp14_) {

6050

break;

6051

}

6052

_tmp15_ = _arg_name_it;

6053

_tmp16_ = vala_iterator_get (_tmp15_);

6054

arg_name = (gchar*) _tmp16_;

6055

_tmp17_ = attr;

6056

_tmp18_ = _tmp17_->args;

6057

_tmp19_ = arg_name;

6058

_tmp20_ = vala_map_get (_tmp18_, _tmp19_);

6059

value = (gchar*) _tmp20_;

6060

_tmp21_ = value;

6061

_tmp22_ = g_str_has_prefix (_tmp21_, "\"");

6062

if (_tmp22_) {

6063

ValaAttribute* _tmp23_;

6064

const gchar* _tmp24_;

6065

gchar* _tmp25_ = NULL;

6066

_tmp23_ = attr;

6067

_tmp24_ = arg_name;

6068

_tmp25_ = vala_attribute_get_string (_tmp23_, _tmp24_);

6069

_g_free0 (value);

6070

value = _tmp25_;

6071

}

6072

vala_gir_writer_write_indent (self);

6073

_tmp26_ = self->priv->buffer;

6074

_tmp27_ = name;

6075

_tmp28_ = arg_name;

6076

_tmp29_ = vala_gir_writer_camel_case_to_canonical (self, _tmp28_);

6077

_tmp30_ = _tmp29_;

6078

_tmp31_ = value;

6079

g_string_append_printf (_tmp26_, "<annotation key=\"%s.%s\" value=\"%s\"/>\n", _tmp27_, _tmp30_, _tmp31_);

6080

_g_free0 (_tmp30_);

6081

_g_free0 (value);

6082

_g_free0 (arg_name);

6083

}

6084

_vala_iterator_unref0 (_arg_name_it);

6085

}

6086

_g_free0 (name);

6087

_vala_code_node_unref0 (attr);

6088

}

6089

}

6090

}

6091

}

6092

6093

6094

static gboolean string_contains (const gchar* self, const gchar* needle) {

6095

gboolean result = FALSE;

6096

const gchar* _tmp0_;

6097

gchar* _tmp1_ = NULL;

6098

g_return_val_if_fail (self != NULL, FALSE);

6099

g_return_val_if_fail (needle != NULL, FALSE);

6100

_tmp0_ = needle;

6101

_tmp1_ = strstr ((gchar*) self, (gchar*) _tmp0_);

6102

result = _tmp1_ != NULL;

6103

return result;

6104

}

6105

6106

6107

static gchar* vala_gir_writer_get_full_gir_name (ValaGIRWriter* self, ValaSymbol* sym) {

6108

gchar* result = NULL;

6109

ValaSymbol* _tmp0_;

6110

gchar* _tmp1_ = NULL;

6111

gchar* _tmp2_;

6112

const gchar* _tmp3_;

6113

const gchar* _tmp8_;

6114

gchar* _tmp9_;

6115

gchar* gir_name;

6116

ValaSymbol* _tmp10_;

6117

ValaSymbol* _tmp11_;

6118

ValaSymbol* _tmp12_;

6119

ValaSymbol* _tmp13_;

6120

const gchar* _tmp14_;

6121

const gchar* _tmp15_;

6122

ValaSymbol* _tmp20_;

6123

ValaSymbol* _tmp21_;

6124

ValaSymbol* _tmp22_;

6125

gchar* _tmp23_ = NULL;

6126

gchar* parent_gir_name;

6127

const gchar* _tmp24_;

6128

gchar* _tmp25_ = NULL;

6129

const gchar* _tmp26_;

6130

gboolean _tmp27_ = FALSE;

6131

const gchar* _tmp32_;

6132

gchar* _tmp33_;

6133

gchar* self_gir_name;

6134

const gchar* _tmp34_;

6135

gboolean _tmp35_ = FALSE;

6136

g_return_val_if_fail (self != NULL, NULL);

6137

g_return_val_if_fail (sym != NULL, NULL);

6138

_tmp0_ = sym;

6139

_tmp1_ = vala_code_node_get_attribute_string ((ValaCodeNode*) _tmp0_, "GIR", "name");

6140

_tmp2_ = _tmp1_;

6141

_tmp3_ = _tmp2_;

6142

if (_tmp3_ == NULL) {

6143

ValaSymbol* _tmp4_;

6144

const gchar* _tmp5_;

6145

const gchar* _tmp6_;

6146

gchar* _tmp7_;

6147

_tmp4_ = sym;

6148

_tmp5_ = vala_symbol_get_name (_tmp4_);

6149

_tmp6_ = _tmp5_;

6150

_tmp7_ = g_strdup (_tmp6_);

6151

_g_free0 (_tmp2_);

6152

_tmp2_ = _tmp7_;

6153

}

6154

_tmp8_ = _tmp2_;

6155

_tmp9_ = g_strdup (_tmp8_);

6156

gir_name = _tmp9_;

6157

_tmp10_ = sym;

6158

_tmp11_ = vala_symbol_get_parent_symbol (_tmp10_);

6159

_tmp12_ = _tmp11_;

6160

if (_tmp12_ == NULL) {

6161

result = gir_name;

6162

_g_free0 (_tmp2_);

6163

return result;

6164

}

6165

_tmp13_ = sym;

6166

_tmp14_ = vala_symbol_get_name (_tmp13_);

6167

_tmp15_ = _tmp14_;

6168

if (_tmp15_ == NULL) {

6169

ValaSymbol* _tmp16_;

6170

ValaSymbol* _tmp17_;

6171

ValaSymbol* _tmp18_;

6172

gchar* _tmp19_ = NULL;

6173

_tmp16_ = sym;

6174

_tmp17_ = vala_symbol_get_parent_symbol (_tmp16_);

6175

_tmp18_ = _tmp17_;

6176

_tmp19_ = vala_gir_writer_get_full_gir_name (self, _tmp18_);

6177

result = _tmp19_;

6178

_g_free0 (gir_name);

6179

_g_free0 (_tmp2_);

6180

return result;

6181

}

6182

_tmp20_ = sym;

6183

_tmp21_ = vala_symbol_get_parent_symbol (_tmp20_);

6184

_tmp22_ = _tmp21_;

6185

_tmp23_ = vala_gir_writer_get_full_gir_name (self, _tmp22_);

6186

parent_gir_name = _tmp23_;

6187

_tmp24_ = parent_gir_name;

6188

if (_tmp24_ == NULL) {

6189

result = gir_name;

6190

_g_free0 (parent_gir_name);

6191

_g_free0 (_tmp2_);

6192

return result;

6193

}

6194

_tmp26_ = gir_name;

6195

_tmp27_ = g_str_has_prefix (_tmp26_, ".");

6196

if (_tmp27_) {

6197

const gchar* _tmp28_;

6198

gchar* _tmp29_ = NULL;

6199

_tmp28_ = gir_name;

6200

_tmp29_ = string_substring (_tmp28_, (glong) 1, (glong) (-1));

6201

_g_free0 (_tmp25_);

6202

_tmp25_ = _tmp29_;

6203

} else {

6204

const gchar* _tmp30_;

6205

gchar* _tmp31_;

6206

_tmp30_ = gir_name;

6207

_tmp31_ = g_strdup (_tmp30_);

6208

_g_free0 (_tmp25_);

6209

_tmp25_ = _tmp31_;

6210

}

6211

_tmp32_ = _tmp25_;

6212

_tmp33_ = g_strdup (_tmp32_);

6213

self_gir_name = _tmp33_;

6214

_tmp34_ = parent_gir_name;

6215

_tmp35_ = string_contains (_tmp34_, ".");

6216

if (_tmp35_) {

6217

const gchar* _tmp36_;

6218

const gchar* _tmp37_;

6219

gchar* _tmp38_ = NULL;

6220

_tmp36_ = parent_gir_name;

6221

_tmp37_ = self_gir_name;

6222

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

6223

result = _tmp38_;

6224

_g_free0 (self_gir_name);

6225

_g_free0 (_tmp25_);

6226

_g_free0 (parent_gir_name);

6227

_g_free0 (gir_name);

6228

_g_free0 (_tmp2_);

6229

return result;

6230

} else {

6231

const gchar* _tmp39_;

6232

const gchar* _tmp40_;

6233

gchar* _tmp41_ = NULL;

6234

_tmp39_ = parent_gir_name;

6235

_tmp40_ = self_gir_name;

6236

_tmp41_ = g_strdup_printf ("%s.%s", _tmp39_, _tmp40_);

6237

result = _tmp41_;

6238

_g_free0 (self_gir_name);

6239

_g_free0 (_tmp25_);

6240

_g_free0 (parent_gir_name);

6241

_g_free0 (gir_name);

6242

_g_free0 (_tmp2_);

6243

return result;

6244

}

6245

_g_free0 (self_gir_name);

6246

_g_free0 (_tmp25_);

6247

_g_free0 (parent_gir_name);

6248

_g_free0 (gir_name);

6249

_g_free0 (_tmp2_);

6250

}

6251

6252

6253

static gchar* vala_gir_writer_gi_type_name (ValaGIRWriter* self, ValaTypeSymbol* type_symbol) {

6254

gchar* result = NULL;

6255

ValaTypeSymbol* _tmp0_;

6256

ValaSymbol* _tmp1_;

6257

ValaSymbol* _tmp2_;

6258

ValaSymbol* _tmp3_;

6259

ValaSymbol* parent;

6260

ValaSymbol* _tmp4_;

6261

ValaTypeSymbol* _tmp65_;

6262

gchar* _tmp66_ = NULL;

6263

g_return_val_if_fail (self != NULL, NULL);

6264

g_return_val_if_fail (type_symbol != NULL, NULL);

6265

_tmp0_ = type_symbol;

6266

_tmp1_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp0_);

6267

_tmp2_ = _tmp1_;

6268

_tmp3_ = _vala_code_node_ref0 (_tmp2_);

6269

parent = _tmp3_;

6270

_tmp4_ = parent;

6271

if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp4_, VALA_TYPE_NAMESPACE)) {

6272

ValaSymbol* _tmp5_;

6273

ValaNamespace* _tmp6_;

6274

ValaNamespace* ns;

6275

ValaNamespace* _tmp7_;

6276

gchar* _tmp8_ = NULL;

6277

gchar* _tmp9_;

6278

const gchar* _tmp10_;

6279

const gchar* _tmp15_;

6280

gchar* _tmp16_;

6281

gchar* ns_gir_name;

6282

const gchar* _tmp17_;

6283

_tmp5_ = parent;

6284

_tmp6_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp5_, VALA_TYPE_NAMESPACE) ? ((ValaNamespace*) _tmp5_) : NULL);

6285

ns = _tmp6_;

6286

_tmp7_ = ns;

6287

_tmp8_ = vala_code_node_get_attribute_string ((ValaCodeNode*) _tmp7_, "GIR", "name");

6288

_tmp9_ = _tmp8_;

6289

_tmp10_ = _tmp9_;

6290

if (_tmp10_ == NULL) {

6291

ValaNamespace* _tmp11_;

6292

const gchar* _tmp12_;

6293

const gchar* _tmp13_;

6294

gchar* _tmp14_;

6295

_tmp11_ = ns;

6296

_tmp12_ = vala_symbol_get_name ((ValaSymbol*) _tmp11_);

6297

_tmp13_ = _tmp12_;

6298

_tmp14_ = g_strdup (_tmp13_);

6299

_g_free0 (_tmp9_);

6300

_tmp9_ = _tmp14_;

6301

}

6302

_tmp15_ = _tmp9_;

6303

_tmp16_ = g_strdup (_tmp15_);

6304

ns_gir_name = _tmp16_;

6305

_tmp17_ = ns_gir_name;

6306

if (_tmp17_ != NULL) {

6307

ValaTypeSymbol* _tmp18_;

6308

ValaSourceReference* _tmp19_;

6309

ValaSourceReference* _tmp20_;

6310

ValaSourceFile* _tmp21_;

6311

ValaSourceFile* _tmp22_;

6312

const gchar* _tmp23_;

6313

const gchar* _tmp24_;

6314

_tmp18_ = type_symbol;

6315

_tmp19_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp18_);

6316

_tmp20_ = _tmp19_;

6317

_tmp21_ = vala_source_reference_get_file (_tmp20_);

6318

_tmp22_ = _tmp21_;

6319

_tmp23_ = vala_source_file_get_gir_namespace (_tmp22_);

6320

_tmp24_ = _tmp23_;

6321

if (_tmp24_ != NULL) {

6322

ValaTypeSymbol* _tmp25_;

6323

ValaSourceReference* _tmp26_;

6324

ValaSourceReference* _tmp27_;

6325

ValaSourceFile* _tmp28_;

6326

ValaSourceFile* _tmp29_;

6327

const gchar* _tmp30_;

6328

const gchar* _tmp31_;

6329

ValaTypeSymbol* _tmp32_;

6330

ValaSourceReference* _tmp33_;

6331

ValaSourceReference* _tmp34_;

6332

ValaSourceFile* _tmp35_;

6333

ValaSourceFile* _tmp36_;

6334

const gchar* _tmp37_;

6335

const gchar* _tmp38_;

6336

ValaGIRWriterGIRNamespace external = {0};

6337

ValaArrayList* _tmp39_;

6338

ValaGIRWriterGIRNamespace _tmp40_;

6339

gboolean _tmp41_ = FALSE;

6340

ValaTypeSymbol* _tmp44_;

6341

gchar* _tmp45_ = NULL;

6342

gchar* _tmp46_;

6343

const gchar* _tmp47_;

6344

const gchar* _tmp52_;

6345

gchar* _tmp53_;

6346

gchar* type_name;

6347

ValaTypeSymbol* _tmp54_;

6348

ValaSourceReference* _tmp55_;

6349

ValaSourceReference* _tmp56_;

6350

ValaSourceFile* _tmp57_;

6351

ValaSourceFile* _tmp58_;

6352

const gchar* _tmp59_;

6353

const gchar* _tmp60_;

6354

const gchar* _tmp61_;

6355

gchar* _tmp62_ = NULL;

6356

_tmp25_ = type_symbol;

6357

_tmp26_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp25_);

6358

_tmp27_ = _tmp26_;

6359

_tmp28_ = vala_source_reference_get_file (_tmp27_);

6360

_tmp29_ = _tmp28_;

6361

_tmp30_ = vala_source_file_get_gir_namespace (_tmp29_);

6362

_tmp31_ = _tmp30_;

6363

_tmp32_ = type_symbol;

6364

_tmp33_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp32_);

6365

_tmp34_ = _tmp33_;

6366

_tmp35_ = vala_source_reference_get_file (_tmp34_);

6367

_tmp36_ = _tmp35_;

6368

_tmp37_ = vala_source_file_get_gir_version (_tmp36_);

6369

_tmp38_ = _tmp37_;

6370

vala_gir_writer_gir_namespace_init (&external, _tmp31_, _tmp38_);

6371

_tmp39_ = self->priv->externals;

6372

_tmp40_ = external;

6373

_tmp41_ = vala_collection_contains ((ValaCollection*) _tmp39_, &_tmp40_);

6374

if (!_tmp41_) {

6375

ValaArrayList* _tmp42_;

6376

ValaGIRWriterGIRNamespace _tmp43_;

6377

_tmp42_ = self->priv->externals;

6378

_tmp43_ = external;

6379

vala_collection_add ((ValaCollection*) _tmp42_, &_tmp43_);

6380

}

6381

_tmp44_ = type_symbol;

6382

_tmp45_ = vala_code_node_get_attribute_string ((ValaCodeNode*) _tmp44_, "GIR", "name");

6383

_tmp46_ = _tmp45_;

6384

_tmp47_ = _tmp46_;

6385

if (_tmp47_ == NULL) {

6386

ValaTypeSymbol* _tmp48_;

6387

const gchar* _tmp49_;

6388

const gchar* _tmp50_;

6389

gchar* _tmp51_;

6390

_tmp48_ = type_symbol;

6391

_tmp49_ = vala_symbol_get_name ((ValaSymbol*) _tmp48_);

6392

_tmp50_ = _tmp49_;

6393

_tmp51_ = g_strdup (_tmp50_);

6394

_g_free0 (_tmp46_);

6395

_tmp46_ = _tmp51_;

6396

}

6397

_tmp52_ = _tmp46_;

6398

_tmp53_ = g_strdup (_tmp52_);

6399

type_name = _tmp53_;

6400

_tmp54_ = type_symbol;

6401

_tmp55_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp54_);

6402

_tmp56_ = _tmp55_;

6403

_tmp57_ = vala_source_reference_get_file (_tmp56_);

6404

_tmp58_ = _tmp57_;

6405

_tmp59_ = vala_source_file_get_gir_namespace (_tmp58_);

6406

_tmp60_ = _tmp59_;

6407

_tmp61_ = type_name;

6408

_tmp62_ = g_strdup_printf ("%s.%s", _tmp60_, _tmp61_);

6409

result = _tmp62_;

6410

_g_free0 (type_name);

6411

_g_free0 (_tmp46_);

6412

vala_gir_writer_gir_namespace_destroy (&external);

6413

_g_free0 (ns_gir_name);

6414

_g_free0 (_tmp9_);

6415

_vala_code_node_unref0 (ns);

6416

_vala_code_node_unref0 (parent);

6417

return result;

6418

} else {

6419

ValaHashSet* _tmp63_;

6420

ValaNamespace* _tmp64_;

6421

_tmp63_ = self->priv->unannotated_namespaces;

6422

_tmp64_ = ns;

6423

vala_collection_add ((ValaCollection*) _tmp63_, _tmp64_);

6424

}

6425

}

6426

_g_free0 (ns_gir_name);

6427

_g_free0 (_tmp9_);

6428

_vala_code_node_unref0 (ns);

6429

}

6430

_tmp65_ = type_symbol;

6431

_tmp66_ = vala_gir_writer_get_full_gir_name (self, (ValaSymbol*) _tmp65_);

6432

result = _tmp66_;

6433

_vala_code_node_unref0 (parent);

6434

return result;

6435

}

6436

6437

6438

static gchar* vala_gir_writer_literal_expression_to_value_string (ValaGIRWriter* self, ValaExpression* literal) {

6439

gchar* result = NULL;

6440

ValaExpression* _tmp0_;

6441

g_return_val_if_fail (self != NULL, NULL);

6442

g_return_val_if_fail (literal != NULL, NULL);

6443

_tmp0_ = literal;

6444

if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp0_, VALA_TYPE_STRING_LITERAL)) {

6445

ValaExpression* _tmp1_;

6446

ValaStringLiteral* _tmp2_;

6447

ValaStringLiteral* lit;

6448

ValaStringLiteral* _tmp3_;

6449

_tmp1_ = literal;

6450

_tmp2_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp1_, VALA_TYPE_STRING_LITERAL) ? ((ValaStringLiteral*) _tmp1_) : NULL);

6451

lit = _tmp2_;

6452

_tmp3_ = lit;

6453

if (_tmp3_ != NULL) {

6454

ValaStringLiteral* _tmp4_;

6455

gchar* _tmp5_ = NULL;

6456

gchar* _tmp6_;

6457

gchar* _tmp7_ = NULL;

6458

gchar* _tmp8_;

6459

_tmp4_ = lit;

6460

_tmp5_ = vala_string_literal_eval (_tmp4_);

6461

_tmp6_ = _tmp5_;

6462

_tmp7_ = g_markup_escape_text (_tmp6_, (gssize) (-1));

6463

_tmp8_ = _tmp7_;

6464

_g_free0 (_tmp6_);

6465

result = _tmp8_;

6466

_vala_code_node_unref0 (lit);

6467

return result;

6468

}

6469

_vala_code_node_unref0 (lit);

6470

} else {

6471

ValaExpression* _tmp9_;

6472

_tmp9_ = literal;

6473

if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp9_, VALA_TYPE_CHARACTER_LITERAL)) {

6474

ValaExpression* _tmp10_;

6475

gunichar _tmp11_ = 0U;

6476

gchar* _tmp12_ = NULL;

6477

_tmp10_ = literal;

6478

_tmp11_ = vala_character_literal_get_char (G_TYPE_CHECK_INSTANCE_CAST (_tmp10_, VALA_TYPE_CHARACTER_LITERAL, ValaCharacterLiteral));

6479

_tmp12_ = g_strdup_printf ("%c", (gint) ((gchar) _tmp11_));

6480

result = _tmp12_;

6481

return result;

6482

} else {

6483

ValaExpression* _tmp13_;

6484

_tmp13_ = literal;

6485

if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp13_, VALA_TYPE_BOOLEAN_LITERAL)) {

6486

const gchar* _tmp14_ = NULL;

6487

ValaExpression* _tmp15_;

6488

gboolean _tmp16_;

6489

gboolean _tmp17_;

6490

const gchar* _tmp18_;

6491

gchar* _tmp19_;

6492

_tmp15_ = literal;

6493

_tmp16_ = vala_boolean_literal_get_value (G_TYPE_CHECK_INSTANCE_CAST (_tmp15_, VALA_TYPE_BOOLEAN_LITERAL, ValaBooleanLiteral));

6494

_tmp17_ = _tmp16_;

6495

if (_tmp17_) {

6496

_tmp14_ = "true";

6497

} else {

6498

_tmp14_ = "false";

6499

}

6500

_tmp18_ = _tmp14_;

6501

_tmp19_ = g_strdup (_tmp18_);

6502

result = _tmp19_;

6503

return result;

6504

} else {

6505

ValaExpression* _tmp20_;

6506

_tmp20_ = literal;

6507

if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp20_, VALA_TYPE_REAL_LITERAL)) {

6508

ValaExpression* _tmp21_;

6509

const gchar* _tmp22_;

6510

const gchar* _tmp23_;

6511

gchar* _tmp24_;

6512

_tmp21_ = literal;

6513

_tmp22_ = vala_real_literal_get_value (G_TYPE_CHECK_INSTANCE_CAST (_tmp21_, VALA_TYPE_REAL_LITERAL, ValaRealLiteral));

6514

_tmp23_ = _tmp22_;

6515

_tmp24_ = g_strdup (_tmp23_);

6516

result = _tmp24_;

6517

return result;

6518

} else {

6519

ValaExpression* _tmp25_;

6520

_tmp25_ = literal;

6521

if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp25_, VALA_TYPE_INTEGER_LITERAL)) {

6522

ValaExpression* _tmp26_;

6523

const gchar* _tmp27_;

6524

const gchar* _tmp28_;

6525

gchar* _tmp29_;

6526

_tmp26_ = literal;

6527

_tmp27_ = vala_integer_literal_get_value (G_TYPE_CHECK_INSTANCE_CAST (_tmp26_, VALA_TYPE_INTEGER_LITERAL, ValaIntegerLiteral));

6528

_tmp28_ = _tmp27_;

6529

_tmp29_ = g_strdup (_tmp28_);

6530

result = _tmp29_;

6531

return result;

6532

} else {

6533

ValaExpression* _tmp30_;

6534

_tmp30_ = literal;

6535

if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp30_, VALA_TYPE_UNARY_EXPRESSION)) {

6536

ValaExpression* _tmp31_;

6537

ValaUnaryExpression* _tmp32_;

6538

ValaUnaryExpression* unary;

6539

ValaUnaryExpression* _tmp33_;

6540

ValaUnaryOperator _tmp34_;

6541

ValaUnaryOperator _tmp35_;

6542

_tmp31_ = literal;

6543

_tmp32_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp31_, VALA_TYPE_UNARY_EXPRESSION, ValaUnaryExpression));

6544

unary = _tmp32_;

6545

_tmp33_ = unary;

6546

_tmp34_ = vala_unary_expression_get_operator (_tmp33_);

6547

_tmp35_ = _tmp34_;

6548

if (_tmp35_ == VALA_UNARY_OPERATOR_MINUS) {

6549

ValaUnaryExpression* _tmp36_;

6550

ValaExpression* _tmp37_;

6551

ValaExpression* _tmp38_;

6552

_tmp36_ = unary;

6553

_tmp37_ = vala_unary_expression_get_inner (_tmp36_);

6554

_tmp38_ = _tmp37_;

6555

if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp38_, VALA_TYPE_REAL_LITERAL)) {

6556

ValaUnaryExpression* _tmp39_;

6557

ValaExpression* _tmp40_;

6558

ValaExpression* _tmp41_;

6559

const gchar* _tmp42_;

6560

const gchar* _tmp43_;

6561

gchar* _tmp44_;

6562

_tmp39_ = unary;

6563

_tmp40_ = vala_unary_expression_get_inner (_tmp39_);

6564

_tmp41_ = _tmp40_;

6565

_tmp42_ = vala_real_literal_get_value (G_TYPE_CHECK_INSTANCE_CAST (_tmp41_, VALA_TYPE_REAL_LITERAL, ValaRealLiteral));

6566

_tmp43_ = _tmp42_;

6567

_tmp44_ = g_strconcat ("-", _tmp43_, NULL);

6568

result = _tmp44_;

6569

_vala_code_node_unref0 (unary);

6570

return result;

6571

} else {

6572

ValaUnaryExpression* _tmp45_;

6573

ValaExpression* _tmp46_;

6574

ValaExpression* _tmp47_;

6575

_tmp45_ = unary;

6576

_tmp46_ = vala_unary_expression_get_inner (_tmp45_);

6577

_tmp47_ = _tmp46_;

6578

if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp47_, VALA_TYPE_INTEGER_LITERAL)) {

6579

ValaUnaryExpression* _tmp48_;

6580

ValaExpression* _tmp49_;

6581

ValaExpression* _tmp50_;

6582

const gchar* _tmp51_;

6583

const gchar* _tmp52_;

6584

gchar* _tmp53_;

6585

_tmp48_ = unary;

6586

_tmp49_ = vala_unary_expression_get_inner (_tmp48_);

6587

_tmp50_ = _tmp49_;

6588

_tmp51_ = vala_integer_literal_get_value (G_TYPE_CHECK_INSTANCE_CAST (_tmp50_, VALA_TYPE_INTEGER_LITERAL, ValaIntegerLiteral));

6589

_tmp52_ = _tmp51_;

6590

_tmp53_ = g_strconcat ("-", _tmp52_, NULL);

6591

result = _tmp53_;

6592

_vala_code_node_unref0 (unary);

6593

return result;

6594

}

6595

}

6596

}

6597

_vala_code_node_unref0 (unary);

6598

}

6599

}

6600

}

6601

}

6602

}

6603

}

6604

result = NULL;

6605

return result;

6606

}

6607

6608

6609

static gchar* vala_gir_writer_camel_case_to_canonical (ValaGIRWriter* self, const gchar* name) {

6610

gchar* result = NULL;

6611

const gchar* _tmp0_;

6612

gchar* _tmp1_ = NULL;

6613

gchar* _tmp2_;

6614

gchar** _tmp3_;

6615

gchar** _tmp4_ = NULL;

6616

gchar** _tmp5_;

6617

gint _tmp5__length1;

6618

gchar** parts;

6619

gint parts_length1;

6620

gint _parts_size_;

6621

gchar* _tmp6_ = NULL;

6622

g_return_val_if_fail (self != NULL, NULL);

6623

g_return_val_if_fail (name != NULL, NULL);

6624

_tmp0_ = name;

6625

_tmp1_ = vala_symbol_camel_case_to_lower_case (_tmp0_);

6626

_tmp2_ = _tmp1_;

6627

_tmp4_ = _tmp3_ = g_strsplit (_tmp2_, "_", 0);

6628

_tmp5_ = _tmp4_;

6629

_tmp5__length1 = _vala_array_length (_tmp3_);

6630

_g_free0 (_tmp2_);

6631

parts = _tmp5_;

6632

parts_length1 = _tmp5__length1;

6633

_parts_size_ = parts_length1;

6634

_tmp6_ = g_strjoinv ("-", parts);

6635

result = _tmp6_;

6636

parts = (_vala_array_free (parts, parts_length1, (GDestroyNotify) g_free), NULL);

6637

return result;

6638

}

6639

6640

6641

static gboolean vala_gir_writer_check_accessibility (ValaGIRWriter* self, ValaSymbol* sym) {

6642

gboolean result = FALSE;

6643

gboolean _tmp0_ = FALSE;

6644

ValaSymbol* _tmp1_;

6645

ValaSymbolAccessibility _tmp2_;

6646

ValaSymbolAccessibility _tmp3_;

6647

gboolean _tmp7_;

6648

g_return_val_if_fail (self != NULL, FALSE);

6649

g_return_val_if_fail (sym != NULL, FALSE);

6650

_tmp1_ = sym;

6651

_tmp2_ = vala_symbol_get_access (_tmp1_);

6652

_tmp3_ = _tmp2_;

6653

if (_tmp3_ == VALA_SYMBOL_ACCESSIBILITY_PUBLIC) {

6654

_tmp0_ = TRUE;

6655

} else {

6656

ValaSymbol* _tmp4_;

6657

ValaSymbolAccessibility _tmp5_;

6658

ValaSymbolAccessibility _tmp6_;

6659

_tmp4_ = sym;

6660

_tmp5_ = vala_symbol_get_access (_tmp4_);

6661

_tmp6_ = _tmp5_;

6662

_tmp0_ = _tmp6_ == VALA_SYMBOL_ACCESSIBILITY_PROTECTED;

6663

}

6664

_tmp7_ = _tmp0_;

6665

if (_tmp7_) {

6666

result = TRUE;

6667

return result;

6668

}

6669

result = FALSE;

6670

return result;

6671

}

6672

6673

6674

ValaGIRWriter* vala_gir_writer_construct (GType object_type) {

6675

ValaGIRWriter* self = NULL;

6676

self = (ValaGIRWriter*) vala_code_visitor_construct (object_type);

6677

return self;

6678

}

6679

6680

6681

ValaGIRWriter* vala_gir_writer_new (void) {

6682

return vala_gir_writer_construct (VALA_TYPE_GIR_WRITER);

6683

}

6684

6685

6686

static void vala_gir_writer_gir_namespace_init (ValaGIRWriterGIRNamespace *self, const gchar* ns, const gchar* version) {

6687

const gchar* _tmp0_;

6688

gchar* _tmp1_;

6689

const gchar* _tmp2_;

6690

gchar* _tmp3_;

6691

g_return_if_fail (ns != NULL);

6692

g_return_if_fail (version != NULL);

6693

memset (self, 0, sizeof (ValaGIRWriterGIRNamespace));

6694

_tmp0_ = ns;

6695

_tmp1_ = g_strdup (_tmp0_);

6696

_g_free0 ((*self).ns);

6697

(*self).ns = _tmp1_;

6698

_tmp2_ = version;

6699

_tmp3_ = g_strdup (_tmp2_);

6700

_g_free0 ((*self).version);

6701

(*self).version = _tmp3_;

6702

}

6703

6704

6705

static gboolean vala_gir_writer_gir_namespace_equal (ValaGIRWriterGIRNamespace *self, ValaGIRWriterGIRNamespace* g) {

6706

gboolean result = FALSE;

6707

gboolean _tmp0_ = FALSE;

6708

const gchar* _tmp1_;

6709

ValaGIRWriterGIRNamespace _tmp2_;

6710

const gchar* _tmp3_;

6711

gboolean _tmp7_;

6712

g_return_val_if_fail (g != NULL, FALSE);

6713

_tmp1_ = (*self).ns;

6714

_tmp2_ = *g;

6715

_tmp3_ = _tmp2_.ns;

6716

if (g_strcmp0 (_tmp1_, _tmp3_) == 0) {

6717

const gchar* _tmp4_;

6718

ValaGIRWriterGIRNamespace _tmp5_;

6719

const gchar* _tmp6_;

6720

_tmp4_ = (*self).version;

6721

_tmp5_ = *g;

6722

_tmp6_ = _tmp5_.version;

6723

_tmp0_ = g_strcmp0 (_tmp4_, _tmp6_) == 0;

6724

} else {

6725

_tmp0_ = FALSE;

6726

}

6727

_tmp7_ = _tmp0_;

6728

result = _tmp7_;

6729

return result;

6730

}

6731

6732

6733

static void vala_gir_writer_gir_namespace_copy (const ValaGIRWriterGIRNamespace* self, ValaGIRWriterGIRNamespace* dest) {

6734

const gchar* _tmp0_;

6735

gchar* _tmp1_;

6736

const gchar* _tmp2_;

6737

gchar* _tmp3_;

6738

_tmp0_ = (*self).ns;

6739

_tmp1_ = g_strdup (_tmp0_);

6740

_g_free0 ((*dest).ns);

6741

(*dest).ns = _tmp1_;

6742

_tmp2_ = (*self).version;

6743

_tmp3_ = g_strdup (_tmp2_);

6744

_g_free0 ((*dest).version);

6745

(*dest).version = _tmp3_;

6746

}

6747

6748

6749

static void vala_gir_writer_gir_namespace_destroy (ValaGIRWriterGIRNamespace* self) {

6750

_g_free0 ((*self).ns);

6751

_g_free0 ((*self).version);

6752

}

6753

6754

6755

static ValaGIRWriterGIRNamespace* vala_gir_writer_gir_namespace_dup (const ValaGIRWriterGIRNamespace* self) {

6756

ValaGIRWriterGIRNamespace* dup;

6757

dup = g_new0 (ValaGIRWriterGIRNamespace, 1);

6758

vala_gir_writer_gir_namespace_copy (self, dup);

6759

return dup;

6760

}

6761

6762

6763

static void vala_gir_writer_gir_namespace_free (ValaGIRWriterGIRNamespace* self) {

6764

vala_gir_writer_gir_namespace_destroy (self);

6765

g_free (self);

6766

}

6767

6768

6769

static GType vala_gir_writer_gir_namespace_get_type (void) {

6770

static volatile gsize vala_gir_writer_gir_namespace_type_id__volatile = 0;

6771

if (g_once_init_enter (&vala_gir_writer_gir_namespace_type_id__volatile)) {

6772

GType vala_gir_writer_gir_namespace_type_id;

6773

vala_gir_writer_gir_namespace_type_id = g_boxed_type_register_static ("ValaGIRWriterGIRNamespace", (GBoxedCopyFunc) vala_gir_writer_gir_namespace_dup, (GBoxedFreeFunc) vala_gir_writer_gir_namespace_free);

6774

g_once_init_leave (&vala_gir_writer_gir_namespace_type_id__volatile, vala_gir_writer_gir_namespace_type_id);

6775

}

6776

return vala_gir_writer_gir_namespace_type_id__volatile;

6777

}

6778

6779

6780

static void vala_gir_writer_class_init (ValaGIRWriterClass * klass) {

6781

vala_gir_writer_parent_class = g_type_class_peek_parent (klass);

6782

VALA_CODE_VISITOR_CLASS (klass)->finalize = vala_gir_writer_finalize;

6783

g_type_class_add_private (klass, sizeof (ValaGIRWriterPrivate));

6784

VALA_GIR_WRITER_CLASS (klass)->get_interface_comment = vala_gir_writer_real_get_interface_comment;

6785

VALA_GIR_WRITER_CLASS (klass)->get_struct_comment = vala_gir_writer_real_get_struct_comment;

6786

VALA_GIR_WRITER_CLASS (klass)->get_enum_comment = vala_gir_writer_real_get_enum_comment;

6787

VALA_GIR_WRITER_CLASS (klass)->get_class_comment = vala_gir_writer_real_get_class_comment;

6788

VALA_GIR_WRITER_CLASS (klass)->get_error_code_comment = vala_gir_writer_real_get_error_code_comment;

6789

VALA_GIR_WRITER_CLASS (klass)->get_enum_value_comment = vala_gir_writer_real_get_enum_value_comment;

6790

VALA_GIR_WRITER_CLASS (klass)->get_constant_comment = vala_gir_writer_real_get_constant_comment;

6791

VALA_GIR_WRITER_CLASS (klass)->get_error_domain_comment = vala_gir_writer_real_get_error_domain_comment;

6792

VALA_GIR_WRITER_CLASS (klass)->get_field_comment = vala_gir_writer_real_get_field_comment;

6793

VALA_GIR_WRITER_CLASS (klass)->get_delegate_comment = vala_gir_writer_real_get_delegate_comment;

6794

VALA_GIR_WRITER_CLASS (klass)->get_method_comment = vala_gir_writer_real_get_method_comment;

6795

VALA_GIR_WRITER_CLASS (klass)->get_property_comment = vala_gir_writer_real_get_property_comment;

6796

VALA_GIR_WRITER_CLASS (klass)->get_delegate_return_comment = vala_gir_writer_real_get_delegate_return_comment;

6797

VALA_GIR_WRITER_CLASS (klass)->get_signal_return_comment = vala_gir_writer_real_get_signal_return_comment;

6798

VALA_GIR_WRITER_CLASS (klass)->get_method_return_comment = vala_gir_writer_real_get_method_return_comment;

6799

VALA_GIR_WRITER_CLASS (klass)->get_signal_comment = vala_gir_writer_real_get_signal_comment;

6800

VALA_GIR_WRITER_CLASS (klass)->get_parameter_comment = vala_gir_writer_real_get_parameter_comment;

6801

VALA_CODE_VISITOR_CLASS (klass)->visit_namespace = vala_gir_writer_real_visit_namespace;

6802

VALA_CODE_VISITOR_CLASS (klass)->visit_class = vala_gir_writer_real_visit_class;

6803

VALA_CODE_VISITOR_CLASS (klass)->visit_struct = vala_gir_writer_real_visit_struct;

6804

VALA_CODE_VISITOR_CLASS (klass)->visit_interface = vala_gir_writer_real_visit_interface;

6805

VALA_CODE_VISITOR_CLASS (klass)->visit_enum = vala_gir_writer_real_visit_enum;

6806

VALA_CODE_VISITOR_CLASS (klass)->visit_enum_value = vala_gir_writer_real_visit_enum_value;

6807

VALA_CODE_VISITOR_CLASS (klass)->visit_error_domain = vala_gir_writer_real_visit_error_domain;

6808

VALA_CODE_VISITOR_CLASS (klass)->visit_error_code = vala_gir_writer_real_visit_error_code;

6809

VALA_CODE_VISITOR_CLASS (klass)->visit_constant = vala_gir_writer_real_visit_constant;

6810

VALA_CODE_VISITOR_CLASS (klass)->visit_field = vala_gir_writer_real_visit_field;

6811

VALA_CODE_VISITOR_CLASS (klass)->visit_delegate = vala_gir_writer_real_visit_delegate;

6812

VALA_CODE_VISITOR_CLASS (klass)->visit_method = vala_gir_writer_real_visit_method;

6813

VALA_CODE_VISITOR_CLASS (klass)->visit_creation_method = vala_gir_writer_real_visit_creation_method;

6814

VALA_CODE_VISITOR_CLASS (klass)->visit_property = vala_gir_writer_real_visit_property;

6815

VALA_CODE_VISITOR_CLASS (klass)->visit_signal = vala_gir_writer_real_visit_signal;

6816

}

6817

6818

6819

static void vala_gir_writer_instance_init (ValaGIRWriter * self) {

6820

GString* _tmp0_;

6821

GHashFunc _tmp1_;

6822

GEqualFunc _tmp2_;

6823

ValaHashSet* _tmp3_;

6824

GHashFunc _tmp4_;

6825

GEqualFunc _tmp5_;

6826

ValaHashSet* _tmp6_;

6827

GEqualFunc _tmp7_;

6828

ValaArrayList* _tmp8_;

6829

GEqualFunc _tmp9_;

6830

ValaArrayList* _tmp10_;

6831

ValaArrayList* _tmp11_;

6832

self->priv = VALA_GIR_WRITER_GET_PRIVATE (self);

6833

_tmp0_ = g_string_new ("");

6834

self->priv->buffer = _tmp0_;

6835

_tmp1_ = g_direct_hash;

6836

_tmp2_ = g_direct_equal;

6837

_tmp3_ = vala_hash_set_new (VALA_TYPE_NAMESPACE, (GBoxedCopyFunc) vala_code_node_ref, vala_code_node_unref, _tmp1_, _tmp2_);

6838

self->priv->unannotated_namespaces = _tmp3_;

6839

_tmp4_ = g_direct_hash;

6840

_tmp5_ = g_direct_equal;

6841

_tmp6_ = vala_hash_set_new (VALA_TYPE_NAMESPACE, (GBoxedCopyFunc) vala_code_node_ref, vala_code_node_unref, _tmp4_, _tmp5_);

6842

self->priv->our_namespaces = _tmp6_;

6843

_tmp7_ = g_direct_equal;

6844

_tmp8_ = vala_array_list_new (VALA_TYPE_SYMBOL, (GBoxedCopyFunc) vala_code_node_ref, vala_code_node_unref, _tmp7_);

6845

self->priv->hierarchy = _tmp8_;

6846

_tmp9_ = g_direct_equal;

6847

_tmp10_ = vala_array_list_new (VALA_TYPE_CODE_NODE, (GBoxedCopyFunc) vala_code_node_ref, vala_code_node_unref, _tmp9_);

6848

self->priv->deferred = _tmp10_;

6849

_tmp11_ = vala_array_list_new (VALA_GIR_WRITER_TYPE_GIR_NAMESPACE, (GBoxedCopyFunc) vala_gir_writer_gir_namespace_dup, vala_gir_writer_gir_namespace_free, (GEqualFunc) vala_gir_writer_gir_namespace_equal);

6850

self->priv->externals = _tmp11_;

6851

}

6852

6853

6854

static void vala_gir_writer_finalize (ValaCodeVisitor* obj) {

6855

ValaGIRWriter * self;

6856

self = G_TYPE_CHECK_INSTANCE_CAST (obj, VALA_TYPE_GIR_WRITER, ValaGIRWriter);

6857

_vala_code_context_unref0 (self->priv->context);

6858

_g_free0 (self->priv->directory);

6859

_g_free0 (self->priv->gir_namespace);

6860

_g_free0 (self->priv->gir_version);

6861

_g_string_free0 (self->priv->buffer);

6862

_fclose0 (self->priv->stream);

6863

_vala_iterable_unref0 (self->priv->unannotated_namespaces);

6864

_vala_iterable_unref0 (self->priv->our_namespaces);

6865

_vala_iterable_unref0 (self->priv->hierarchy);

6866

_vala_iterable_unref0 (self->priv->deferred);

6867

_vala_code_node_unref0 (self->priv->gobject_type);

6868

_vala_code_node_unref0 (self->priv->ginitiallyunowned_type);

6869

_vala_iterable_unref0 (self->priv->externals);

6870

VALA_CODE_VISITOR_CLASS (vala_gir_writer_parent_class)->finalize (obj);

6871

}

6872

6873

6874

/**

6875

* Code visitor generating .gir file for the public interface.

6876

6877

GType vala_gir_writer_get_type (void) {

6878

static volatile gsize vala_gir_writer_type_id__volatile = 0;

6879

if (g_once_init_enter (&vala_gir_writer_type_id__volatile)) {

6880

static const GTypeInfo g_define_type_info = { sizeof (ValaGIRWriterClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) vala_gir_writer_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ValaGIRWriter), 0, (GInstanceInitFunc) vala_gir_writer_instance_init, NULL };

6881

GType vala_gir_writer_type_id;

6882

vala_gir_writer_type_id = g_type_register_static (VALA_TYPE_CODE_VISITOR, "ValaGIRWriter", &g_define_type_info, 0);

6883

g_once_init_leave (&vala_gir_writer_type_id__volatile, vala_gir_writer_type_id);

6884

}

6885

return vala_gir_writer_type_id__volatile;

6886

}

6887

6888

6889

static void _vala_array_destroy (gpointer array, gint array_length, GDestroyNotify destroy_func) {

6890

if ((array != NULL) && (destroy_func != NULL)) {

6891

int i;

6892

for (i = 0; i < array_length; i = i + 1) {

6893

if (((gpointer*) array)[i] != NULL) {

6894

destroy_func (((gpointer*) array)[i]);

6895

}

6896

}

6897

}

6898

}

6899

6900

6901

static void _vala_array_free (gpointer array, gint array_length, GDestroyNotify destroy_func) {

6902

_vala_array_destroy (array, array_length, destroy_func);

6903

g_free (array);

6904

}

6905

6906

6907

static gint _vala_array_length (gpointer array) {

6908

int length;

6909

length = 0;

6910

if (array) {

6911

while (((gpointer*) array)[length]) {

6912

length++;

6913

}

6914

}

6915

return length;

6916

}

6917

6918

6919

Older »