← Back to branch summary

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

« back to all changes in this revision

Viewing changes to contrib/ICSharpCode.NRefactory.CSharp/Parser/mcs/reflection.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:
contrib/ICSharpCode.NRefactory.CSharp/Parser/mcs/reflection.cs
1
 
ļ»æ//
2
 
// reflection.cs: System.Reflection and System.Reflection.Emit specific implementations
3
 
//
4
 
// Author: Marek Safar (marek.safar@gmail.com)
5
 
//
6
 
// Dual licensed under the terms of the MIT X11 or GNU GPL
7
 
//
8
 
// Copyright 2009-2010 Novell, Inc. 
9
 
//
10
 
//
11
 
 
12
 
using System;
13
 
using System.Collections.Generic;
14
 
using System.Reflection;
15
 
using System.IO;
16
 
using System.Runtime.CompilerServices;
17
 
using System.Reflection.Emit;
18
 
using System.Security;
19
 
 
20
 
namespace Mono.CSharp
21
 
{
22
 
#if STATIC
23
 
        public class ReflectionImporter
24
 
        {
25
 
                public ReflectionImporter (ModuleContainer module, BuiltinTypes builtin)
26
 
                {
27
 
                        throw new NotSupportedException ();
28
 
                }
29
 
 
30
 
                public void ImportAssembly (Assembly assembly, RootNamespace targetNamespace)
31
 
                {
32
 
                        throw new NotSupportedException ();
33
 
                }
34
 
 
35
 
                public ImportedModuleDefinition ImportModule (Module module, RootNamespace targetNamespace)
36
 
                {
37
 
                        throw new NotSupportedException ();
38
 
                }
39
 
 
40
 
                public TypeSpec ImportType (Type type)
41
 
                {
42
 
                        throw new NotSupportedException ();
43
 
                }
44
 
        }
45
 
#else
46
 
        public sealed class ReflectionImporter : MetadataImporter
47
 
        {
48
 
                public ReflectionImporter (ModuleContainer module, BuiltinTypes builtin)
49
 
                        : base (module)
50
 
                {
51
 
                        Initialize (builtin);
52
 
                }
53
 
 
54
 
                public override void AddCompiledType (TypeBuilder builder, TypeSpec spec)
55
 
                {
56
 
                }
57
 
 
58
 
                protected override MemberKind DetermineKindFromBaseType (Type baseType)
59
 
                {
60
 
                        if (baseType == typeof (ValueType))
61
 
                                return MemberKind.Struct;
62
 
 
63
 
                        if (baseType == typeof (System.Enum))
64
 
                                return MemberKind.Enum;
65
 
 
66
 
                        if (baseType == typeof (MulticastDelegate))
67
 
                                return MemberKind.Delegate;
68
 
 
69
 
                        return MemberKind.Class;
70
 
                }
71
 
 
72
 
                protected override bool HasVolatileModifier (Type[] modifiers)
73
 
                {
74
 
                        foreach (var t in modifiers) {
75
 
                                if (t == typeof (IsVolatile))
76
 
                                        return true;
77
 
                        }
78
 
 
79
 
                        return false;
80
 
                }
81
 
 
82
 
                public void ImportAssembly (Assembly assembly, RootNamespace targetNamespace)
83
 
                {
84
 
                        // It can be used more than once when importing same assembly
85
 
                        // into 2 or more global aliases
86
 
                        var definition = GetAssemblyDefinition (assembly);
87
 
 
88
 
                        //
89
 
                        // This part tries to simulate loading of top-level
90
 
                        // types only, any missing dependencies are ignores here.
91
 
                        // Full error report is reported later when the type is
92
 
                        // actually used
93
 
                        //
94
 
                        Type[] all_types;
95
 
                        try {
96
 
                                all_types = assembly.GetTypes ();
97
 
                        } catch (ReflectionTypeLoadException e) {
98
 
                                all_types = e.Types;
99
 
                        }
100
 
 
101
 
                        ImportTypes (all_types, targetNamespace, definition.HasExtensionMethod);
102
 
                }
103
 
 
104
 
                public ImportedModuleDefinition ImportModule (Module module, RootNamespace targetNamespace)
105
 
                {
106
 
                        var module_definition = new ImportedModuleDefinition (module);
107
 
                        module_definition.ReadAttributes ();
108
 
 
109
 
                        Type[] all_types;
110
 
                        try {
111
 
                                all_types = module.GetTypes ();
112
 
                        } catch (ReflectionTypeLoadException e) {
113
 
                                all_types = e.Types;
114
 
                        }
115
 
 
116
 
                        ImportTypes (all_types, targetNamespace, false);
117
 
 
118
 
                        return module_definition;
119
 
                }
120
 
 
121
 
                void Initialize (BuiltinTypes builtin)
122
 
                {
123
 
                        //
124
 
                        // Setup mapping for build-in types to avoid duplication of their definition
125
 
                        //
126
 
                        compiled_types.Add (typeof (object), builtin.Object);
127
 
                        compiled_types.Add (typeof (System.ValueType), builtin.ValueType);
128
 
                        compiled_types.Add (typeof (System.Attribute), builtin.Attribute);
129
 
 
130
 
                        compiled_types.Add (typeof (int), builtin.Int);
131
 
                        compiled_types.Add (typeof (long), builtin.Long);
132
 
                        compiled_types.Add (typeof (uint), builtin.UInt);
133
 
                        compiled_types.Add (typeof (ulong), builtin.ULong);
134
 
                        compiled_types.Add (typeof (byte), builtin.Byte);
135
 
                        compiled_types.Add (typeof (sbyte), builtin.SByte);
136
 
                        compiled_types.Add (typeof (short), builtin.Short);
137
 
                        compiled_types.Add (typeof (ushort), builtin.UShort);
138
 
 
139
 
                        compiled_types.Add (typeof (System.Collections.IEnumerator), builtin.IEnumerator);
140
 
                        compiled_types.Add (typeof (System.Collections.IEnumerable), builtin.IEnumerable);
141
 
                        compiled_types.Add (typeof (System.IDisposable), builtin.IDisposable);
142
 
 
143
 
                        compiled_types.Add (typeof (char), builtin.Char);
144
 
                        compiled_types.Add (typeof (string), builtin.String);
145
 
                        compiled_types.Add (typeof (float), builtin.Float);
146
 
                        compiled_types.Add (typeof (double), builtin.Double);
147
 
                        compiled_types.Add (typeof (decimal), builtin.Decimal);
148
 
                        compiled_types.Add (typeof (bool), builtin.Bool);
149
 
                        compiled_types.Add (typeof (System.IntPtr), builtin.IntPtr);
150
 
                        compiled_types.Add (typeof (System.UIntPtr), builtin.UIntPtr);
151
 
 
152
 
                        compiled_types.Add (typeof (System.MulticastDelegate), builtin.MulticastDelegate);
153
 
                        compiled_types.Add (typeof (System.Delegate), builtin.Delegate);
154
 
                        compiled_types.Add (typeof (System.Enum), builtin.Enum);
155
 
                        compiled_types.Add (typeof (System.Array), builtin.Array);
156
 
                        compiled_types.Add (typeof (void), builtin.Void);
157
 
                        compiled_types.Add (typeof (System.Type), builtin.Type);
158
 
                        compiled_types.Add (typeof (System.Exception), builtin.Exception);
159
 
                        compiled_types.Add (typeof (System.RuntimeFieldHandle), builtin.RuntimeFieldHandle);
160
 
                        compiled_types.Add (typeof (System.RuntimeTypeHandle), builtin.RuntimeTypeHandle);
161
 
                }
162
 
        }
163
 
 
164
 
        [System.Runtime.InteropServices.StructLayout (System.Runtime.InteropServices.LayoutKind.Explicit)]
165
 
        struct SingleConverter
166
 
        {
167
 
                [System.Runtime.InteropServices.FieldOffset (0)]
168
 
                int i;
169
 
 
170
 
#pragma warning disable 414
171
 
                [System.Runtime.InteropServices.FieldOffset (0)]
172
 
                float f;
173
 
#pragma warning restore 414
174
 
 
175
 
                public static int SingleToInt32Bits (float v)
176
 
                {
177
 
                        SingleConverter c = new SingleConverter ();
178
 
                        c.f = v;
179
 
                        return c.i;
180
 
                }
181
 
        }
182
 
 
183
 
#endif
184
 
 
185
 
        public class AssemblyDefinitionDynamic : AssemblyDefinition
186
 
        {
187
 
                //
188
 
                // In-memory only assembly container
189
 
                //
190
 
                public AssemblyDefinitionDynamic (ModuleContainer module, string name)
191
 
                        : base (module, name)
192
 
                {
193
 
                }
194
 
 
195
 
                //
196
 
                // Assembly container with file output
197
 
                //
198
 
                public AssemblyDefinitionDynamic (ModuleContainer module, string name, string fileName)
199
 
                        : base (module, name, fileName)
200
 
                {
201
 
                }
202
 
 
203
 
                public Module IncludeModule (string moduleFile)
204
 
                {
205
 
                        return builder_extra.AddModule (moduleFile);
206
 
                }
207
 
 
208
 
#if !STATIC
209
 
                public override ModuleBuilder CreateModuleBuilder ()
210
 
                {
211
 
                        if (file_name == null)
212
 
                                return Builder.DefineDynamicModule (Name, false);
213
 
 
214
 
                        return base.CreateModuleBuilder ();
215
 
                }
216
 
#endif
217
 
                //
218
 
                // Initializes the code generator
219
 
                //
220
 
                public bool Create (AppDomain domain, AssemblyBuilderAccess access)
221
 
                {
222
 
#if STATIC
223
 
                        throw new NotSupportedException ();
224
 
#else
225
 
                        ResolveAssemblySecurityAttributes ();
226
 
                        var an = CreateAssemblyName ();
227
 
 
228
 
                        Builder = file_name == null ?
229
 
                                domain.DefineDynamicAssembly (an, access) :
230
 
                                domain.DefineDynamicAssembly (an, access, Dirname (file_name));
231
 
 
232
 
                        module.Create (this, CreateModuleBuilder ());
233
 
                        builder_extra = new AssemblyBuilderMonoSpecific (Builder, Compiler);
234
 
                        return true;
235
 
#endif
236
 
                }
237
 
 
238
 
                static string Dirname (string name)
239
 
                {
240
 
                        int pos = name.LastIndexOf ('/');
241
 
 
242
 
                        if (pos != -1)
243
 
                                return name.Substring (0, pos);
244
 
 
245
 
                        pos = name.LastIndexOf ('\\');
246
 
                        if (pos != -1)
247
 
                                return name.Substring (0, pos);
248
 
 
249
 
                        return ".";
250
 
                }
251
 
 
252
 
#if !STATIC
253
 
                protected override void SaveModule (PortableExecutableKinds pekind, ImageFileMachine machine)
254
 
                {
255
 
                        try {
256
 
                                var module_only = typeof (AssemblyBuilder).GetProperty ("IsModuleOnly", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
257
 
                                var set_module_only = module_only.GetSetMethod (true);
258
 
 
259
 
                                set_module_only.Invoke (Builder, new object[] { true });
260
 
                        } catch {
261
 
                                base.SaveModule (pekind, machine);
262
 
                        }
263
 
 
264
 
                        Builder.Save (file_name, pekind, machine);
265
 
                }
266
 
#endif
267
 
        }
268
 
 
269
 
        //
270
 
        // Extension to System.Reflection.Emit.AssemblyBuilder to have fully compatible
271
 
        // compiler
272
 
        //
273
 
        class AssemblyBuilderMonoSpecific : AssemblyBuilderExtension
274
 
        {
275
 
                static MethodInfo adder_method;
276
 
                static MethodInfo add_permission;
277
 
                static MethodInfo add_type_forwarder;
278
 
                static MethodInfo win32_icon_define;
279
 
                static FieldInfo assembly_version;
280
 
                static FieldInfo assembly_algorithm;
281
 
                static FieldInfo assembly_culture;
282
 
                static FieldInfo assembly_flags;
283
 
 
284
 
                AssemblyBuilder builder;
285
 
 
286
 
                public AssemblyBuilderMonoSpecific (AssemblyBuilder ab, CompilerContext ctx)
287
 
                        : base (ctx)
288
 
                {
289
 
                        this.builder = ab;
290
 
                }
291
 
 
292
 
                public override Module AddModule (string module)
293
 
                {
294
 
                        try {
295
 
                                if (adder_method == null)
296
 
                                        adder_method = typeof (AssemblyBuilder).GetMethod ("AddModule", BindingFlags.Instance | BindingFlags.NonPublic);
297
 
 
298
 
                                return (Module) adder_method.Invoke (builder, new object[] { module });
299
 
                        } catch {
300
 
                                return base.AddModule (module);
301
 
                        }
302
 
                }
303
 
 
304
 
                public override void AddPermissionRequests (PermissionSet[] permissions)
305
 
                {
306
 
                        try {
307
 
                                if (add_permission == null)
308
 
                                        add_permission = typeof (AssemblyBuilder).GetMethod ("AddPermissionRequests", BindingFlags.Instance | BindingFlags.NonPublic);
309
 
 
310
 
                                add_permission.Invoke (builder, permissions);
311
 
                        } catch {
312
 
                                base.AddPermissionRequests (permissions);
313
 
                        }
314
 
                }
315
 
 
316
 
                public override void AddTypeForwarder (TypeSpec type, Location loc)
317
 
                {
318
 
                        try {
319
 
                                if (add_type_forwarder == null) {
320
 
                                        add_type_forwarder = typeof (AssemblyBuilder).GetMethod ("AddTypeForwarder", BindingFlags.NonPublic | BindingFlags.Instance);
321
 
                                }
322
 
 
323
 
                                add_type_forwarder.Invoke (builder, new object[] { type.GetMetaInfo () });
324
 
                        } catch {
325
 
                                base.AddTypeForwarder (type, loc);
326
 
                        }
327
 
                }
328
 
 
329
 
                public override void DefineWin32IconResource (string fileName)
330
 
                {
331
 
                        try {
332
 
                                if (win32_icon_define == null)
333
 
                                        win32_icon_define = typeof (AssemblyBuilder).GetMethod ("DefineIconResource", BindingFlags.Instance | BindingFlags.NonPublic);
334
 
 
335
 
                                win32_icon_define.Invoke (builder, new object[] { fileName });
336
 
                        } catch {
337
 
                                base.DefineWin32IconResource (fileName);
338
 
                        }
339
 
                }
340
 
 
341
 
                public override void SetAlgorithmId (uint value, Location loc)
342
 
                {
343
 
                        try {
344
 
                                if (assembly_algorithm == null)
345
 
                                        assembly_algorithm = typeof (AssemblyBuilder).GetField ("algid", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.SetField);
346
 
 
347
 
                                assembly_algorithm.SetValue (builder, value);
348
 
                        } catch {
349
 
                                base.SetAlgorithmId (value, loc);
350
 
                        }
351
 
                }
352
 
 
353
 
                public override void SetCulture (string culture, Location loc)
354
 
                {
355
 
                        try {
356
 
                                if (assembly_culture == null)
357
 
                                        assembly_culture = typeof (AssemblyBuilder).GetField ("culture", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.SetField);
358
 
 
359
 
                                assembly_culture.SetValue (builder, culture);
360
 
                        } catch {
361
 
                                base.SetCulture (culture, loc);
362
 
                        }
363
 
                }
364
 
 
365
 
                public override void SetFlags (uint flags, Location loc)
366
 
                {
367
 
                        try {
368
 
                                if (assembly_flags == null)
369
 
                                        assembly_flags = typeof (AssemblyBuilder).GetField ("flags", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.SetField);
370
 
 
371
 
                                assembly_flags.SetValue (builder, flags);
372
 
                        } catch {
373
 
                                base.SetFlags (flags, loc);
374
 
                        }
375
 
                }
376
 
 
377
 
                public override void SetVersion (Version version, Location loc)
378
 
                {
379
 
                        try {
380
 
                                if (assembly_version == null)
381
 
                                        assembly_version = typeof (AssemblyBuilder).GetField ("version", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.SetField);
382
 
 
383
 
                                assembly_version.SetValue (builder, version.ToString (4));
384
 
                        } catch {
385
 
                                base.SetVersion (version, loc);
386
 
                        }
387
 
                }
388
 
        }
389
 
 
390
 
        //
391
 
        // Reflection based references loader
392
 
        //
393
 
        class DynamicLoader : AssemblyReferencesLoader<Assembly>
394
 
        {
395
 
                readonly ReflectionImporter importer;
396
 
 
397
 
                public DynamicLoader (ReflectionImporter importer, CompilerContext compiler)
398
 
                        : base (compiler)
399
 
                {
400
 
                        paths.Add (GetSystemDir ());
401
 
 
402
 
                        this.importer = importer;
403
 
                }
404
 
 
405
 
                public ReflectionImporter Importer {
406
 
                        get {
407
 
                                return importer;
408
 
                        }
409
 
                }
410
 
 
411
 
                protected override string[] GetDefaultReferences ()
412
 
                {
413
 
                        //
414
 
                        // For now the "default config" is harcoded into the compiler
415
 
                        // we can move this outside later
416
 
                        //
417
 
                        var default_references = new List<string> (8);
418
 
 
419
 
                        default_references.Add ("System");
420
 
                        default_references.Add ("System.Xml");
421
 
#if NET_2_1
422
 
                        default_references.Add ("System.Net");
423
 
                        default_references.Add ("System.Windows");
424
 
                        default_references.Add ("System.Windows.Browser");
425
 
#endif
426
 
 
427
 
                        if (compiler.Settings.Version > LanguageVersion.ISO_2)
428
 
                                default_references.Add ("System.Core");
429
 
                        if (compiler.Settings.Version > LanguageVersion.V_3)
430
 
                                default_references.Add ("Microsoft.CSharp");
431
 
 
432
 
                        return default_references.ToArray ();
433
 
                }
434
 
 
435
 
                //
436
 
                // Returns the directory where the system assemblies are installed
437
 
                //
438
 
                static string GetSystemDir ()
439
 
                {
440
 
                        return Path.GetDirectoryName (typeof (object).Assembly.Location);
441
 
                }
442
 
 
443
 
                public override bool HasObjectType (Assembly assembly)
444
 
                {
445
 
                        return assembly.GetType (compiler.BuiltinTypes.Object.FullName) != null;
446
 
                }
447
 
 
448
 
                public override Assembly LoadAssemblyFile (string assembly, bool isImplicitReference)
449
 
                {
450
 
                        Assembly a = null;
451
 
 
452
 
                        try {
453
 
                                try {
454
 
                                        char[] path_chars = { '/', '\\' };
455
 
 
456
 
                                        if (assembly.IndexOfAny (path_chars) != -1) {
457
 
                                                a = Assembly.LoadFrom (assembly);
458
 
                                        } else {
459
 
                                                string ass = assembly;
460
 
                                                if (ass.EndsWith (".dll") || ass.EndsWith (".exe"))
461
 
                                                        ass = assembly.Substring (0, assembly.Length - 4);
462
 
                                                a = Assembly.Load (ass);
463
 
                                        }
464
 
                                } catch (FileNotFoundException) {
465
 
                                        bool err = !isImplicitReference;
466
 
                                        foreach (string dir in paths) {
467
 
                                                string full_path = Path.Combine (dir, assembly);
468
 
                                                if (!assembly.EndsWith (".dll") && !assembly.EndsWith (".exe"))
469
 
                                                        full_path += ".dll";
470
 
 
471
 
                                                try {
472
 
                                                        a = Assembly.LoadFrom (full_path);
473
 
                                                        err = false;
474
 
                                                        break;
475
 
                                                } catch (FileNotFoundException) {
476
 
                                                }
477
 
                                        }
478
 
 
479
 
                                        if (err) {
480
 
                                                Error_FileNotFound (assembly);
481
 
                                                return a;
482
 
                                        }
483
 
                                }
484
 
                        } catch (BadImageFormatException) {
485
 
                                Error_FileCorrupted (assembly);
486
 
                        }
487
 
 
488
 
                        return a;
489
 
                }
490
 
 
491
 
                Module LoadModuleFile (AssemblyDefinitionDynamic assembly, string module)
492
 
                {
493
 
                        string total_log = "";
494
 
 
495
 
                        try {
496
 
                                try {
497
 
                                        return assembly.IncludeModule (module);
498
 
                                } catch (FileNotFoundException) {
499
 
                                        bool err = true;
500
 
                                        foreach (string dir in paths) {
501
 
                                                string full_path = Path.Combine (dir, module);
502
 
                                                if (!module.EndsWith (".netmodule"))
503
 
                                                        full_path += ".netmodule";
504
 
 
505
 
                                                try {
506
 
                                                        return assembly.IncludeModule (full_path);
507
 
                                                } catch (FileNotFoundException ff) {
508
 
                                                        total_log += ff.FusionLog;
509
 
                                                }
510
 
                                        }
511
 
                                        if (err) {
512
 
                                                Error_FileNotFound (module);
513
 
                                                return null;
514
 
                                        }
515
 
                                }
516
 
                        } catch (BadImageFormatException) {
517
 
                                Error_FileCorrupted (module);
518
 
                        }
519
 
 
520
 
                        return null;
521
 
                }
522
 
 
523
 
                public void LoadModules (AssemblyDefinitionDynamic assembly, RootNamespace targetNamespace)
524
 
                {
525
 
                        foreach (var moduleName in compiler.Settings.Modules) {
526
 
                                var m = LoadModuleFile (assembly, moduleName);
527
 
                                if (m == null)
528
 
                                        continue;
529
 
 
530
 
                                var md = importer.ImportModule (m, targetNamespace);
531
 
                                assembly.AddModule (md);
532
 
                        }
533
 
                }
534
 
 
535
 
                public override void LoadReferences (ModuleContainer module)
536
 
                {
537
 
                        Assembly corlib;
538
 
                        List<Tuple<RootNamespace, Assembly>> loaded;
539
 
                        base.LoadReferencesCore (module, out corlib, out loaded);
540
 
 
541
 
                        if (corlib == null)
542
 
                                return;
543
 
 
544
 
                        importer.ImportAssembly (corlib, module.GlobalRootNamespace);
545
 
                        foreach (var entry in loaded) {
546
 
                                importer.ImportAssembly (entry.Item2, entry.Item1);
547
 
                        }
548
 
                }
549
 
        }
550
 
}
 
 
b'\\ No newline at end of file'