~ubuntu-branches/ubuntu/trusty/monodevelop/trusty-proposed

if (!string.IsNullOrEmpty(attributeSection.AttributeTarget) && !string.Equals(attributeSection.AttributeTarget, "return", StringComparison.OrdinalIgnoreCase)) {

185

outputFormatter.PrintText(char.ToUpperInvariant(attributeSection.AttributeTarget[0]) + attributeSection.AttributeTarget.Substring(1));

186

outputFormatter.PrintToken(Tokens.Colon);

187

outputFormatter.Space();

188

}

189

Debug.Assert(attributeSection.Attributes != null);

190

AppendCommaSeparatedList(attributeSection.Attributes);

191

192

outputFormatter.PrintText(">");

193

194

if ("assembly".Equals(attributeSection.AttributeTarget, StringComparison.InvariantCultureIgnoreCase)

195

|| "module".Equals(attributeSection.AttributeTarget, StringComparison.InvariantCultureIgnoreCase)) {

196

outputFormatter.NewLine();

197

} else {

198

if (printAttributeSectionInline)

199

outputFormatter.Space();

200

else

201

outputFormatter.PrintLineContinuation();

202

}

203

204

return null;

205

}

206

207

public override object TrackedVisitAttribute(ICSharpCode.OldNRefactory.Ast.Attribute attribute, object data)

208

{

209

outputFormatter.PrintIdentifier(attribute.Name);

210

if (attribute.PositionalArguments.Count > 0 || attribute.NamedArguments.Count > 0) {

211

outputFormatter.PrintToken(Tokens.OpenParenthesis);

212

AppendCommaSeparatedList(attribute.PositionalArguments);

213

214

if (attribute.NamedArguments.Count > 0) {

215

if (attribute.PositionalArguments.Count > 0) {

216

outputFormatter.PrintToken(Tokens.Comma);

217

outputFormatter.Space();

218

}

219

AppendCommaSeparatedList(attribute.NamedArguments);

220

}

221

outputFormatter.PrintToken(Tokens.CloseParenthesis);

222

}

223

return null;

224

}

225

226

public override object TrackedVisitNamedArgumentExpression(NamedArgumentExpression namedArgumentExpression, object data)

227

{

228

outputFormatter.PrintIdentifier(namedArgumentExpression.Name);

229

outputFormatter.Space();

230

outputFormatter.PrintToken(Tokens.Colon);

231

outputFormatter.PrintToken(Tokens.Assign);

232

outputFormatter.Space();

233

TrackedVisit(namedArgumentExpression.Expression, data);

234

return null;

235

}

236

237

public override object TrackedVisitUsing(Using @using, object data)

238

{

239

Debug.Fail("Should never be called. The usings should be handled in Visit(UsingDeclaration)");

240

return null;

241

}

242

243

public override object TrackedVisitUsingDeclaration(UsingDeclaration usingDeclaration, object data)

244

{

245

outputFormatter.Indent();

246

outputFormatter.PrintToken(Tokens.Imports);

247

outputFormatter.Space();

248

for (int i = 0; i < usingDeclaration.Usings.Count; ++i) {

249

outputFormatter.PrintIdentifier(((Using)usingDeclaration.Usings[i]).Name);

250

if (((Using)usingDeclaration.Usings[i]).IsAlias) {

251

outputFormatter.Space();

252

outputFormatter.PrintToken(Tokens.Assign);

253

outputFormatter.Space();

254

TrackedVisit(((Using)usingDeclaration.Usings[i]).Alias, data);

255

}

256

if (i + 1 < usingDeclaration.Usings.Count) {

257

outputFormatter.PrintToken(Tokens.Comma);

258

outputFormatter.Space();

259

}

260

}

261

outputFormatter.NewLine();

262

return null;

263

}

264

265

public override object TrackedVisitNamespaceDeclaration(NamespaceDeclaration namespaceDeclaration, object data)

266

{

267

outputFormatter.Indent();

268

outputFormatter.PrintToken(Tokens.Namespace);

269

outputFormatter.Space();

270

outputFormatter.PrintIdentifier(namespaceDeclaration.Name);

271

outputFormatter.NewLine();

272

273

++outputFormatter.IndentationLevel;

274

namespaceDeclaration.AcceptChildren(this, data);

275

--outputFormatter.IndentationLevel;

276

277

outputFormatter.Indent();

278

outputFormatter.PrintToken(Tokens.End);

279

outputFormatter.Space();

280

outputFormatter.PrintToken(Tokens.Namespace);

281

outputFormatter.NewLine();

282

return null;

283

}

284

285

static int GetTypeToken(TypeDeclaration typeDeclaration)

286

{

287

switch (typeDeclaration.Type) {

288

case ClassType.Class:

289

return Tokens.Class;

290

case ClassType.Enum:

291

return Tokens.Enum;

292

case ClassType.Interface:

293

return Tokens.Interface;

294

case ClassType.Struct:

295

return Tokens.Structure;

296

default:

297

return Tokens.Class;

298

}

299

}

300

301

void PrintTemplates(List<TemplateDefinition> templates)

302

{

303

if (templates != null && templates.Count > 0) {

304

outputFormatter.PrintToken(Tokens.OpenParenthesis);

305

outputFormatter.PrintToken(Tokens.Of);

306

outputFormatter.Space();

307

AppendCommaSeparatedList(templates);

308

outputFormatter.PrintToken(Tokens.CloseParenthesis);

309

}

310

}

311

312

public override object TrackedVisitTypeDeclaration(TypeDeclaration typeDeclaration, object data)

313

{

314

VisitAttributes(typeDeclaration.Attributes, data);

315

316

outputFormatter.Indent();

317

OutputModifier(typeDeclaration.Modifier, true);

318

319

int typeToken = GetTypeToken(typeDeclaration);

320

outputFormatter.PrintToken(typeToken);

321

outputFormatter.Space();

322

outputFormatter.PrintIdentifier(typeDeclaration.Name);

323

324

PrintTemplates(typeDeclaration.Templates);

325

326

if (typeDeclaration.Type == ClassType.Enum

327

&& typeDeclaration.BaseTypes != null && typeDeclaration.BaseTypes.Count > 0)

328

{

329

outputFormatter.Space();

330

outputFormatter.PrintToken(Tokens.As);

331

outputFormatter.Space();

332

foreach (TypeReference baseTypeRef in typeDeclaration.BaseTypes) {

333

TrackedVisit(baseTypeRef, data);

334

}

335

}

336

337

outputFormatter.NewLine();

338

++outputFormatter.IndentationLevel;

339

340

if (typeDeclaration.BaseTypes != null && typeDeclaration.Type != ClassType.Enum) {

341

foreach (TypeReference baseTypeRef in typeDeclaration.BaseTypes) {

342

outputFormatter.Indent();

343

344

string baseType = baseTypeRef.Type;

345

if (baseType.IndexOf('.') >= 0) {

346

baseType = baseType.Substring(baseType.LastIndexOf('.') + 1);

347

}

348

bool baseTypeIsInterface = baseType.Length >= 2 && baseType[0] == 'I' && Char.IsUpper(baseType[1]);

349

350

if (!baseTypeIsInterface || typeDeclaration.Type == ClassType.Interface) {

351

outputFormatter.PrintToken(Tokens.Inherits);

352

} else {

353

outputFormatter.PrintToken(Tokens.Implements);

354

}

355

outputFormatter.Space();

356

TrackedVisit(baseTypeRef, data);

357

outputFormatter.NewLine();

358

}

359

}

360

361

TypeDeclaration oldType = currentType;

362

currentType = typeDeclaration;

363

364

if (typeDeclaration.Type == ClassType.Enum) {

365

OutputEnumMembers(typeDeclaration, data);

366

} else {

367

typeDeclaration.AcceptChildren(this, data);

368

}

369

currentType = oldType;

370

371

--outputFormatter.IndentationLevel;

372

373

374

outputFormatter.Indent();

375

outputFormatter.PrintToken(Tokens.End);

376

outputFormatter.Space();

377

outputFormatter.PrintToken(typeToken);

378

outputFormatter.NewLine();

379

return null;

380

}

381

382

void OutputEnumMembers(TypeDeclaration typeDeclaration, object data)

383

{

384

foreach (FieldDeclaration fieldDeclaration in typeDeclaration.Children) {

385

BeginVisit(fieldDeclaration);

386

VariableDeclaration f = (VariableDeclaration)fieldDeclaration.Fields[0];

387

VisitAttributes(fieldDeclaration.Attributes, data);

388

outputFormatter.Indent();

389

outputFormatter.PrintIdentifier(f.Name);

390

if (f.Initializer != null && !f.Initializer.IsNull) {

391

outputFormatter.Space();

392

outputFormatter.PrintToken(Tokens.Assign);

393

outputFormatter.Space();

394

TrackedVisit(f.Initializer, data);

395

}

396

outputFormatter.NewLine();

397

EndVisit(fieldDeclaration);

398

}

399

}

400

401

public override object TrackedVisitTemplateDefinition(TemplateDefinition templateDefinition, object data)

402

{

403

VisitAttributes(templateDefinition.Attributes, data);

404

outputFormatter.PrintIdentifier(templateDefinition.Name);

405

if (templateDefinition.Bases.Count > 0) {

406

outputFormatter.PrintText(" As ");

407

VisitReturnTypeAttributes(templateDefinition.Attributes, data);

408

if (templateDefinition.Bases.Count == 1) {

409

TrackedVisit(templateDefinition.Bases[0], data);

410

} else {

411

outputFormatter.PrintToken(Tokens.OpenCurlyBrace);

412

AppendCommaSeparatedList(templateDefinition.Bases);

413

outputFormatter.PrintToken(Tokens.CloseCurlyBrace);

414

}

415

}

416

return null;

417

}

418

419

public override object TrackedVisitDelegateDeclaration(DelegateDeclaration delegateDeclaration, object data)

420

{

421

VisitAttributes(delegateDeclaration.Attributes, data);

422

423

outputFormatter.Indent();

424

OutputModifier(delegateDeclaration.Modifier, true);

425

outputFormatter.PrintToken(Tokens.Delegate);

426

outputFormatter.Space();

427

428

bool isFunction = (delegateDeclaration.ReturnType.Type != "System.Void");

429

if (isFunction) {

430

outputFormatter.PrintToken(Tokens.Function);

431

outputFormatter.Space();

432

} else {

433

outputFormatter.PrintToken(Tokens.Sub);

434

outputFormatter.Space();

435

}

436

outputFormatter.PrintIdentifier(delegateDeclaration.Name);

437

438

PrintTemplates(delegateDeclaration.Templates);

439

440

outputFormatter.PrintToken(Tokens.OpenParenthesis);

441

AppendCommaSeparatedList(delegateDeclaration.Parameters);

442

outputFormatter.PrintToken(Tokens.CloseParenthesis);

443

444

if (isFunction) {

445

outputFormatter.Space();

446

outputFormatter.PrintToken(Tokens.As);

447

outputFormatter.Space();

448

VisitReturnTypeAttributes(delegateDeclaration.Attributes, data);

449

TrackedVisit(delegateDeclaration.ReturnType, data);

450

}

451

outputFormatter.NewLine();

452

return null;

453

}

454

455

public override object TrackedVisitOptionDeclaration(OptionDeclaration optionDeclaration, object data)

456

{

457

outputFormatter.PrintToken(Tokens.Option);

458

outputFormatter.Space();

459

switch (optionDeclaration.OptionType) {

460

case OptionType.Strict:

461

outputFormatter.PrintToken(Tokens.Strict);

462

if (!optionDeclaration.OptionValue) {

463

outputFormatter.Space();

464

outputFormatter.PrintToken(Tokens.Off);

465

}

466

break;

467

case OptionType.Explicit:

468

outputFormatter.PrintToken(Tokens.Explicit);

469

outputFormatter.Space();

470

if (!optionDeclaration.OptionValue) {

471

outputFormatter.Space();

472

outputFormatter.PrintToken(Tokens.Off);

473

}

474

break;

475

case OptionType.CompareBinary:

476

outputFormatter.PrintToken(Tokens.Compare);

477

outputFormatter.Space();

478

outputFormatter.PrintToken(Tokens.Binary);

479

break;

480

case OptionType.CompareText:

481

outputFormatter.PrintToken(Tokens.Compare);

482

outputFormatter.Space();

483

outputFormatter.PrintToken(Tokens.Text);

484

break;

485

}

486

outputFormatter.NewLine();

487

return null;

488

}

489

#endregion

490

491

#region Type level

492

TypeReference currentVariableType;

493

public override object TrackedVisitFieldDeclaration(FieldDeclaration fieldDeclaration, object data)

494

{

495

496

VisitAttributes(fieldDeclaration.Attributes, data);

497

outputFormatter.Indent();

498

if (fieldDeclaration.Modifier == Modifiers.None) {

499

outputFormatter.PrintToken(Tokens.Private);

500

outputFormatter.Space();

501

} else if (fieldDeclaration.Modifier == Modifiers.Dim) {

502

outputFormatter.PrintToken(Tokens.Dim);

503

outputFormatter.Space();

504

} else {

505

OutputModifier(fieldDeclaration.Modifier);

506

}

507

currentVariableType = fieldDeclaration.TypeReference;

508

AppendCommaSeparatedList(fieldDeclaration.Fields);

509

currentVariableType = null;

510

511

outputFormatter.NewLine();

512

513

return null;

514

}

515

516

public override object TrackedVisitVariableDeclaration(VariableDeclaration variableDeclaration, object data)

517

{

518

outputFormatter.PrintIdentifier(variableDeclaration.Name);

519

520

TypeReference varType = currentVariableType;

521

if (varType != null && varType.IsNull)

522

varType = null;

523

if (varType == null && !variableDeclaration.TypeReference.IsNull)

524

varType = variableDeclaration.TypeReference;

525

526

if (varType != null) {

527

outputFormatter.Space();

528

outputFormatter.PrintToken(Tokens.As);

529

outputFormatter.Space();

530

ObjectCreateExpression init = variableDeclaration.Initializer as ObjectCreateExpression;

531

if (init != null && TypeReference.AreEqualReferences(init.CreateType, varType)) {

532

TrackedVisit(variableDeclaration.Initializer, data);

533

return null;

534

} else {

535

TrackedVisit(varType, data);

536

}

537

}

538

539

if (!variableDeclaration.Initializer.IsNull) {

540

outputFormatter.Space();

541

outputFormatter.PrintToken(Tokens.Assign);

542

outputFormatter.Space();

543

TrackedVisit(variableDeclaration.Initializer, data);

544

}

545

return null;

546

}

