← Back to branch summary

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

« back to all changes in this revision

Viewing changes to external/mono-addins/Mono.Addins.CecilReflector/Mono.Cecil/Mono.Cecil/ModuleDefinition.cs

  • Committer: Package Import Robot
  • Author(s): Jo Shields
  • Date: 2013-05-12 09:46:03 UTC
  • mto: This revision was merged to the branch mainline in revision 29.
  • Revision ID: package-import@ubuntu.com-20130512094603-mad323bzcxvmcam0
Tags: upstream-4.0.5+dfsg
Import upstream version 4.0.5+dfsg

Show diffs side-by-side

added added

removed removed

Lines of Context:
external/mono-addins/Mono.Addins.CecilReflector/Mono.Cecil/Mono.Cecil/ModuleDefinition.cs
 
1
//
 
2
// ModuleDefinition.cs
 
3
//
 
4
// Author:
 
5
//   Jb Evain (jbevain@gmail.com)
 
6
//
 
7
// Copyright (c) 2008 - 2010 Jb Evain
 
8
//
 
9
// Permission is hereby granted, free of charge, to any person obtaining
 
10
// a copy of this software and associated documentation files (the
 
11
// "Software"), to deal in the Software without restriction, including
 
12
// without limitation the rights to use, copy, modify, merge, publish,
 
13
// distribute, sublicense, and/or sell copies of the Software, and to
 
14
// permit persons to whom the Software is furnished to do so, subject to
 
15
// the following conditions:
 
16
//
 
17
// The above copyright notice and this permission notice shall be
 
18
// included in all copies or substantial portions of the Software.
 
19
//
 
20
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 
21
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 
22
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 
23
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
 
24
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
 
25
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 
26
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
27
//
 
28
 
 
29
using System;
 
30
using System.Collections.Generic;
 
31
using System.IO;
 
32
using SR = System.Reflection;
 
33
 
 
34
using Mono.Cecil.Cil;
 
35
using Mono.Cecil.Metadata;
 
36
using Mono.Cecil.PE;
 
37
using Mono.Collections.Generic;
 
