Free cookie consent management tool by TermsFeed Policy Generator

source: branches/CodeEditor/HeuristicLab.ExtLibs/HeuristicLab.NRefactory/5.5.0/NRefactory.CSharp-5.5.0/Parser/mcs/reflection.cs @ 11700

Last change on this file since 11700 was 11700, checked in by jkarder, 9 years ago

#2077: created branch and added first version

File size: 14.7 KB
Line 
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
12using System;
13using System.Collections.Generic;
14using System.Reflection;
15using System.IO;
16using System.Runtime.CompilerServices;
17using System.Reflection.Emit;
18using System.Security;
19
20namespace 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    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, true);
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 || FULL_AOT_RUNTIME
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}
Note: See TracBrowser for help on using the repository browser.