547

548

public override object TrackedVisitPropertyDeclaration(PropertyDeclaration propertyDeclaration, object data)

549

{

550

VisitAttributes(propertyDeclaration.Attributes, data);

551

outputFormatter.Indent();

552

OutputModifier(propertyDeclaration.Modifier);

553

554

if ((propertyDeclaration.Modifier & (Modifiers.ReadOnly | Modifiers.WriteOnly)) == Modifiers.None) {

555

if (propertyDeclaration.IsReadOnly) {

556

outputFormatter.PrintToken(Tokens.ReadOnly);

557

outputFormatter.Space();

558

} else if (propertyDeclaration.IsWriteOnly) {

559

outputFormatter.PrintToken(Tokens.WriteOnly);

560

outputFormatter.Space();

561

}

562

}

563

564

outputFormatter.PrintToken(Tokens.Property);

565

outputFormatter.Space();

566

outputFormatter.PrintIdentifier(propertyDeclaration.Name);

567

568

outputFormatter.PrintToken(Tokens.OpenParenthesis);

569

AppendCommaSeparatedList(propertyDeclaration.Parameters);

570

outputFormatter.PrintToken(Tokens.CloseParenthesis);

571

outputFormatter.Space();

572

outputFormatter.PrintToken(Tokens.As);

573

outputFormatter.Space();

574

VisitReturnTypeAttributes(propertyDeclaration.Attributes, data);

575

TrackedVisit(propertyDeclaration.TypeReference, data);

576

577

PrintInterfaceImplementations(propertyDeclaration.InterfaceImplementations);

578

579

outputFormatter.NewLine();

580

581

if (!IsAbstract(propertyDeclaration)) {

582

outputFormatter.IsInMemberBody = true;

583

++outputFormatter.IndentationLevel;

584

exitTokenStack.Push(Tokens.Property);

585

TrackedVisit(propertyDeclaration.GetRegion, data);

586

TrackedVisit(propertyDeclaration.SetRegion, data);

587

exitTokenStack.Pop();

588

--outputFormatter.IndentationLevel;

589

outputFormatter.IsInMemberBody = false;

590

591

outputFormatter.Indent();

592

outputFormatter.PrintToken(Tokens.End);

593

outputFormatter.Space();

594

outputFormatter.PrintToken(Tokens.Property);

595

outputFormatter.NewLine();

596

}

597

598

return null;

599

}

600

601

public override object TrackedVisitPropertyGetRegion(PropertyGetRegion propertyGetRegion, object data)

602

{

603

VisitAttributes(propertyGetRegion.Attributes, data);

604

outputFormatter.Indent();

605

OutputModifier(propertyGetRegion.Modifier);

606

outputFormatter.PrintToken(Tokens.Get);

607

outputFormatter.NewLine();

608

609

++outputFormatter.IndentationLevel;

610

TrackedVisit(propertyGetRegion.Block, data);

611

--outputFormatter.IndentationLevel;

612

outputFormatter.Indent();

613

outputFormatter.PrintToken(Tokens.End);

614

outputFormatter.Space();

615

outputFormatter.PrintToken(Tokens.Get);

616

outputFormatter.NewLine();

617

return null;

618

}

619

620

public override object TrackedVisitPropertySetRegion(PropertySetRegion propertySetRegion, object data)

621

{

622

VisitAttributes(propertySetRegion.Attributes, data);

623

outputFormatter.Indent();

624

OutputModifier(propertySetRegion.Modifier);

625

outputFormatter.PrintToken(Tokens.Set);

626

outputFormatter.NewLine();

627

628

++outputFormatter.IndentationLevel;

629

TrackedVisit(propertySetRegion.Block, data);

630

--outputFormatter.IndentationLevel;

631

outputFormatter.Indent();

632

outputFormatter.PrintToken(Tokens.End);

633

outputFormatter.Space();

634

outputFormatter.PrintToken(Tokens.Set);

635

outputFormatter.NewLine();

636

return null;

637

}

638

639

TypeReference currentEventType = null;

640

public override object TrackedVisitEventDeclaration(EventDeclaration eventDeclaration, object data)

641

{

642

bool customEvent = eventDeclaration.HasAddRegion || eventDeclaration.HasRemoveRegion;

643

644

VisitAttributes(eventDeclaration.Attributes, data);

645

outputFormatter.Indent();

646

OutputModifier(eventDeclaration.Modifier);

647

if (customEvent) {

648

outputFormatter.PrintText("Custom");

649

outputFormatter.Space();

650

}

651

652

outputFormatter.PrintToken(Tokens.Event);

653

outputFormatter.Space();

654

outputFormatter.PrintIdentifier(eventDeclaration.Name);

655

656

if (eventDeclaration.Parameters.Count > 0) {

657

outputFormatter.PrintToken(Tokens.OpenParenthesis);

658

this.AppendCommaSeparatedList(eventDeclaration.Parameters);

659

outputFormatter.PrintToken(Tokens.CloseParenthesis);

660

}

661

outputFormatter.Space();

662

outputFormatter.PrintToken(Tokens.As);

663

outputFormatter.Space();

664

VisitReturnTypeAttributes(eventDeclaration.Attributes, data);

665

TrackedVisit(eventDeclaration.TypeReference, data);

666

667

PrintInterfaceImplementations(eventDeclaration.InterfaceImplementations);

668

669

if (!eventDeclaration.Initializer.IsNull) {

670

outputFormatter.Space();

671

outputFormatter.PrintToken(Tokens.Assign);

672

outputFormatter.Space();

673

TrackedVisit(eventDeclaration.Initializer, data);

674

}

675

676

outputFormatter.NewLine();

677

678

if (customEvent) {

679

++outputFormatter.IndentationLevel;

680

currentEventType = eventDeclaration.TypeReference;

681

exitTokenStack.Push(Tokens.Sub);

682

TrackedVisit(eventDeclaration.AddRegion, data);

683

TrackedVisit(eventDeclaration.RemoveRegion, data);

684

exitTokenStack.Pop();

685

--outputFormatter.IndentationLevel;

686

687

outputFormatter.Indent();

688

outputFormatter.PrintToken(Tokens.End);

689

outputFormatter.Space();

690

outputFormatter.PrintToken(Tokens.Event);

691

outputFormatter.NewLine();

692

}

693

return null;

694

}

695

696

void PrintInterfaceImplementations(IList<InterfaceImplementation> list)

697

{

698

if (list == null || list.Count == 0)

699

return;

700

outputFormatter.Space();

701

outputFormatter.PrintToken(Tokens.Implements);

702

for (int i = 0; i < list.Count; i++) {

703

if (i > 0)

704

outputFormatter.PrintToken(Tokens.Comma);

705

outputFormatter.Space();

706

TrackedVisit(list[i].InterfaceType, null);

707

outputFormatter.PrintToken(Tokens.Dot);

708

outputFormatter.PrintIdentifier(list[i].MemberName);

709

}

710

}

711

712

public override object TrackedVisitEventAddRegion(EventAddRegion eventAddRegion, object data)

713

{

714

VisitAttributes(eventAddRegion.Attributes, data);

715

outputFormatter.Indent();

716

outputFormatter.PrintText("AddHandler(");

717

if (eventAddRegion.Parameters.Count == 0) {

718

outputFormatter.PrintToken(Tokens.ByVal);

719

outputFormatter.Space();

720

outputFormatter.PrintIdentifier("value");

721

outputFormatter.Space();

722

outputFormatter.PrintToken(Tokens.As);

723

outputFormatter.Space();

724

TrackedVisit(currentEventType, data);

725

} else {

726

this.AppendCommaSeparatedList(eventAddRegion.Parameters);

727

}

728

outputFormatter.PrintToken(Tokens.CloseParenthesis);

729

outputFormatter.NewLine();

730

731

++outputFormatter.IndentationLevel;

732

TrackedVisit(eventAddRegion.Block, data);

733

--outputFormatter.IndentationLevel;

734

735

outputFormatter.Indent();

736

outputFormatter.PrintToken(Tokens.End);

737

outputFormatter.Space();

738

outputFormatter.PrintText("AddHandler");

739

outputFormatter.NewLine();

740

return null;

741

}

742

743

public override object TrackedVisitEventRemoveRegion(EventRemoveRegion eventRemoveRegion, object data)

744

{

745

VisitAttributes(eventRemoveRegion.Attributes, data);

746

outputFormatter.Indent();

747

outputFormatter.PrintText("RemoveHandler");

748

outputFormatter.PrintToken(Tokens.OpenParenthesis);

749

if (eventRemoveRegion.Parameters.Count == 0) {

750

outputFormatter.PrintToken(Tokens.ByVal);

751

outputFormatter.Space();

752

outputFormatter.PrintIdentifier("value");

753

outputFormatter.Space();

754

outputFormatter.PrintToken(Tokens.As);

755

outputFormatter.Space();

756

TrackedVisit(currentEventType, data);

757

} else {

758

this.AppendCommaSeparatedList(eventRemoveRegion.Parameters);

759

}

760

outputFormatter.PrintToken(Tokens.CloseParenthesis);

761

outputFormatter.NewLine();

762

763

++outputFormatter.IndentationLevel;

764

TrackedVisit(eventRemoveRegion.Block, data);

765

--outputFormatter.IndentationLevel;

766

767

outputFormatter.Indent();

768

outputFormatter.PrintToken(Tokens.End);

769

outputFormatter.Space();

770

outputFormatter.PrintText("RemoveHandler");

771

outputFormatter.NewLine();

772

return null;

773

}

774

775

public override object TrackedVisitEventRaiseRegion(EventRaiseRegion eventRaiseRegion, object data)

776

{

777

VisitAttributes(eventRaiseRegion.Attributes, data);

778

outputFormatter.Indent();

779

outputFormatter.PrintText("RaiseEvent");

780

outputFormatter.PrintToken(Tokens.OpenParenthesis);

781

if (eventRaiseRegion.Parameters.Count == 0) {

782

outputFormatter.PrintToken(Tokens.ByVal);

783

outputFormatter.Space();

784

outputFormatter.PrintIdentifier("value");

785

outputFormatter.Space();

786

outputFormatter.PrintToken(Tokens.As);

787

outputFormatter.Space();

788

TrackedVisit(currentEventType, data);

789

} else {

790

this.AppendCommaSeparatedList(eventRaiseRegion.Parameters);

791

}

792

outputFormatter.PrintToken(Tokens.CloseParenthesis);

793

outputFormatter.NewLine();

794

795

++outputFormatter.IndentationLevel;

796

TrackedVisit(eventRaiseRegion.Block, data);

797

--outputFormatter.IndentationLevel;

798

799

outputFormatter.Indent();

800

outputFormatter.PrintToken(Tokens.End);

801

outputFormatter.Space();

802

outputFormatter.PrintText("RaiseEvent");

803

outputFormatter.NewLine();

804

return null;

805

}

806

807

public override object TrackedVisitParameterDeclarationExpression(ParameterDeclarationExpression parameterDeclarationExpression, object data)

808

{

809

printAttributeSectionInline = true;

810

VisitAttributes(parameterDeclarationExpression.Attributes, data);

811

printAttributeSectionInline = false;

812

OutputModifier(parameterDeclarationExpression.ParamModifier, parameterDeclarationExpression.StartLocation);

813

outputFormatter.PrintIdentifier(parameterDeclarationExpression.ParameterName);

814

outputFormatter.Space();

815

outputFormatter.PrintToken(Tokens.As);

816

outputFormatter.Space();

817

VisitReturnTypeAttributes(parameterDeclarationExpression.Attributes, data);

818

TrackedVisit(parameterDeclarationExpression.TypeReference, data);

819

return null;

820

}

821

822

public override object TrackedVisitMethodDeclaration(MethodDeclaration methodDeclaration, object data)

823

{

824

VisitAttributes(methodDeclaration.Attributes, data);

825

if (methodDeclaration.IsExtensionMethod) {

826

outputFormatter.Indent();

827

outputFormatter.PrintText("<System.Runtime.CompilerServices.Extension> _");

828

outputFormatter.NewLine();

829

}

830

outputFormatter.Indent();

831

OutputModifier(methodDeclaration.Modifier);

832

833

bool isSub = methodDeclaration.TypeReference.IsNull ||

834

methodDeclaration.TypeReference.Type == "System.Void";

835

836

if (isSub) {

837

outputFormatter.PrintToken(Tokens.Sub);

838

} else {

839

outputFormatter.PrintToken(Tokens.Function);

840

}

841

outputFormatter.Space();

842

outputFormatter.PrintIdentifier(methodDeclaration.Name);

843

844

PrintTemplates(methodDeclaration.Templates);

845

846

outputFormatter.PrintToken(Tokens.OpenParenthesis);

847

AppendCommaSeparatedList(methodDeclaration.Parameters);

848

outputFormatter.PrintToken(Tokens.CloseParenthesis);

849

850

if (!isSub) {

851

outputFormatter.Space();

852

outputFormatter.PrintToken(Tokens.As);

853

outputFormatter.Space();

854

VisitReturnTypeAttributes(methodDeclaration.Attributes, data);

855

TrackedVisit(methodDeclaration.TypeReference, data);

856

}

857

858

PrintInterfaceImplementations(methodDeclaration.InterfaceImplementations);

859

860

if (methodDeclaration.HandlesClause.Count > 0) {

861

outputFormatter.Space();

862

outputFormatter.PrintToken(Tokens.Handles);

863

for (int i = 0; i < methodDeclaration.HandlesClause.Count; i++) {

864

if (i > 0)

865

outputFormatter.PrintToken(Tokens.Comma);

866

outputFormatter.Space();

867

outputFormatter.PrintText(methodDeclaration.HandlesClause[i]);

868

}

869

}

870

871

outputFormatter.NewLine();

872

873

if (!IsAbstract(methodDeclaration)) {

874

outputFormatter.IsInMemberBody = true;

875

BeginVisit(methodDeclaration.Body);

876

++outputFormatter.IndentationLevel;

877

exitTokenStack.Push(isSub ? Tokens.Sub : Tokens.Function);

878

// we're doing the tracking manually using BeginVisit/EndVisit, so call Tracked... directly

879

this.TrackedVisitBlockStatement(methodDeclaration.Body, data);

880

exitTokenStack.Pop();

881

--outputFormatter.IndentationLevel;

882

883

outputFormatter.Indent();

884

outputFormatter.PrintToken(Tokens.End);

885

outputFormatter.Space();

886

if (isSub) {

887

outputFormatter.PrintToken(Tokens.Sub);

888

} else {

889

outputFormatter.PrintToken(Tokens.Function);

890

}

891

outputFormatter.NewLine();

892

EndVisit(methodDeclaration.Body);

893

outputFormatter.IsInMemberBody = false;

894

}

895

return null;

896

}

