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

public void SetSignature(Type returnType, Type[] returnTypeRequiredCustomModifiers, Type[] returnTypeOptionalCustomModifiers, Type[] parameterTypes, Type[][] parameterTypeRequiredCustomModifiers, Type[][] parameterTypeOptionalCustomModifiers)

349

{

350

SetSignature(returnType, parameterTypes, PackedCustomModifiers.CreateFromExternal(returnTypeOptionalCustomModifiers, returnTypeRequiredCustomModifiers,

351

parameterTypeOptionalCustomModifiers, parameterTypeRequiredCustomModifiers, Util.NullSafeLength(parameterTypes)));

352

}

353

354

public void __SetSignature(Type returnType, CustomModifiers returnTypeCustomModifiers, Type[] parameterTypes, CustomModifiers[] parameterTypeCustomModifiers)

355

{

356

SetSignature(returnType, parameterTypes, PackedCustomModifiers.CreateFromExternal(returnTypeCustomModifiers, parameterTypeCustomModifiers, Util.NullSafeLength(parameterTypes)));

357

}

358

359

private void SetSignature(Type returnType, Type[] parameterTypes, PackedCustomModifiers customModifiers)

360

{

361

CheckSig();

362

this.returnType = returnType ?? this.Module.universe.System_Void;

363

this.parameterTypes = Util.Copy(parameterTypes);

364

this.customModifiers = customModifiers;

365

}

366

367

public GenericTypeParameterBuilder[] DefineGenericParameters(params string[] names)

368

{

369

CheckSig();

370

if (gtpb != null)

371

{

372

throw new InvalidOperationException("Generic parameters already defined.");

373

}

374

gtpb = new GenericTypeParameterBuilder[names.Length];

375

for (int i = 0; i < names.Length; i++)

376

{

377

gtpb[i] = new GenericTypeParameterBuilder(names[i], null, this, i);

378

}

379

return (GenericTypeParameterBuilder[])gtpb.Clone();

380

}

381

382

public override MethodInfo MakeGenericMethod(params Type[] typeArguments)

383

{

384

return new GenericMethodInstance(typeBuilder, this, typeArguments);

385

}

386

387

public override MethodInfo GetGenericMethodDefinition()

388

{

389

if (gtpb == null)

390

{

391

throw new InvalidOperationException();

392

}

393

return this;

394

}

395

396

public override Type[] GetGenericArguments()

397

{

398

return Util.Copy(gtpb);

399

}

400

401

internal override Type GetGenericMethodArgument(int index)

402

{

403

return gtpb[index];

404

}

405

406

internal override int GetGenericMethodArgumentCount()

407

{

408

return gtpb == null ? 0 : gtpb.Length;

409

}

410

411

public override Type ReturnType

412

{

413

get { return returnType; }

414

}

415

416

public override ParameterInfo ReturnParameter

417

{

418

get { return new ParameterInfoImpl(this, -1); }

419

}

420

421

public override MethodAttributes Attributes

422

{

423

get { return attributes; }

424

}

425

426

public void __SetAttributes(MethodAttributes attributes)

427

{

428

this.attributes = attributes;

429

}

430

431

public void __SetCallingConvention(CallingConventions callingConvention)

432

{

433

this.callingConvention = callingConvention;

434

this.methodSignature = null;

435

}

436

437

public override MethodImplAttributes GetMethodImplementationFlags()

438

{

439

return implFlags;

440

}

441

442

private sealed class ParameterInfoImpl : ParameterInfo

443

