Merge pull request #2483 from ludovic-henry/monoerror-mono_string_new_size

[mono.git] / mcs / mcs / ikvm.cs

diff --git a/mcs/mcs/ikvm.cs b/mcs/mcs/ikvm.cs
index c2e247037ef2f62e9ad16ca51a0b16f0ef2674dd..4ed8cf62a4ecb7bc49e9684521b0fb0176b981b5 100644 (file)
--- a/mcs/mcs/ikvm.cs
+++ b/mcs/mcs/ikvm.cs
@@ -220,6 +220,11 @@ namespace Mono.CSharp
                        return Builder.__AddModule (moduleFile);
                }
 
+               protected override List<string[]> GetNotUnifiedReferences (AssemblyName assemblyName)
+               {
+                       return loader.GetNotUnifiedReferences (assemblyName);
+               }
+
                protected override void SaveModule (PortableExecutableKinds pekind, ImageFileMachine machine)
                {
                        module.Builder.__Save (pekind, machine);
@@ -233,20 +238,24 @@ namespace Mono.CSharp
                Assembly corlib;
                readonly List<Tuple<AssemblyName, string, Assembly>> loaded_names;
                static readonly Dictionary<string, string[]> sdk_directory;
+               Dictionary<AssemblyName, List<string[]>> resolved_version_mismatches;
 
                static StaticLoader ()
                {
                        sdk_directory = new Dictionary<string, string[]> ();
                        sdk_directory.Add ("2", new string[] { "2.0", "net_2_0", "v2.0.50727" });
                        sdk_directory.Add ("4", new string[] { "4.0", "net_4_0", "v4.0.30319" });
-                       sdk_directory.Add ("4.5", new string[] { "4.5", "net_4_5", "v4.0.30319" });
+                       sdk_directory.Add ("4.5", new string[] { "4.5", "net_4_x", "v4.0.30319" });
                }
 
                public StaticLoader (StaticImporter importer, CompilerContext compiler)
                        : base (compiler)
                {
                        this.importer = importer;
-                       domain = new Universe (UniverseOptions.MetadataOnly | UniverseOptions.ResolveMissingMembers | UniverseOptions.DisableFusion);
+                       domain = new Universe (UniverseOptions.MetadataOnly | UniverseOptions.ResolveMissingMembers | 
+                               UniverseOptions.DisableFusion | UniverseOptions.DecodeVersionInfoAttributeBlobs |
+                               UniverseOptions.DeterministicOutput);
+                       
                        domain.AssemblyResolve += AssemblyReferenceResolver;
                        loaded_names = new List<Tuple<AssemblyName, string, Assembly>> ();
 
@@ -350,11 +359,23 @@ namespace Mono.CSharp
                                var v2 = version_mismatch.GetName ().Version;
 
                                if (v1 > v2) {
-//                                     compiler.Report.SymbolRelatedToPreviousError (args.RequestingAssembly.Location);
-                                       compiler.Report.Error (1705, "Assembly `{0}' references `{1}' which has a higher version number than imported assembly `{2}'",
-                                               args.RequestingAssembly.FullName, refname, version_mismatch.GetName ().FullName);
+                                       if (resolved_version_mismatches == null)
+                                               resolved_version_mismatches = new Dictionary<AssemblyName, List<string[]>> ();
+
+                                       var an = args.RequestingAssembly.GetName ();
+                                       List<string[]> names;
+                                       if (!resolved_version_mismatches.TryGetValue (an, out names)) {
+                                               names = new List<string[]> ();
+                                               resolved_version_mismatches.Add (an, names);
+                                       }
+
+                                       names.Add (new[] {
+                                               args.RequestingAssembly.Location,
+                                               string.Format ("Assembly `{0}' depends on `{1}' which has a higher version number than referenced assembly `{2}'",
+                                                       args.RequestingAssembly.FullName, refname, version_mismatch.GetName ().FullName)
+                                       });
 
-                                       return domain.CreateMissingAssembly (args.Name);
+                                       return version_mismatch;
                                }
 
                                if (!is_fx_assembly) {
@@ -409,9 +430,22 @@ namespace Mono.CSharp
                        return default_references.ToArray ();
                }
 
+               public List<string[]> GetNotUnifiedReferences (AssemblyName assemblyName)
+               {
+                       List<string[]> list = null;
+                       if (resolved_version_mismatches != null)
+                               resolved_version_mismatches.TryGetValue (assemblyName, out list);
+
+                       return list;
+               }
+
                public override bool HasObjectType (Assembly assembly)
                {
-                       return assembly.GetType (compiler.BuiltinTypes.Object.FullName) != null;
+                       try {
+                               return assembly.GetType (compiler.BuiltinTypes.Object.FullName) != null;
+                       } catch (Exception e) {
+                               throw new InternalErrorException (e, "Failed to load assembly `{0}'", assembly.FullName);
+                       }
                }
 
                public override Assembly LoadAssemblyFile (string fileName, bool isImplicitReference)
@@ -583,7 +617,25 @@ namespace Mono.CSharp
 
                public override void DefineWin32IconResource (string fileName)
                {
-                       builder.__DefineIconResource (File.ReadAllBytes (fileName));
+                       byte[] bytes;
+                       try {
+                               bytes = File.ReadAllBytes (fileName);
+                       } catch (Exception e) {
+                               ctx.Report.Error (7064, Location.Null, "Error opening icon file `{0}'. {1}", fileName, e.Message);
+                               return;
+                       }
+
+                       builder.__DefineIconResource (bytes);
+               }
+
+               public override AssemblyName[] GetReferencedAssemblies ()
+               {
+                       foreach (var m in builder.Modules) {
+                               if (m is ModuleBuilder)
+                                       return m.__GetReferencedAssemblies ();
+                       }
+
+                       return new AssemblyName [0];
                }
 
                public override void SetAlgorithmId (uint value, Location loc)