897

898

public override object TrackedVisitInterfaceImplementation(InterfaceImplementation interfaceImplementation, object data)

899

{

900

throw new InvalidOperationException();

901

}

902

903

bool IsAbstract(AttributedNode node)

904

{

905

if ((node.Modifier & Modifiers.Abstract) == Modifiers.Abstract)

906

return true;

907

return currentType != null && currentType.Type == ClassType.Interface;

908

}

909

910

public override object TrackedVisitConstructorDeclaration(ConstructorDeclaration constructorDeclaration, object data)

911

{

912

VisitAttributes(constructorDeclaration.Attributes, data);

913

outputFormatter.Indent();

914

OutputModifier(constructorDeclaration.Modifier);

915

outputFormatter.PrintToken(Tokens.Sub);

916

outputFormatter.Space();

917

outputFormatter.PrintToken(Tokens.New);

918

outputFormatter.PrintToken(Tokens.OpenParenthesis);

919

AppendCommaSeparatedList(constructorDeclaration.Parameters);

920

outputFormatter.PrintToken(Tokens.CloseParenthesis);

921

outputFormatter.NewLine();

922

923

outputFormatter.IsInMemberBody = true;

924

++outputFormatter.IndentationLevel;

925

exitTokenStack.Push(Tokens.Sub);

926

927

TrackedVisit(constructorDeclaration.ConstructorInitializer, data);

928

929

TrackedVisit(constructorDeclaration.Body, data);

930

exitTokenStack.Pop();

931

--outputFormatter.IndentationLevel;

932

outputFormatter.IsInMemberBody = false;

933

934

outputFormatter.Indent();

935

outputFormatter.PrintToken(Tokens.End);

936

outputFormatter.Space();

937

outputFormatter.PrintToken(Tokens.Sub);

938

outputFormatter.NewLine();

939

940

return null;

941

}

942

943

public override object TrackedVisitConstructorInitializer(ConstructorInitializer constructorInitializer, object data)

944

{

945

outputFormatter.Indent();

946

if (constructorInitializer.ConstructorInitializerType == ConstructorInitializerType.This) {

947

outputFormatter.PrintToken(Tokens.Me);

948

} else {

949

outputFormatter.PrintToken(Tokens.MyBase);

950

}

951

outputFormatter.PrintToken(Tokens.Dot);

952

outputFormatter.PrintToken(Tokens.New);

953

outputFormatter.PrintToken(Tokens.OpenParenthesis);

954

AppendCommaSeparatedList(constructorInitializer.Arguments);

955

outputFormatter.PrintToken(Tokens.CloseParenthesis);

956

957

outputFormatter.NewLine();

958

return null;

959

}

960

961

public override object TrackedVisitIndexerDeclaration(IndexerDeclaration indexerDeclaration, object data)

962

{

963

VisitAttributes(indexerDeclaration.Attributes, data);

964

outputFormatter.Indent();

965

OutputModifier(indexerDeclaration.Modifier);

966

outputFormatter.PrintToken(Tokens.Default);

967

outputFormatter.Space();

968

if (indexerDeclaration.IsReadOnly) {

969

outputFormatter.PrintToken(Tokens.ReadOnly);

970

outputFormatter.Space();

971

} else if (indexerDeclaration.IsWriteOnly) {

972

outputFormatter.PrintToken(Tokens.WriteOnly);

973

outputFormatter.Space();

974

}

975

976

outputFormatter.PrintToken(Tokens.Property);

977

outputFormatter.Space();

978

outputFormatter.PrintIdentifier("Item");

979

980

outputFormatter.PrintToken(Tokens.OpenParenthesis);

981

AppendCommaSeparatedList(indexerDeclaration.Parameters);

982

outputFormatter.PrintToken(Tokens.CloseParenthesis);

983

outputFormatter.Space();

984

outputFormatter.PrintToken(Tokens.As);

985

outputFormatter.Space();

986

VisitReturnTypeAttributes(indexerDeclaration.Attributes, data);

987

TrackedVisit(indexerDeclaration.TypeReference, data);

988

PrintInterfaceImplementations(indexerDeclaration.InterfaceImplementations);

989

990

outputFormatter.NewLine();

991

++outputFormatter.IndentationLevel;

992

exitTokenStack.Push(Tokens.Property);

993

TrackedVisit(indexerDeclaration.GetRegion, data);

994

TrackedVisit(indexerDeclaration.SetRegion, data);

995

exitTokenStack.Pop();

996

--outputFormatter.IndentationLevel;

997

998

outputFormatter.Indent();

999

outputFormatter.PrintToken(Tokens.End);

1000

outputFormatter.Space();

1001

outputFormatter.PrintToken(Tokens.Property);

1002

outputFormatter.NewLine();

1003

return null;

1004

}

1005

1006

public override object TrackedVisitDestructorDeclaration(DestructorDeclaration destructorDeclaration, object data)

1007

{

1008

outputFormatter.Indent();

1009

outputFormatter.PrintText("Protected Overrides Sub Finalize()");

1010

outputFormatter.NewLine();

1011

1012

++outputFormatter.IndentationLevel;

1013

exitTokenStack.Push(Tokens.Sub);

1014

1015

outputFormatter.Indent();

1016

outputFormatter.PrintToken(Tokens.Try);

1017

outputFormatter.NewLine();

1018

1019

++outputFormatter.IndentationLevel;

1020

TrackedVisit(destructorDeclaration.Body, data);

1021

--outputFormatter.IndentationLevel;

1022

1023

outputFormatter.Indent();

1024

outputFormatter.PrintToken(Tokens.Finally);

1025

outputFormatter.NewLine();

1026

1027

++outputFormatter.IndentationLevel;

1028

outputFormatter.Indent();

1029

outputFormatter.PrintText("MyBase.Finalize()");

1030

outputFormatter.NewLine();

1031

--outputFormatter.IndentationLevel;

1032

1033

outputFormatter.Indent();

1034

outputFormatter.PrintToken(Tokens.End);

1035

outputFormatter.Space();

1036

outputFormatter.PrintToken(Tokens.Try);

1037

outputFormatter.NewLine();

1038

1039

exitTokenStack.Pop();

1040

--outputFormatter.IndentationLevel;

1041

1042

outputFormatter.Indent();

1043

outputFormatter.PrintToken(Tokens.End);

1044

outputFormatter.Space();

1045

outputFormatter.PrintToken(Tokens.Sub);

1046

outputFormatter.NewLine();

1047

1048

return null;

1049

}

1050

1051

public override object TrackedVisitOperatorDeclaration(OperatorDeclaration operatorDeclaration, object data)

1052

{

1053

VisitAttributes(operatorDeclaration.Attributes, data);

1054

outputFormatter.Indent();

1055

OutputModifier(operatorDeclaration.Modifier);

1056

1057

if (operatorDeclaration.IsConversionOperator) {

1058

if (operatorDeclaration.ConversionType == ConversionType.Implicit) {

1059

outputFormatter.PrintToken(Tokens.Widening);

1060

} else {

1061

outputFormatter.PrintToken(Tokens.Narrowing);

1062

}

1063

outputFormatter.Space();

1064

}

1065

1066

outputFormatter.PrintToken(Tokens.Operator);

1067

outputFormatter.Space();

1068

1069

int op = -1;

1070

1071

switch(operatorDeclaration.OverloadableOperator)

1072

{

1073

case OverloadableOperatorType.Add:

1074

case OverloadableOperatorType.UnaryPlus:

1075

op = Tokens.Plus;

1076

break;

1077

case OverloadableOperatorType.UnaryMinus:

1078

case OverloadableOperatorType.Subtract:

1079

op = Tokens.Minus;

1080

break;

1081

case OverloadableOperatorType.Multiply:

1082

op = Tokens.Times;

1083

break;

1084

case OverloadableOperatorType.Divide:

1085

op = Tokens.Div;

1086

break;

1087

case OverloadableOperatorType.Modulus:

1088

op = Tokens.Mod;

1089

break;

1090

case OverloadableOperatorType.Concat:

1091

op = Tokens.ConcatString;

1092

break;

1093

case OverloadableOperatorType.Not:

1094

op = Tokens.Not;

1095

break;

1096

case OverloadableOperatorType.BitNot:

1097

op = Tokens.Not;

1098

break;

1099

case OverloadableOperatorType.BitwiseAnd:

1100

op = Tokens.And;

1101

break;

1102

case OverloadableOperatorType.BitwiseOr:

1103

op = Tokens.Or;

1104

break;

1105

case OverloadableOperatorType.ExclusiveOr:

1106

op = Tokens.Xor;

1107

break;

1108

case OverloadableOperatorType.ShiftLeft:

1109

op = Tokens.ShiftLeft;

1110

break;

1111

case OverloadableOperatorType.ShiftRight:

1112

op = Tokens.ShiftRight;

1113

break;

1114

case OverloadableOperatorType.GreaterThan:

1115

op = Tokens.GreaterThan;

1116

break;

1117

case OverloadableOperatorType.GreaterThanOrEqual:

1118

op = Tokens.GreaterEqual;

1119

break;

1120

case OverloadableOperatorType.Equality:

1121

op = Tokens.Assign;

1122

break;

1123

case OverloadableOperatorType.InEquality:

1124

op = Tokens.NotEqual;

1125

break;

1126

case OverloadableOperatorType.LessThan:

1127

op = Tokens.LessThan;

1128

break;

1129

case OverloadableOperatorType.LessThanOrEqual:

1130

op = Tokens.LessEqual;

1131

break;

1132

case OverloadableOperatorType.Increment:

1133

Error("Increment operator is not supported in Visual Basic", operatorDeclaration.StartLocation);

1134

break;

1135

case OverloadableOperatorType.Decrement:

1136

Error("Decrement operator is not supported in Visual Basic", operatorDeclaration.StartLocation);

1137

break;

1138

case OverloadableOperatorType.IsTrue:

1139

outputFormatter.PrintText("IsTrue");

1140

break;

1141

case OverloadableOperatorType.IsFalse:

1142

outputFormatter.PrintText("IsFalse");

1143

break;

1144

case OverloadableOperatorType.Like:

1145

op = Tokens.Like;

1146

break;

1147

case OverloadableOperatorType.Power:

1148

op = Tokens.Power;

1149

break;

1150

case OverloadableOperatorType.CType:

1151

op = Tokens.CType;

1152

break;

1153

case OverloadableOperatorType.DivideInteger:

1154

op = Tokens.DivInteger;

1155

break;

1156

}

1157

1158

1159

1160

if (operatorDeclaration.IsConversionOperator) {

1161

outputFormatter.PrintToken(Tokens.CType);

1162

} else {

1163

if(op != -1) outputFormatter.PrintToken(op);

1164

}

1165

1166

PrintTemplates(operatorDeclaration.Templates);

1167

outputFormatter.PrintToken(Tokens.OpenParenthesis);

1168

AppendCommaSeparatedList(operatorDeclaration.Parameters);

1169

outputFormatter.PrintToken(Tokens.CloseParenthesis);

1170

if (!operatorDeclaration.TypeReference.IsNull) {

1171

outputFormatter.Space();

1172

outputFormatter.PrintToken(Tokens.As);

1173

outputFormatter.Space();

1174

VisitReturnTypeAttributes(operatorDeclaration.Attributes, data);

1175

TrackedVisit(operatorDeclaration.TypeReference, data);

1176

}

1177

1178

outputFormatter.NewLine();

1179

1180

++outputFormatter.IndentationLevel;

1181

TrackedVisit(operatorDeclaration.Body, data);

1182

--outputFormatter.IndentationLevel;

1183

1184

outputFormatter.Indent();

1185

outputFormatter.PrintToken(Tokens.End);

1186

outputFormatter.Space();

1187

outputFormatter.PrintToken(Tokens.Operator);

1188

outputFormatter.NewLine();

1189

1190

return null;

1191

}

1192

1193

public override object TrackedVisitDeclareDeclaration(DeclareDeclaration declareDeclaration, object data)

1194

{

1195

VisitAttributes(declareDeclaration.Attributes, data);

1196

outputFormatter.Indent();

1197

OutputModifier(declareDeclaration.Modifier);

1198

outputFormatter.PrintToken(Tokens.Declare);

1199

outputFormatter.Space();

1200

1201

switch (declareDeclaration.Charset) {

1202

case CharsetModifier.Auto:

1203

outputFormatter.PrintToken(Tokens.Auto);

1204

outputFormatter.Space();

1205

break;

1206

case CharsetModifier.Unicode:

1207

outputFormatter.PrintToken(Tokens.Unicode);

1208

outputFormatter.Space();

1209

break;

1210

case CharsetModifier.Ansi:

1211

outputFormatter.PrintToken(Tokens.Ansi);

1212

outputFormatter.Space();

1213

break;

1214

}

1215

1216

bool isVoid = declareDeclaration.TypeReference.IsNull || declareDeclaration.TypeReference.Type == "System.Void";

1217

if (isVoid) {

1218

outputFormatter.PrintToken(Tokens.Sub);

1219

} else {

1220

outputFormatter.PrintToken(Tokens.Function);

1221

}

1222

outputFormatter.Space();

1223

1224

outputFormatter.PrintIdentifier(declareDeclaration.Name);

1225

1226

outputFormatter.Space();

1227

outputFormatter.PrintToken(Tokens.Lib);

1228

outputFormatter.Space();

1229

outputFormatter.PrintText(ConvertString(declareDeclaration.Library));

1230

outputFormatter.Space();

1231

1232

if (declareDeclaration.Alias.Length > 0) {

1233

outputFormatter.PrintToken(Tokens.Alias);

1234

outputFormatter.Space();

1235

outputFormatter.PrintText(ConvertString(declareDeclaration.Alias));

1236

outputFormatter.Space();

1237

}

1238

1239

outputFormatter.PrintToken(Tokens.OpenParenthesis);

1240

AppendCommaSeparatedList(declareDeclaration.Parameters);

1241

outputFormatter.PrintToken(Tokens.CloseParenthesis);

1242

1243

if (!isVoid) {

1244

outputFormatter.Space();

1245

outputFormatter.PrintToken(Tokens.As);

1246

outputFormatter.Space();

1247

VisitReturnTypeAttributes(declareDeclaration.Attributes, data);

1248

TrackedVisit(declareDeclaration.TypeReference, data);

1249

}

1250

1251

outputFormatter.NewLine();

1252

1253

return null;

1254

}

