diff options
27 files changed, 300 insertions, 353 deletions
diff --git a/Mono.Cecil.Cil/CodeReader.cs b/Mono.Cecil.Cil/CodeReader.cs index 61d04d9..7165ed0 100644 --- a/Mono.Cecil.Cil/CodeReader.cs +++ b/Mono.Cecil.Cil/CodeReader.cs @@ -35,58 +35,38 @@ using RVA = System.UInt32; namespace Mono.Cecil.Cil { - sealed class CodeReader : ByteBuffer { + sealed class CodeReader : BinaryStreamReader { readonly internal MetadataReader reader; int start; - Section code_section; - MethodDefinition method; MethodBody body; int Offset { - get { return base.position - start; } + get { return Position - start; } } - public CodeReader (Section section, MetadataReader reader) - : base (section.Data) + public CodeReader (MethodDefinition method, MetadataReader reader) + : base (reader.image.Stream) { - this.code_section = section; this.reader = reader; + this.reader.context = method; + this.Position = (int) reader.image.ResolveVirtualAddress ((uint) method.RVA); } - public MethodBody ReadMethodBody (MethodDefinition method) + public static MethodBody ReadMethodBody (MethodDefinition method, MetadataReader metadata) { - this.method = method; - this.body = new MethodBody (method); + var reader = new CodeReader (method, metadata); + reader.body = new MethodBody (method); - reader.context = method; + reader.ReadMethodBody (); - ReadMethodBody (); - - return this.body; - } - - public void MoveTo (int rva) - { - if (!IsInSection (rva)) { - code_section = reader.image.GetSectionAtVirtualAddress ((uint) rva); - Reset (code_section.Data); - } - - base.position = rva - (int) code_section.VirtualAddress; - } - - bool IsInSection (int rva) - { - return code_section.VirtualAddress <= rva && rva < code_section.VirtualAddress + code_section.SizeOfRawData; + return reader.body; } void ReadMethodBody () { - MoveTo (method.RVA); - var flags = ReadByte (); switch (flags & 0x3) { case 0x2: // tiny @@ -95,7 +75,7 @@ namespace Mono.Cecil.Cil { ReadCode (); break; case 0x3: // fat - base.position--; + Advance (-1); ReadFatMethod (); break; default: @@ -138,17 +118,17 @@ namespace Mono.Cecil.Cil { void ReadCode () { - start = position; + start = Position; var code_size = body.code_size; - if (code_size < 0 || buffer.Length <= (uint) (code_size + position)) + if (code_size < 0 || Length <= (uint) (code_size + Position)) code_size = 0; var end = start + code_size; var instructions = body.instructions = new InstructionCollection (code_size / 3); - while (position < end) { - var offset = base.position - start; + while (Position < end) { + var offset = Position - start; var opcode = ReadOpCode (); var current = new Instruction (offset, opcode); @@ -323,7 +303,7 @@ namespace Mono.Cecil.Cil { void ReadFatSection () { - position--; + Advance (-1); var count = (ReadInt32 () >> 8) / 24; ReadExceptionHandlers ( @@ -369,6 +349,7 @@ namespace Mono.Cecil.Cil { void Align (int align) { align--; + var position = Position; Advance (((position + align) & ~align) - position); } @@ -384,11 +365,6 @@ namespace Mono.Cecil.Cil { var buffer = new ByteBuffer (); symbols = new MethodSymbols (method.Name); - this.method = method; - reader.context = method; - - MoveTo (method.RVA); - var flags = ReadByte (); MetadataToken local_var_token; @@ -401,8 +377,7 @@ namespace Mono.Cecil.Cil { PatchRawCode (buffer, symbols.code_size, writer); break; case 0x3: // fat - base.position--; - + Advance (-1); PatchRawFatMethod (buffer, symbols, writer, out local_var_token); break; default: @@ -519,9 +494,9 @@ namespace Mono.Cecil.Cil { void PatchRawSection (ByteBuffer buffer, MetadataBuilder metadata) { - var position = base.position; + var position = Position; Align (4); - buffer.WriteBytes (base.position - position); + buffer.WriteBytes (Position - position); const byte fat_format = 0x40; const byte more_sects = 0x80; @@ -552,7 +527,7 @@ namespace Mono.Cecil.Cil { void PatchRawFatSection (ByteBuffer buffer, MetadataBuilder metadata) { - position--; + Advance (-1); var length = ReadInt32 (); buffer.WriteInt32 (length); diff --git a/Mono.Cecil.Cil/CodeWriter.cs b/Mono.Cecil.Cil/CodeWriter.cs index 02876aa..6ce8452 100644 --- a/Mono.Cecil.Cil/CodeWriter.cs +++ b/Mono.Cecil.Cil/CodeWriter.cs @@ -93,7 +93,7 @@ namespace Mono.Cecil.Cil { void WriteUnresolvedMethodBody (MethodDefinition method) { - var code_reader = metadata.module.Read (method, (_, reader) => reader.code); + var code_reader = metadata.module.Read (method, (m, reader) => new CodeReader (m, reader)); MethodSymbols symbols; var buffer = code_reader.PatchRawMethodBody (method, this, out symbols); diff --git a/Mono.Cecil.Metadata/BlobHeap.cs b/Mono.Cecil.Metadata/BlobHeap.cs index e7e2928..2488569 100644 --- a/Mono.Cecil.Metadata/BlobHeap.cs +++ b/Mono.Cecil.Metadata/BlobHeap.cs @@ -28,25 +28,21 @@ using System; -using Mono.Cecil.PE; - namespace Mono.Cecil.Metadata { sealed class BlobHeap : Heap { - public BlobHeap (Section section, uint start, uint size) - : base (section, start, size) + public BlobHeap (byte [] data) + : base (data) { } public byte [] Read (uint index) { - if (index == 0 || index > Size - 1) + if (index == 0 || index > this.data.Length - 1) return Empty<byte>.Array; - var data = Section.Data; - - int position = (int) (index + Offset); + int position = (int) index; int length = (int) data.ReadCompressedUInt32 (ref position); var buffer = new byte [length]; diff --git a/Mono.Cecil.Metadata/GuidHeap.cs b/Mono.Cecil.Metadata/GuidHeap.cs index 1adc079..4199af1 100644 --- a/Mono.Cecil.Metadata/GuidHeap.cs +++ b/Mono.Cecil.Metadata/GuidHeap.cs @@ -28,14 +28,12 @@ using System; -using Mono.Cecil.PE; - namespace Mono.Cecil.Metadata { sealed class GuidHeap : Heap { - public GuidHeap (Section section, uint start, uint size) - : base (section, start, size) + public GuidHeap (byte [] data) + : base (data) { } @@ -50,10 +48,9 @@ namespace Mono.Cecil.Metadata { index--; - Buffer.BlockCopy (Section.Data, (int) (Offset + index), buffer, 0, guid_size); + Buffer.BlockCopy (this.data, (int) index, buffer, 0, guid_size); return new Guid (buffer); - } } } diff --git a/Mono.Cecil.Metadata/Heap.cs b/Mono.Cecil.Metadata/Heap.cs index bc21acd..715e59b 100644 --- a/Mono.Cecil.Metadata/Heap.cs +++ b/Mono.Cecil.Metadata/Heap.cs @@ -26,23 +26,17 @@ // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. // -using Mono.Cecil.PE; - namespace Mono.Cecil.Metadata { abstract class Heap { public int IndexSize; - public readonly Section Section; - public readonly uint Offset; - public readonly uint Size; + internal byte [] data; - protected Heap (Section section, uint offset, uint size) + protected Heap (byte [] data) { - this.Section = section; - this.Offset = offset; - this.Size = size; + this.data = data; } } } diff --git a/Mono.Cecil.Metadata/StringHeap.cs b/Mono.Cecil.Metadata/StringHeap.cs index 4a0a0af..f195535 100644 --- a/Mono.Cecil.Metadata/StringHeap.cs +++ b/Mono.Cecil.Metadata/StringHeap.cs @@ -30,16 +30,14 @@ using System; using System.Collections.Generic; using System.Text; -using Mono.Cecil.PE; - namespace Mono.Cecil.Metadata { class StringHeap : Heap { readonly Dictionary<uint, string> strings = new Dictionary<uint, string> (); - public StringHeap (Section section, uint start, uint size) - : base (section, start, size) + public StringHeap (byte [] data) + : base (data) { } @@ -52,7 +50,7 @@ namespace Mono.Cecil.Metadata { if (strings.TryGetValue (index, out @string)) return @string; - if (index > Size - 1) + if (index > data.Length - 1) return string.Empty; @string = ReadStringAt (index); @@ -65,8 +63,7 @@ namespace Mono.Cecil.Metadata { protected virtual string ReadStringAt (uint index) { int length = 0; - byte [] data = Section.Data; - int start = (int) (index + Offset); + int start = (int) index; for (int i = start; ; i++) { if (data [i] == 0) diff --git a/Mono.Cecil.Metadata/TableHeap.cs b/Mono.Cecil.Metadata/TableHeap.cs index 9bc0edd..25a2ccc 100644 --- a/Mono.Cecil.Metadata/TableHeap.cs +++ b/Mono.Cecil.Metadata/TableHeap.cs @@ -98,8 +98,8 @@ namespace Mono.Cecil.Metadata { get { return Tables [(int) table]; } } - public TableHeap (Section section, uint start, uint size) - : base (section, start, size) + public TableHeap (byte [] data) + : base (data) { } diff --git a/Mono.Cecil.Metadata/UserStringHeap.cs b/Mono.Cecil.Metadata/UserStringHeap.cs index 5910508..7046eff 100644 --- a/Mono.Cecil.Metadata/UserStringHeap.cs +++ b/Mono.Cecil.Metadata/UserStringHeap.cs @@ -26,23 +26,18 @@ // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. // -using System; - -using Mono.Cecil.PE; - namespace Mono.Cecil.Metadata { sealed class UserStringHeap : StringHeap { - public UserStringHeap (Section section, uint start, uint size) - : base (section, start, size) + public UserStringHeap (byte [] data) + : base (data) { } protected override string ReadStringAt (uint index) { - byte [] data = Section.Data; - int start = (int) (index + Offset); + int start = (int) index; uint length = (uint) (data.ReadCompressedUInt32 (ref start) & ~1); if (length < 1) diff --git a/Mono.Cecil.PE/BinaryStreamReader.cs b/Mono.Cecil.PE/BinaryStreamReader.cs index ec2477c..77a8b44 100644 --- a/Mono.Cecil.PE/BinaryStreamReader.cs +++ b/Mono.Cecil.PE/BinaryStreamReader.cs @@ -33,17 +33,31 @@ namespace Mono.Cecil.PE { class BinaryStreamReader : BinaryReader { + public int Position { + get { return (int) BaseStream.Position; } + set { BaseStream.Position = value; } + } + + public int Length { + get { return (int) BaseStream.Length; } + } + public BinaryStreamReader (Stream stream) : base (stream) { } - protected void Advance (int bytes) + public void Advance (int bytes) { BaseStream.Seek (bytes, SeekOrigin.Current); } - protected DataDirectory ReadDataDirectory () + public void MoveTo (uint position) + { + BaseStream.Seek (position, SeekOrigin.Begin); + } + + public DataDirectory ReadDataDirectory () { return new DataDirectory (ReadUInt32 (), ReadUInt32 ()); } diff --git a/Mono.Cecil.PE/ByteBuffer.cs b/Mono.Cecil.PE/ByteBuffer.cs index c7ae7ae..4f32c09 100644 --- a/Mono.Cecil.PE/ByteBuffer.cs +++ b/Mono.Cecil.PE/ByteBuffer.cs @@ -52,12 +52,6 @@ namespace Mono.Cecil.PE { this.length = this.buffer.Length; } - public void Reset (byte [] buffer) - { - this.buffer = buffer ?? Empty<byte>.Array; - this.length = this.buffer.Length; - } - public void Advance (int length) { position += length; diff --git a/Mono.Cecil.PE/Image.cs b/Mono.Cecil.PE/Image.cs index 9a04494..8971b13 100644 --- a/Mono.Cecil.PE/Image.cs +++ b/Mono.Cecil.PE/Image.cs @@ -27,8 +27,8 @@ // using System; +using System.IO; -using Mono; using Mono.Cecil.Cil; using Mono.Cecil.Metadata; @@ -36,12 +36,13 @@ using RVA = System.UInt32; namespace Mono.Cecil.PE { - sealed class Image { + sealed class Image : IDisposable { + + public Stream Stream; public ModuleKind Kind; public TargetRuntime Runtime; public TargetArchitecture Architecture; - public string FileName; public Section [] Sections; @@ -131,29 +132,42 @@ namespace Mono.Cecil.PE { return null; } + public BinaryStreamReader GetReaderAt (RVA rva) + { + var reader = new BinaryStreamReader (Stream); + reader.MoveTo (ResolveVirtualAddress (rva)); + return reader; + } + public ImageDebugDirectory GetDebugHeader (out byte [] header) { - var section = GetSectionAtVirtualAddress (Debug.VirtualAddress); - var buffer = new ByteBuffer (section.Data); - buffer.position = (int) (Debug.VirtualAddress - section.VirtualAddress); + var reader = GetReaderAt (Debug.VirtualAddress); var directory = new ImageDebugDirectory { - Characteristics = buffer.ReadInt32 (), - TimeDateStamp = buffer.ReadInt32 (), - MajorVersion = buffer.ReadInt16 (), - MinorVersion = buffer.ReadInt16 (), - Type = buffer.ReadInt32 (), - SizeOfData = buffer.ReadInt32 (), - AddressOfRawData = buffer.ReadInt32 (), - PointerToRawData = buffer.ReadInt32 (), + Characteristics = reader.ReadInt32 (), + TimeDateStamp = reader.ReadInt32 (), + MajorVersion = reader.ReadInt16 (), + MinorVersion = reader.ReadInt16 (), + Type = reader.ReadInt32 (), + SizeOfData = reader.ReadInt32 (), + AddressOfRawData = reader.ReadInt32 (), + PointerToRawData = reader.ReadInt32 (), }; - buffer.position = (int) (directory.PointerToRawData - section.PointerToRawData); + reader = GetReaderAt ((uint) directory.AddressOfRawData); + header = reader.ReadBytes (directory.SizeOfData); + return directory; + } - header = new byte [directory.SizeOfData]; - Buffer.BlockCopy (buffer.buffer, buffer.position, header, 0, header.Length); + ~Image () + { + if (Stream != null) + Stream.Dispose (); + } - return directory; + public void Dispose () + { + Stream.Dispose (); } } } diff --git a/Mono.Cecil.PE/ImageReader.cs b/Mono.Cecil.PE/ImageReader.cs index 734b00a..1205e0b 100644 --- a/Mono.Cecil.PE/ImageReader.cs +++ b/Mono.Cecil.PE/ImageReader.cs @@ -42,12 +42,13 @@ namespace Mono.Cecil.PE { DataDirectory cli; DataDirectory metadata; + uint table_heap_offset; + public ImageReader (Stream stream) : base (stream) { image = new Image (); - - image.FileName = stream.GetFullyQualifiedName (); + image.Stream = stream; } void MoveTo (DataDirectory directory) @@ -55,11 +56,6 @@ namespace Mono.Cecil.PE { BaseStream.Position = image.ResolveVirtualAddress (directory.VirtualAddress); } - void MoveTo (uint position) - { - BaseStream.Position = position; - } - void ReadImage () { if (BaseStream.Length < 128) @@ -275,31 +271,11 @@ namespace Mono.Cecil.PE { Advance (16); sections [i] = section; - - ReadSectionData (section); } image.Sections = sections; } - void ReadSectionData (Section section) - { - var position = BaseStream.Position; - - MoveTo (section.PointerToRawData); - - var length = (int) section.SizeOfRawData; - var data = new byte [length]; - int offset = 0, read; - - while ((read = Read (data, offset, length - offset)) > 0) - offset += read; - - section.Data = data; - - BaseStream.Position = position; - } - void ReadCLIHeader () { MoveTo (cli); @@ -362,39 +338,50 @@ namespace Mono.Cecil.PE { void ReadMetadataStream (Section section) { // Offset 4 - uint start = metadata.VirtualAddress - section.VirtualAddress + ReadUInt32 (); // relative to the section start + uint offset = metadata.VirtualAddress - section.VirtualAddress + ReadUInt32 (); // relative to the section start // Size 4 uint size = ReadUInt32 (); + var data = ReadHeapData (offset, size); + var name = ReadAlignedString (16); switch (name) { case "#~": case "#-": - image.TableHeap = new TableHeap (section, start, size); + image.TableHeap = new TableHeap (data); + table_heap_offset = offset; break; case "#Strings": - image.StringHeap = new StringHeap (section, start, size); + image.StringHeap = new StringHeap (data); break; case "#Blob": - image.BlobHeap = new BlobHeap (section, start, size); + image.BlobHeap = new BlobHeap (data); break; case "#GUID": - image.GuidHeap = new GuidHeap (section, start, size); + image.GuidHeap = new GuidHeap (data); break; case "#US": - image.UserStringHeap = new UserStringHeap (section, start, size); + image.UserStringHeap = new UserStringHeap (data); break; } } + byte [] ReadHeapData (uint offset, uint size) + { + var position = BaseStream.Position; + MoveTo (offset + image.MetadataSection.PointerToRawData); + var data = ReadBytes ((int) size); + BaseStream.Position = position; + + return data; + } + void ReadTableHeap () { var heap = image.TableHeap; - uint start = heap.Section.PointerToRawData; - - MoveTo (heap.Offset + start); + MoveTo (table_heap_offset + image.MetadataSection.PointerToRawData); // Reserved 4 // MajorVersion 1 @@ -447,7 +434,7 @@ namespace Mono.Cecil.PE { void ComputeTableInformations () { - uint offset = (uint) BaseStream.Position - image.MetadataSection.PointerToRawData; // header + uint offset = (uint) BaseStream.Position - table_heap_offset - image.MetadataSection.PointerToRawData; // header int stridx_size = image.StringHeap.IndexSize; int blobidx_size = image.BlobHeap != null ? image.BlobHeap.IndexSize : 2; diff --git a/Mono.Cecil.PE/ImageWriter.cs b/Mono.Cecil.PE/ImageWriter.cs index 6f921d9..b5cdbe9 100644 --- a/Mono.Cecil.PE/ImageWriter.cs +++ b/Mono.Cecil.PE/ImageWriter.cs @@ -95,9 +95,8 @@ namespace Mono.Cecil.PE { if (rsrc == null) return; - var raw_resources = new byte [rsrc.Data.Length]; - Buffer.BlockCopy (rsrc.Data, 0, raw_resources, 0, rsrc.Data.Length); - win32_resources = new ByteBuffer (raw_resources); + var reader = module.Image.GetReaderAt (rsrc.VirtualAddress); + win32_resources = new ByteBuffer (reader.ReadBytes ((int) rsrc.SizeOfRawData)); } Section GetImageResourceSection () diff --git a/Mono.Cecil.PE/Section.cs b/Mono.Cecil.PE/Section.cs index 6a4c7ba..938d1a2 100644 --- a/Mono.Cecil.PE/Section.cs +++ b/Mono.Cecil.PE/Section.cs @@ -38,6 +38,5 @@ namespace Mono.Cecil.PE { public uint VirtualSize; public uint SizeOfRawData; public uint PointerToRawData; - public byte [] Data; } } diff --git a/Mono.Cecil/AssemblyDefinition.cs b/Mono.Cecil/AssemblyDefinition.cs index f1b5d25..70929b7 100644 --- a/Mono.Cecil/AssemblyDefinition.cs +++ b/Mono.Cecil/AssemblyDefinition.cs @@ -33,7 +33,7 @@ using Mono.Collections.Generic; namespace Mono.Cecil { - public sealed class AssemblyDefinition : ICustomAttributeProvider, ISecurityDeclarationProvider { + public sealed class AssemblyDefinition : ICustomAttributeProvider, ISecurityDeclarationProvider, IDisposable { AssemblyNameDefinition name; @@ -107,6 +107,13 @@ namespace Mono.Cecil { { } + public void Dispose () + { + var modules = this.Modules; + for (int i = 0; i < modules.Count; i++) + modules [i].Dispose (); + } + #if !READ_ONLY public static AssemblyDefinition CreateAssembly (AssemblyNameDefinition assemblyName, string moduleName, ModuleKind kind) { diff --git a/Mono.Cecil/AssemblyReader.cs b/Mono.Cecil/AssemblyReader.cs index 72cb480..9b9669c 100644 --- a/Mono.Cecil/AssemblyReader.cs +++ b/Mono.Cecil/AssemblyReader.cs @@ -364,7 +364,6 @@ namespace Mono.Cecil { readonly internal MetadataSystem metadata; internal IGenericContext context; - internal CodeReader code; uint Position { get { return (uint) base.position; } @@ -372,12 +371,11 @@ namespace Mono.Cecil { } public MetadataReader (ModuleDefinition module) - : base (module.Image.MetadataSection.Data) + : base (module.Image.TableHeap.data) { this.image = module.Image; this.module = module; this.metadata = module.MetadataSystem; - this.code = new CodeReader (image.MetadataSection, this); } int GetCodedIndexSize (CodedIndex index) @@ -660,17 +658,9 @@ namespace Mono.Cecil { public MemoryStream GetManagedResourceStream (uint offset) { - var rva = image.Resources.VirtualAddress; - var section = image.GetSectionAtVirtualAddress (rva); - var position = (rva - section.VirtualAddress) + offset; - var buffer = section.Data; - - var length = buffer [position] - | (buffer [position + 1] << 8) - | (buffer [position + 2] << 16) - | (buffer [position + 3] << 24); - - return new MemoryStream (buffer, (int) position + 4, length); + var reader = image.GetReaderAt (image.Resources.VirtualAddress); + reader.Advance ((int) offset); + return new MemoryStream (reader.ReadBytes (reader.ReadInt32 ())); } void PopulateVersionAndFlags (AssemblyNameReference name) @@ -1216,13 +1206,8 @@ namespace Mono.Cecil { byte [] GetFieldInitializeValue (int size, RVA rva) { - var section = image.GetSectionAtVirtualAddress (rva); - if (section == null) - return Empty<byte>.Array; - - var value = new byte [size]; - Buffer.BlockCopy (section.Data, (int) (rva - section.VirtualAddress), value, 0, size); - return value; + var reader = image.GetReaderAt (rva); + return reader.ReadBytes (size); } static int GetFieldTypeSize (TypeReference type) @@ -1980,7 +1965,7 @@ namespace Mono.Cecil { public MethodBody ReadMethodBody (MethodDefinition method) { - return code.ReadMethodBody (method); + return CodeReader.ReadMethodBody (method, this); } public CallSite ReadCallSite (MetadataToken token) @@ -2624,19 +2609,12 @@ namespace Mono.Cecil { } public SignatureReader (uint blob, MetadataReader reader) - : base (reader.buffer) + : base (reader.image.BlobHeap.data) { this.reader = reader; - - MoveToBlob (blob); - - this.sig_length = ReadCompressedUInt32 (); - this.start = (uint) position; - } - - void MoveToBlob (uint blob) - { - position = (int) (reader.image.BlobHeap.Offset + blob); + this.start = blob; + this.position = (int) this.start; + this.sig_length = ReadCompressedUInt32(); } MetadataToken ReadTypeTokenSignature () @@ -3151,7 +3129,7 @@ namespace Mono.Cecil { public bool CanReadMore () { - return position - start < sig_length; + return position - start <= sig_length; } } } diff --git a/Mono.Cecil/AssemblyWriter.cs b/Mono.Cecil/AssemblyWriter.cs index a2d3ffa..9e597ca 100644 --- a/Mono.Cecil/AssemblyWriter.cs +++ b/Mono.Cecil/AssemblyWriter.cs @@ -114,6 +114,9 @@ namespace Mono.Cecil { var writer = ImageWriter.CreateWriter (module, metadata, stream); + if (module.HasImage) + module.Image.Dispose (); + writer.WriteImage (); #if !SILVERLIGHT && !CF diff --git a/Mono.Cecil/ModuleDefinition.cs b/Mono.Cecil/ModuleDefinition.cs index 0d137e0..4e4ef37 100644 --- a/Mono.Cecil/ModuleDefinition.cs +++ b/Mono.Cecil/ModuleDefinition.cs @@ -189,7 +189,7 @@ namespace Mono.Cecil { #endif - public sealed class ModuleDefinition : ModuleReference, ICustomAttributeProvider { + public sealed class ModuleDefinition : ModuleReference, ICustomAttributeProvider, IDisposable { internal Image Image; internal MetadataSystem MetadataSystem; @@ -439,11 +439,17 @@ namespace Mono.Cecil { this.runtime = image.Runtime; this.architecture = image.Architecture; this.attributes = image.Attributes; - this.fq_name = image.FileName; + this.fq_name = image.Stream.GetFullyQualifiedName (); this.reader = new MetadataReader (this); } + public void Dispose () + { + if (Image != null) + Image.Dispose (); + } + public bool HasTypeReference (string fullName) { return HasTypeReference (string.Empty, fullName); @@ -915,9 +921,7 @@ namespace Mono.Cecil { public static ModuleDefinition ReadModule (string fileName, ReaderParameters parameters) { - using (var stream = GetFileStream (fileName, FileMode.Open, FileAccess.Read, FileShare.Read)) { - return ReadModule (stream, parameters); - } + return ReadModule (GetFileStream (fileName, FileMode.Open, FileAccess.Read, FileShare.Read), parameters); } static void CheckStream (object stream) diff --git a/Test/Mono.Cecil.Tests/Addin.cs b/Test/Mono.Cecil.Tests/Addin.cs index 38b02ce..469d158 100644 --- a/Test/Mono.Cecil.Tests/Addin.cs +++ b/Test/Mono.Cecil.Tests/Addin.cs @@ -153,19 +153,20 @@ namespace Mono.Cecil.Tests { ModuleDefinition RoundTrip (string location, ReaderParameters reader_parameters, string folder) { - var module = ModuleDefinition.ReadModule (location, reader_parameters); - var rt_folder = Path.Combine (Path.GetTempPath (), folder); - if (!Directory.Exists (rt_folder)) - Directory.CreateDirectory (rt_folder); - var rt_module = Path.Combine (rt_folder, Path.GetFileName (location)); - - var writer_parameters = new WriterParameters { - SymbolWriterProvider = GetSymbolWriterProvider (attribute), - }; + var rt_folder = Path.Combine(Path.GetTempPath(), folder); + if (!Directory.Exists(rt_folder)) + Directory.CreateDirectory(rt_folder); + var rt_module = Path.Combine(rt_folder, Path.GetFileName(location)); + + using (var module = ModuleDefinition.ReadModule (location, reader_parameters)) { + var writer_parameters = new WriterParameters { + SymbolWriterProvider = GetSymbolWriterProvider (attribute), + }; - Reflect.InvokeMethod (Method, Fixture, new object [] { module }); + Reflect.InvokeMethod (Method, Fixture, new object [] { module }); - module.Write (rt_module, writer_parameters); + module.Write (rt_module, writer_parameters); + } if (attribute.Verify) CompilationService.Verify (rt_module); @@ -176,11 +177,13 @@ namespace Mono.Cecil.Tests { public override TestResult RunTest () { var result = new TestResult (TestName); - var module = GetModule (); - if (module == null) - return result; - Reflect.InvokeMethod (Method, Fixture, new object [] { module }); + using (var module = GetModule ()) { + if (module == null) + return result; + + Reflect.InvokeMethod (Method, Fixture, new object [] { module }); + } result.Success (); return result; diff --git a/Test/Mono.Cecil.Tests/CustomAttributesTests.cs b/Test/Mono.Cecil.Tests/CustomAttributesTests.cs index 6565ba6..ab8897d 100644 --- a/Test/Mono.Cecil.Tests/CustomAttributesTests.cs +++ b/Test/Mono.Cecil.Tests/CustomAttributesTests.cs @@ -376,6 +376,8 @@ namespace Mono.Cecil.Tests { Assert.IsNotNull (attribute); Assert.AreEqual ("CaBlob", (string) attribute.ConstructorArguments [0].Value); + + module.Dispose (); } static void AssertCustomAttribute (string expected, CustomAttribute attribute) diff --git a/Test/Mono.Cecil.Tests/Extensions.cs b/Test/Mono.Cecil.Tests/Extensions.cs index 0788d21..ab27e9b 100644 --- a/Test/Mono.Cecil.Tests/Extensions.cs +++ b/Test/Mono.Cecil.Tests/Extensions.cs @@ -1,4 +1,5 @@ using System; +using System.IO; using System.Linq; using SR = System.Reflection; @@ -20,7 +21,7 @@ namespace Mono.Cecil.Tests { public static TypeDefinition ToDefinition (this Type self) { - var module = ModuleDefinition.ReadModule (self.Module.FullyQualifiedName); + var module = ModuleDefinition.ReadModule (new MemoryStream (File.ReadAllBytes (self.Module.FullyQualifiedName))); return (TypeDefinition) module.LookupToken (self.MetadataToken); } diff --git a/Test/Mono.Cecil.Tests/ImageReadTests.cs b/Test/Mono.Cecil.Tests/ImageReadTests.cs index c601fc9..f2db8b1 100644 --- a/Test/Mono.Cecil.Tests/ImageReadTests.cs +++ b/Test/Mono.Cecil.Tests/ImageReadTests.cs @@ -15,113 +15,115 @@ namespace Mono.Cecil.Tests { [Test] public void ImageSections () { - var image = GetResourceImage ("hello.exe"); - - Assert.AreEqual (3, image.Sections.Length); - Assert.AreEqual (".text", image.Sections [0].Name); - Assert.AreEqual (".rsrc", image.Sections [1].Name); - Assert.AreEqual (".reloc", image.Sections [2].Name); + using (var image = GetResourceImage ("hello.exe")) { + Assert.AreEqual (3, image.Sections.Length); + Assert.AreEqual (".text", image.Sections [0].Name); + Assert.AreEqual (".rsrc", image.Sections [1].Name); + Assert.AreEqual (".reloc", image.Sections [2].Name); + } } [Test] public void ImageMetadataVersion () { - var image = GetResourceImage ("hello.exe"); - Assert.AreEqual (TargetRuntime.Net_2_0, image.Runtime); + using (var image = GetResourceImage ("hello.exe")) + Assert.AreEqual (TargetRuntime.Net_2_0, image.Runtime); - image = GetResourceImage ("hello1.exe"); - Assert.AreEqual (TargetRuntime.Net_1_1, image.Runtime); + using (var image = GetResourceImage ("hello1.exe")) + Assert.AreEqual (TargetRuntime.Net_1_1, image.Runtime); } [Test] public void ImageModuleKind () { - var image = GetResourceImage ("hello.exe"); - Assert.AreEqual (ModuleKind.Console, image.Kind); + using (var image = GetResourceImage ("hello.exe")) + Assert.AreEqual (ModuleKind.Console, image.Kind); - image = GetResourceImage ("libhello.dll"); - Assert.AreEqual (ModuleKind.Dll, image.Kind); + using (var image = GetResourceImage ("libhello.dll")) + Assert.AreEqual (ModuleKind.Dll, image.Kind); - image = GetResourceImage ("hellow.exe"); - Assert.AreEqual (ModuleKind.Windows, image.Kind); + using (var image = GetResourceImage ("hellow.exe")) + Assert.AreEqual (ModuleKind.Windows, image.Kind); } [Test] public void MetadataHeaps () { - var image = GetResourceImage ("hello.exe"); - - Assert.IsNotNull (image.TableHeap); + using (var image = GetResourceImage ("hello.exe")) { + Assert.IsNotNull (image.TableHeap); - Assert.IsNotNull (image.StringHeap); - Assert.AreEqual (string.Empty, image.StringHeap.Read (0)); - Assert.AreEqual ("<Module>", image.StringHeap.Read (1)); + Assert.IsNotNull (image.StringHeap); + Assert.AreEqual (string.Empty, image.StringHeap.Read (0)); + Assert.AreEqual ("<Module>", image.StringHeap.Read (1)); - Assert.IsNotNull (image.UserStringHeap); - Assert.AreEqual (string.Empty, image.UserStringHeap.Read (0)); - Assert.AreEqual ("Hello Cecil World !", image.UserStringHeap.Read (1)); + Assert.IsNotNull (image.UserStringHeap); + Assert.AreEqual (string.Empty, image.UserStringHeap.Read (0)); + Assert.AreEqual ("Hello Cecil World !", image.UserStringHeap.Read (1)); - Assert.IsNotNull (image.GuidHeap); - Assert.AreEqual (new Guid (), image.GuidHeap.Read (0)); - Assert.AreEqual (new Guid ("C3BC2BD3-2576-4D00-A80E-465B5632415F"), image.GuidHeap.Read (1)); + Assert.IsNotNull (image.GuidHeap); + Assert.AreEqual (new Guid (), image.GuidHeap.Read (0)); + Assert.AreEqual (new Guid ("C3BC2BD3-2576-4D00-A80E-465B5632415F"), image.GuidHeap.Read (1)); - Assert.IsNotNull (image.BlobHeap); - Assert.AreEqual (new byte [0], image.BlobHeap.Read (0)); + Assert.IsNotNull (image.BlobHeap); + Assert.AreEqual (new byte [0], image.BlobHeap.Read (0)); + } } [Test] public void TablesHeap () { - var image = GetResourceImage ("hello.exe"); - var heap = image.TableHeap; - - Assert.IsNotNull (heap); - - Assert.AreEqual (1, heap [Table.Module].Length); - Assert.AreEqual (4, heap [Table.TypeRef].Length); - Assert.AreEqual (2, heap [Table.TypeDef].Length); - Assert.AreEqual (0, heap [Table.Field].Length); - Assert.AreEqual (2, heap [Table.Method].Length); - Assert.AreEqual (4, heap [Table.MemberRef].Length); - Assert.AreEqual (2, heap [Table.CustomAttribute].Length); - Assert.AreEqual (1, heap [Table.Assembly].Length); - Assert.AreEqual (1, heap [Table.AssemblyRef].Length); + using (var image = GetResourceImage ("hello.exe")) { + var heap = image.TableHeap; + + Assert.IsNotNull (heap); + + Assert.AreEqual (1, heap [Table.Module].Length); + Assert.AreEqual (4, heap [Table.TypeRef].Length); + Assert.AreEqual (2, heap [Table.TypeDef].Length); + Assert.AreEqual (0, heap [Table.Field].Length); + Assert.AreEqual (2, heap [Table.Method].Length); + Assert.AreEqual (4, heap [Table.MemberRef].Length); + Assert.AreEqual (2, heap [Table.CustomAttribute].Length); + Assert.AreEqual (1, heap [Table.Assembly].Length); + Assert.AreEqual (1, heap [Table.AssemblyRef].Length); + } } [Test] public void ReadX64Image () { - var image = GetResourceImage ("hello.x64.exe"); + using (var image = GetResourceImage ("hello.x64.exe")) { - Assert.AreEqual (TargetArchitecture.AMD64, image.Architecture); - Assert.AreEqual (ModuleAttributes.ILOnly, image.Attributes); + Assert.AreEqual (TargetArchitecture.AMD64, image.Architecture); + Assert.AreEqual (ModuleAttributes.ILOnly, image.Attributes); + } } [Test] public void ReadIA64Image () { - var image = GetResourceImage ("hello.ia64.exe"); - - Assert.AreEqual (TargetArchitecture.IA64, image.Architecture); - Assert.AreEqual (ModuleAttributes.ILOnly, image.Attributes); + using (var image = GetResourceImage ("hello.ia64.exe")) { + Assert.AreEqual (TargetArchitecture.IA64, image.Architecture); + Assert.AreEqual (ModuleAttributes.ILOnly, image.Attributes); + } } [Test] public void ReadX86Image () { - var image = GetResourceImage ("hello.x86.exe"); - - Assert.AreEqual (TargetArchitecture.I386, image.Architecture); - Assert.AreEqual (ModuleAttributes.ILOnly | ModuleAttributes.Required32Bit, image.Attributes); + using (var image = GetResourceImage ("hello.x86.exe")) { + Assert.AreEqual (TargetArchitecture.I386, image.Architecture); + Assert.AreEqual (ModuleAttributes.ILOnly | ModuleAttributes.Required32Bit, image.Attributes); + } } [Test] public void ReadAnyCpuImage () { - var image = GetResourceImage ("hello.anycpu.exe"); - - Assert.AreEqual (TargetArchitecture.I386, image.Architecture); - Assert.AreEqual (ModuleAttributes.ILOnly, image.Attributes); + using (var image = GetResourceImage ("hello.anycpu.exe")) { + Assert.AreEqual (TargetArchitecture.I386, image.Architecture); + Assert.AreEqual (ModuleAttributes.ILOnly, image.Attributes); + } } } } diff --git a/Test/Mono.Cecil.Tests/ImportCecilTests.cs b/Test/Mono.Cecil.Tests/ImportCecilTests.cs index 3fa0406..7554863 100644 --- a/Test/Mono.Cecil.Tests/ImportCecilTests.cs +++ b/Test/Mono.Cecil.Tests/ImportCecilTests.cs @@ -213,11 +213,10 @@ namespace Mono.Cecil.Tests { public void ImportMethodOnOpenGeneric () { var generic = typeof (Generic<>).ToDefinition (); - var module = ModuleDefinition.CreateModule ("foo", ModuleKind.Dll); - - var method = module.Import (generic.GetMethod ("Method")); - - Assert.AreEqual ("T Mono.Cecil.Tests.ImportCecilTests/Generic`1::Method(T)", method.FullName); + using (var module = ModuleDefinition.CreateModule ("foo", ModuleKind.Dll)) { + var method = module.Import (generic.GetMethod ("Method")); + Assert.AreEqual ("T Mono.Cecil.Tests.ImportCecilTests/Generic`1::Method(T)", method.FullName); + } } delegate void Emitter (ModuleDefinition module, MethodBody body); diff --git a/Test/Mono.Cecil.Tests/ImportReflectionTests.cs b/Test/Mono.Cecil.Tests/ImportReflectionTests.cs index dd1d28a..ffb2619 100644 --- a/Test/Mono.Cecil.Tests/ImportReflectionTests.cs +++ b/Test/Mono.Cecil.Tests/ImportReflectionTests.cs @@ -209,13 +209,13 @@ namespace Mono.Cecil.Tests { [Test] public void ImportGenericTypeDefOrOpen () { - var module = typeof (Foo<>).ToDefinition ().Module; + using (var module = typeof (Foo<>).ToDefinition ().Module) { + var foo_def = module.Import (typeof (Foo<>)); + var foo_open = module.Import (typeof (Foo<>), foo_def); - var foo_def = module.Import (typeof (Foo<>)); - var foo_open = module.Import (typeof (Foo<>), foo_def); - - Assert.AreEqual ("Mono.Cecil.Tests.ImportReflectionTests/Foo`1", foo_def.FullName); - Assert.AreEqual ("Mono.Cecil.Tests.ImportReflectionTests/Foo`1<TFoo>", foo_open.FullName); + Assert.AreEqual ("Mono.Cecil.Tests.ImportReflectionTests/Foo`1", foo_def.FullName); + Assert.AreEqual ("Mono.Cecil.Tests.ImportReflectionTests/Foo`1<TFoo>", foo_open.FullName); + } } [Test] @@ -225,12 +225,12 @@ namespace Mono.Cecil.Tests { var generic_list_foo_open = typeof (Generic<>).MakeGenericType (list_foo); var foo_def = typeof (Foo<>).ToDefinition (); - var module = foo_def.Module; + using (var module = foo_def.Module) { + var generic_foo = module.Import (generic_list_foo_open, foo_def); - var generic_foo = module.Import (generic_list_foo_open, foo_def); - - Assert.AreEqual ("Mono.Cecil.Tests.ImportReflectionTests/Generic`1<System.Collections.Generic.List`1<TFoo>>", - generic_foo.FullName); + Assert.AreEqual ("Mono.Cecil.Tests.ImportReflectionTests/Generic`1<System.Collections.Generic.List`1<TFoo>>", + generic_foo.FullName); + } } [Test] @@ -240,12 +240,12 @@ namespace Mono.Cecil.Tests { var generic_foo_open = typeof (Generic<>).MakeGenericType (foo_open); var foo_def = typeof (Foo<>).ToDefinition (); - var module = foo_def.Module; + using (var module = foo_def.Module) { + var generic_foo = module.Import (generic_foo_open, foo_def); - var generic_foo = module.Import (generic_foo_open, foo_def); - - Assert.AreEqual ("Mono.Cecil.Tests.ImportReflectionTests/Generic`1<Mono.Cecil.Tests.ImportReflectionTests/Foo`1<TFoo>>", - generic_foo.FullName); + Assert.AreEqual ("Mono.Cecil.Tests.ImportReflectionTests/Generic`1<Mono.Cecil.Tests.ImportReflectionTests/Foo`1<TFoo>>", + generic_foo.FullName); + } } [Test] @@ -255,12 +255,12 @@ namespace Mono.Cecil.Tests { var foo_open_array = foo_open.MakeArrayType (); var foo_def = typeof (Foo<>).ToDefinition (); - var module = foo_def.Module; + using (var module = foo_def.Module) { + var array_foo = module.Import (foo_open_array, foo_def); - var array_foo = module.Import (foo_open_array, foo_def); - - Assert.AreEqual ("Mono.Cecil.Tests.ImportReflectionTests/Foo`1<TFoo>[]", - array_foo.FullName); + Assert.AreEqual ("Mono.Cecil.Tests.ImportReflectionTests/Foo`1<TFoo>[]", + array_foo.FullName); + } } [Test] @@ -271,12 +271,12 @@ namespace Mono.Cecil.Tests { var generic_list_foo_open_field = generic_list_foo_open.GetField ("Field"); var foo_def = typeof (Foo<>).ToDefinition (); - var module = foo_def.Module; + using (var module = foo_def.Module) { + var generic_field = module.Import (generic_list_foo_open_field, foo_def); - var generic_field = module.Import (generic_list_foo_open_field, foo_def); - - Assert.AreEqual ("TFoo Mono.Cecil.Tests.ImportReflectionTests/Generic`1<System.Collections.Generic.List`1<TFoo>>::Field", - generic_field.FullName); + Assert.AreEqual ("TFoo Mono.Cecil.Tests.ImportReflectionTests/Generic`1<System.Collections.Generic.List`1<TFoo>>::Field", + generic_field.FullName); + } } [Test] @@ -287,36 +287,36 @@ namespace Mono.Cecil.Tests { var generic_list_foo_open_method = generic_list_foo_open.GetMethod ("Method"); var foo_def = typeof (Foo<>).ToDefinition (); - var module = foo_def.Module; + using (var module = foo_def.Module) { + var generic_method = module.Import (generic_list_foo_open_method, foo_def); - var generic_method = module.Import (generic_list_foo_open_method, foo_def); - - Assert.AreEqual ("TFoo Mono.Cecil.Tests.ImportReflectionTests/Generic`1<System.Collections.Generic.List`1<TFoo>>::Method(TFoo)", - generic_method.FullName); + Assert.AreEqual ("TFoo Mono.Cecil.Tests.ImportReflectionTests/Generic`1<System.Collections.Generic.List`1<TFoo>>::Method(TFoo)", + generic_method.FullName); + } } [Test] public void ImportMethodOnOpenGenericType () { - var module = typeof (Generic<>).ToDefinition ().Module; + using (var module = typeof (Generic<>).ToDefinition ().Module) { + var method = module.Import (typeof (Generic<>).GetMethod ("Method")); - var method = module.Import (typeof (Generic<>).GetMethod ("Method")); - - Assert.AreEqual ("T Mono.Cecil.Tests.ImportReflectionTests/Generic`1<T>::Method(T)", method.FullName); + Assert.AreEqual ("T Mono.Cecil.Tests.ImportReflectionTests/Generic`1<T>::Method(T)", method.FullName); + } } [Test] public void ImportGenericMethodOnOpenGenericType () { - var module = typeof (Generic<>).ToDefinition ().Module; + using (var module = typeof (Generic<>).ToDefinition ().Module) { + var generic_method = module.Import (typeof (Generic<>).GetMethod ("GenericMethod")); - var generic_method = module.Import (typeof (Generic<>).GetMethod ("GenericMethod")); + Assert.AreEqual ("TS Mono.Cecil.Tests.ImportReflectionTests/Generic`1<T>::GenericMethod(T,TS)", generic_method.FullName); - Assert.AreEqual ("TS Mono.Cecil.Tests.ImportReflectionTests/Generic`1<T>::GenericMethod(T,TS)", generic_method.FullName); + generic_method = module.Import (typeof (Generic<>).GetMethod ("GenericMethod"), generic_method); - generic_method = module.Import (typeof (Generic<>).GetMethod ("GenericMethod"), generic_method); - - Assert.AreEqual ("TS Mono.Cecil.Tests.ImportReflectionTests/Generic`1<T>::GenericMethod<TS>(T,TS)", generic_method.FullName); + Assert.AreEqual ("TS Mono.Cecil.Tests.ImportReflectionTests/Generic`1<T>::GenericMethod<TS>(T,TS)", generic_method.FullName); + } } delegate void Emitter (ModuleDefinition module, MethodBody body); diff --git a/Test/Mono.Cecil.Tests/ModuleTests.cs b/Test/Mono.Cecil.Tests/ModuleTests.cs index 00f9e1a..ee0b3d1 100644 --- a/Test/Mono.Cecil.Tests/ModuleTests.cs +++ b/Test/Mono.Cecil.Tests/ModuleTests.cs @@ -197,10 +197,10 @@ namespace Mono.Cecil.Tests { [Test] public void MixedModeModule () { - var module = GetResourceModule ("cppcli.dll"); - - Assert.AreEqual (1, module.ModuleReferences.Count); - Assert.AreEqual (string.Empty, module.ModuleReferences [0].Name); + using (var module = GetResourceModule ("cppcli.dll")) { + Assert.AreEqual (1, module.ModuleReferences.Count); + Assert.AreEqual (string.Empty, module.ModuleReferences [0].Name); + } } [Test] @@ -211,40 +211,28 @@ namespace Mono.Cecil.Tests { } [Test] - public void WriteModuleTwice () - { - var module = GetResourceModule ("iterator.exe"); - - var path = Path.Combine (Path.GetTempPath (), "cecil"); - var file = Path.Combine (path, "iteratorrt.exe"); - - module.Write (file); - module.Write (file); - } - - [Test] public void GetTypeNamespacePlusName () { - var module = GetResourceModule ("moda.netmodule"); - - var type = module.GetType ("Module.A", "Foo"); - Assert.IsNotNull (type); + using (var module = GetResourceModule ("moda.netmodule")) { + var type = module.GetType ("Module.A", "Foo"); + Assert.IsNotNull (type); + } } [Test] public void OpenModuleImmediate () { - var module = GetResourceModule ("hello.exe", ReadingMode.Immediate); - - Assert.AreEqual (ReadingMode.Immediate, module.ReadingMode); + using (var module = GetResourceModule ("hello.exe", ReadingMode.Immediate)) { + Assert.AreEqual (ReadingMode.Immediate, module.ReadingMode); + } } [Test] public void OpenModuleDeferred () { - var module = GetResourceModule ("hello.exe", ReadingMode.Deferred); - - Assert.AreEqual (ReadingMode.Deferred, module.ReadingMode); + using (var module = GetResourceModule ("hello.exe", ReadingMode.Deferred)) { + Assert.AreEqual (ReadingMode.Deferred, module.ReadingMode); + } } } } diff --git a/Test/Mono.Cecil.Tests/ResolveTests.cs b/Test/Mono.Cecil.Tests/ResolveTests.cs index 9ec1be8..ca0cd56 100644 --- a/Test/Mono.Cecil.Tests/ResolveTests.cs +++ b/Test/Mono.Cecil.Tests/ResolveTests.cs @@ -113,12 +113,13 @@ namespace Mono.Cecil.Tests { resolver.Register (mma.Assembly); - var current_module = GetCurrentModule (parameters); - var reference = new TypeReference ("Module.A", "Foo", current_module, AssemblyNameReference.Parse (mma.Assembly.FullName), false); + using (var current_module = GetCurrentModule (parameters)) { + var reference = new TypeReference ("Module.A", "Foo", current_module, AssemblyNameReference.Parse (mma.Assembly.FullName), false); - var definition = reference.Resolve (); - Assert.IsNotNull (definition); - Assert.AreEqual ("Module.A.Foo", definition.FullName); + var definition = reference.Resolve (); + Assert.IsNotNull (definition); + Assert.AreEqual ("Module.A.Foo", definition.FullName); + } } [Test] diff --git a/rocks/Mono.Cecil.Rocks/ILParser.cs b/rocks/Mono.Cecil.Rocks/ILParser.cs index 6f745bc..4a5be3b 100644 --- a/rocks/Mono.Cecil.Rocks/ILParser.cs +++ b/rocks/Mono.Cecil.Rocks/ILParser.cs @@ -79,8 +79,6 @@ namespace Mono.Cecil.Rocks { var context = CreateContext (method, visitor); var code = context.Code; - code.MoveTo (method.RVA); - var flags = code.ReadByte (); switch (flags & 0x3) { @@ -89,7 +87,7 @@ namespace Mono.Cecil.Rocks { ParseCode (code_size, context); break; case 0x3: // fat - code.position--; + code.Advance (-1); ParseFatMethod (context); break; default: @@ -99,7 +97,7 @@ namespace Mono.Cecil.Rocks { static ParseContext CreateContext (MethodDefinition method, IILVisitor visitor) { - var code = method.Module.Read (method, (_, reader) => new CodeReader (reader.image.MetadataSection, reader)); + var code = method.Module.Read (method, (m, reader) => new CodeReader (method, reader)); return new ParseContext { Code = code, @@ -128,10 +126,10 @@ namespace Mono.Cecil.Rocks { var metadata = context.Metadata; var visitor = context.Visitor; - var start = code.position; + var start = code.Position; var end = start + code_size; - while (code.position < end) { + while (code.Position < end) { var il_opcode = code.ReadByte (); var opcode = il_opcode != 0xfe ? OpCodes.OneByteOpCode [il_opcode] |