mcs/class/IKVM.Reflection/Reader/AssemblyReader.cs

   1 /*
   2   Copyright (C) 2009 Jeroen Frijters
   3
   4   This software is provided 'as-is', without any express or implied
   5   warranty.  In no event will the authors be held liable for any damages
   6   arising from the use of this software.
   7
   8   Permission is granted to anyone to use this software for any purpose,
   9   including commercial applications, and to alter it and redistribute it
  10   freely, subject to the following restrictions:
  11
  12   1. The origin of this software must not be misrepresented; you must not
  13      claim that you wrote the original software. If you use this software
  14      in a product, an acknowledgment in the product documentation would be
  15      appreciated but is not required.
  16   2. Altered source versions must be plainly marked as such, and must not be
  17      misrepresented as being the original software.
  18   3. This notice may not be removed or altered from any source distribution.
  19
  20   Jeroen Frijters
  21   jeroen@frijters.net
  22
  23 */
  24 using System;
  25 using System.Collections.Generic;
  26 using System.Configuration.Assemblies;
  27 using System.IO;
  28 using IKVM.Reflection.Metadata;
  29
  30 namespace IKVM.Reflection.Reader
  31 {
  32         sealed class AssemblyReader : Assembly
  33         {
  34                 private const int ContainsNoMetaData = 0x0001;
  35                 private readonly string location;
  36                 private readonly ModuleReader manifestModule;
  37                 private readonly Module[] externalModules;
  38
  39                 internal AssemblyReader(string location, ModuleReader manifestModule)
  40                         : base(manifestModule.universe)
  41                 {
  42                         this.location = location;
  43                         this.manifestModule = manifestModule;
  44                         externalModules = new Module[manifestModule.File.records.Length];
  45                 }
  46
  47                 public override string Location
  48                 {
  49                         get { return location; }
  50                 }
  51
  52                 public override AssemblyName GetName()
  53                 {
  54                         return GetNameImpl(ref manifestModule.AssemblyTable.records[0]);
  55                 }
  56
  57                 private AssemblyName GetNameImpl(ref AssemblyTable.Record rec)
  58                 {
  59                         AssemblyName name = new AssemblyName();
  60                         name.Name = manifestModule.GetString(rec.Name);
  61                         name.Version = new Version(rec.MajorVersion, rec.MinorVersion, rec.BuildNumber, rec.RevisionNumber);
  62                         if (rec.PublicKey != 0)
  63                         {
  64                                 name.SetPublicKey(manifestModule.GetBlobCopy(rec.PublicKey));
  65                         }
  66                         else
  67                         {
  68                                 name.SetPublicKey(Empty<byte>.Array);
  69                         }
  70                         if (rec.Culture != 0)
  71                         {
  72                                 name.Culture = manifestModule.GetString(rec.Culture);
  73                         }
  74                         else
  75                         {
  76                                 name.Culture = "";
  77                         }
  78                         name.HashAlgorithm = (AssemblyHashAlgorithm)rec.HashAlgId;
  79                         name.CodeBase = this.CodeBase;
  80                         name.RawFlags = (AssemblyNameFlags)rec.Flags;
  81                         return name;
  82                 }
  83
  84                 public override Type[] GetTypes()
  85                 {
  86                         if (externalModules.Length == 0)
  87                         {
  88                                 return manifestModule.GetTypes();
  89                         }
  90
  91                         List<Type> list = new List<Type>();
  92                         foreach (Module module in GetModules(false))
  93                         {
  94                                 list.AddRange(module.GetTypes());
  95                         }
  96                         return list.ToArray();
  97                 }
  98
  99                 internal override Type FindType(TypeName typeName)
 100                 {
 101                         Type type = manifestModule.FindType(typeName);
 102                         for (int i = 0; type == null && i < externalModules.Length; i++)
 103                         {
 104                                 if ((manifestModule.File.records[i].Flags & ContainsNoMetaData) == 0)
 105                                 {
 106                                         type = GetModule(i).FindType(typeName);
 107                                 }
 108                         }
 109                         return type;
 110                 }
 111
 112                 public override string ImageRuntimeVersion
 113                 {
 114                         get { return manifestModule.__ImageRuntimeVersion; }
 115                 }
 116
 117                 public override Module ManifestModule
 118                 {
 119                         get { return manifestModule; }
 120                 }
 121
 122                 public override Module[] GetLoadedModules(bool getResourceModules)
 123                 {
 124                         List<Module> list = new List<Module>();
 125                         list.Add(manifestModule);
 126                         foreach (Module m in externalModules)
 127                         {
 128                                 if (m != null)
 129                                 {
 130                                         list.Add(m);
 131                                 }
 132                         }
 133                         return list.ToArray();
 134                 }
 135
 136                 public override Module[] GetModules(bool getResourceModules)
 137                 {
 138                         if (externalModules.Length == 0)
 139                         {
 140                                 return new Module[] { manifestModule };
 141                         }
 142                         else
 143                         {
 144                                 List<Module> list = new List<Module>();
 145                                 list.Add(manifestModule);
 146                                 for (int i = 0; i < manifestModule.File.records.Length; i++)
 147                                 {
 148                                         if (getResourceModules || (manifestModule.File.records[i].Flags & ContainsNoMetaData) == 0)
 149                                         {
 150                                                 list.Add(GetModule(i));
 151                                         }
 152                                 }
 153                                 return list.ToArray();
 154                         }
 155                 }
 156
 157                 public override Module GetModule(string name)
 158                 {
 159                         if (name.Equals(manifestModule.ScopeName, StringComparison.InvariantCultureIgnoreCase))
 160                         {
 161                                 return manifestModule;
 162                         }
 163                         int index = GetModuleIndex(name);
 164                         if (index != -1)
 165                         {
 166                                 return GetModule(index);
 167                         }
 168                         return null;
 169                 }
 170
 171                 private int GetModuleIndex(string name)
 172                 {
 173                         for (int i = 0; i < manifestModule.File.records.Length; i++)
 174                         {
 175                                 if (name.Equals(manifestModule.GetString(manifestModule.File.records[i].Name), StringComparison.InvariantCultureIgnoreCase))
 176                                 {
 177                                         return i;
 178                                 }
 179                         }
 180                         return -1;
 181                 }
 182
 183                 private Module GetModule(int index)
 184                 {
 185                         if (externalModules[index] != null)
 186                         {
 187                                 return externalModules[index];
 188                         }
 189                         // TODO add ModuleResolve event
 190                         string location = Path.Combine(Path.GetDirectoryName(this.location), manifestModule.GetString(manifestModule.File.records[index].Name));
 191                         return LoadModule(index, null, location);
 192                 }
 193
 194                 private Module LoadModule(int index, byte[] rawModule, string location)
 195                 {
 196                         if ((manifestModule.File.records[index].Flags & ContainsNoMetaData) != 0)
 197                         {
 198                                 return externalModules[index] = new ResourceModule(manifestModule, index, location);
 199                         }
 200                         else
 201                         {
 202                                 if (rawModule == null)
 203                                 {
 204                                         rawModule = File.ReadAllBytes(location);
 205                                 }
 206                                 return externalModules[index] = new ModuleReader(this, manifestModule.universe, new MemoryStream(rawModule), location);
 207                         }
 208                 }
 209
 210                 public override Module LoadModule(string moduleName, byte[] rawModule)
 211                 {
 212                         int index = GetModuleIndex(moduleName);
 213                         if (index == -1)
 214                         {
 215                                 throw new ArgumentException();
 216                         }
 217                         if (externalModules[index] != null)
 218                         {
 219                                 return externalModules[index];
 220                         }
 221                         return LoadModule(index, rawModule, null);
 222                 }
 223
 224                 public override MethodInfo EntryPoint
 225                 {
 226                         get { return manifestModule.GetEntryPoint(); }
 227                 }
 228
 229                 public override string[] GetManifestResourceNames()
 230                 {
 231                         return manifestModule.GetManifestResourceNames();
 232                 }
 233
 234                 public override ManifestResourceInfo GetManifestResourceInfo(string resourceName)
 235                 {
 236                         return manifestModule.GetManifestResourceInfo(resourceName);
 237                 }
 238
 239                 public override Stream GetManifestResourceStream(string resourceName)
 240                 {
 241                         return manifestModule.GetManifestResourceStream(resourceName);
 242                 }
 243
 244                 public override AssemblyName[] GetReferencedAssemblies()
 245                 {
 246                         return manifestModule.__GetReferencedAssemblies();
 247                 }
 248
 249                 public override AssemblyNameFlags __AssemblyFlags
 250                 {
 251                         get { return (AssemblyNameFlags)manifestModule.AssemblyTable.records[0].Flags; }
 252                 }
 253
 254                 internal string Name
 255                 {
 256                         get { return manifestModule.GetString(manifestModule.AssemblyTable.records[0].Name); }
 257                 }
 258
 259                 internal override IList<CustomAttributeData> GetCustomAttributesData(Type attributeType)
 260                 {
 261                         return manifestModule.GetCustomAttributes(0x20000001, attributeType);
 262                 }
 263         }
 264 }