1255

#endregion

1256

1257

#region Statements

1258

public override object TrackedVisitBlockStatement(BlockStatement blockStatement, object data)

1259

{

1260

if (blockStatement.Parent is BlockStatement) {

1261

outputFormatter.Indent();

1262

outputFormatter.PrintText("If True Then");

1263

outputFormatter.NewLine();

1264

outputFormatter.IndentationLevel += 1;

1265

}

1266

VisitStatementList(blockStatement.Children);

1267

if (blockStatement.Parent is BlockStatement) {

1268

outputFormatter.IndentationLevel -= 1;

1269

outputFormatter.Indent();

1270

outputFormatter.PrintText("End If");

1271

outputFormatter.NewLine();

1272

}

1273

return null;

1274

}

1275

1276

void PrintIndentedBlock(Statement stmt)

1277

{

1278

outputFormatter.IndentationLevel += 1;

1279

if (stmt is BlockStatement) {

1280

TrackedVisit(stmt, null);

1281

} else {

1282

outputFormatter.Indent();

1283

TrackedVisit(stmt, null);

1284

outputFormatter.NewLine();

1285

}

1286

outputFormatter.IndentationLevel -= 1;

1287

}

1288

1289

void PrintIndentedBlock(IEnumerable statements)

1290

{

1291

outputFormatter.IndentationLevel += 1;

1292

VisitStatementList(statements);

1293

outputFormatter.IndentationLevel -= 1;

1294

}

1295

1296

void VisitStatementList(IEnumerable statements)

1297

{

1298

foreach (Statement stmt in statements) {

1299

if (stmt is BlockStatement) {

1300

TrackedVisit(stmt, null);

1301

} else {

1302

outputFormatter.Indent();

1303

TrackedVisit(stmt, null);

1304

outputFormatter.NewLine();

1305

}

1306

}

1307

}

1308

1309

public override object TrackedVisitAddHandlerStatement(AddHandlerStatement addHandlerStatement, object data)

1310

{

1311

outputFormatter.PrintToken(Tokens.AddHandler);

1312

outputFormatter.Space();

1313

TrackedVisit(addHandlerStatement.EventExpression, data);

1314

outputFormatter.PrintToken(Tokens.Comma);

1315

outputFormatter.Space();

1316

TrackedVisit(addHandlerStatement.HandlerExpression, data);

1317

return null;

1318

}

1319

1320

public override object TrackedVisitRemoveHandlerStatement(RemoveHandlerStatement removeHandlerStatement, object data)

1321

{

1322

outputFormatter.PrintToken(Tokens.RemoveHandler);

1323

outputFormatter.Space();

1324

TrackedVisit(removeHandlerStatement.EventExpression, data);

1325

outputFormatter.PrintToken(Tokens.Comma);

1326

outputFormatter.Space();

1327

TrackedVisit(removeHandlerStatement.HandlerExpression, data);

1328

return null;

1329

}

1330

1331

public override object TrackedVisitRaiseEventStatement(RaiseEventStatement raiseEventStatement, object data)

1332

{

1333

outputFormatter.PrintToken(Tokens.RaiseEvent);

1334

outputFormatter.Space();

1335

outputFormatter.PrintIdentifier(raiseEventStatement.EventName);

1336

outputFormatter.PrintToken(Tokens.OpenParenthesis);

1337

AppendCommaSeparatedList(raiseEventStatement.Arguments);

1338

outputFormatter.PrintToken(Tokens.CloseParenthesis);

1339

return null;

1340

}

1341

1342

public override object TrackedVisitEraseStatement(EraseStatement eraseStatement, object data)

1343

{

1344

outputFormatter.PrintToken(Tokens.Erase);

1345

outputFormatter.Space();

1346

AppendCommaSeparatedList(eraseStatement.Expressions);

1347

return null;

1348

}

1349

1350

public override object TrackedVisitErrorStatement(ErrorStatement errorStatement, object data)

1351

{

1352

outputFormatter.PrintToken(Tokens.Error);

1353

outputFormatter.Space();

1354

TrackedVisit(errorStatement.Expression, data);

1355

return null;

1356

}

1357

1358

public override object TrackedVisitOnErrorStatement(OnErrorStatement onErrorStatement, object data)

1359

{

1360

outputFormatter.PrintToken(Tokens.On);

1361

outputFormatter.Space();

1362

outputFormatter.PrintToken(Tokens.Error);

1363

outputFormatter.Space();

1364

TrackedVisit(onErrorStatement.EmbeddedStatement, data);

1365

return null;

1366

}

1367

1368

public override object TrackedVisitReDimStatement(ReDimStatement reDimStatement, object data)

1369

{

1370

outputFormatter.PrintToken(Tokens.ReDim);

1371

outputFormatter.Space();

1372

if (reDimStatement.IsPreserve) {

1373

outputFormatter.PrintToken(Tokens.Preserve);

1374

outputFormatter.Space();

1375

}

1376

1377

AppendCommaSeparatedList(reDimStatement.ReDimClauses);

1378

return null;

1379

}

1380

1381

public override object TrackedVisitExpressionStatement(ExpressionStatement expressionStatement, object data)

1382

{

1383

TrackedVisit(expressionStatement.Expression, data);

1384

return null;

1385

}

1386

1387

public override object TrackedVisitLocalVariableDeclaration(LocalVariableDeclaration localVariableDeclaration, object data)

1388

{

1389

if (localVariableDeclaration.Modifier != Modifiers.None) {

1390

OutputModifier(localVariableDeclaration.Modifier);

1391

}

1392

if (!isUsingResourceAcquisition) {

1393

if ((localVariableDeclaration.Modifier & Modifiers.Const) == 0) {

1394

outputFormatter.PrintToken(Tokens.Dim);

1395

}

1396

outputFormatter.Space();

1397

}

1398

currentVariableType = localVariableDeclaration.TypeReference;

1399

1400

AppendCommaSeparatedList(localVariableDeclaration.Variables);

1401

currentVariableType = null;

1402

1403

return null;

1404

}

1405

1406

public override object TrackedVisitEmptyStatement(EmptyStatement emptyStatement, object data)

1407

{

1408

outputFormatter.NewLine();

1409

return null;

1410

}

1411

1412

public override object TrackedVisitYieldStatement(YieldStatement yieldStatement, object data)

1413

{

1414

UnsupportedNode(yieldStatement);

1415

outputFormatter.PrintText("yield ");

1416

TrackedVisit(yieldStatement.Statement, data);

1417

return null;

1418

}

1419

1420

public override object TrackedVisitReturnStatement(ReturnStatement returnStatement, object data)

1421

{

1422

outputFormatter.PrintToken(Tokens.Return);

1423

if (!returnStatement.Expression.IsNull) {

1424

outputFormatter.Space();

1425

TrackedVisit(returnStatement.Expression, data);

1426

}

1427

return null;

1428

}

1429

1430

public override object TrackedVisitIfElseStatement(IfElseStatement ifElseStatement, object data)

1431

{

1432

outputFormatter.PrintToken(Tokens.If);

1433

outputFormatter.Space();

1434

TrackedVisit(ifElseStatement.Condition, data);

1435

outputFormatter.Space();

1436

outputFormatter.PrintToken(Tokens.Then);

1437

outputFormatter.NewLine();

1438

1439

PrintIndentedBlock(ifElseStatement.TrueStatement);

1440

1441

foreach (ElseIfSection elseIfSection in ifElseStatement.ElseIfSections) {

1442

TrackedVisit(elseIfSection, data);

1443

}

1444

1445

if (ifElseStatement.HasElseStatements) {

1446

outputFormatter.Indent();

1447

outputFormatter.PrintToken(Tokens.Else);

1448

outputFormatter.NewLine();

1449

PrintIndentedBlock(ifElseStatement.FalseStatement);

1450

}

1451

1452

outputFormatter.Indent();

1453

outputFormatter.PrintToken(Tokens.End);

1454

outputFormatter.Space();

1455

outputFormatter.PrintToken(Tokens.If);

1456

return null;

1457

}

1458

1459

public override object TrackedVisitElseIfSection(ElseIfSection elseIfSection, object data)

1460

{

1461

outputFormatter.Indent();

1462

outputFormatter.PrintToken(Tokens.ElseIf);

1463

outputFormatter.Space();

1464

TrackedVisit(elseIfSection.Condition, data);

1465

outputFormatter.Space();

1466

outputFormatter.PrintToken(Tokens.Then);

1467

outputFormatter.NewLine();

1468

PrintIndentedBlock(elseIfSection.EmbeddedStatement);

1469

return null;

1470

}

1471

1472

public override object TrackedVisitForStatement(ForStatement forStatement, object data)

1473

{

1474

// Is converted to {initializer} while <Condition> {Embedded} {Iterators} end while

1475

exitTokenStack.Push(Tokens.While);

1476

bool isFirstLine = true;

1477

foreach (INode node in forStatement.Initializers) {

1478

if (!isFirstLine)

1479

outputFormatter.Indent();

1480

isFirstLine = false;

1481

TrackedVisit(node, data);

1482

outputFormatter.NewLine();

1483

}

1484

if (!isFirstLine)

1485

outputFormatter.Indent();

1486

outputFormatter.PrintToken(Tokens.While);

1487

outputFormatter.Space();

1488

if (forStatement.Condition.IsNull) {

1489

outputFormatter.PrintToken(Tokens.True);

1490

} else {

1491

TrackedVisit(forStatement.Condition, data);

1492

}

1493

outputFormatter.NewLine();

1494

1495

PrintIndentedBlock(forStatement.EmbeddedStatement);

1496

PrintIndentedBlock(forStatement.Iterator);

1497

1498

outputFormatter.Indent();

1499

outputFormatter.PrintToken(Tokens.End);

1500

outputFormatter.Space();

1501

outputFormatter.PrintToken(Tokens.While);

1502

exitTokenStack.Pop();

1503

return null;

1504

}

1505

1506

public override object TrackedVisitLabelStatement(LabelStatement labelStatement, object data)

1507

{

1508

outputFormatter.PrintIdentifier(labelStatement.Label);

1509

outputFormatter.PrintToken(Tokens.Colon);

1510

return null;

1511

}

1512

1513

public override object TrackedVisitGotoStatement(GotoStatement gotoStatement, object data)

1514

{

1515

outputFormatter.PrintToken(Tokens.GoTo);

1516

outputFormatter.Space();

1517

outputFormatter.PrintIdentifier(gotoStatement.Label);

1518

return null;

1519

}

1520

1521

public override object TrackedVisitSwitchStatement(SwitchStatement switchStatement, object data)

1522

{

1523

exitTokenStack.Push(Tokens.Select);

1524

outputFormatter.PrintToken(Tokens.Select);

1525

outputFormatter.Space();

1526

outputFormatter.PrintToken(Tokens.Case);

1527

outputFormatter.Space();

1528

TrackedVisit(switchStatement.SwitchExpression, data);

1529

outputFormatter.NewLine();

1530

++outputFormatter.IndentationLevel;

1531

foreach (SwitchSection section in switchStatement.SwitchSections) {

1532

TrackedVisit(section, data);

1533

}

1534

--outputFormatter.IndentationLevel;

1535

outputFormatter.Indent();

1536

outputFormatter.PrintToken(Tokens.End);

1537

outputFormatter.Space();

1538

outputFormatter.PrintToken(Tokens.Select);

1539

exitTokenStack.Pop();

1540

return null;

1541

}

1542

1543

public override object TrackedVisitSwitchSection(SwitchSection switchSection, object data)

1544

{

1545

outputFormatter.Indent();

1546

outputFormatter.PrintToken(Tokens.Case);

1547

outputFormatter.Space();

1548

this.AppendCommaSeparatedList(switchSection.SwitchLabels);

1549

outputFormatter.NewLine();

1550

1551

PrintIndentedBlock(switchSection.Children);

1552

1553

return null;

1554

}

1555

1556

public override object TrackedVisitCaseLabel(CaseLabel caseLabel, object data)

1557

{

1558

if (caseLabel.IsDefault) {

1559

outputFormatter.PrintToken(Tokens.Else);

1560

} else {

1561

if (caseLabel.BinaryOperatorType != BinaryOperatorType.None) {

1562

switch (caseLabel.BinaryOperatorType) {

1563

case BinaryOperatorType.Equality:

1564

outputFormatter.PrintToken(Tokens.Assign);

1565

break;

1566

case BinaryOperatorType.InEquality:

1567

outputFormatter.PrintToken(Tokens.LessThan);

1568

outputFormatter.PrintToken(Tokens.GreaterThan);

1569

break;

1570

1571

case BinaryOperatorType.GreaterThan:

1572

outputFormatter.PrintToken(Tokens.GreaterThan);

1573

break;

1574

case BinaryOperatorType.GreaterThanOrEqual:

1575

outputFormatter.PrintToken(Tokens.GreaterEqual);

1576

break;

1577

case BinaryOperatorType.LessThan:

1578

outputFormatter.PrintToken(Tokens.LessThan);

1579

break;

1580

case BinaryOperatorType.LessThanOrEqual:

1581

outputFormatter.PrintToken(Tokens.LessEqual);

1582

break;

1583

}

1584

outputFormatter.Space();

1585

}

1586

1587

TrackedVisit(caseLabel.Label, data);

1588

if (!caseLabel.ToExpression.IsNull) {

1589

outputFormatter.Space();

1590

outputFormatter.PrintToken(Tokens.To);

1591

outputFormatter.Space();

1592

TrackedVisit(caseLabel.ToExpression, data);

1593

}

1594

}

1595

1596

return null;

1597

}

1598

1599

public override object TrackedVisitBreakStatement(BreakStatement breakStatement, object data)

1600

{

1601

outputFormatter.PrintToken(Tokens.Exit);

1602

if (exitTokenStack.Count > 0) {

1603

outputFormatter.Space();

1604

outputFormatter.PrintToken(exitTokenStack.Peek());

1605

}

1606

return null;

1607

}

1608

1609

public override object TrackedVisitStopStatement(StopStatement stopStatement, object data)

1610

{

1611

outputFormatter.PrintToken(Tokens.Stop);

1612

return null;

1613

}

1614

1615