{

444

private readonly MethodBuilder method;

445

private readonly int parameter;

446

447

internal ParameterInfoImpl(MethodBuilder method, int parameter)

448

{

449

this.method = method;

450

this.parameter = parameter;

451

}

452

453

private ParameterBuilder ParameterBuilder

454

{

455

get

456

{

457

if (method.parameters != null)

458

{

459

foreach (ParameterBuilder pb in method.parameters)

460

{

461

// ParameterBuilder.Position is 1-based

462

if (pb.Position - 1 == parameter)

463

{

464

return pb;

465

}

466

}

467

}

468

return null;

469

}

470

}

471

472

public override string Name

473

{

474

get

475

{

476

ParameterBuilder pb = this.ParameterBuilder;

477

return pb != null ? pb.Name : null;

478

}

479

}

480

481

public override Type ParameterType

482

{

483

get { return parameter == -1 ? method.returnType : method.parameterTypes[parameter]; }

484

}

485

486

public override ParameterAttributes Attributes

487

{

488

get

489

{

490

ParameterBuilder pb = this.ParameterBuilder;

491

return pb != null ? (ParameterAttributes)pb.Attributes : ParameterAttributes.None;

492

}

493

}

494

495

public override int Position

496

{

497

get { return parameter; }

498

}

499

500

public override object RawDefaultValue

501

{

502

get

503

{

504

ParameterBuilder pb = this.ParameterBuilder;

505

if (pb != null && (pb.Attributes & (int)ParameterAttributes.HasDefault) != 0)

506

{

507

return method.ModuleBuilder.Constant.GetRawConstantValue(method.ModuleBuilder, pb.PseudoToken);

508

}

509

if (pb != null && (pb.Attributes & (int)ParameterAttributes.Optional) != 0)

510

{

511

return Missing.Value;

512

}

513

return null;

514

}

515

}

516

517

public override CustomModifiers __GetCustomModifiers()

518

{

519

return method.customModifiers.GetParameterCustomModifiers(parameter);

520

}

521

522

public override bool __TryGetFieldMarshal(out FieldMarshal fieldMarshal)

523

{

524

fieldMarshal = new FieldMarshal();

525

return false;

526

}

527

528

public override MemberInfo Member

529

{

530

get { return method; }

531

}

532

533

public override int MetadataToken

534

{

535

get

536

{

537

ParameterBuilder pb = this.ParameterBuilder;

538

return pb != null ? pb.PseudoToken : 0x08000000;

539

}

540

}

541

542

internal override Module Module

543

{

544

get { return method.Module; }

545

}

546

}

547

548

public override ParameterInfo[] GetParameters()

549

{

550

ParameterInfo[] parameters = new ParameterInfo[parameterTypes.Length];

551

for (int i = 0; i < parameters.Length; i++)

552

{

553

parameters[i] = new ParameterInfoImpl(this, i);

554

}

555

return parameters;

556

}

557

558

internal override int ParameterCount

559

{

560

get { return parameterTypes.Length; }

561

}

562

563

public override Type DeclaringType

564

{

565

get { return typeBuilder.IsModulePseudoType ? null : typeBuilder; }

566

}

567

568

public override string Name

569

{

570

get { return name; }

571

}

572

573

public override CallingConventions CallingConvention

574

{

575

get { return callingConvention; }

576

}

577

578

public override int MetadataToken

579

{

580

get { return pseudoToken; }

581

}

582

583

public override bool IsGenericMethod

584

{

585

get { return gtpb != null; }

586

}

587

588

public override bool IsGenericMethodDefinition

589

{

590

get { return gtpb != null; }

591

}

592

593

public override Module Module

594

{

595

get { return typeBuilder.Module; }

596

}

597

598

public Module GetModule()

599

{

600

return typeBuilder.Module;

601

}

602

603

public MethodToken GetToken()

604

{

605

return new MethodToken(pseudoToken);

606

}

607

608

public override MethodBody GetMethodBody()

609

{

610

throw new NotSupportedException();

611

}

612

613

public override int __MethodRVA

614

{

615

get { throw new NotImplementedException(); }

616

}

617

618

public bool InitLocals

619

{

620

get { return initLocals; }

621

set { initLocals = value; }

622

}

623

624

public void __AddUnmanagedExport(string name, int ordinal)

625

{

626

this.ModuleBuilder.AddUnmanagedExport(name, ordinal, this, new RelativeVirtualAddress(0xFFFFFFFF));

627

}

628

629

public void CreateMethodBody(byte[] il, int count)

630

{

631

if (il == null)

632

{

633

throw new NotSupportedException();

634

}

635

if (il.Length != count)

636

{

637

Array.Resize(ref il, count);

638

}

639

SetMethodBody(il, 16, null, null, null);

640

}

641

642

public void SetMethodBody(byte[] il, int maxStack, byte[] localSignature, IEnumerable<ExceptionHandler> exceptionHandlers, IEnumerable<int> tokenFixups)