38
 
 
39
namespace Mono.Cecil {
 
40
 
 
41
        public enum ReadingMode {
 
42
                Immediate = 1,
 
43
                Deferred = 2,
 
44
        }
 
45
 
 
46
        public sealed class ReaderParameters {
 
47
 
 
48
                ReadingMode reading_mode;
 
49
                IAssemblyResolver assembly_resolver;
 
50
                Stream symbol_stream;
 
51
                ISymbolReaderProvider symbol_reader_provider;
 
52
                bool read_symbols;
 
53
 
 
54
                public ReadingMode ReadingMode {
 
55
                        get { return reading_mode; }
 
56
                        set { reading_mode = value; }
 
57
                }
 
58
 
 
59
                public IAssemblyResolver AssemblyResolver {
 
60
                        get { return assembly_resolver; }
 
61
                        set { assembly_resolver = value; }
 
62
                }
 
63
 
 
64
                public Stream SymbolStream {
 
65
                        get { return symbol_stream; }
 
66
                        set { symbol_stream = value; }
 
67
                }
 
68
 
 
69
                public ISymbolReaderProvider SymbolReaderProvider {
 
70
                        get { return symbol_reader_provider; }
 
71
                        set { symbol_reader_provider = value; }
 
72
                }
 
73
 
 
74
                public bool ReadSymbols {
 
75
                        get { return read_symbols; }
 
76
                        set { read_symbols = value; }
 
77
                }
 
78
 
 
79
                public ReaderParameters ()
 
80
                        : this (ReadingMode.Deferred)
 
81
                {
 
82
                }
 
83
 
 
84
                public ReaderParameters (ReadingMode readingMode)
 
85
                {
 
86
                        this.reading_mode = readingMode;
 
87
                }
 
88
        }
 
89
 
 
90
#if !READ_ONLY
 
91
 
 
92
        public sealed class ModuleParameters {
 
93
 
 
94
                ModuleKind kind;
 
95
                TargetRuntime runtime;
 
96
                TargetArchitecture architecture;
 
97
                IAssemblyResolver assembly_resolver;
 
98
 
 
99
                public ModuleKind Kind {
 
100
                        get { return kind; }
 
101
                        set { kind = value; }
 
102
                }
 
103
 
 
104
                public TargetRuntime Runtime {
 
105
                        get { return runtime; }
 
106
                        set { runtime = value; }
 
107
                }
 
108
 
 
109
                public TargetArchitecture Architecture {
 
110
                        get { return architecture; }
 
111
                        set { architecture = value; }
 
112
                }
 
113
 
 
114
                public IAssemblyResolver AssemblyResolver {
 
115
                        get { return assembly_resolver; }
 
116
                        set { assembly_resolver = value; }
 
117
                }
 
118
 
 
119
                public ModuleParameters ()
 
120
                {
 
121
                        this.kind = ModuleKind.Dll;
 
122
                        this.runtime = GetCurrentRuntime ();
 
123
                        this.architecture = TargetArchitecture.I386;
 
124
                }
 
125
 
 
126
                static TargetRuntime GetCurrentRuntime ()
 
127
                {
 
128
#if !CF
 
129
                        return typeof (object).Assembly.ImageRuntimeVersion.ParseRuntime ();
 
130
#else
 
131
                        var corlib_version = typeof (object).Assembly.GetName ().Version;
 
132
                        switch (corlib_version.Major) {
 
133
                        case 1:
 
134
                                return corlib_version.Minor == 0
 
135
                                        ? TargetRuntime.Net_1_0
 
136
                                        : TargetRuntime.Net_1_1;
 
137
                        case 2:
 
138
                                return TargetRuntime.Net_2_0;
 
139
                        case 4:
 
140
                                return TargetRuntime.Net_4_0;
 
141
                        default:
 
142
                                throw new NotSupportedException ();
 
143
                        }
 
144
#endif
 
145
                }
 
146
        }
 
147
 
 
148
        public sealed class WriterParameters {
 
149
 
 
150
                Stream symbol_stream;
 
151
                ISymbolWriterProvider symbol_writer_provider;
 
152
                bool write_symbols;
 
153
#if !SILVERLIGHT && !CF
 
154
                SR.StrongNameKeyPair key_pair;
 
155
#endif
 
156
                public Stream SymbolStream {
 
157
                        get { return symbol_stream; }
 
158
                        set { symbol_stream = value; }
 
159
                }
 
160
 
 
161
                public ISymbolWriterProvider SymbolWriterProvider {
 
162
                        get { return symbol_writer_provider; }
 
163
                        set { symbol_writer_provider = value; }
 
164
                }
 
165
 
 
166
                public bool WriteSymbols {
 
167
                        get { return write_symbols; }
 
168
                        set { write_symbols = value; }
 
169
                }
 
170
#if !SILVERLIGHT && !CF
 
171
                public SR.StrongNameKeyPair StrongNameKeyPair {
 
172
                        get { return key_pair; }
 
173
                        set { key_pair = value; }
 
174
                }
 
175
#endif
 
176
        }
 
177
 
 
178
#endif
 
179
 
 
180
        public sealed class ModuleDefinition : ModuleReference, ICustomAttributeProvider {
 
181
 
 
182
                internal Image Image;
 
183
                internal MetadataSystem MetadataSystem;
 
184
                internal ReadingMode ReadingMode;
 
185
                internal ISymbolReaderProvider SymbolReaderProvider;
 
186
                internal ISymbolReader SymbolReader;
 
187
 
 
188
                internal IAssemblyResolver assembly_resolver;
 
189
                internal TypeSystem type_system;
 
190
 
 
191
                readonly MetadataReader reader;
 
192
                readonly string fq_name;
 
193
 
 
194
                internal ModuleKind kind;
 
195
                TargetRuntime runtime;
 
196
                TargetArchitecture architecture;
 
197
                ModuleAttributes attributes;
 
198
                Guid mvid;
 
199
 
 
200
                internal AssemblyDefinition assembly;
 
201
                MethodDefinition entry_point;
 
202
 
 
203
#if !READ_ONLY
 
204
                MetadataImporter importer;
 
205
#endif
 
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;
 
212
 
 
213
                public bool IsMain {
 
214
                        get { return kind != ModuleKind.NetModule; }
 
215
                }
 
216
 
 
217
                public ModuleKind Kind {
 
218
                        get { return kind; }
 
219
                        set { kind = value; }
 
220
                }
 
221
 
 
222
                public TargetRuntime Runtime {
 
223
                        get { return runtime; }
 
224
                        set { runtime = value; }
 
225
                }
 
226
 
 
227
                public TargetArchitecture Architecture {
 
228
                        get { return architecture; }
 
229
                        set { architecture = value; }
 
230
                }
 
231
 
 
232
                public ModuleAttributes Attributes {
 
233
                        get { return attributes; }
 
234
                        set { attributes = value; }
 
235
                }
 
236
 
 
237
                public string FullyQualifiedName {
 
238
                        get { return fq_name; }
 
239
                }
 
240
 
 
241
                public Guid Mvid {
 
242
                        get { return mvid; }
 
243
                        set { mvid = value; }
 
244
                }
 
245
 
 
246
                internal bool HasImage {
 
247
                        get { return Image != null; }
 
248
                }
 
249
 
 
250
                public bool HasSymbols {
 
251
                        get { return SymbolReader != null; }
 
252
                }
 
253
 
 
254
                public override MetadataScopeType MetadataScopeType {
 
255
                        get { return MetadataScopeType.ModuleDefinition; }
 
256
                }
 
257
 
 
258
                public AssemblyDefinition Assembly {
 
259
                        get { return assembly; }
 
260
                }
 
261
 
 
262
#if !READ_ONLY
 
263
                internal MetadataImporter MetadataImporter {
 
264
                        get { return importer ?? (importer = new MetadataImporter (this)); }
 
265
                }
 
266
#endif
 
267
 
 
268
                public IAssemblyResolver AssemblyResolver {
 
269
                        get { return assembly_resolver; }
 
270
                }
 
271
 
 
272
                public TypeSystem TypeSystem {
 
273
                        get { return type_system ?? (type_system = TypeSystem.CreateTypeSystem (this)); }
 
274
                }
 
275
 
 
276
                public bool HasAssemblyReferences {
 
277
                        get {
 
278
                                if (references != null)
 
279
                                        return references.Count > 0;
 
280
 
 
281
                                return HasImage && Image.HasTable (Table.AssemblyRef);
 
282
                        }
 
283
                }
 
284
 
 
285
                public Collection<AssemblyNameReference> AssemblyReferences {
 
286
                        get {
 
287
                                if (references != null)
 
288
                                        return references;
 
289
 
 
290
                                if (HasImage)
 
291
                                        return references = Read (this, (_, reader) => reader.ReadAssemblyReferences ());
 
292
 
 
293
                                return references = new Collection<AssemblyNameReference> ();
 
294
                        }
 
295
                }
 
296
 
 
297
                public bool HasModuleReferences {
 
298
                        get {
 
299
                                if (modules != null)
 
300
                                        return modules.Count > 0;
 
301
 
 
302
                                return HasImage && Image.HasTable (Table.ModuleRef);
 
303
                        }
 
304
                }
 
305
 
 
306
                public Collection<ModuleReference> ModuleReferences {
 
307
                        get {
 
308
                                if (modules != null)
 
309
                                        return modules;
 
310
 
 
311
                                if (HasImage)
 
312
                                        return modules = Read (this, (_, reader) => reader.ReadModuleReferences ());
 
313
 
 
314
                                return modules = new Collection<ModuleReference> ();
 
315
                        }
 
316
                }
 
317
 
 
318
                public bool HasResources {
 
319
                        get {
 
320
                                if (resources != null)
 
321
                                        return resources.Count > 0;
 
322
 
 
323
                                if (HasImage)
 
324
                                        return Image.HasTable (Table.ManifestResource) || Read (this, (_, reader) => reader.HasFileResource ());
 
325
 
 
326
                                return false;
 
327
                        }
 
328
                }
 
329
 
 
330
                public Collection<Resource> Resources {
 
331
                        get {
 
332
                                if (resources != null)
 
333
                                        return resources;
 
334
 
 
335
                                if (HasImage)
 
336
                                        return resources = Read (this, (_, reader) => reader.ReadResources ());
 
337
 
 
338
                                return resources = new Collection<Resource> ();
 
339
                        }
 
340
                }
 
341
 
 
342
                public bool HasCustomAttributes {
 
343
                        get {
 
344
                                if (custom_attributes != null)
 
345
                                        return custom_attributes.Count > 0;
 
346
 
 
347
                                return this.GetHasCustomAttributes (this);
 
348
                        }
 
349
                }
 
350
 
 
351
                public Collection<CustomAttribute> CustomAttributes {
 
352
                        get { return custom_attributes ?? (custom_attributes = this.GetCustomAttributes (this)); }
 
353
                }
 
354
 
 
355
                public bool HasTypes {
 
356
                        get {
 
357
                                if (types != null)
 
358
                                        return types.Count > 0;
 
359
 
 
360
                                return HasImage && Image.HasTable (Table.TypeDef);
 
361
                        }
 
362
                }
 
363
 
 
364
                public Collection<TypeDefinition> Types {
 
365
                        get {
 
366
                                if (types != null)
 
367
                                        return types;
 
368
 
 
369
                                if (HasImage)
 
370
                                        return types = Read (this, (_, reader) => reader.ReadTypes ());
 
371
 
 
372
                                return types = new TypeDefinitionCollection (this);
 
373
                        }
 
374
                }
 
375
 
 
376
                public bool HasExportedTypes {
 
377
                        get {
 
378
                                if (exported_types != null)
 
379
                                        return exported_types.Count > 0;
 
380
 
 
381
                                return HasImage && Image.HasTable (Table.ExportedType);
 
382
                        }
 
383
                }
 
384
 
 
385
                public Collection<ExportedType> ExportedTypes {
 
386
                        get {
 
387
                                if (exported_types != null)
 
388
                                        return exported_types;
 
389
 
 
390
                                if (HasImage)
 
391
                                        return exported_types = Read (this, (_, reader) => reader.ReadExportedTypes ());
 
392
 
 
393
                                return exported_types = new Collection<ExportedType> ();
 
394
                        }
 
395
                }
 
396
 
 
397
                public MethodDefinition EntryPoint {
 
398
                        get {
 
399
                                if (entry_point != null)
 
400
                                        return entry_point;
 
401
 
 
402
                                if (HasImage)
 
403
                                        return entry_point = Read (this, (_, reader) => reader.ReadEntryPoint ());
 
404
 
 
405
                                return entry_point = null;
 
406
                        }
 
407
                        set { entry_point = value; }
 
408
                }
 
409
 
 
410
                internal ModuleDefinition ()
 
411
                {
 
412
                        this.MetadataSystem = new MetadataSystem ();
 
413
                        this.token = new MetadataToken (TokenType.Module, 1);
 
414
                        this.assembly_resolver = GlobalAssemblyResolver.Instance;
 
415
                }
 
416
 
 
417
                internal ModuleDefinition (Image image)
 
418
                        : this ()
 
419
                {
 
420
                        this.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;
 
426
 
 
427
                        this.reader = new MetadataReader (this);
 
428
                }
 
429
 
 
430
                public bool HasTypeReference (string fullName)
 
431
                {
 
432
                        return HasTypeReference (string.Empty, fullName);
 
433
                }
 
434
 
 
435
                public bool HasTypeReference (string scope, string fullName)
 
436
                {
 
437
                        CheckFullName (fullName);
 
438
 
 
439
                        if (!HasImage)
 
440
                                return false;
 
441
 
 
442
                        return Read (this, (_, reader) => reader.GetTypeReference (scope, fullName) != null);
 
443
                }
 
444
 
 
445
                public bool TryGetTypeReference (string fullName, out TypeReference type)
 
446
                {
 
447
                        return TryGetTypeReference (string.Empty, fullName, out type);
 
448
                }
 
449
 
 
450
                public bool TryGetTypeReference (string scope, string fullName, out TypeReference type)
 
451
                {
 
452
                        CheckFullName (fullName);
 
453
 
 
454
                        if (!HasImage) {
 
455
                                type = null;
 
456
                                return false;
 
457
                        }
 
458
 
 
459
                        return (type = Read (this, (_, reader) => reader.GetTypeReference (scope, fullName))) != null;
 
460
                }
 
461
 
 
462
                public IEnumerable<TypeReference> GetTypeReferences ()
 
463
                {
 
464
                        if (!HasImage)
 
465
                                return Empty<TypeReference>.Array;
 
466
 
 
467
                        return Read (this, (_, reader) => reader.GetTypeReferences ());
 
468
                }
 
469
 
 
470
                public IEnumerable<MemberReference> GetMemberReferences ()
 
471
                {
 
472
                        if (!HasImage)
 
473
                                return Empty<MemberReference>.Array;
 
474
 
 
475
                        return Read (this, (_, reader) => reader.GetMemberReferences ());
 
476
                }
 
477
 
 
478
                public TypeDefinition GetType (string fullName)
 
479
                {
 
480
                        CheckFullName (fullName);
 
481
 
 
482
                        var position = fullName.IndexOf ('/');
 
483
                        if (position > 0)
 
484
                                return GetNestedType (fullName);
 
485
 
 
486
                        return ((TypeDefinitionCollection) this.Types).GetType (fullName);
 
487
                }
 
488
 
 
489
                public TypeDefinition GetType (string @namespace, string name)
 
490
                {
 
491
                        Mixin.CheckName (name);
 
492
 
 
493
                        return ((TypeDefinitionCollection) this.Types).GetType (@namespace ?? string.Empty, name);
 
494
                }
 
495
 
 
496
                static void CheckFullName (string fullName)
 
497
                {
 
498
                        if (fullName == null)
 
499
                                throw new ArgumentNullException ("fullName");
 
500
                        if (fullName.Length == 0)
 
501
                                throw new ArgumentException ();
 
502
                }
 
503
 
 
504
                TypeDefinition GetNestedType (string fullname)
 
505
                {
 
506
                        var names = fullname.Split ('/');
 
507
                        var type = GetType (names [0]);
 
508
 
 
509
                        if (type == null)
 
510
                                return null;
 
511
 
 
512
                        for (int i = 1; i < names.Length; i++) {
 
513
                                var nested_type = type.GetNestedType (names [i]);
 
514
                                if (nested_type == null)
 
515
                                        return null;
 
516
 
 
517
                                type = nested_type;
 
518
                        }
 
519
 
 
520
                        return type;
 
521
                }
 
522
 
 
523
                internal FieldDefinition Resolve (FieldReference field)
 
524
                {
 
525
                        return MetadataResolver.Resolve (AssemblyResolver, field);
 
526
                }
 
527
 
 
528
                internal MethodDefinition Resolve (MethodReference method)
 
529
                {
 
530
                        return MetadataResolver.Resolve (AssemblyResolver, method);
 
531
                }
 
532
 
 
533
                internal TypeDefinition Resolve (TypeReference type)
 
534
                {
 
535
                        return MetadataResolver.Resolve (AssemblyResolver, type);
 
536
                }
 
537
 
 
538
#if !READ_ONLY
 
539
 
 
540
                static void CheckType (object type)
 
541
                {
 
542
                        if (type == null)
 
543
                                throw new ArgumentNullException ("type");
 
544
                }
 
545
 
 
546
                static void CheckField (object field)
 
547
                {
 
548
                        if (field == null)
 
549
                                throw new ArgumentNullException ("field");
 
550
                }
 
551
 
 
552
                static void CheckMethod (object method)
 
553
                {
 
554
                        if (method == null)
 
555
                                throw new ArgumentNullException ("method");
 
556
                }
 
557
 
 
558
                static void CheckContext (IGenericParameterProvider context, ModuleDefinition module)
 
559
                {
 
560
                        if (context == null)
 
561
                                return;
 
562
 
 
563
                        if (context.Module != module)
 
564
                                throw new ArgumentException ();
 
565
                }
 
566
 
 
567
#if !CF
 
568
                public TypeReference Import (Type type)
 
569
                {
 
570
                        CheckType (type);
 
571
 
 
572
                        return MetadataImporter.ImportType (type, null, ImportGenericKind.Definition);
 
573
                }
 
574
 
 
575
                public TypeReference Import (Type type, TypeReference context)
 
576
                {
 
577
                        return Import (type, (IGenericParameterProvider) context);
 
578
                }
 
579
 
 
580
                public TypeReference Import (Type type, MethodReference context)
 
581
                {
 
582
                        return Import (type, (IGenericParameterProvider) context);
 
583
                }
 
584
 
 
585
                TypeReference Import (Type type, IGenericParameterProvider context)
 
586
                {
 
587
                        CheckType (type);
 
588
                        CheckContext (context, this);
 
589
 
 
590
                        return MetadataImporter.ImportType (
 
591
                                type,
 
592
                                (IGenericContext) context,
 
593
                                context != null
 
594
                                        ? ImportGenericKind.Open
 
595
                                        : ImportGenericKind.Definition);
 
596
                }
 
597
 
 
598
                public FieldReference Import (SR.FieldInfo field)
 
599
                {
 
600
                        CheckField (field);
 
601
 
 
602
                        return MetadataImporter.ImportField (field, null);
 
603
                }
 
604
 
 
605
                public FieldReference Import (SR.FieldInfo field, TypeReference context)
 
606
                {
 
607
                        return Import (field, (IGenericParameterProvider) context);
 
608
                }
 
609
 
 
610
                public FieldReference Import (SR.FieldInfo field, MethodReference context)
 
611
                {
 
612
                        return Import (field, (IGenericParameterProvider) context);
 
613
                }
 
614
 
 
615
                FieldReference Import (SR.FieldInfo field, IGenericParameterProvider context)
 
616
                {
 
617
                        CheckField (field);
 
618
                        CheckContext (context, this);
 
619
 
 
620
                        return MetadataImporter.ImportField (field, (IGenericContext) context);
 
621
                }
 
622
 
 
623
                public MethodReference Import (SR.MethodBase method)
 
624
                {
 
625
                        CheckMethod (method);
 
626
 
 
627
                        return MetadataImporter.ImportMethod (method, null, ImportGenericKind.Definition);
 
628
                }
 
629
 
 
630
                public MethodReference Import (SR.MethodBase method, TypeReference context)
 
631
                {
 
632
                        return Import (method, (IGenericParameterProvider) context);
 
633
                }
 
634
 
 
635
                public MethodReference Import (SR.MethodBase method, MethodReference context)
 
636
                {
 
637
                        return Import (method, (IGenericParameterProvider) context);
 
638
                }
 
639
 
 
640
                MethodReference Import (SR.MethodBase method, IGenericParameterProvider context)
 
641
                {
 
642
                        CheckMethod (method);
 
643
                        CheckContext (context, this);
 
644
 
 
645
                        return MetadataImporter.ImportMethod (method,
 
646
                                (IGenericContext) context,
 
647
                                context != null
 
648
                                        ? ImportGenericKind.Open
 
649
                                        : ImportGenericKind.Definition);
 
650
                }
 
651
#endif
 
652
 
 
653
                public TypeReference Import (TypeReference type)
 
654
                {
 
655
                        CheckType (type);
 
656
 
 
657
                        if (type.Module == this)
 
658
                                return type;
 
659
 
 
660
                        return MetadataImporter.ImportType (type, null);
 
661
                }
 
662
 
 
663
                public TypeReference Import (TypeReference type, TypeReference context)
 
664
                {
 
665
                        return Import (type, (IGenericParameterProvider) context);
 
666
                }
 
667
 
 
668
                public TypeReference Import (TypeReference type, MethodReference context)
 
669
                {
 
670
                        return Import (type, (IGenericParameterProvider) context);
 
671
                }
 
672
 
 
673
                TypeReference Import (TypeReference type, IGenericParameterProvider context)
 
674
                {
 
675
                        CheckType (type);
 
676
 
 
677
                        if (type.Module == this)
 
678
                                return type;
 
679
 
 
680
                        CheckContext (context, this);
 
681
 
 
682
                        return MetadataImporter.ImportType (type, (IGenericContext) context);
 
683
                }
 
684
 
 
685
                public FieldReference Import (FieldReference field)
 
686
                {
 
687
                        CheckField (field);
 
688
 
 
689
                        if (field.Module == this)
 
690
                                return field;
 
691
 
 
692
                        return MetadataImporter.ImportField (field, null);
 
693
                }
 
694
 
 
695
                public FieldReference Import (FieldReference field, TypeReference context)
 
696
                {
 
697
                        return Import (field, (IGenericParameterProvider) context);
 
698
                }
 
699
 
 
700
                public FieldReference Import (FieldReference field, MethodReference context)
 
701
                {
 
702
                        return Import (field, (IGenericParameterProvider) context);
 
703
                }
 
704
 
 
705
                FieldReference Import (FieldReference field, IGenericParameterProvider context)
 
706
                {
 
707
                        CheckField (field);
 
708
 
 
709
                        if (field.Module == this)
 
710
                                return field;
 
711
 
 
712
                        CheckContext (context, this);
 
713
 
 
714
                        return MetadataImporter.ImportField (field, (IGenericContext) context);
 
715
                }
 
716
 
 
717
                public MethodReference Import (MethodReference method)
 
718
                {
 
719
                        CheckMethod (method);
 
720
 
 
721
                        if (method.Module == this)
 
722
                                return method;
 
723
 
 
724
                        return MetadataImporter.ImportMethod (method, null);
 
725
                }
 
726
 
 
727
                public MethodReference Import (MethodReference method, TypeReference context)
 
728
                {
 
729
                        return Import (method, (IGenericParameterProvider) context);
 
730
                }
 
731
 
 
732
                public MethodReference Import (MethodReference method, MethodReference context)
 
733
                {
 
734
                        return Import (method, (IGenericParameterProvider) context);
 
735
                }
 
736
 
 
737
                MethodReference Import (MethodReference method, IGenericParameterProvider context)
 
738
                {
 
739
                        CheckMethod (method);
 
740
 
 
741
                        if (method.Module == this)
 
742
                                return method;
 
743
 
 
744
                        CheckContext (context, this);
 
745
 
 
746
                        return MetadataImporter.ImportMethod (method, (IGenericContext) context);
 
747
                }
 
748
 
 
749
#endif
 
750
 
 
751
                public IMetadataTokenProvider LookupToken (int token)
 
752
                {
 
753
                        return LookupToken (new MetadataToken ((uint) token));
 
754
                }
 
755
 
 
756
                public IMetadataTokenProvider LookupToken (MetadataToken token)
 
757
                {
 
758
                        return Read (this, (_, reader) => reader.LookupToken (token));
 
759
                }
 
760
 
 
761
                internal TRet Read<TItem, TRet> (TItem item, Func<TItem, MetadataReader, TRet> read)
 
762
                {
 
763
                        var position = reader.position;
 
764
                        var context = reader.context;
 
765
 
 
766
                        var ret = read (item, reader);
 
767
 
 
768
                        reader.position = position;
 
769
                        reader.context = context;
 
770
 
 
771
                        return ret;
 
772
                }
 
773
 
 
774
                void ProcessDebugHeader ()
 
775
                {
 
776
                        if (Image == null || Image.Debug.IsZero)
 
777
                                return;
 
778
 
 
779
                        byte [] header;
 
780
                        var directory = Image.GetDebugHeader (out header);
 
781
 
 
782
                        if (!SymbolReader.ProcessDebugHeader (directory, header))
 
783
                                throw new InvalidOperationException ();
 
784
                }
 
785
 
 
786
#if !READ_ONLY
 
787
 
 
788
                public static ModuleDefinition CreateModule (string name, ModuleKind kind)
 
789
                {
 
790
                        return CreateModule (name, new ModuleParameters { Kind = kind });
 
791
                }
 
792
 
 
793
                public static ModuleDefinition CreateModule (string name, ModuleParameters parameters)
 
794
                {
 
795
                        Mixin.CheckName (name);
 
796
                        Mixin.CheckParameters (parameters);
 
797
 
 
798
                        var module = new ModuleDefinition {
 
799
                                Name = name,
 
800
                                kind = parameters.Kind,
 
801
                                runtime = parameters.Runtime,
 
802
                                architecture = parameters.Architecture,
 
803
                                mvid = Guid.NewGuid (),
 
804
                                Attributes = ModuleAttributes.ILOnly,
 
805
                        };
 
806
 
 
807
                        if (parameters.AssemblyResolver != null)
 
808
                                module.assembly_resolver = parameters.AssemblyResolver;
 
809
 
 
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;
 
815
                        }
 
816
 
 
817
                        module.Types.Add (new TypeDefinition (string.Empty, "<Module>", TypeAttributes.NotPublic));
 
818
 
 
819
                        return module;
 
820
                }
 
821
 
 
822
#endif
 
823
 
 
824
                public void ReadSymbols ()
 
825
                {
 
826
                        if (string.IsNullOrEmpty (fq_name))
 
827
                                throw new InvalidOperationException ();
 
828
 
 
829
                        var provider = SymbolProvider.GetPlatformReaderProvider ();
 
830
 
 
831
                        SymbolReader = provider.GetSymbolReader (this, fq_name);
 
832
 
 
833
                        ProcessDebugHeader ();
 
834
                }
 
835
 
 
836
                public void ReadSymbols (ISymbolReader reader)
 
837
                {
 
838
                        if (reader == null)
 
839
                                throw new ArgumentNullException ("reader");
 
840
 
 
841
                        SymbolReader = reader;
 
842
 
 
843
                        ProcessDebugHeader ();
 
844
                }
 
845
 
 
846
                public static ModuleDefinition ReadModule (string fileName)
 
847
                {
 
848
                        return ReadModule (fileName, new ReaderParameters (ReadingMode.Deferred));
 
849
                }
 
850
 
 
851
                public static ModuleDefinition ReadModule (Stream stream)
 
852
                {
 
853
                        return ReadModule (stream, new ReaderParameters (ReadingMode.Deferred));
 
854
                }
 
855
 
 
856
                public static ModuleDefinition ReadModule (string fileName, ReaderParameters parameters)
 
857
                {
 
858
                        using (var stream = GetFileStream (fileName, FileMode.Open, FileAccess.Read, FileShare.Read)) {
 
859
                                return ReadModule (stream, parameters);
 
860
                        }
 
861
                }
 
862
 
 
863
                static void CheckStream (object stream)
 
864
                {
 
865
                        if (stream == null)
 
866
                                throw new ArgumentNullException ("stream");
 
867
                }
 
868
 
 
869
                public static ModuleDefinition ReadModule (Stream stream, ReaderParameters parameters)
 
870
                {
 
871
                        CheckStream (stream);
 
872
                        if (!stream.CanRead || !stream.CanSeek)
 
873
                                throw new ArgumentException ();
 
874
                        Mixin.CheckParameters (parameters);
 
875
 
 
876
                        return ModuleReader.CreateModuleFrom (
 
877
                                ImageReader.ReadImageFrom (stream),
 
878
                                parameters);
 
879
                }
 
880
 
 
881
                static Stream GetFileStream (string fileName, FileMode mode, FileAccess access, FileShare share)
 
882
                {
 
883
                        if (fileName == null)
 
884
                                throw new ArgumentNullException ("fileName");
 
885
                        if (fileName.Length == 0)
 
886
                                throw new ArgumentException ();
 
887
 
 
888
                        return new FileStream (fileName, mode, access, share);
 
889
                }
 
890
 
 
891
#if !READ_ONLY
 
892
 
 
893
                public void Write (string fileName)
 
894
                {
 
895
                        Write (fileName, new WriterParameters ());
 
896
                }
 
897
 
 
898
                public void Write (Stream stream)
 
899
                {
 
900
                        Write (stream, new WriterParameters ());
 
901
                }
 
902
 
 
903
                public void Write (string fileName, WriterParameters parameters)
 
904
                {
 
905
                        using (var stream = GetFileStream (fileName, FileMode.Create, FileAccess.ReadWrite, FileShare.None)) {
 
906
                                Write (stream, parameters);
 
907
                        }
 
908
                }
 
909
 
 
910
                public void Write (Stream stream, WriterParameters parameters)
 
911
                {
 
912
                        CheckStream (stream);
 
913
                        if (!stream.CanWrite || !stream.CanSeek)
 
914
                                throw new ArgumentException ();
 
915
                        Mixin.CheckParameters (parameters);
 
916
 
 
917
                        ModuleWriter.WriteModuleTo (this, stream, parameters);
 
918
                }
 
919
 
 
920
#endif
 
921
 
 
922
        }
 