public override object TrackedVisitResumeStatement(ResumeStatement resumeStatement, object data)

1616

{

1617

outputFormatter.PrintToken(Tokens.Resume);

1618

outputFormatter.Space();

1619

if (resumeStatement.IsResumeNext) {

1620

outputFormatter.PrintToken(Tokens.Next);

1621

} else {

1622

outputFormatter.PrintIdentifier(resumeStatement.LabelName);

1623

}

1624

return null;

1625

}

1626

1627

public override object TrackedVisitEndStatement(EndStatement endStatement, object data)

1628

{

1629

outputFormatter.PrintToken(Tokens.End);

1630

return null;

1631

}

1632

1633

public override object TrackedVisitContinueStatement(ContinueStatement continueStatement, object data)

1634

{

1635

outputFormatter.PrintToken(Tokens.Continue);

1636

outputFormatter.Space();

1637

switch (continueStatement.ContinueType) {

1638

case ContinueType.Do:

1639

outputFormatter.PrintToken(Tokens.Do);

1640

break;

1641

case ContinueType.For:

1642

outputFormatter.PrintToken(Tokens.For);

1643

break;

1644

case ContinueType.While:

1645

outputFormatter.PrintToken(Tokens.While);

1646

break;

1647

default:

1648

outputFormatter.PrintToken(exitTokenStack.Peek());

1649

break;

1650

}

1651

return null;

1652

}

1653

1654

public override object TrackedVisitGotoCaseStatement(GotoCaseStatement gotoCaseStatement, object data)

1655

{

1656

outputFormatter.PrintText("goto case ");

1657

if (gotoCaseStatement.IsDefaultCase) {

1658

outputFormatter.PrintText("default");

1659

} else {

1660

TrackedVisit(gotoCaseStatement.Expression, null);

1661

}

1662

return null;

1663

}

1664

1665

public override object TrackedVisitDoLoopStatement(DoLoopStatement doLoopStatement, object data)

1666

{

1667

if (doLoopStatement.ConditionPosition == ConditionPosition.None) {

1668

Error(String.Format("Unknown condition position for loop : {0}.", doLoopStatement), doLoopStatement.StartLocation);

1669

}

1670

1671

if (doLoopStatement.ConditionPosition == ConditionPosition.Start) {

1672

switch (doLoopStatement.ConditionType) {

1673

case ConditionType.DoWhile:

1674

exitTokenStack.Push(Tokens.Do);

1675

outputFormatter.PrintToken(Tokens.Do);

1676

outputFormatter.Space();

1677

outputFormatter.PrintToken(Tokens.While);

1678

break;

1679

case ConditionType.While:

1680

exitTokenStack.Push(Tokens.While);

1681

outputFormatter.PrintToken(Tokens.While);

1682

break;

1683

case ConditionType.Until:

1684

exitTokenStack.Push(Tokens.Do);

1685

outputFormatter.PrintToken(Tokens.Do);

1686

outputFormatter.Space();

1687

outputFormatter.PrintToken(Tokens.While);

1688

break;

1689

default:

1690

throw new InvalidOperationException();

1691

}

1692

outputFormatter.Space();

1693

TrackedVisit(doLoopStatement.Condition, null);

1694

} else {

1695

exitTokenStack.Push(Tokens.Do);

1696

outputFormatter.PrintToken(Tokens.Do);

1697

}

1698

1699

outputFormatter.NewLine();

1700

1701

PrintIndentedBlock(doLoopStatement.EmbeddedStatement);

1702

1703

outputFormatter.Indent();

1704

if (doLoopStatement.ConditionPosition == ConditionPosition.Start && doLoopStatement.ConditionType == ConditionType.While) {

1705

outputFormatter.PrintToken(Tokens.End);

1706

outputFormatter.Space();

1707

outputFormatter.PrintToken(Tokens.While);

1708

} else {

1709

outputFormatter.PrintToken(Tokens.Loop);

1710

}

1711

1712

if (doLoopStatement.ConditionPosition == ConditionPosition.End && !doLoopStatement.Condition.IsNull) {

1713

outputFormatter.Space();

1714

switch (doLoopStatement.ConditionType) {

1715

case ConditionType.While:

1716

case ConditionType.DoWhile:

1717

outputFormatter.PrintToken(Tokens.While);

1718

break;

1719

case ConditionType.Until:

1720

outputFormatter.PrintToken(Tokens.Until);

1721

break;

1722

}

1723

outputFormatter.Space();

1724

TrackedVisit(doLoopStatement.Condition, null);

1725

}

1726

exitTokenStack.Pop();

1727

return null;

1728

}

1729

1730

public override object TrackedVisitForeachStatement(ForeachStatement foreachStatement, object data)

1731

{

1732

exitTokenStack.Push(Tokens.For);

1733

outputFormatter.PrintToken(Tokens.For);

1734

outputFormatter.Space();

1735

outputFormatter.PrintToken(Tokens.Each);

1736

outputFormatter.Space();

1737

1738

// loop control variable

1739

outputFormatter.PrintIdentifier(foreachStatement.VariableName);

1740

outputFormatter.Space();

1741

outputFormatter.PrintToken(Tokens.As);

1742

outputFormatter.Space();

1743

TrackedVisit(foreachStatement.TypeReference, data);

1744

1745

outputFormatter.Space();

1746

outputFormatter.PrintToken(Tokens.In);

1747

outputFormatter.Space();

1748

1749

TrackedVisit(foreachStatement.Expression, data);

1750

outputFormatter.NewLine();

1751

1752

PrintIndentedBlock(foreachStatement.EmbeddedStatement);

1753

1754

outputFormatter.Indent();

1755

outputFormatter.PrintToken(Tokens.Next);

1756

if (!foreachStatement.NextExpression.IsNull) {

1757

outputFormatter.Space();

1758

TrackedVisit(foreachStatement.NextExpression, data);

1759

}

1760

exitTokenStack.Pop();

1761

return null;

1762

}

1763

1764

public override object TrackedVisitLockStatement(LockStatement lockStatement, object data)

1765

{

1766

outputFormatter.PrintToken(Tokens.SyncLock);

1767

outputFormatter.Space();

1768

TrackedVisit(lockStatement.LockExpression, data);

1769

outputFormatter.NewLine();

1770

1771

PrintIndentedBlock(lockStatement.EmbeddedStatement);

1772

1773

outputFormatter.Indent();

1774

outputFormatter.PrintToken(Tokens.End);

1775

outputFormatter.Space();

1776

outputFormatter.PrintToken(Tokens.SyncLock);

1777

return null;

1778

}

1779

1780

bool isUsingResourceAcquisition;

1781

1782

public override object TrackedVisitUsingStatement(UsingStatement usingStatement, object data)

1783

{

1784

outputFormatter.PrintToken(Tokens.Using);

1785

outputFormatter.Space();

1786

1787

isUsingResourceAcquisition = true;

1788

TrackedVisit(usingStatement.ResourceAcquisition, data);

1789

isUsingResourceAcquisition = false;

1790

outputFormatter.NewLine();

1791

1792

PrintIndentedBlock(usingStatement.EmbeddedStatement);

1793

1794

outputFormatter.Indent();

1795

outputFormatter.PrintToken(Tokens.End);

1796

outputFormatter.Space();

1797

outputFormatter.PrintToken(Tokens.Using);

1798

1799

return null;

1800

}

1801

1802

public override object TrackedVisitWithStatement(WithStatement withStatement, object data)

1803

{

1804

outputFormatter.PrintToken(Tokens.With);

1805

outputFormatter.Space();

1806

TrackedVisit(withStatement.Expression, data);

1807

outputFormatter.NewLine();

1808

1809

PrintIndentedBlock(withStatement.Body);

1810

1811

outputFormatter.PrintToken(Tokens.End);

1812

outputFormatter.Space();

1813

outputFormatter.PrintToken(Tokens.With);

1814

return null;

1815

}

1816

1817

public override object TrackedVisitTryCatchStatement(TryCatchStatement tryCatchStatement, object data)

1818

{

1819

exitTokenStack.Push(Tokens.Try);

1820

outputFormatter.PrintToken(Tokens.Try);

1821

outputFormatter.NewLine();

1822

1823

PrintIndentedBlock(tryCatchStatement.StatementBlock);

1824

1825

foreach (CatchClause catchClause in tryCatchStatement.CatchClauses) {

1826

TrackedVisit(catchClause, data);

1827

}

1828

1829

if (!tryCatchStatement.FinallyBlock.IsNull) {

1830

outputFormatter.Indent();

1831

outputFormatter.PrintToken(Tokens.Finally);

1832

outputFormatter.NewLine();

1833

PrintIndentedBlock(tryCatchStatement.FinallyBlock);

1834

}

1835

outputFormatter.Indent();

1836

outputFormatter.PrintToken(Tokens.End);

1837

outputFormatter.Space();

1838

outputFormatter.PrintToken(Tokens.Try);

1839

exitTokenStack.Pop();

1840

return null;

1841

}

1842

1843

public override object TrackedVisitCatchClause(CatchClause catchClause, object data)

1844

{

1845

outputFormatter.Indent();

1846

outputFormatter.PrintToken(Tokens.Catch);

1847

1848

if (!catchClause.TypeReference.IsNull) {

1849

outputFormatter.Space();

1850

if (catchClause.VariableName.Length > 0) {

1851

outputFormatter.PrintIdentifier(catchClause.VariableName);

1852

} else {

1853

outputFormatter.PrintIdentifier("generatedExceptionName");

1854

}

1855

outputFormatter.Space();

1856

outputFormatter.PrintToken(Tokens.As);

1857

outputFormatter.Space();

1858

outputFormatter.PrintIdentifier(catchClause.TypeReference.Type);

1859

}

1860

1861

if (!catchClause.Condition.IsNull) {

1862

outputFormatter.Space();

1863

outputFormatter.PrintToken(Tokens.When);

1864

outputFormatter.Space();

1865

TrackedVisit(catchClause.Condition, data);

1866

}

1867

outputFormatter.NewLine();

1868

1869

PrintIndentedBlock(catchClause.StatementBlock);

1870

1871

return null;

1872

}

1873

1874

public override object TrackedVisitThrowStatement(ThrowStatement throwStatement, object data)

1875

{

1876

outputFormatter.PrintToken(Tokens.Throw);

1877

if (!throwStatement.Expression.IsNull) {

1878

outputFormatter.Space();

1879

TrackedVisit(throwStatement.Expression, data);

1880

}

1881

return null;

1882

}

1883

1884

public override object TrackedVisitFixedStatement(FixedStatement fixedStatement, object data)

1885

{

1886

UnsupportedNode(fixedStatement);

1887

return TrackedVisit(fixedStatement.EmbeddedStatement, data);

1888

}

1889

1890

public override object TrackedVisitUnsafeStatement(UnsafeStatement unsafeStatement, object data)

1891

{

1892

UnsupportedNode(unsafeStatement);

1893

return TrackedVisit(unsafeStatement.Block, data);

1894

}

1895

1896

public override object TrackedVisitCheckedStatement(CheckedStatement checkedStatement, object data)

1897

{

1898

UnsupportedNode(checkedStatement);

1899

return TrackedVisit(checkedStatement.Block, data);

1900

}

1901

1902

public override object TrackedVisitUncheckedStatement(UncheckedStatement uncheckedStatement, object data)

1903

{

1904

UnsupportedNode(uncheckedStatement);

1905

return TrackedVisit(uncheckedStatement.Block, data);

1906

}

1907

1908

public override object TrackedVisitExitStatement(ExitStatement exitStatement, object data)

1909

{

1910

outputFormatter.PrintToken(Tokens.Exit);

1911

if (exitStatement.ExitType != ExitType.None) {

1912

outputFormatter.Space();

1913

switch (exitStatement.ExitType) {

1914

case ExitType.Sub:

1915

outputFormatter.PrintToken(Tokens.Sub);

1916

break;

1917

case ExitType.Function:

1918

outputFormatter.PrintToken(Tokens.Function);

1919

break;

1920

case ExitType.Property:

1921

outputFormatter.PrintToken(Tokens.Property);

1922

break;

1923

case ExitType.Do:

1924

outputFormatter.PrintToken(Tokens.Do);

1925

break;

1926

case ExitType.For:

1927

outputFormatter.PrintToken(Tokens.For);

1928

break;

1929

case ExitType.Try:

1930

outputFormatter.PrintToken(Tokens.Try);

1931

break;

1932

case ExitType.While:

1933

outputFormatter.PrintToken(Tokens.While);

1934

break;

1935

case ExitType.Select:

1936

outputFormatter.PrintToken(Tokens.Select);

1937

break;

1938

default:

1939

Error(String.Format("Unsupported exit type : {0}", exitStatement.ExitType), exitStatement.StartLocation);

1940

break;

1941

}

1942

}

1943

1944

return null;

1945

}

1946

1947

public override object TrackedVisitForNextStatement(ForNextStatement forNextStatement, object data)

1948

{

1949

exitTokenStack.Push(Tokens.For);

1950

outputFormatter.PrintToken(Tokens.For);

1951

outputFormatter.Space();

1952

1953

if (!forNextStatement.LoopVariableExpression.IsNull) {

1954

TrackedVisit(forNextStatement.LoopVariableExpression, data);

1955

} else {

1956

outputFormatter.PrintIdentifier(forNextStatement.VariableName);

1957

1958

if (!forNextStatement.TypeReference.IsNull) {

1959

outputFormatter.Space();

1960

outputFormatter.PrintToken(Tokens.As);

1961

outputFormatter.Space();

1962

TrackedVisit(forNextStatement.TypeReference, data);

1963

}

1964

}

1965

1966

outputFormatter.Space();

1967

outputFormatter.PrintToken(Tokens.Assign);

1968

outputFormatter.Space();

1969

1970

TrackedVisit(forNextStatement.Start, data);

1971

1972

outputFormatter.Space();

1973

outputFormatter.PrintToken(Tokens.To);

1974

outputFormatter.Space();

1975

1976

TrackedVisit(forNextStatement.End, data);

1977

1978

if (!forNextStatement.Step.IsNull) {

1979

outputFormatter.Space();

1980

outputFormatter.PrintToken(Tokens.Step);

1981

outputFormatter.Space();

1982

TrackedVisit(forNextStatement.Step, data);

1983

}

1984

outputFormatter.NewLine();

1985

1986

PrintIndentedBlock(forNextStatement.EmbeddedStatement);

1987

1988

outputFormatter.Indent();

1989

outputFormatter.PrintToken(Tokens.Next);

1990

1991

if (forNextStatement.NextExpressions.Count > 0) {

1992

outputFormatter.Space();

1993

AppendCommaSeparatedList(forNextStatement.NextExpressions);

1994

}

1995

exitTokenStack.Pop();

1996

return null;

1997

}

