Update to the latest IKVM.Reflection

[mono.git] / mcs / class / IKVM.Reflection / Reader / AssemblyReader.cs

diff --git a/mcs/class/IKVM.Reflection/Reader/AssemblyReader.cs b/mcs/class/IKVM.Reflection/Reader/AssemblyReader.cs
index 845bff3817b873ded19f8f48676eb09b788394c4..c64189eeb48975e26bbb7a8c49bed648f68271c0 100644 (file)
--- a/mcs/class/IKVM.Reflection/Reader/AssemblyReader.cs
+++ b/mcs/class/IKVM.Reflection/Reader/AssemblyReader.cs
@@ -49,11 +49,6 @@ namespace IKVM.Reflection.Reader
                        get { return location; }
                }
 
-               public override string FullName
-               {
-                       get { return GetName().FullName; }
-               }
-
                public override AssemblyName GetName()
                {
                        return GetNameImpl(ref manifestModule.AssemblyTable.records[0]);
@@ -82,6 +77,37 @@ namespace IKVM.Reflection.Reader
                        }
                        name.HashAlgorithm = (AssemblyHashAlgorithm)rec.HashAlgId;
                        name.CodeBase = this.CodeBase;
+                       PortableExecutableKinds peKind;
+                       ImageFileMachine machine;
+                       manifestModule.GetPEKind(out peKind, out machine);
+                       switch (machine)
+                       {
+                               case ImageFileMachine.I386:
+                                       // FXBUG we copy the .NET bug that Preferred32Bit implies x86
+                                       if ((peKind & (PortableExecutableKinds.Required32Bit | PortableExecutableKinds.Preferred32Bit)) != 0)
+                                       {
+                                               name.ProcessorArchitecture = ProcessorArchitecture.X86;
+                                       }
+                                       else if ((rec.Flags & 0x70) == 0x70)
+                                       {
+                                               // it's a reference assembly
+                                               name.ProcessorArchitecture = ProcessorArchitecture.None;
+                                       }
+                                       else
+                                       {
+                                               name.ProcessorArchitecture = ProcessorArchitecture.MSIL;
+                                       }
+                                       break;
+                               case ImageFileMachine.IA64:
+                                       name.ProcessorArchitecture = ProcessorArchitecture.IA64;
+                                       break;
+                               case ImageFileMachine.AMD64:
+                                       name.ProcessorArchitecture = ProcessorArchitecture.Amd64;
+                                       break;
+                               case ImageFileMachine.ARM:
+                                       name.ProcessorArchitecture = ProcessorArchitecture.Arm;
+                                       break;
+                       }
                        name.RawFlags = (AssemblyNameFlags)rec.Flags;
                        return name;
                }
@@ -114,9 +140,22 @@ namespace IKVM.Reflection.Reader
                        return type;
                }
 
+               internal override Type FindTypeIgnoreCase(TypeName lowerCaseName)
+               {
+                       Type type = manifestModule.FindTypeIgnoreCase(lowerCaseName);
+                       for (int i = 0; type == null && i < externalModules.Length; i++)
+                       {
+                               if ((manifestModule.File.records[i].Flags & ContainsNoMetaData) == 0)
+                               {
+                                       type = GetModule(i).FindTypeIgnoreCase(lowerCaseName);
+                               }
+                       }
+                       return type;
+               }
+
                public override string ImageRuntimeVersion
                {
-                       get { return manifestModule.ImageRuntimeVersion; }
+                       get { return manifestModule.__ImageRuntimeVersion; }
                }
 
                public override Module ManifestModule
@@ -191,13 +230,12 @@ namespace IKVM.Reflection.Reader
                        {
                                return externalModules[index];
                        }
-                       // TODO add ModuleResolve event
-                       string location = Path.Combine(Path.GetDirectoryName(this.location), manifestModule.GetString(manifestModule.File.records[index].Name));
-                       return LoadModule(index, null, location);
+                       return LoadModule(index, null, manifestModule.GetString(manifestModule.File.records[index].Name));
                }
 
-               private Module LoadModule(int index, byte[] rawModule, string location)
+               private Module LoadModule(int index, byte[] rawModule, string name)
                {
+                       string location = name == null ? null : Path.Combine(Path.GetDirectoryName(this.location), name);
                        if ((manifestModule.File.records[index].Flags & ContainsNoMetaData) != 0)
                        {
                                return externalModules[index] = new ResourceModule(manifestModule, index, location);
@@ -206,7 +244,30 @@ namespace IKVM.Reflection.Reader
                        {
                                if (rawModule == null)
                                {
-                                       rawModule = File.ReadAllBytes(location);
+                                       try
+                                       {
+                                               rawModule = File.ReadAllBytes(location);
+                                       }
+                                       catch (FileNotFoundException)
+                                       {
+                                               if (resolvers != null)
+                                               {
+                                                       ResolveEventArgs arg = new ResolveEventArgs(name, this);
+                                                       foreach (ModuleResolveEventHandler resolver in resolvers)
+                                                       {
+                                                               Module module = resolver(this, arg);
+                                                               if (module != null)
+                                                               {
+                                                                       return module;
+                                                               }
+                                                       }
+                                               }
+                                               if (universe.MissingMemberResolution)
+                                               {
+                                                       return externalModules[index] = new MissingModule(this);
+                                               }
+                                               throw;
+                                       }
                                }
                                return externalModules[index] = new ModuleReader(this, manifestModule.universe, new MemoryStream(rawModule), location);
                        }
@@ -251,14 +312,19 @@ namespace IKVM.Reflection.Reader
                        return manifestModule.__GetReferencedAssemblies();
                }
 
-               public override AssemblyNameFlags __AssemblyFlags
+               protected override AssemblyNameFlags GetAssemblyFlags()
+               {
+                       return (AssemblyNameFlags)manifestModule.AssemblyTable.records[0].Flags;
+               }
+
+               internal string Name
                {
-                       get { return (AssemblyNameFlags)manifestModule.AssemblyTable.records[0].Flags; }
+                       get { return manifestModule.GetString(manifestModule.AssemblyTable.records[0].Name); }
                }
 
                internal override IList<CustomAttributeData> GetCustomAttributesData(Type attributeType)
                {
-                       return manifestModule.GetCustomAttributes(0x20000001, attributeType);
+                       return CustomAttributeData.GetCustomAttributesImpl(null, manifestModule, 0x20000001, attributeType) ?? CustomAttributeData.EmptyList;
                }
        }
 }