923
 
 
924
        static partial class Mixin {
 
925
 
 
926
                public static void CheckParameters (object parameters)
 
927
                {
 
928
                        if (parameters == null)
 
929
                                throw new ArgumentNullException ("parameters");
 
930
                }
 
931
 
 
932
                public static bool HasImage (this ModuleDefinition self)
 
933
                {
 
934
                        return self != null && self.HasImage;
 
935
                }
 
936
 
 
937
                public static string GetFullyQualifiedName (this Stream self)
 
938
                {
 
939
#if !SILVERLIGHT
 
940
                        var file_stream = self as FileStream;
 
941
                        if (file_stream == null)
 
942
                                return string.Empty;
 
943
 
 
944
                        return Path.GetFullPath (file_stream.Name);
 
945
#else
 
946
                        return string.Empty;
 
947
#endif
 
948
                }
 
949
 
 
950
                public static TargetRuntime ParseRuntime (this string self)
 
951
                {
 
952
                        switch (self [1]) {
 
953
                        case '1':
 
954
                                return self [3] == '0'
 
955
                                        ? TargetRuntime.Net_1_0
 
956
                                        : TargetRuntime.Net_1_1;
 
957
                        case '2':
 
958
                                return TargetRuntime.Net_2_0;
 
959
                        case '4':
 
960
                        default:
 
961
                                return TargetRuntime.Net_4_0;
 
962
                        }
 
963
                }
 
964
        }
 
965
}