1998

#endregion

1999

2000

#region Expressions

2001

2002

public override object TrackedVisitClassReferenceExpression(ClassReferenceExpression classReferenceExpression, object data)

2003

{

2004

outputFormatter.PrintToken(Tokens.MyClass);

2005

return null;

2006

}

2007

2008

2009

static string ConvertCharLiteral(char ch)

2010

{

2011

if (Char.IsControl(ch)) {

2012

string charName = GetCharName(ch);

2013

if (charName != null)

2014

return "ControlChars." + charName;

2015

else

2016

return "ChrW(" + ((int)ch).ToString() + ")";

2017

} else if (ch == '"') {

2018

return "\"\"\"\"C";

2019

} else {

2020

return "\"" + ch.ToString() + "\"C";

2021

}

2022

}

2023

2024

static string GetCharName(char ch)

2025

{

2026

switch (ch) {

2027

case '\b':

2028

return "Back";

2029

case '\r':

2030

return "Cr";

2031

case '\f':

2032

return "FormFeed";

2033

case '\n':

2034

return "Lf";

2035

case '\0':

2036

return "NullChar";

2037

case '\t':

2038

return "Tab";

2039

case '\v':

2040

return "VerticalTab";

2041

default:

2042

return null;

2043

}

2044

}

2045

2046

static string ConvertString(string str)

2047

{

2048

StringBuilder sb = new StringBuilder();

2049

bool inString = false;

2050

foreach (char ch in str) {

2051

if (char.IsControl(ch)) {

2052

if (inString) {

2053

sb.Append('"');

2054

inString = false;

2055

}

2056

if (sb.Length > 0)

2057

sb.Append(" & ");

2058

string charName = GetCharName(ch);

2059

if (charName != null)

2060

sb.Append("vb" + charName);

2061

else

2062

sb.Append("ChrW(" + ((int)ch) + ")");

2063

} else {

2064

if (!inString) {

2065

if (sb.Length > 0)

2066

sb.Append(" & ");

2067

sb.Append('"');

2068

inString = true;

2069

}

2070

if (ch == '"') {

2071

sb.Append("\"\"");

2072

} else {

2073

sb.Append(ch);

2074

}

2075

}

2076

}

2077

if (inString)

2078

sb.Append('"');

2079

if (sb.Length == 0)

2080

return "\"\"";

2081

return sb.ToString();

2082

}

2083

2084

public override object TrackedVisitPrimitiveExpression(PrimitiveExpression primitiveExpression, object data)

2085

{

2086

outputFormatter.PrintText(ToVBNetString(primitiveExpression));

2087

return null;

2088

}

2089

2090

internal static string ToVBNetString(PrimitiveExpression primitiveExpression)

2091

{

2092

object val = primitiveExpression.Value;

2093

if (val == null) {

2094

return "Nothing";

2095

}

2096

if (val is bool) {

2097

if ((bool)primitiveExpression.Value) {

2098

return "True";

2099

} else {

2100

return "False";

2101

}

2102

}

2103

2104

if (val is string) {

2105

return ConvertString((string)val);

2106

}

2107

2108

if (val is char) {

2109

return ConvertCharLiteral((char)primitiveExpression.Value);

2110

}

2111

2112

if (val is decimal) {

2113

return ((decimal)primitiveExpression.Value).ToString(NumberFormatInfo.InvariantInfo) + "D";

2114

}

2115

2116

if (val is float) {

2117

return ((float)primitiveExpression.Value).ToString(NumberFormatInfo.InvariantInfo) + "F";

2118

}

2119

2120

if (val is double) {

2121

string text = ((double)val).ToString(NumberFormatInfo.InvariantInfo);

2122

if (text.IndexOf('.') < 0 && text.IndexOf('E') < 0)

2123

return text + ".0";

2124

else

2125

return text;

2126

}

2127

2128

if (val is IFormattable) {

2129

StringBuilder b = new StringBuilder();

2130

if (primitiveExpression.LiteralFormat == LiteralFormat.HexadecimalNumber) {

2131

b.Append("&H");

2132

b.Append(((IFormattable)val).ToString("x", NumberFormatInfo.InvariantInfo));

2133

} else {

2134

b.Append(((IFormattable)val).ToString(null, NumberFormatInfo.InvariantInfo));

2135

}

2136

if (val is ushort || val is uint || val is ulong) {

2137

b.Append('U');

2138

if (val is uint)

2139

b.Append('I');

2140

}

2141

if (val is long || val is ulong)

2142

b.Append('L');

2143

if (val is short || val is ushort)

2144

b.Append('S');

2145

return b.ToString();

2146

} else {

2147

return val.ToString();

2148

}

2149

}

2150

2151

public override object TrackedVisitBinaryOperatorExpression(BinaryOperatorExpression binaryOperatorExpression, object data)

2152

{

2153

int op = 0;

2154

switch (binaryOperatorExpression.Op) {

2155

case BinaryOperatorType.Concat:

2156

op = Tokens.ConcatString;

2157

break;

2158

2159

case BinaryOperatorType.Add:

2160

op = Tokens.Plus;

2161

break;

2162

2163

case BinaryOperatorType.Subtract:

2164

op = Tokens.Minus;

2165

break;

2166

2167

case BinaryOperatorType.Multiply:

2168

op = Tokens.Times;

2169

break;

2170

2171

case BinaryOperatorType.Divide:

2172

op = Tokens.Div;

2173

break;

2174

2175

case BinaryOperatorType.DivideInteger:

2176

op = Tokens.DivInteger;

2177

break;

2178

2179

case BinaryOperatorType.Modulus:

2180

op = Tokens.Mod;

2181

break;

2182

2183

case BinaryOperatorType.ShiftLeft:

2184

op = Tokens.ShiftLeft;

2185

break;

2186

2187

case BinaryOperatorType.ShiftRight:

2188

op = Tokens.ShiftRight;

2189

break;

2190

2191

case BinaryOperatorType.BitwiseAnd:

2192

op = Tokens.And;

2193

break;

2194

case BinaryOperatorType.BitwiseOr:

2195

op = Tokens.Or;

2196

break;

2197

case BinaryOperatorType.ExclusiveOr:

2198

op = Tokens.Xor;

2199

break;

2200

2201

case BinaryOperatorType.LogicalAnd:

2202

op = Tokens.AndAlso;

2203

break;

2204

case BinaryOperatorType.LogicalOr:

2205

op = Tokens.OrElse;

2206

break;

2207

case BinaryOperatorType.ReferenceEquality:

2208

op = Tokens.Is;

2209

break;

2210

case BinaryOperatorType.ReferenceInequality:

2211

op = Tokens.IsNot;

2212

break;

2213

2214

case BinaryOperatorType.Equality:

2215

op = Tokens.Assign;

2216

break;

2217

case BinaryOperatorType.GreaterThan:

2218

op = Tokens.GreaterThan;

2219

break;

2220

case BinaryOperatorType.GreaterThanOrEqual:

2221

op = Tokens.GreaterEqual;

2222

break;

2223

case BinaryOperatorType.InEquality:

2224

op = Tokens.NotEqual;

2225

break;

2226

case BinaryOperatorType.NullCoalescing:

2227

outputFormatter.PrintText("If(");

2228

TrackedVisit(binaryOperatorExpression.Left, data);

2229

outputFormatter.PrintToken(Tokens.Comma);

2230

outputFormatter.Space();

2231

TrackedVisit(binaryOperatorExpression.Right, data);

2232

outputFormatter.PrintToken(Tokens.CloseParenthesis);

2233

return null;

2234

case BinaryOperatorType.DictionaryAccess:

2235

{

2236

PrimitiveExpression pright = binaryOperatorExpression.Right as PrimitiveExpression;

2237

TrackedVisit(binaryOperatorExpression.Left, data);

2238

if (pright != null && pright.Value is string) {

2239

outputFormatter.PrintText("!" + (string)pright.Value);

2240

} else {

2241

outputFormatter.PrintToken(Tokens.OpenParenthesis);

2242

TrackedVisit(binaryOperatorExpression.Right, data);

2243

outputFormatter.PrintToken(Tokens.CloseParenthesis);

2244

}

2245

return null;

2246

}

2247

case BinaryOperatorType.LessThan:

2248

op = Tokens.LessThan;

2249

break;

2250

case BinaryOperatorType.LessThanOrEqual:

2251

op = Tokens.LessEqual;

2252

break;

2253

}

2254

2255

2256

BinaryOperatorExpression childBoe = binaryOperatorExpression.Left as BinaryOperatorExpression;

2257

bool requireParenthesis = childBoe != null && OperatorPrecedence.ComparePrecedenceVB(binaryOperatorExpression.Op, childBoe.Op) > 0;

2258

if (requireParenthesis)

2259

outputFormatter.PrintToken(Tokens.OpenParenthesis);

2260

TrackedVisit(binaryOperatorExpression.Left, data);

2261

if (requireParenthesis)

2262

outputFormatter.PrintToken(Tokens.CloseParenthesis);

2263

2264

outputFormatter.Space();

2265

outputFormatter.PrintToken(op);

2266

outputFormatter.Space();

2267

2268

childBoe = binaryOperatorExpression.Right as BinaryOperatorExpression;

2269

requireParenthesis = childBoe != null && OperatorPrecedence.ComparePrecedenceVB(binaryOperatorExpression.Op, childBoe.Op) >= 0;

2270

if (requireParenthesis)

2271

outputFormatter.PrintToken(Tokens.OpenParenthesis);

2272

TrackedVisit(binaryOperatorExpression.Right, data);

2273

if (requireParenthesis)

2274

outputFormatter.PrintToken(Tokens.CloseParenthesis);

2275

2276

return null;

2277

}

2278

2279

public override object TrackedVisitParenthesizedExpression(ParenthesizedExpression parenthesizedExpression, object data)

2280

{

2281

outputFormatter.PrintToken(Tokens.OpenParenthesis);

2282

TrackedVisit(parenthesizedExpression.Expression, data);

2283

outputFormatter.PrintToken(Tokens.CloseParenthesis);

2284

return null;

2285

}

2286

2287

public override object TrackedVisitInvocationExpression(InvocationExpression invocationExpression, object data)

2288

{

2289

TrackedVisit(invocationExpression.TargetObject, data);

2290

outputFormatter.PrintToken(Tokens.OpenParenthesis);

2291

AppendCommaSeparatedList(invocationExpression.Arguments);

2292

outputFormatter.PrintToken(Tokens.CloseParenthesis);

2293

return null;

2294

}

2295

2296

void PrintTypeArguments(List<TypeReference> typeArguments)

2297

{

2298

if (typeArguments != null && typeArguments.Count > 0) {

2299

outputFormatter.PrintToken(Tokens.OpenParenthesis);

2300

outputFormatter.PrintToken(Tokens.Of);

2301

outputFormatter.Space();

2302

AppendCommaSeparatedList(typeArguments);

2303

outputFormatter.PrintToken(Tokens.CloseParenthesis);

2304

}

2305

}

2306

2307

public override object TrackedVisitIdentifierExpression(IdentifierExpression identifierExpression, object data)

2308

{

2309

outputFormatter.PrintIdentifier(identifierExpression.Identifier);

2310

PrintTypeArguments(identifierExpression.TypeArguments);

2311

return null;

2312

}

2313

2314

public override object TrackedVisitTypeReferenceExpression(TypeReferenceExpression typeReferenceExpression, object data)

2315

{

2316

TrackedVisit(typeReferenceExpression.TypeReference, data);

2317

return null;

2318

}

2319

2320

public override object TrackedVisitUnaryOperatorExpression(UnaryOperatorExpression unaryOperatorExpression, object data)

2321

{

2322

switch (unaryOperatorExpression.Op) {

2323

case UnaryOperatorType.Not:

2324

case UnaryOperatorType.BitNot:

2325

outputFormatter.PrintToken(Tokens.Not);

2326

outputFormatter.Space();

2327

TrackedVisit(unaryOperatorExpression.Expression, data);

2328

return null;

2329

2330

case UnaryOperatorType.Decrement:

2331

outputFormatter.PrintText("System.Threading.Interlocked.Decrement(");

2332

TrackedVisit(unaryOperatorExpression.Expression, data);

2333

outputFormatter.PrintText(")");

2334

return null;

2335

2336

case UnaryOperatorType.Increment:

2337

outputFormatter.PrintText("System.Threading.Interlocked.Increment(");

2338

TrackedVisit(unaryOperatorExpression.Expression, data);

2339

outputFormatter.PrintText(")");

2340

return null;

2341

2342

case UnaryOperatorType.Minus:

2343

outputFormatter.PrintToken(Tokens.Minus);

2344

TrackedVisit(unaryOperatorExpression.Expression, data);

2345

return null;

2346

2347

case UnaryOperatorType.Plus:

2348

outputFormatter.PrintToken(Tokens.Plus);

2349

TrackedVisit(unaryOperatorExpression.Expression, data);

2350

return null;

2351

2352

case UnaryOperatorType.PostDecrement:

2353

outputFormatter.PrintText("System.Math.Max(System.Threading.Interlocked.Decrement(");

2354

TrackedVisit(unaryOperatorExpression.Expression, data);

2355

outputFormatter.PrintText("),");

2356

TrackedVisit(unaryOperatorExpression.Expression, data);

2357

outputFormatter.PrintText(" + 1)");

2358

return null;

2359

2360

case UnaryOperatorType.PostIncrement:

2361

outputFormatter.PrintText("System.Math.Max(System.Threading.Interlocked.Increment(");

2362

TrackedVisit(unaryOperatorExpression.Expression, data);

2363

outputFormatter.PrintText("),");

2364

TrackedVisit(unaryOperatorExpression.Expression, data);

2365

outputFormatter.PrintText(" - 1)");

2366

return null;

2367

2368

case UnaryOperatorType.Dereference:

2369

outputFormatter.PrintToken(Tokens.Times);

2370

TrackedVisit(unaryOperatorExpression.Expression, data);

2371

return null;

2372

case UnaryOperatorType.AddressOf:

2373

outputFormatter.PrintToken(Tokens.AddressOf);

2374

TrackedVisit(unaryOperatorExpression.Expression, data);

2375

return null;

2376

default:

2377

Error("unknown unary operator: " + unaryOperatorExpression.Op.ToString(), unaryOperatorExpression.StartLocation);

2378

outputFormatter.PrintText(unaryOperatorExpression.Op.ToString());

2379

outputFormatter.PrintText("(");

2380

TrackedVisit(unaryOperatorExpression.Expression, data);

2381

outputFormatter.PrintText(")");

2382

return null;

2383

}

2384

}