643

{

644

ByteBuffer bb = this.ModuleBuilder.methodBodies;

645

646

if (localSignature == null && exceptionHandlers == null && maxStack <= 8 && il.Length < 64)

647

{

648

rva = bb.Position;

649

ILGenerator.WriteTinyHeader(bb, il.Length);

650

}

651

else

652

{

653

// fat headers require 4-byte alignment

654

bb.Align(4);

655

rva = bb.Position;

656

ILGenerator.WriteFatHeader(bb, initLocals, exceptionHandlers != null, (ushort)maxStack, il.Length,

657

localSignature == null ? 0 : this.ModuleBuilder.GetSignatureToken(localSignature, localSignature.Length).Token);

658

}

659

660

if (tokenFixups != null)

661

{

662

ILGenerator.AddTokenFixups(bb.Position, this.ModuleBuilder.tokenFixupOffsets, tokenFixups);

663

}

664

bb.Write(il);

665

666

if (exceptionHandlers != null)

667

{

668

List<ILGenerator.ExceptionBlock> exceptions = new List<ILGenerator.ExceptionBlock>();

669

foreach (ExceptionHandler block in exceptionHandlers)

670

{

671

exceptions.Add(new ILGenerator.ExceptionBlock(block));

672

}

673

ILGenerator.WriteExceptionHandlers(bb, exceptions);

674

}

675

}

676

677

internal void Bake()

678

{

679

this.nameIndex = this.ModuleBuilder.Strings.Add(name);

680

this.signature = this.ModuleBuilder.GetSignatureBlobIndex(this.MethodSignature);

681

682

__ReleaseILGenerator();

683

684

if (declarativeSecurity != null)

685

{

686

this.ModuleBuilder.AddDeclarativeSecurity(pseudoToken, declarativeSecurity);

687

}

688

}

689

690

internal ModuleBuilder ModuleBuilder

691

{

692

get { return typeBuilder.ModuleBuilder; }

693

}

694

695

internal void WriteMethodDefRecord(int baseRVA, MetadataWriter mw, ref int paramList)

696

{

697

if (rva != -1)

698

{

699

mw.Write(rva + baseRVA);

700

}

701

else

702

{

703

mw.Write(0);

704

}

705

mw.Write((short)implFlags);

706

mw.Write((short)attributes);

707

mw.WriteStringIndex(nameIndex);

708

mw.WriteBlobIndex(signature);

709

mw.WriteParam(paramList);

710

if (parameters != null)

711

{

712

paramList += parameters.Count;

713

}

714

}

715

716

internal void WriteParamRecords(MetadataWriter mw)

717

{

718

if (parameters != null)

719

{

720

foreach (ParameterBuilder pb in parameters)

721

{

722

pb.WriteParamRecord(mw);

723

}

724

}

725

}

726

727

internal void FixupToken(int token, ref int parameterToken)

728

{

729

typeBuilder.ModuleBuilder.RegisterTokenFixup(this.pseudoToken, token);

730

if (parameters != null)

731

{

732

foreach (ParameterBuilder pb in parameters)

733

{

734

pb.FixupToken(parameterToken++);

735

}

736

}

737

}

738

739

internal override MethodSignature MethodSignature

740

{

741

get

742

{

743

if (methodSignature == null)

744

{

745

methodSignature = MethodSignature.MakeFromBuilder(returnType, parameterTypes, customModifiers, callingConvention, gtpb == null ? 0 : gtpb.Length);

746

}

747

return methodSignature;

748

}

749

}

750

751

internal override int ImportTo(ModuleBuilder other)

752

{

753

return other.ImportMethodOrField(typeBuilder, name, this.MethodSignature);

754

}

755

756

internal void CheckBaked()

757

{

758

typeBuilder.CheckBaked();

759

}

760

761

internal override int GetCurrentToken()

762

{

763

if (typeBuilder.ModuleBuilder.IsSaved)

764

{

765

return typeBuilder.ModuleBuilder.ResolvePseudoToken(pseudoToken);

766

}

767

else

768

{

769

return pseudoToken;

770

}

771

}

772

773

internal override bool IsBaked

774

{

775

get { return typeBuilder.IsBaked; }

776

}

777

}

778

}

Older »