281 строка
8.5 KiB
C#
281 строка
8.5 KiB
C#
using System;
|
|
using System.IO;
|
|
using System.Collections.Generic;
|
|
using System.Xml.XPath;
|
|
|
|
using Mono.Linker;
|
|
using Mono.Linker.Steps;
|
|
using Mono.Tuner;
|
|
using MonoMac.Tuner;
|
|
using MonoTouch.Tuner;
|
|
using Xamarin.Bundler;
|
|
using Xamarin.Linker;
|
|
using Xamarin.Linker.Steps;
|
|
using Xamarin.Utils;
|
|
|
|
using Mono.Cecil;
|
|
using Mono.Cecil.Mdb;
|
|
|
|
namespace MonoMac.Tuner {
|
|
|
|
public class LinkerOptions {
|
|
public AssemblyDefinition MainAssembly { get; set; }
|
|
public string OutputDirectory { get; set; }
|
|
public bool LinkSymbols { get; set; }
|
|
public LinkMode LinkMode { get; set; }
|
|
public AssemblyResolver Resolver { get; set; }
|
|
public IEnumerable<string> SkippedAssemblies { get; set; }
|
|
public I18nAssemblies I18nAssemblies { get; set; }
|
|
public bool EnsureUIThread { get; set; }
|
|
public IList<string> ExtraDefinitions { get; set; }
|
|
public TargetFramework TargetFramework { get; set; }
|
|
public string Architecture { get; set; }
|
|
internal PInvokeWrapperGenerator MarshalNativeExceptionsState { get; set; }
|
|
internal RuntimeOptions RuntimeOptions { get; set; }
|
|
|
|
public static I18nAssemblies ParseI18nAssemblies (string i18n)
|
|
{
|
|
var assemblies = I18nAssemblies.None;
|
|
|
|
foreach (var part in i18n.Split (',')) {
|
|
var assembly = part.Trim ();
|
|
if (string.IsNullOrEmpty (assembly))
|
|
continue;
|
|
|
|
try {
|
|
assemblies |= (I18nAssemblies) Enum.Parse (typeof (I18nAssemblies), assembly, true);
|
|
} catch {
|
|
throw new FormatException ("Unknown value for i18n: " + assembly);
|
|
}
|
|
}
|
|
|
|
return assemblies;
|
|
}
|
|
}
|
|
|
|
public class MonoMacLinkContext : LinkContext {
|
|
|
|
Dictionary<string, List<MethodDefinition>> pinvokes = new Dictionary<string, List<MethodDefinition>> ();
|
|
public Dictionary<string, MemberReference> RequiredSymbols = new Dictionary<string, MemberReference> ();
|
|
List<MethodDefinition> marshal_exception_pinvokes;
|
|
|
|
public MonoMacLinkContext (Pipeline pipeline, AssemblyResolver resolver) : base (pipeline, resolver)
|
|
{
|
|
}
|
|
|
|
public IDictionary<string, List<MethodDefinition>> PInvokeModules {
|
|
get { return pinvokes; }
|
|
}
|
|
|
|
public List<MethodDefinition> MarshalExceptionPInvokes {
|
|
get {
|
|
if (marshal_exception_pinvokes == null)
|
|
marshal_exception_pinvokes = new List<MethodDefinition> ();
|
|
return marshal_exception_pinvokes;
|
|
}
|
|
}
|
|
}
|
|
|
|
class Linker {
|
|
|
|
public static void Process (LinkerOptions options, out LinkContext context, out List<string> assemblies)
|
|
{
|
|
switch (options.TargetFramework.Identifier) {
|
|
case "Xamarin.Mac":
|
|
Profile.Current = new MacMobileProfile (options.Architecture == "x86_64" ? 64 : 32);
|
|
break;
|
|
default:
|
|
Profile.Current = new MonoMacProfile ();
|
|
break;
|
|
}
|
|
Namespaces.Initialize ();
|
|
|
|
var pipeline = CreatePipeline (options);
|
|
|
|
pipeline.PrependStep (new ResolveFromAssemblyStep (options.MainAssembly));
|
|
|
|
context = CreateLinkContext (options, pipeline);
|
|
context.Resolver.AddSearchDirectory (options.OutputDirectory);
|
|
|
|
try {
|
|
pipeline.Process (context);
|
|
} catch (AssemblyResolutionException fnfe) {
|
|
throw new MonoMacException (2002, true, fnfe, fnfe.Message);
|
|
} catch (AggregateException) {
|
|
throw;
|
|
} catch (MonoMacException) {
|
|
throw;
|
|
} catch (ResolutionException re) {
|
|
TypeReference tr = (re.Member as TypeReference);
|
|
IMetadataScope scope = tr == null ? re.Member.DeclaringType.Scope : tr.Scope;
|
|
throw new MonoMacException (2002, true, re, "Failed to resolve \"{0}\" reference from \"{1}\"", re.Member, scope);
|
|
} catch (Exception e) {
|
|
throw new MonoMacException (2001, true, e, "Could not link assemblies. Reason: {0}", e.Message);
|
|
}
|
|
|
|
assemblies = ListAssemblies (context);
|
|
}
|
|
|
|
static LinkContext CreateLinkContext (LinkerOptions options, Pipeline pipeline)
|
|
{
|
|
var context = new MonoMacLinkContext (pipeline, options.Resolver);
|
|
context.CoreAction = AssemblyAction.Link;
|
|
context.LinkSymbols = options.LinkSymbols;
|
|
if (options.LinkSymbols) {
|
|
context.SymbolReaderProvider = new MdbReaderProvider ();
|
|
context.SymbolWriterProvider = new MdbWriterProvider ();
|
|
}
|
|
context.OutputDirectory = options.OutputDirectory;
|
|
return context;
|
|
}
|
|
|
|
static Pipeline CreatePipeline (LinkerOptions options)
|
|
{
|
|
var pipeline = new Pipeline ();
|
|
|
|
pipeline.AppendStep (options.LinkMode == LinkMode.None ? new LoadOptionalReferencesStep () : new LoadReferencesStep ());
|
|
|
|
if (options.I18nAssemblies != I18nAssemblies.None)
|
|
pipeline.AppendStep (new LoadI18nAssemblies (options.I18nAssemblies));
|
|
|
|
// that must be done early since the XML files can "add" new assemblies [#15878]
|
|
// and some of the assemblies might be (directly or referenced) SDK assemblies
|
|
foreach (string definition in options.ExtraDefinitions)
|
|
pipeline.AppendStep (GetResolveStep (definition));
|
|
|
|
if (options.LinkMode != LinkMode.None)
|
|
pipeline.AppendStep (new BlacklistStep ());
|
|
|
|
pipeline.AppendStep (new CustomizeMacActions (options.LinkMode, options.SkippedAssemblies));
|
|
|
|
// We need to store the Field attribute in annotations, since it may end up removed.
|
|
pipeline.AppendStep (new ProcessExportedFields ());
|
|
|
|
if (options.LinkMode != LinkMode.None) {
|
|
pipeline.AppendStep (new TypeMapStep ());
|
|
|
|
pipeline.AppendStep (new SubStepDispatcher {
|
|
new ApplyPreserveAttribute (),
|
|
new CoreRemoveSecurity (),
|
|
new OptimizeGeneratedCodeSubStep (options.EnsureUIThread),
|
|
new CoreRemoveAttributes (),
|
|
new CoreHttpMessageHandler (options),
|
|
new CoreTlsProviderStep (options),
|
|
new MarkNSObjects (),
|
|
});
|
|
|
|
pipeline.AppendStep (new MonoMacPreserveCode (options));
|
|
pipeline.AppendStep (new PreserveCrypto ());
|
|
|
|
pipeline.AppendStep (new MonoMacMarkStep ());
|
|
pipeline.AppendStep (new MacRemoveResources (options));
|
|
pipeline.AppendStep (new MobileSweepStep ());
|
|
pipeline.AppendStep (new CleanStep ());
|
|
|
|
pipeline.AppendStep (new MonoMacNamespaces ());
|
|
pipeline.AppendStep (new RemoveSelectors ());
|
|
|
|
pipeline.AppendStep (new RegenerateGuidStep ());
|
|
}
|
|
|
|
pipeline.AppendStep (new ListExportedSymbols (options.MarshalNativeExceptionsState));
|
|
|
|
pipeline.AppendStep (new OutputStep ());
|
|
|
|
return pipeline;
|
|
}
|
|
|
|
static List<string> ListAssemblies (LinkContext context)
|
|
{
|
|
var list = new List<string> ();
|
|
foreach (var assembly in context.GetAssemblies ()) {
|
|
if (context.Annotations.GetAction (assembly) == AssemblyAction.Delete)
|
|
continue;
|
|
|
|
list.Add (GetFullyQualifiedName (assembly));
|
|
}
|
|
|
|
return list;
|
|
}
|
|
|
|
static string GetFullyQualifiedName (AssemblyDefinition assembly)
|
|
{
|
|
return assembly.MainModule.FullyQualifiedName;
|
|
}
|
|
|
|
static ResolveFromXmlStep GetResolveStep (string filename)
|
|
{
|
|
filename = Path.GetFullPath (filename);
|
|
|
|
if (!File.Exists (filename))
|
|
throw new MonoMacException (2004, true, "Extra linker definitions file '{0}' could not be located.", filename);
|
|
|
|
try {
|
|
using (StreamReader sr = new StreamReader (filename)) {
|
|
return new ResolveFromXmlStep (new XPathDocument (new StringReader (sr.ReadToEnd ())));
|
|
}
|
|
}
|
|
catch (Exception e) {
|
|
throw new MonoMacException (2005, true, e, "Definitions from '{0}' could not be parsed.", filename);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
public class CustomizeMacActions : CustomizeActions
|
|
{
|
|
LinkMode link_mode;
|
|
|
|
public CustomizeMacActions (LinkMode mode, IEnumerable<string> skipped_assemblies)
|
|
: base (mode == LinkMode.SDKOnly, skipped_assemblies)
|
|
{
|
|
link_mode = mode;
|
|
}
|
|
|
|
protected override bool IsLinked (AssemblyDefinition assembly)
|
|
{
|
|
if (link_mode == LinkMode.None)
|
|
return false;
|
|
|
|
return base.IsLinked (assembly);
|
|
}
|
|
|
|
protected override void ProcessAssembly (AssemblyDefinition assembly)
|
|
{
|
|
if (link_mode == LinkMode.None) {
|
|
Annotations.SetAction (assembly, AssemblyAction.Copy);
|
|
return;
|
|
}
|
|
|
|
base.ProcessAssembly (assembly);
|
|
}
|
|
}
|
|
|
|
class LoadOptionalReferencesStep : LoadReferencesStep
|
|
{
|
|
HashSet<AssemblyNameDefinition> _references = new HashSet<AssemblyNameDefinition> ();
|
|
|
|
protected override void ProcessAssembly (AssemblyDefinition assembly)
|
|
{
|
|
ProcessReferences (assembly);
|
|
}
|
|
|
|
void ProcessReferences (AssemblyDefinition assembly)
|
|
{
|
|
if (_references.Contains (assembly.Name))
|
|
return;
|
|
|
|
_references.Add (assembly.Name);
|
|
|
|
foreach (AssemblyNameReference reference in assembly.MainModule.AssemblyReferences) {
|
|
try {
|
|
ProcessReferences (Context.Resolve (reference));
|
|
} catch (AssemblyResolutionException fnfe) {
|
|
ErrorHelper.Warning (2013, fnfe, "Failed to resolve the reference to \"{0}\", referenced in \"{1}\". The app will not include the referenced assembly, and may fail at runtime.", fnfe.AssemblyReference.FullName, assembly.Name.FullName);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|