2385

2386

public override object TrackedVisitAssignmentExpression(AssignmentExpression assignmentExpression, object data)

2387

{

2388

int op = 0;

2389

bool unsupportedOpAssignment = false;

2390

switch (assignmentExpression.Op) {

2391

case AssignmentOperatorType.Assign:

2392

op = Tokens.Assign;

2393

break;

2394

case AssignmentOperatorType.Add:

2395

op = Tokens.PlusAssign;

2396

break;

2397

case AssignmentOperatorType.Subtract:

2398

op = Tokens.MinusAssign;

2399

break;

2400

case AssignmentOperatorType.Multiply:

2401

op = Tokens.TimesAssign;

2402

break;

2403

case AssignmentOperatorType.Divide:

2404

op = Tokens.DivAssign;

2405

break;

2406

case AssignmentOperatorType.ShiftLeft:

2407

op = Tokens.ShiftLeftAssign;

2408

break;

2409

case AssignmentOperatorType.ShiftRight:

2410

op = Tokens.ShiftRightAssign;

2411

break;

2412

2413

case AssignmentOperatorType.ExclusiveOr:

2414

op = Tokens.Xor;

2415

unsupportedOpAssignment = true;

2416

break;

2417

case AssignmentOperatorType.Modulus:

2418

op = Tokens.Mod;

2419

unsupportedOpAssignment = true;

2420

break;

2421

case AssignmentOperatorType.BitwiseAnd:

2422

op = Tokens.And;

2423

unsupportedOpAssignment = true;

2424

break;

2425

case AssignmentOperatorType.BitwiseOr:

2426

op = Tokens.Or;

2427

unsupportedOpAssignment = true;

2428

break;

2429

}

2430

2431

TrackedVisit(assignmentExpression.Left, data);

2432

outputFormatter.Space();

2433

2434

if (unsupportedOpAssignment) { // left = left OP right

2435

outputFormatter.PrintToken(Tokens.Assign);

2436

outputFormatter.Space();

2437

TrackedVisit(assignmentExpression.Left, data);

2438

outputFormatter.Space();

2439

}

2440

2441

outputFormatter.PrintToken(op);

2442

outputFormatter.Space();

2443

TrackedVisit(assignmentExpression.Right, data);

2444

2445

return null;

2446

}

2447

2448

public override object TrackedVisitSizeOfExpression(SizeOfExpression sizeOfExpression, object data)

2449

{

2450

if (!sizeOfExpression.TypeReference.IsArrayType && sizeOfExpression.TypeReference.PointerNestingLevel == 0) {

2451

switch (sizeOfExpression.TypeReference.Type) {

2452

case "System.Byte":

2453

case "System.SByte":

2454

outputFormatter.PrintText("1");

2455

return null;

2456

case "System.Char":

2457

case "System.Int16":

2458

case "System.UInt16":

2459

outputFormatter.PrintText("2");

2460

return null;

2461

case "System.Single":

2462

case "System.Int32":

2463

case "System.UInt32":

2464

outputFormatter.PrintText("4");

2465

return null;

2466

case "System.Double":

2467

case "System.Int64":

2468

case "System.UInt64":

2469

outputFormatter.PrintText("8");

2470

return null;

2471

}

2472

}

2473

UnsupportedNode(sizeOfExpression);

2474

outputFormatter.PrintText("sizeof(");

2475

TrackedVisit(sizeOfExpression.TypeReference, data);

2476

outputFormatter.PrintText(")");

2477

return null;

2478

}

2479

2480

public override object TrackedVisitTypeOfExpression(TypeOfExpression typeOfExpression, object data)

2481

{

2482

outputFormatter.PrintToken(Tokens.GetType);

2483

outputFormatter.PrintToken(Tokens.OpenParenthesis);

2484

TrackedVisit(typeOfExpression.TypeReference, data);

2485

outputFormatter.PrintToken(Tokens.CloseParenthesis);

2486

return null;

2487

}

2488

2489

public override object TrackedVisitDefaultValueExpression(DefaultValueExpression defaultValueExpression, object data)

2490

{

2491

// assigning nothing to a generic type in VB compiles to a DefaultValueExpression

2492

outputFormatter.PrintToken(Tokens.Nothing);

2493

return null;

2494

}

2495

2496

public override object TrackedVisitTypeOfIsExpression(TypeOfIsExpression typeOfIsExpression, object data)

2497

{

2498

outputFormatter.PrintToken(Tokens.TypeOf);

2499

outputFormatter.Space();

2500

TrackedVisit(typeOfIsExpression.Expression, data);

2501

outputFormatter.Space();

2502

outputFormatter.PrintToken(Tokens.Is);

2503

outputFormatter.Space();

2504

TrackedVisit(typeOfIsExpression.TypeReference, data);

2505

return null;

2506

}

2507

2508

public override object TrackedVisitAddressOfExpression(AddressOfExpression addressOfExpression, object data)

2509

{

2510

outputFormatter.PrintToken(Tokens.AddressOf);

2511

outputFormatter.Space();

2512

TrackedVisit(addressOfExpression.Expression, data);

2513

return null;

2514

}

2515

2516

public override object TrackedVisitAnonymousMethodExpression(AnonymousMethodExpression anonymousMethodExpression, object data)

2517

{

2518

OutputAnonymousMethodWithStatementBody(anonymousMethodExpression.Parameters, anonymousMethodExpression.Body);

2519

return null;

2520

}

2521

2522

public override object TrackedVisitCheckedExpression(CheckedExpression checkedExpression, object data)

2523

{

2524

UnsupportedNode(checkedExpression);

2525

return TrackedVisit(checkedExpression.Expression, data);

2526

}

2527

2528

public override object TrackedVisitUncheckedExpression(UncheckedExpression uncheckedExpression, object data)

2529

{

2530

UnsupportedNode(uncheckedExpression);

2531

return TrackedVisit(uncheckedExpression.Expression, data);

2532

}

2533

2534

public override object TrackedVisitPointerReferenceExpression(PointerReferenceExpression pointerReferenceExpression, object data)

2535

{

2536

UnsupportedNode(pointerReferenceExpression);

2537

TrackedVisit(pointerReferenceExpression.TargetObject, data);

2538

outputFormatter.PrintText(".");

2539

outputFormatter.PrintIdentifier(pointerReferenceExpression.MemberName);

2540

PrintTypeArguments(pointerReferenceExpression.TypeArguments);

2541

return null;

2542

}

2543

2544

public override object TrackedVisitCastExpression(CastExpression castExpression, object data)

2545

{

2546

if (castExpression.CastType == CastType.TryCast) {

2547

return PrintCast(Tokens.TryCast, castExpression);

2548

}

2549

if (castExpression.CastType == CastType.Cast || castExpression.CastTo.IsArrayType) {

2550

return PrintCast(Tokens.DirectCast, castExpression);

2551

}

2552

switch (castExpression.CastTo.Type) {

2553

case "System.Boolean":

2554

outputFormatter.PrintToken(Tokens.CBool);

2555

break;

2556

case "System.Byte":

2557

outputFormatter.PrintToken(Tokens.CByte);

2558

break;

2559

case "System.SByte":

2560

outputFormatter.PrintToken(Tokens.CSByte);

2561

break;

2562

case "System.Char":

2563

outputFormatter.PrintToken(Tokens.CChar);

2564

break;

2565

case "System.DateTime":

2566

outputFormatter.PrintToken(Tokens.CDate);

2567

break;

2568

case "System.Decimal":

2569

outputFormatter.PrintToken(Tokens.CDec);

2570

break;

2571

case "System.Double":

2572

outputFormatter.PrintToken(Tokens.CDbl);

2573

break;

2574

case "System.Int16":

2575

outputFormatter.PrintToken(Tokens.CShort);

2576

break;

2577

case "System.Int32":

2578

outputFormatter.PrintToken(Tokens.CInt);

2579

break;

2580

case "System.Int64":

2581

outputFormatter.PrintToken(Tokens.CLng);

2582

break;

2583

case "System.UInt16":

2584

outputFormatter.PrintToken(Tokens.CUShort);

2585

break;

2586

case "System.UInt32":

2587

outputFormatter.PrintToken(Tokens.CUInt);

2588

break;

2589

case "System.UInt64":

2590

outputFormatter.PrintToken(Tokens.CULng);

2591

break;

2592

case "System.Object":

2593

outputFormatter.PrintToken(Tokens.CObj);

2594

break;

2595

case "System.Single":

2596

outputFormatter.PrintToken(Tokens.CSng);

2597

break;

2598

case "System.String":

2599

outputFormatter.PrintToken(Tokens.CStr);

2600

break;

2601

default:

2602

return PrintCast(Tokens.CType, castExpression);

2603

}

2604

outputFormatter.PrintToken(Tokens.OpenParenthesis);

2605

TrackedVisit(castExpression.Expression, data);

2606

outputFormatter.PrintToken(Tokens.CloseParenthesis);

2607

return null;

2608

}

2609

2610

object PrintCast(int castToken, CastExpression castExpression)

2611

{

2612

outputFormatter.PrintToken(castToken);

2613

outputFormatter.PrintToken(Tokens.OpenParenthesis);

2614

TrackedVisit(castExpression.Expression, null);

2615

outputFormatter.PrintToken(Tokens.Comma);

2616

outputFormatter.Space();

2617

TrackedVisit(castExpression.CastTo, null);

2618

outputFormatter.PrintToken(Tokens.CloseParenthesis);

2619

return null;

2620

}

2621

2622

public override object TrackedVisitStackAllocExpression(StackAllocExpression stackAllocExpression, object data)

2623

{

2624

UnsupportedNode(stackAllocExpression);

2625

outputFormatter.PrintText("stackalloc");

2626

return null;

2627

}

2628

2629

public override object TrackedVisitIndexerExpression(IndexerExpression indexerExpression, object data)

2630

{

2631

TrackedVisit(indexerExpression.TargetObject, data);

2632

outputFormatter.PrintToken(Tokens.OpenParenthesis);

2633

AppendCommaSeparatedList(indexerExpression.Indexes);

2634

outputFormatter.PrintToken(Tokens.CloseParenthesis);

2635

return null;

2636

}

2637

2638

public override object TrackedVisitThisReferenceExpression(ThisReferenceExpression thisReferenceExpression, object data)

2639

{

2640

outputFormatter.PrintToken(Tokens.Me);

2641

return null;

2642

}

2643

2644

public override object TrackedVisitBaseReferenceExpression(BaseReferenceExpression baseReferenceExpression, object data)

2645

{

2646

outputFormatter.PrintToken(Tokens.MyBase);

2647

return null;

2648

}

2649

2650

public override object TrackedVisitObjectCreateExpression(ObjectCreateExpression objectCreateExpression, object data)

2651

{

2652

outputFormatter.PrintToken(Tokens.New);

2653

outputFormatter.Space();

2654

TrackedVisit(objectCreateExpression.CreateType, data);

2655

outputFormatter.PrintToken(Tokens.OpenParenthesis);

2656

AppendCommaSeparatedList(objectCreateExpression.Parameters);

2657

outputFormatter.PrintToken(Tokens.CloseParenthesis);

2658

return null;

2659

}

2660

2661

public override object TrackedVisitArrayCreateExpression(ArrayCreateExpression arrayCreateExpression, object data)

2662

{

2663

outputFormatter.PrintToken(Tokens.New);

2664

outputFormatter.Space();

2665

PrintTypeReferenceWithoutArray(arrayCreateExpression.CreateType);

2666

2667

if (arrayCreateExpression.Arguments.Count > 0) {

2668

outputFormatter.PrintToken(Tokens.OpenParenthesis);

2669

AppendCommaSeparatedList(arrayCreateExpression.Arguments);

2670

outputFormatter.PrintToken(Tokens.CloseParenthesis);

2671

PrintArrayRank(arrayCreateExpression.CreateType.RankSpecifier, 1);

2672

} else {

2673

PrintArrayRank(arrayCreateExpression.CreateType.RankSpecifier, 0);

2674

}

2675

2676

outputFormatter.Space();

2677

2678

if (arrayCreateExpression.ArrayInitializer.IsNull) {

2679

outputFormatter.PrintToken(Tokens.OpenCurlyBrace);

2680

outputFormatter.PrintToken(Tokens.CloseCurlyBrace);

2681

} else {

2682

TrackedVisit(arrayCreateExpression.ArrayInitializer, data);

2683

}

2684

return null;

2685

}

2686

2687

public override object TrackedVisitCollectionInitializerExpression(CollectionInitializerExpression arrayInitializerExpression, object data)

2688

{

2689

outputFormatter.PrintToken(Tokens.OpenCurlyBrace);

2690

this.AppendCommaSeparatedList(arrayInitializerExpression.CreateExpressions);

2691

outputFormatter.PrintToken(Tokens.CloseCurlyBrace);

2692

return null;

2693

}

2694

2695

public override object TrackedVisitMemberReferenceExpression(MemberReferenceExpression memberReferenceExpression, object data)

2696

{

2697

TrackedVisit(memberReferenceExpression.TargetObject, data);

2698

outputFormatter.PrintToken(Tokens.Dot);

2699

outputFormatter.PrintIdentifier(memberReferenceExpression.MemberName);

2700

PrintTypeArguments(memberReferenceExpression.TypeArguments);

2701

return null;

2702

}

2703

2704

public override object TrackedVisitDirectionExpression(DirectionExpression directionExpression, object data)

2705

{

2706

// VB does not need to specify the direction in method calls

2707

TrackedVisit(directionExpression.Expression, data);

2708

return null;

2709

}

2710

2711

2712

public override object TrackedVisitConditionalExpression(ConditionalExpression conditionalExpression, object data)

2713

{

2714

outputFormatter.PrintText("If");

2715

outputFormatter.PrintToken(Tokens.OpenParenthesis);

2716

TrackedVisit(conditionalExpression.Condition, data);

2717

outputFormatter.PrintToken(Tokens.Comma);

2718

outputFormatter.Space();

2719

TrackedVisit(conditionalExpression.TrueExpression, data);

2720

outputFormatter.PrintToken(Tokens.Comma);

2721

outputFormatter.Space();

2722

TrackedVisit(conditionalExpression.FalseExpression, data);

2723

outputFormatter.PrintToken(Tokens.CloseParenthesis);

2724

return null;

2725

}

