26
26
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
30
using System.Collections.Generic;
32
using SR = System.Reflection;
35
using Mono.Cecil.Metadata;
37
using Mono.Collections.Generic;
29
39
namespace Mono.Cecil {
32
using SR = System.Reflection;
33
using SS = System.Security;
34
using SSP = System.Security.Permissions;
38
using Mono.Cecil.Binary;
39
using Mono.Cecil.Metadata;
41
public sealed class ModuleDefinition : ModuleReference, ICustomAttributeProvider, IMetadataScope,
42
IReflectionStructureVisitable, IReflectionVisitable {
48
AssemblyNameReferenceCollection m_asmRefs;
49
ModuleReferenceCollection m_modRefs;
50
ResourceCollection m_res;
51
TypeDefinitionCollection m_types;
52
TypeReferenceCollection m_refs;
53
ExternTypeCollection m_externs;
54
MemberReferenceCollection m_members;
55
CustomAttributeCollection m_customAttrs;
57
AssemblyDefinition m_asm;
60
ImageReader m_imgReader;
61
ReflectionController m_controller;
62
MetadataResolver m_resolver;
63
SecurityDeclarationReader m_secReader;
41
public enum ReadingMode {
46
public sealed class ReaderParameters {
48
ReadingMode reading_mode;
49
IAssemblyResolver assembly_resolver;
51
ISymbolReaderProvider symbol_reader_provider;
54
public ReadingMode ReadingMode {
55
get { return reading_mode; }
56
set { reading_mode = value; }
59
public IAssemblyResolver AssemblyResolver {
60
get { return assembly_resolver; }
61
set { assembly_resolver = value; }
64
public Stream SymbolStream {
65
get { return symbol_stream; }
66
set { symbol_stream = value; }
69
public ISymbolReaderProvider SymbolReaderProvider {
70
get { return symbol_reader_provider; }
71
set { symbol_reader_provider = value; }
74
public bool ReadSymbols {
75
get { return read_symbols; }
76
set { read_symbols = value; }
79
public ReaderParameters ()
80
: this (ReadingMode.Deferred)
84
public ReaderParameters (ReadingMode readingMode)
86
this.reading_mode = readingMode;
92
public sealed class ModuleParameters {
95
TargetRuntime runtime;
96
TargetArchitecture architecture;
97
IAssemblyResolver assembly_resolver;
99
public ModuleKind Kind {
101
set { kind = value; }
104
public TargetRuntime Runtime {
105
get { return runtime; }
106
set { runtime = value; }
109
public TargetArchitecture Architecture {
110
get { return architecture; }
111
set { architecture = value; }
114
public IAssemblyResolver AssemblyResolver {
115
get { return assembly_resolver; }
116
set { assembly_resolver = value; }
119
public ModuleParameters ()
121
this.kind = ModuleKind.Dll;
122
this.runtime = GetCurrentRuntime ();
123
this.architecture = TargetArchitecture.I386;
126
static TargetRuntime GetCurrentRuntime ()
129
return typeof (object).Assembly.ImageRuntimeVersion.ParseRuntime ();
131
var corlib_version = typeof (object).Assembly.GetName ().Version;
132
switch (corlib_version.Major) {
134
return corlib_version.Minor == 0
135
? TargetRuntime.Net_1_0
136
: TargetRuntime.Net_1_1;
138
return TargetRuntime.Net_2_0;
140
return TargetRuntime.Net_4_0;
142
throw new NotSupportedException ();
148
public sealed class WriterParameters {
150
Stream symbol_stream;
151
ISymbolWriterProvider symbol_writer_provider;
153
#if !SILVERLIGHT && !CF
154
SR.StrongNameKeyPair key_pair;
156
public Stream SymbolStream {
157
get { return symbol_stream; }
158
set { symbol_stream = value; }
161
public ISymbolWriterProvider SymbolWriterProvider {
162
get { return symbol_writer_provider; }
163
set { symbol_writer_provider = value; }
166
public bool WriteSymbols {
167
get { return write_symbols; }
168
set { write_symbols = value; }
170
#if !SILVERLIGHT && !CF
171
public SR.StrongNameKeyPair StrongNameKeyPair {
172
get { return key_pair; }
173
set { key_pair = value; }
180
public sealed class ModuleDefinition : ModuleReference, ICustomAttributeProvider {
182
internal Image Image;
183
internal MetadataSystem MetadataSystem;
184
internal ReadingMode ReadingMode;
185
internal ISymbolReaderProvider SymbolReaderProvider;
186
internal ISymbolReader SymbolReader;
188
internal IAssemblyResolver assembly_resolver;
189
internal TypeSystem type_system;
191
readonly MetadataReader reader;
192
readonly string fq_name;
194
internal ModuleKind kind;
195
TargetRuntime runtime;
196
TargetArchitecture architecture;
197
ModuleAttributes attributes;
200
internal AssemblyDefinition assembly;
201
MethodDefinition entry_point;
204
MetadataImporter importer;
206
Collection<CustomAttribute> custom_attributes;
207
Collection<AssemblyNameReference> references;
208
Collection<ModuleReference> modules;
209
Collection<Resource> resources;
210
Collection<ExportedType> exported_types;
211
TypeDefinitionCollection types;
214
get { return kind != ModuleKind.NetModule; }
217
public ModuleKind Kind {
219
set { kind = value; }
222
public TargetRuntime Runtime {
223
get { return runtime; }
224
set { runtime = value; }
227
public TargetArchitecture Architecture {
228
get { return architecture; }
229
set { architecture = value; }
232
public ModuleAttributes Attributes {
233
get { return attributes; }
234
set { attributes = value; }
237
public string FullyQualifiedName {
238
get { return fq_name; }
65
241
public Guid Mvid {
66
get { return m_mvid; }
67
set { m_mvid = value; }
71
get { return m_main; }
72
set { m_main = value; }
75
public AssemblyNameReferenceCollection AssemblyReferences {
76
get { return m_asmRefs; }
79
public ModuleReferenceCollection ModuleReferences {
80
get { return m_modRefs; }
83
public ResourceCollection Resources {
87
public TypeDefinitionCollection Types {
88
get { return m_types; }
91
public TypeReferenceCollection TypeReferences {
92
get { return m_refs; }
95
public MemberReferenceCollection MemberReferences {
96
get { return m_members; }
99
public ExternTypeCollection ExternTypes {
101
if (m_externs == null)
102
m_externs = new ExternTypeCollection (this);
243
set { mvid = value; }
246
internal bool HasImage {
247
get { return Image != null; }
250
public bool HasSymbols {
251
get { return SymbolReader != null; }
254
public override MetadataScopeType MetadataScopeType {
255
get { return MetadataScopeType.ModuleDefinition; }
258
public AssemblyDefinition Assembly {
259
get { return assembly; }
263
internal MetadataImporter MetadataImporter {
264
get { return importer ?? (importer = new MetadataImporter (this)); }
268
public IAssemblyResolver AssemblyResolver {
269
get { return assembly_resolver; }
272
public TypeSystem TypeSystem {
273
get { return type_system ?? (type_system = TypeSystem.CreateTypeSystem (this)); }
276
public bool HasAssemblyReferences {
278
if (references != null)
279
return references.Count > 0;
281
return HasImage && Image.HasTable (Table.AssemblyRef);
285
public Collection<AssemblyNameReference> AssemblyReferences {
287
if (references != null)
291
return references = Read (this, (_, reader) => reader.ReadAssemblyReferences ());
293
return references = new Collection<AssemblyNameReference> ();
297
public bool HasModuleReferences {
300
return modules.Count > 0;
302
return HasImage && Image.HasTable (Table.ModuleRef);
306
public Collection<ModuleReference> ModuleReferences {
312
return modules = Read (this, (_, reader) => reader.ReadModuleReferences ());
314
return modules = new Collection<ModuleReference> ();
318
public bool HasResources {
320
if (resources != null)
321
return resources.Count > 0;
324
return Image.HasTable (Table.ManifestResource) || Read (this, (_, reader) => reader.HasFileResource ());
330
public Collection<Resource> Resources {
332
if (resources != null)
336
return resources = Read (this, (_, reader) => reader.ReadResources ());
338
return resources = new Collection<Resource> ();
108
342
public bool HasCustomAttributes {
109
get { return (m_customAttrs == null) ? false : (m_customAttrs.Count > 0); }
112
public CustomAttributeCollection CustomAttributes {
114
if (m_customAttrs == null)
115
m_customAttrs = new CustomAttributeCollection (this);
117
return m_customAttrs;
121
public AssemblyDefinition Assembly {
122
get { return m_asm; }
125
internal ReflectionController Controller {
126
get { return m_controller; }
129
internal MetadataResolver Resolver {
130
get { return m_resolver; }
133
internal ImageReader ImageReader {
134
get { return m_imgReader; }
138
get { return m_image; }
145
public ModuleDefinition (string name, AssemblyDefinition asm) :
146
this (name, asm, null, false)
150
public ModuleDefinition (string name, AssemblyDefinition asm, bool main) :
151
this (name, asm, null, main)
155
internal ModuleDefinition (string name, AssemblyDefinition asm, StructureReader reader, bool main) : base (name)
158
throw new ArgumentNullException ("asm");
159
if (name == null || name.Length == 0)
160
throw new ArgumentNullException ("name");
165
m_mvid = Guid.NewGuid ();
167
if (reader != null) {
168
m_image = reader.Image;
169
m_imgReader = reader.ImageReader;
170
m_manifestOnly = reader.ManifestOnly;
172
m_image = Image.CreateImage ();
174
m_modRefs = new ModuleReferenceCollection (this);
175
m_asmRefs = new AssemblyNameReferenceCollection (this);
176
m_res = new ResourceCollection (this);
177
m_types = new TypeDefinitionCollection (this);
178
m_refs = new TypeReferenceCollection (this);
179
m_members = new MemberReferenceCollection (this);
181
m_controller = new ReflectionController (this);
182
m_resolver = new MetadataResolver (asm);
185
public IMetadataTokenProvider LookupByToken (MetadataToken token)
187
return m_controller.Reader.LookupByToken (token);
190
public IMetadataTokenProvider LookupByToken (TokenType table, int rid)
192
return LookupByToken (new MetadataToken (table, (uint) rid));
195
void CheckContext (TypeDefinition context)
197
if (context.Module != this)
198
throw new ArgumentException ("The context parameter does not belongs to this module");
200
CheckGenericParameterProvider (context);
203
void CheckContext (MethodDefinition context)
205
CheckGenericParameterProvider (context);
208
static void CheckGenericParameterProvider (IGenericParameterProvider context)
344
if (custom_attributes != null)
345
return custom_attributes.Count > 0;
347
return this.GetHasCustomAttributes (this);
351
public Collection<CustomAttribute> CustomAttributes {
352
get { return custom_attributes ?? (custom_attributes = this.GetCustomAttributes (this)); }
355
public bool HasTypes {
358
return types.Count > 0;
360
return HasImage && Image.HasTable (Table.TypeDef);
364
public Collection<TypeDefinition> Types {
370
return types = Read (this, (_, reader) => reader.ReadTypes ());
372
return types = new TypeDefinitionCollection (this);
376
public bool HasExportedTypes {
378
if (exported_types != null)
379
return exported_types.Count > 0;
381
return HasImage && Image.HasTable (Table.ExportedType);
385
public Collection<ExportedType> ExportedTypes {
387
if (exported_types != null)
388
return exported_types;
391
return exported_types = Read (this, (_, reader) => reader.ReadExportedTypes ());
393
return exported_types = new Collection<ExportedType> ();
397
public MethodDefinition EntryPoint {
399
if (entry_point != null)
403
return entry_point = Read (this, (_, reader) => reader.ReadEntryPoint ());
405
return entry_point = null;
407
set { entry_point = value; }
410
internal ModuleDefinition ()
412
this.MetadataSystem = new MetadataSystem ();
413
this.token = new MetadataToken (TokenType.Module, 1);
414
this.assembly_resolver = GlobalAssemblyResolver.Instance;
417
internal ModuleDefinition (Image image)
421
this.kind = image.Kind;
422
this.runtime = image.Runtime;
423
this.architecture = image.Architecture;
424
this.attributes = image.Attributes;
425
this.fq_name = image.FileName;
427
this.reader = new MetadataReader (this);
430
public bool HasTypeReference (string fullName)
432
return HasTypeReference (string.Empty, fullName);
435
public bool HasTypeReference (string scope, string fullName)
437
CheckFullName (fullName);
442
return Read (this, (_, reader) => reader.GetTypeReference (scope, fullName) != null);
445
public bool TryGetTypeReference (string fullName, out TypeReference type)
447
return TryGetTypeReference (string.Empty, fullName, out type);
450
public bool TryGetTypeReference (string scope, string fullName, out TypeReference type)
452
CheckFullName (fullName);
459
return (type = Read (this, (_, reader) => reader.GetTypeReference (scope, fullName))) != null;
462
public IEnumerable<TypeReference> GetTypeReferences ()
465
return Empty<TypeReference>.Array;
467
return Read (this, (_, reader) => reader.GetTypeReferences ());
470
public IEnumerable<MemberReference> GetMemberReferences ()
473
return Empty<MemberReference>.Array;
475
return Read (this, (_, reader) => reader.GetMemberReferences ());
478
public TypeDefinition GetType (string fullName)
480
CheckFullName (fullName);
482
var position = fullName.IndexOf ('/');
484
return GetNestedType (fullName);
486
return ((TypeDefinitionCollection) this.Types).GetType (fullName);
489
public TypeDefinition GetType (string @namespace, string name)
491
Mixin.CheckName (name);
493
return ((TypeDefinitionCollection) this.Types).GetType (@namespace ?? string.Empty, name);
496
static void CheckFullName (string fullName)
498
if (fullName == null)
499
throw new ArgumentNullException ("fullName");
500
if (fullName.Length == 0)
501
throw new ArgumentException ();
504
TypeDefinition GetNestedType (string fullname)
506
var names = fullname.Split ('/');
507
var type = GetType (names [0]);
512
for (int i = 1; i < names.Length; i++) {
513
var nested_type = type.GetNestedType (names [i]);
514
if (nested_type == null)
523
internal FieldDefinition Resolve (FieldReference field)
525
return MetadataResolver.Resolve (AssemblyResolver, field);
528
internal MethodDefinition Resolve (MethodReference method)
530
return MetadataResolver.Resolve (AssemblyResolver, method);
533
internal TypeDefinition Resolve (TypeReference type)
535
return MetadataResolver.Resolve (AssemblyResolver, type);
540
static void CheckType (object type)
543
throw new ArgumentNullException ("type");
546
static void CheckField (object field)
549
throw new ArgumentNullException ("field");
552
static void CheckMethod (object method)
555
throw new ArgumentNullException ("method");
558
static void CheckContext (IGenericParameterProvider context, ModuleDefinition module)
210
560
if (context == null)
211
throw new ArgumentNullException ("context");
212
if (context.GenericParameters.Count == 0)
213
throw new ArgumentException ("The context parameter is not a generic type");
216
ImportContext GetContext ()
218
return new ImportContext (m_controller.Importer);
221
static ImportContext GetContext (IImporter importer)
223
return new ImportContext (importer);
226
ImportContext GetContext (TypeDefinition context)
228
return new ImportContext (m_controller.Importer, context);
231
ImportContext GetContext (MethodDefinition context)
233
return new ImportContext (m_controller.Importer, context);
236
static ImportContext GetContext (IImporter importer, TypeDefinition context)
238
return new ImportContext (importer, context);
563
if (context.Module != module)
564
throw new ArgumentException ();
241
568
public TypeReference Import (Type type)
244
throw new ArgumentNullException ("type");
246
return m_controller.Helper.ImportSystemType (type, GetContext ());
249
public TypeReference Import (Type type, TypeDefinition context)
252
throw new ArgumentNullException ("type");
253
CheckContext (context);
255
return m_controller.Helper.ImportSystemType (type, GetContext (context));
258
public TypeReference Import (Type type, MethodDefinition context)
261
throw new ArgumentNullException ("type");
262
CheckContext (context);
264
return m_controller.Helper.ImportSystemType (type, GetContext (context));
267
public MethodReference Import (SR.MethodBase meth)
270
throw new ArgumentNullException ("meth");
272
if (meth is SR.ConstructorInfo)
273
return m_controller.Helper.ImportConstructorInfo (
274
meth as SR.ConstructorInfo, GetContext ());
276
return m_controller.Helper.ImportMethodInfo (
277
meth as SR.MethodInfo, GetContext ());
280
public MethodReference Import (SR.MethodBase meth, TypeDefinition context)
283
throw new ArgumentNullException ("meth");
284
CheckContext (context);
286
ImportContext import_context = GetContext (context);
288
if (meth is SR.ConstructorInfo)
289
return m_controller.Helper.ImportConstructorInfo (
290
meth as SR.ConstructorInfo, import_context);
292
return m_controller.Helper.ImportMethodInfo (
293
meth as SR.MethodInfo, import_context);
572
return MetadataImporter.ImportType (type, null, ImportGenericKind.Definition);
575
public TypeReference Import (Type type, TypeReference context)
577
return Import (type, (IGenericParameterProvider) context);
580
public TypeReference Import (Type type, MethodReference context)
582
return Import (type, (IGenericParameterProvider) context);
585
TypeReference Import (Type type, IGenericParameterProvider context)
588
CheckContext (context, this);
590
return MetadataImporter.ImportType (
592
(IGenericContext) context,
594
? ImportGenericKind.Open
595
: ImportGenericKind.Definition);
296
598
public FieldReference Import (SR.FieldInfo field)
299
throw new ArgumentNullException ("field");
301
return m_controller.Helper.ImportFieldInfo (field, GetContext ());
304
public FieldReference Import (SR.FieldInfo field, TypeDefinition context)
307
throw new ArgumentNullException ("field");
308
CheckContext (context);
310
return m_controller.Helper.ImportFieldInfo (field, GetContext (context));
313
public FieldReference Import (SR.FieldInfo field, MethodDefinition context)
316
throw new ArgumentNullException ("field");
317
CheckContext (context);
319
return m_controller.Helper.ImportFieldInfo (field, GetContext (context));
602
return MetadataImporter.ImportField (field, null);
605
public FieldReference Import (SR.FieldInfo field, TypeReference context)
607
return Import (field, (IGenericParameterProvider) context);
610
public FieldReference Import (SR.FieldInfo field, MethodReference context)
612
return Import (field, (IGenericParameterProvider) context);
615
FieldReference Import (SR.FieldInfo field, IGenericParameterProvider context)
618
CheckContext (context, this);
620
return MetadataImporter.ImportField (field, (IGenericContext) context);
623
public MethodReference Import (SR.MethodBase method)
625
CheckMethod (method);
627
return MetadataImporter.ImportMethod (method, null, ImportGenericKind.Definition);
630
public MethodReference Import (SR.MethodBase method, TypeReference context)
632
return Import (method, (IGenericParameterProvider) context);
635
public MethodReference Import (SR.MethodBase method, MethodReference context)
637
return Import (method, (IGenericParameterProvider) context);
640
MethodReference Import (SR.MethodBase method, IGenericParameterProvider context)
642
CheckMethod (method);
643
CheckContext (context, this);
645
return MetadataImporter.ImportMethod (method,
646
(IGenericContext) context,
648
? ImportGenericKind.Open
649
: ImportGenericKind.Definition);
322
653
public TypeReference Import (TypeReference type)
325
throw new ArgumentNullException ("type");
327
return m_controller.Importer.ImportTypeReference (type, GetContext ());
330
public TypeReference Import (TypeReference type, TypeDefinition context)
333
throw new ArgumentNullException ("type");
334
CheckContext (context);
336
return m_controller.Importer.ImportTypeReference (type, GetContext (context));
339
public TypeReference Import (TypeReference type, MethodDefinition context)
342
throw new ArgumentNullException ("type");
343
CheckContext (context);
345
return m_controller.Importer.ImportTypeReference (type, GetContext (context));
348
public MethodReference Import (MethodReference meth)
351
throw new ArgumentNullException ("meth");
353
return m_controller.Importer.ImportMethodReference (meth, GetContext ());
356
public MethodReference Import (MethodReference meth, TypeDefinition context)
359
throw new ArgumentNullException ("meth");
360
CheckContext (context);
362
return m_controller.Importer.ImportMethodReference (meth, GetContext (context));
365
public MethodReference Import (MethodReference meth, MethodDefinition context)
368
throw new ArgumentNullException ("meth");
369
CheckContext (context);
371
return m_controller.Importer.ImportMethodReference (meth, GetContext (context));
657
if (type.Module == this)
660
return MetadataImporter.ImportType (type, null);
663
public TypeReference Import (TypeReference type, TypeReference context)
665
return Import (type, (IGenericParameterProvider) context);
668
public TypeReference Import (TypeReference type, MethodReference context)
670
return Import (type, (IGenericParameterProvider) context);
673
TypeReference Import (TypeReference type, IGenericParameterProvider context)
677
if (type.Module == this)
680
CheckContext (context, this);
682
return MetadataImporter.ImportType (type, (IGenericContext) context);
374
685
public FieldReference Import (FieldReference field)
377
throw new ArgumentNullException ("field");
379
return m_controller.Importer.ImportFieldReference (field, GetContext ());
382
public FieldReference Import (FieldReference field, TypeDefinition context)
385
throw new ArgumentNullException ("field");
386
CheckContext (context);
388
return m_controller.Importer.ImportFieldReference (field, GetContext (context));
391
public FieldReference Import (FieldReference field, MethodDefinition context)
394
throw new ArgumentNullException ("field");
395
CheckContext (context);
397
return m_controller.Importer.ImportFieldReference (field, GetContext (context));
400
static FieldDefinition ImportFieldDefinition (FieldDefinition field, ImportContext context)
402
return FieldDefinition.Clone (field, context);
405
static MethodDefinition ImportMethodDefinition (MethodDefinition meth, ImportContext context)
407
return MethodDefinition.Clone (meth, context);
410
static TypeDefinition ImportTypeDefinition (TypeDefinition type, ImportContext context)
412
return TypeDefinition.Clone (type, context);
415
public TypeDefinition Inject (TypeDefinition type)
417
return Inject (type, m_controller.Importer);
420
public TypeDefinition Inject (TypeDefinition type, IImporter importer)
423
throw new ArgumentNullException ("type");
424
if (importer == null)
425
throw new ArgumentNullException ("importer");
427
TypeDefinition definition = ImportTypeDefinition (type, GetContext (importer));
428
this.Types.Add (definition);
432
public TypeDefinition Inject (TypeDefinition type, TypeDefinition context)
434
return Inject (type, context, m_controller.Importer);
437
public TypeDefinition Inject (TypeDefinition type, TypeDefinition context, IImporter importer)
439
Check (type, context, importer);
441
TypeDefinition definition = ImportTypeDefinition (type, GetContext (importer, context));
442
context.NestedTypes.Add (definition);
446
public MethodDefinition Inject (MethodDefinition meth, TypeDefinition context)
448
return Inject (meth, context, m_controller.Importer);
451
void Check (IMemberDefinition definition, TypeDefinition context, IImporter importer)
453
if (definition == null)
454
throw new ArgumentNullException ("definition");
456
throw new ArgumentNullException ("context");
457
if (importer == null)
458
throw new ArgumentNullException ("importer");
459
if (context.Module != this)
460
throw new ArgumentException ("The context parameter does not belongs to this module");
463
public MethodDefinition Inject (MethodDefinition meth, TypeDefinition context, IImporter importer)
465
Check (meth, context, importer);
467
MethodDefinition definition = ImportMethodDefinition (meth, GetContext (importer, context));
468
context.Methods.Add (definition);
472
public FieldDefinition Inject (FieldDefinition field, TypeDefinition context)
474
return Inject (field, context, m_controller.Importer);
477
public FieldDefinition Inject (FieldDefinition field, TypeDefinition context, IImporter importer)
479
Check (field, context, importer);
481
FieldDefinition definition = ImportFieldDefinition (field, GetContext (importer, context));
482
context.Fields.Add (definition);
486
public void FullLoad ()
489
m_controller.Reader.VisitModuleDefinition (this);
491
foreach (TypeDefinition type in this.Types) {
492
foreach (MethodDefinition meth in type.Methods)
494
foreach (MethodDefinition ctor in type.Constructors)
498
if (m_controller.Reader.SymbolReader == null)
689
if (field.Module == this)
692
return MetadataImporter.ImportField (field, null);
695
public FieldReference Import (FieldReference field, TypeReference context)
697
return Import (field, (IGenericParameterProvider) context);
700
public FieldReference Import (FieldReference field, MethodReference context)
702
return Import (field, (IGenericParameterProvider) context);
705
FieldReference Import (FieldReference field, IGenericParameterProvider context)
709
if (field.Module == this)
712
CheckContext (context, this);
714
return MetadataImporter.ImportField (field, (IGenericContext) context);
717
public MethodReference Import (MethodReference method)
719
CheckMethod (method);
721
if (method.Module == this)
724
return MetadataImporter.ImportMethod (method, null);
727
public MethodReference Import (MethodReference method, TypeReference context)
729
return Import (method, (IGenericParameterProvider) context);
732
public MethodReference Import (MethodReference method, MethodReference context)
734
return Import (method, (IGenericParameterProvider) context);
737
MethodReference Import (MethodReference method, IGenericParameterProvider context)
739
CheckMethod (method);
741
if (method.Module == this)
744
CheckContext (context, this);
746
return MetadataImporter.ImportMethod (method, (IGenericContext) context);
751
public IMetadataTokenProvider LookupToken (int token)
753
return LookupToken (new MetadataToken ((uint) token));
756
public IMetadataTokenProvider LookupToken (MetadataToken token)
758
return Read (this, (_, reader) => reader.LookupToken (token));
761
internal TRet Read<TItem, TRet> (TItem item, Func<TItem, MetadataReader, TRet> read)
763
var position = reader.position;
764
var context = reader.context;
766
var ret = read (item, reader);
768
reader.position = position;
769
reader.context = context;
774
void ProcessDebugHeader ()
776
if (Image == null || Image.Debug.IsZero)
501
m_controller.Reader.SymbolReader.Dispose ();
502
m_controller.Reader.SymbolReader = null;
505
public void LoadSymbols ()
507
m_controller.Reader.SymbolReader = SymbolStoreHelper.GetReader (this);
510
public void LoadSymbols (ISymbolReader reader)
512
m_controller.Reader.SymbolReader = reader;
515
public void SaveSymbols ()
517
m_controller.Writer.SaveSymbols = true;
520
public void SaveSymbols (ISymbolWriter writer)
523
m_controller.Writer.SymbolWriter = writer;
526
public void SaveSymbols (string outputDirectory)
529
m_controller.Writer.OutputFile = outputDirectory;
532
public void SaveSymbols (string outputDirectory, ISymbolWriter writer)
534
SaveSymbols (outputDirectory);
535
m_controller.Writer.SymbolWriter = writer;
538
public byte [] GetAsByteArray (CustomAttribute ca)
540
CustomAttribute customAttr = ca;
542
if (customAttr.Blob != null)
543
return customAttr.Blob;
547
return m_controller.Writer.SignatureWriter.CompressCustomAttribute (
548
ReflectionWriter.GetCustomAttributeSig (ca), ca.Constructor);
551
public byte [] GetAsByteArray (SecurityDeclaration dec)
553
// TODO - add support for 2.0 format
554
// note: the 1.x format is still supported in 2.0 so this isn't an immediate problem
558
#if !CF_1_0 && !CF_2_0
559
if (dec.PermissionSet != null)
560
return Encoding.Unicode.GetBytes (dec.PermissionSet.ToXml ().ToString ());
566
public CustomAttribute FromByteArray (MethodReference ctor, byte [] data)
568
return m_controller.Reader.GetCustomAttribute (ctor, data);
571
public SecurityDeclaration FromByteArray (SecurityAction action, byte [] declaration)
573
if (m_secReader == null)
574
m_secReader = new SecurityDeclarationReader (Image.MetadataRoot, m_controller.Reader);
575
return m_secReader.FromByteArray (action, declaration);
578
public override void Accept (IReflectionStructureVisitor visitor)
580
visitor.VisitModuleDefinition (this);
582
this.AssemblyReferences.Accept (visitor);
583
this.ModuleReferences.Accept (visitor);
584
this.Resources.Accept (visitor);
587
public void Accept (IReflectionVisitor visitor)
589
visitor.VisitModuleDefinition (this);
591
this.Types.Accept (visitor);
592
this.TypeReferences.Accept (visitor);
595
public override string ToString ()
597
string s = (m_main ? "(main), Mvid=" : "Mvid=");
780
var directory = Image.GetDebugHeader (out header);
782
if (!SymbolReader.ProcessDebugHeader (directory, header))
783
throw new InvalidOperationException ();
788
public static ModuleDefinition CreateModule (string name, ModuleKind kind)
790
return CreateModule (name, new ModuleParameters { Kind = kind });
793
public static ModuleDefinition CreateModule (string name, ModuleParameters parameters)
795
Mixin.CheckName (name);
796
Mixin.CheckParameters (parameters);
798
var module = new ModuleDefinition {
800
kind = parameters.Kind,
801
runtime = parameters.Runtime,
802
architecture = parameters.Architecture,
803
mvid = Guid.NewGuid (),
804
Attributes = ModuleAttributes.ILOnly,
807
if (parameters.AssemblyResolver != null)
808
module.assembly_resolver = parameters.AssemblyResolver;
810
if (parameters.Kind != ModuleKind.NetModule) {
811
var assembly = new AssemblyDefinition ();
812
module.assembly = assembly;
813
module.assembly.Name = new AssemblyNameDefinition (name, new Version (0, 0));
814
assembly.main_module = module;
817
module.Types.Add (new TypeDefinition (string.Empty, "<Module>", TypeAttributes.NotPublic));
824
public void ReadSymbols ()
826
if (string.IsNullOrEmpty (fq_name))
827
throw new InvalidOperationException ();
829
var provider = SymbolProvider.GetPlatformReaderProvider ();
831
SymbolReader = provider.GetSymbolReader (this, fq_name);
833
ProcessDebugHeader ();
836
public void ReadSymbols (ISymbolReader reader)
839
throw new ArgumentNullException ("reader");
841
SymbolReader = reader;
843
ProcessDebugHeader ();
846
public static ModuleDefinition ReadModule (string fileName)
848
return ReadModule (fileName, new ReaderParameters (ReadingMode.Deferred));
851
public static ModuleDefinition ReadModule (Stream stream)
853
return ReadModule (stream, new ReaderParameters (ReadingMode.Deferred));
856
public static ModuleDefinition ReadModule (string fileName, ReaderParameters parameters)
858
using (var stream = GetFileStream (fileName, FileMode.Open, FileAccess.Read, FileShare.Read)) {
859
return ReadModule (stream, parameters);
863
static void CheckStream (object stream)
866
throw new ArgumentNullException ("stream");
869
public static ModuleDefinition ReadModule (Stream stream, ReaderParameters parameters)
871
CheckStream (stream);
872
if (!stream.CanRead || !stream.CanSeek)
873
throw new ArgumentException ();
874
Mixin.CheckParameters (parameters);
876
return ModuleReader.CreateModuleFrom (
877
ImageReader.ReadImageFrom (stream),
881
static Stream GetFileStream (string fileName, FileMode mode, FileAccess access, FileShare share)
883
if (fileName == null)
884
throw new ArgumentNullException ("fileName");
885
if (fileName.Length == 0)
886
throw new ArgumentException ();
888
return new FileStream (fileName, mode, access, share);
893
public void Write (string fileName)
895
Write (fileName, new WriterParameters ());
898
public void Write (Stream stream)
900
Write (stream, new WriterParameters ());
903
public void Write (string fileName, WriterParameters parameters)
905
using (var stream = GetFileStream (fileName, FileMode.Create, FileAccess.ReadWrite, FileShare.None)) {
906
Write (stream, parameters);
910
public void Write (Stream stream, WriterParameters parameters)
912
CheckStream (stream);
913
if (!stream.CanWrite || !stream.CanSeek)
914
throw new ArgumentException ();
915
Mixin.CheckParameters (parameters);
917
ModuleWriter.WriteModuleTo (this, stream, parameters);
924
static partial class Mixin {
926
public static void CheckParameters (object parameters)
928
if (parameters == null)
929
throw new ArgumentNullException ("parameters");
932
public static bool HasImage (this ModuleDefinition self)
934
return self != null && self.HasImage;
937
public static string GetFullyQualifiedName (this Stream self)
940
var file_stream = self as FileStream;
941
if (file_stream == null)
944
return Path.GetFullPath (file_stream.Name);
950
public static TargetRuntime ParseRuntime (this string self)
954
return self [3] == '0'
955
? TargetRuntime.Net_1_0
956
: TargetRuntime.Net_1_1;
958
return TargetRuntime.Net_2_0;
961
return TargetRuntime.Net_4_0;
added
removed
contrib/Mono.Cecil/Mono.Cecil/Mono.Cecil/ModuleDefinition.cs