2726

2727

#endregion

2728

#endregion

2729

2730

2731

void OutputModifier(ParameterModifiers modifier, Location position)

2732

{

2733

switch (modifier) {

2734

case ParameterModifiers.None:

2735

case ParameterModifiers.In:

2736

if (prettyPrintOptions.OutputByValModifier) {

2737

outputFormatter.PrintToken(Tokens.ByVal);

2738

outputFormatter.Space();

2739

}

2740

break;

2741

case ParameterModifiers.Out:

2742

//Error("Out parameter converted to ByRef", position);

2743

outputFormatter.PrintToken(Tokens.ByRef);

2744

outputFormatter.Space();

2745

break;

2746

case ParameterModifiers.Params:

2747

outputFormatter.PrintToken(Tokens.ParamArray);

2748

outputFormatter.Space();

2749

break;

2750

case ParameterModifiers.Ref:

2751

outputFormatter.PrintToken(Tokens.ByRef);

2752

outputFormatter.Space();

2753

break;

2754

case ParameterModifiers.Optional:

2755

outputFormatter.PrintToken(Tokens.Optional);

2756

outputFormatter.Space();

2757

break;

2758

default:

2759

Error(String.Format("Unsupported modifier : {0}", modifier), position);

2760

break;

2761

}

2762

}

2763

2764

void OutputModifier(Modifiers modifier)

2765

{

2766

OutputModifier(modifier, false);

2767

}

2768

2769

void OutputModifier(Modifiers modifier, bool forTypeDecl)

2770

{

2771

if ((modifier & Modifiers.Public) == Modifiers.Public) {

2772

outputFormatter.PrintToken(Tokens.Public);

2773

outputFormatter.Space();

2774

} else if ((modifier & Modifiers.Private) == Modifiers.Private) {

2775

outputFormatter.PrintToken(Tokens.Private);

2776

outputFormatter.Space();

2777

} else if ((modifier & (Modifiers.Protected | Modifiers.Internal)) == (Modifiers.Protected | Modifiers.Internal)) {

2778

outputFormatter.PrintToken(Tokens.Protected);

2779

outputFormatter.Space();

2780

outputFormatter.PrintToken(Tokens.Friend);

2781

outputFormatter.Space();

2782

} else if ((modifier & Modifiers.Internal) == Modifiers.Internal) {

2783

outputFormatter.PrintToken(Tokens.Friend);

2784

outputFormatter.Space();

2785

} else if ((modifier & Modifiers.Protected) == Modifiers.Protected) {

2786

outputFormatter.PrintToken(Tokens.Protected);

2787

outputFormatter.Space();

2788

}

2789

2790

if ((modifier & Modifiers.Static) == Modifiers.Static) {

2791

outputFormatter.PrintToken(Tokens.Shared);

2792

outputFormatter.Space();

2793

}

2794

if ((modifier & Modifiers.Virtual) == Modifiers.Virtual) {

2795

outputFormatter.PrintToken(Tokens.Overridable);

2796

outputFormatter.Space();

2797

}

2798

if ((modifier & Modifiers.Abstract) == Modifiers.Abstract) {

2799

outputFormatter.PrintToken(forTypeDecl ? Tokens.MustInherit : Tokens.MustOverride);

2800

outputFormatter.Space();

2801

}

2802

if ((modifier & Modifiers.Override) == Modifiers.Override) {

2803

outputFormatter.PrintToken(Tokens.Overloads);

2804

outputFormatter.Space();

2805

outputFormatter.PrintToken(Tokens.Overrides);

2806

outputFormatter.Space();

2807

}

2808

if ((modifier & Modifiers.New) == Modifiers.New) {

2809

outputFormatter.PrintToken(Tokens.Shadows);

2810

outputFormatter.Space();

2811

}

2812

2813

if ((modifier & Modifiers.Sealed) == Modifiers.Sealed) {

2814

outputFormatter.PrintToken(forTypeDecl ? Tokens.NotInheritable : Tokens.NotOverridable);

2815

outputFormatter.Space();

2816

}

2817

2818

if ((modifier & Modifiers.ReadOnly) == Modifiers.ReadOnly) {

2819

outputFormatter.PrintToken(Tokens.ReadOnly);

2820

outputFormatter.Space();

2821

}

2822

if ((modifier & Modifiers.WriteOnly) == Modifiers.WriteOnly) {

2823

outputFormatter.PrintToken(Tokens.WriteOnly);

2824

outputFormatter.Space();

2825

}

2826

if ((modifier & Modifiers.Const) == Modifiers.Const) {

2827

outputFormatter.PrintToken(Tokens.Const);

2828

outputFormatter.Space();

2829

}

2830

if ((modifier & Modifiers.Partial) == Modifiers.Partial) {

2831

outputFormatter.PrintToken(Tokens.Partial);

2832

outputFormatter.Space();

2833

}

2834

2835

if ((modifier & Modifiers.Extern) == Modifiers.Extern) {

2836

// not required in VB

2837

}

2838

2839

if ((modifier & Modifiers.Volatile) == Modifiers.Volatile) {

2840

Error("'Volatile' modifier not convertable", Location.Empty);

2841

}

2842

2843

if ((modifier & Modifiers.Unsafe) == Modifiers.Unsafe) {

2844

Error("'Unsafe' modifier not convertable", Location.Empty);

2845

}

2846

}

2847

2848

public void AppendCommaSeparatedList<T>(ICollection<T> list) where T : class, INode

2849

{

2850

if (list != null) {

2851

int i = 0;

2852

foreach (T node in list) {

2853

TrackedVisit(node, null);

2854

if (i + 1 < list.Count) {

2855

outputFormatter.PrintToken(Tokens.Comma);

2856

outputFormatter.Space();

2857

if ((i + 1) % 6 == 0) {

2858

outputFormatter.PrintLineContinuation();

2859

outputFormatter.Indent();

2860

outputFormatter.PrintText("\t");

2861

}

2862

}

2863

i++;

2864

}

2865

}

2866

}

2867

2868

void VisitAttributes(ICollection attributes, object data)

2869

{

2870

if (attributes == null) {

2871

return;

2872

}

2873

foreach (AttributeSection section in attributes) {

2874

if (string.Equals(section.AttributeTarget, "return", StringComparison.OrdinalIgnoreCase))

2875

continue;

2876

TrackedVisit(section, data);

2877

}

2878

}

2879

2880

void VisitReturnTypeAttributes(ICollection attributes, object data)

2881

{

2882

if (attributes == null) {

2883

return;

2884

}

2885

printAttributeSectionInline = true;

2886

foreach (AttributeSection section in attributes) {

2887

if (string.Equals(section.AttributeTarget, "return", StringComparison.OrdinalIgnoreCase)) {

2888

TrackedVisit(section, data);

2889

}

2890

}

2891

printAttributeSectionInline = false;

2892

}

2893

2894

public override object TrackedVisitLambdaExpression(LambdaExpression lambdaExpression, object data)

2895

{

2896

if (!lambdaExpression.ExpressionBody.IsNull) {

2897

outputFormatter.PrintToken(Tokens.Function);

2898

outputFormatter.PrintToken(Tokens.OpenParenthesis);

2899

AppendCommaSeparatedList(lambdaExpression.Parameters);

2900

outputFormatter.PrintToken(Tokens.CloseParenthesis);

2901

outputFormatter.Space();

2902

return lambdaExpression.ExpressionBody.AcceptVisitor(this, data);

2903

} else {

2904

OutputAnonymousMethodWithStatementBody(lambdaExpression.Parameters, lambdaExpression.StatementBody);

2905

return null;

2906

}

2907

}

2908

2909

void OutputAnonymousMethodWithStatementBody(List<ParameterDeclarationExpression> parameters, BlockStatement body)

2910

{

2911

Error("VB does not support anonymous methods/lambda expressions with a statement body", body.StartLocation);

2912

2913

outputFormatter.PrintToken(Tokens.Function);

2914

outputFormatter.PrintToken(Tokens.OpenParenthesis);

2915

AppendCommaSeparatedList(parameters);

2916

outputFormatter.PrintToken(Tokens.CloseParenthesis);

2917

outputFormatter.Space();

2918

outputFormatter.PrintToken(Tokens.Do);

2919

outputFormatter.NewLine();

2920

2921

++outputFormatter.IndentationLevel;

2922

exitTokenStack.Push(Tokens.Function);

2923

body.AcceptVisitor(this, null);

2924

exitTokenStack.Pop();

2925

--outputFormatter.IndentationLevel;

2926

2927

outputFormatter.Indent();

2928

outputFormatter.PrintToken(Tokens.End);

2929

outputFormatter.Space();

2930

outputFormatter.PrintToken(Tokens.Function);

2931

}

2932

2933

public override object TrackedVisitQueryExpression(QueryExpression queryExpression, object data)

2934

{

2935

if (queryExpression.IsQueryContinuation) {

2936

queryExpression.FromClause.InExpression.AcceptVisitor(this, data);

2937

}

2938

outputFormatter.IndentationLevel++;

2939

if (queryExpression.IsQueryContinuation) {

2940

outputFormatter.PrintToken(Tokens.Into);

2941

outputFormatter.PrintIdentifier(queryExpression.FromClause.Identifier);

2942

} else {

2943

queryExpression.FromClause.AcceptVisitor(this, data);

2944

}

2945

queryExpression.MiddleClauses.ForEach(PrintClause);

2946

PrintClause(queryExpression.SelectOrGroupClause);

2947

outputFormatter.IndentationLevel--;

2948

return null;

2949

}

2950

2951

void PrintClause(QueryExpressionClause clause)

2952

{

2953

if (!clause.IsNull) {

2954

outputFormatter.PrintLineContinuation();

2955

outputFormatter.Indent();

2956

clause.AcceptVisitor(this, null);

2957

}

2958

}

2959

2960

public override object TrackedVisitQueryExpressionFromClause(QueryExpressionFromClause fromClause, object data)

2961

{

2962

outputFormatter.PrintText("From");

2963

outputFormatter.Space();

2964

VisitQueryExpressionFromOrJoinClause(fromClause, data);

2965

return null;

2966

}

2967

2968

public override object TrackedVisitQueryExpressionJoinClause(QueryExpressionJoinClause joinClause, object data)

2969

{

2970

outputFormatter.PrintText("Join");

2971

outputFormatter.Space();

2972

VisitQueryExpressionFromOrJoinClause(joinClause, data);

2973

outputFormatter.Space();

2974

outputFormatter.PrintToken(Tokens.On);

2975

outputFormatter.Space();

2976

joinClause.OnExpression.AcceptVisitor(this, data);

2977

outputFormatter.Space();

2978

outputFormatter.PrintToken(Tokens.Assign);

2979

outputFormatter.Space();

2980

joinClause.EqualsExpression.AcceptVisitor(this, data);

2981

if (!string.IsNullOrEmpty(joinClause.IntoIdentifier)) {

2982

outputFormatter.Space();

2983

outputFormatter.PrintText("Into");

2984

outputFormatter.Space();

2985

outputFormatter.PrintIdentifier(joinClause.IntoIdentifier);

2986

}

2987

return null;

2988

}

2989

2990

void VisitQueryExpressionFromOrJoinClause(QueryExpressionFromOrJoinClause clause, object data)

2991

{

2992

outputFormatter.PrintIdentifier(clause.Identifier);

2993

outputFormatter.Space();

2994

outputFormatter.PrintToken(Tokens.In);

2995

outputFormatter.Space();

2996

clause.InExpression.AcceptVisitor(this, data);

2997

}

2998

2999

public override object TrackedVisitQueryExpressionLetClause(QueryExpressionLetClause letClause, object data)

3000

{

3001

outputFormatter.PrintToken(Tokens.Let);

3002

outputFormatter.Space();

3003

outputFormatter.PrintIdentifier(letClause.Identifier);

3004

outputFormatter.Space();

3005

outputFormatter.PrintToken(Tokens.Assign);

3006

outputFormatter.Space();

3007

return letClause.Expression.AcceptVisitor(this, data);

3008

}

3009

3010

public override object TrackedVisitQueryExpressionGroupClause(QueryExpressionGroupClause groupClause, object data)

3011

{

3012

outputFormatter.PrintText("Group");

3013

outputFormatter.Space();

3014

groupClause.Projection.AcceptVisitor(this, data);

3015

outputFormatter.Space();

3016

outputFormatter.PrintText("By");

3017

outputFormatter.Space();

3018

return groupClause.GroupBy.AcceptVisitor(this, data);

3019

}

3020

3021

public override object TrackedVisitQueryExpressionOrderClause(QueryExpressionOrderClause queryExpressionOrderClause, object data)

3022

{

3023

outputFormatter.PrintText("Order By");

3024

outputFormatter.Space();

3025

AppendCommaSeparatedList(queryExpressionOrderClause.Orderings);

3026

return null;

3027

}

3028

3029

public override object TrackedVisitQueryExpressionOrdering(QueryExpressionOrdering ordering, object data)

3030

{

3031

ordering.Criteria.AcceptVisitor(this, data);

3032

if (ordering.Direction == QueryExpressionOrderingDirection.Ascending) {

3033

outputFormatter.Space();

3034

outputFormatter.PrintText("Ascending");

3035

} else if (ordering.Direction == QueryExpressionOrderingDirection.Descending) {

3036

outputFormatter.Space();

3037

outputFormatter.PrintText("Descending");

3038

}

3039

return null;

3040

}

3041

3042

public override object TrackedVisitQueryExpressionSelectClause(QueryExpressionSelectClause selectClause, object data)

3043

{

3044

outputFormatter.PrintToken(Tokens.Select);

3045

outputFormatter.Space();

3046

return selectClause.Projection.AcceptVisitor(this, data);

3047

}

3048

3049

public override object TrackedVisitQueryExpressionWhereClause(QueryExpressionWhereClause whereClause, object data)

3050

{

3051

outputFormatter.PrintText("Where");

3052

outputFormatter.Space();

3053

return whereClause.Condition.AcceptVisitor(this, data);

3054

}

3055

3056

public override object TrackedVisitExternAliasDirective(ExternAliasDirective externAliasDirective, object data)

3057

{

3058

UnsupportedNode(externAliasDirective);

3059

return null;

3060

}

3061

}

3062

}

Older »