private SourceFile(IApkFile apk, JarFile jar, ISpySettings settings, MapFileLookup mapFile, string singleFilePath = null)
{
this.apk = apk;
this.jar = jar;
this.settings = settings;
this.mapFile = mapFile;
this.singleFilePath = singleFilePath;
#if DEBUG || ENABLE_SHOW_AST
classLoader = new AssemblyClassLoader(module.OnClassLoaded);
var modParams = new ModuleParameters
{
AssemblyResolver = new AssemblyResolver(new[] { Frameworks.Instance.FirstOrDefault().Folder }, classLoader, module.OnAssemblyLoaded),
Kind = ModuleKind.Dll
};
assembly = AssemblyDefinition.CreateAssembly(new AssemblyNameDefinition("spy", Version.Parse("1.0.0.0")), "main", modParams);
classLoader.LoadAssembly(assembly);
var dot42Assembly = modParams.AssemblyResolver.Resolve("dot42");
// Force loading of classes
if (jar != null)
{
foreach (var fileName in jar.ClassFileNames)
{
OpenClass(fileName);
}
}
#endif
}
public void CompileIfRequired(ilspy::Mono.Cecil.AssemblyDefinition assembly, bool stopBeforeGeneratingCode = false)
{
if (_compiler != null && _previousAssembly == assembly
&& (_isFullyCompiled || stopBeforeGeneratingCode))
return;
CompilationErrors = null;
_compiler = null;
#if DEBUG
var framework = Frameworks.Instance.GetBySdkVersion(15);
#else
var framework = Frameworks.Instance.GetNewestVersion();
#endif
string frameworkFolder = framework.Folder;
var refFolders = new List<string> { frameworkFolder };
var module = new XModule();
var classLoader = new AssemblyClassLoader(module.OnClassLoaded);
var resolver = new AssemblyResolver(refFolders, classLoader, module.OnAssemblyLoaded);
var parameter = new ReaderParameters(ReadingMode.Immediate) { AssemblyResolver = resolver,ReadSymbols = true};
var assemblies = new[] { resolver.Load(assembly.MainModule.FullyQualifiedName, parameter) }.ToList();
List<AssemblyDefinition> references = new List<AssemblyDefinition>();
if(assembly.MainModule.Name != "dot42.dll")
references = new[] { resolver.Load(AssemblyConstants.SdkAssemblyName, parameter) }.ToList();
foreach (var a in assemblies)
references.Remove(a);
var c = new AssemblyCompiler(CompilationMode.All, assemblies, references, new Table("pkg.name"),
new NameConverter("pkg.name", ""), true,
new AssemblyClassLoader(file => { }), definition => null,
new DexMethodBodyCompilerCache(), new HashSet<string>(),
module, _generateSetNextInstructionCode);
c.StopCompilationBeforeGeneratingCode = stopBeforeGeneratingCode;
c.StopAtFirstError = false;
try
{
c.Compile();
}
catch (AggregateException ex)
{
CompilationErrors = ex.Flatten().InnerExceptions.Select(e => e.Message.Replace(": ", "\n// ").Replace("; ", "\n// & ")).ToList();
}
if (c.MapFile != null)
{
c.MapFile.Optimize();
MapFile = new MapFileLookup(c.MapFile);
}
_compiler = c;
_previousAssembly = assembly;
_isFullyCompiled = !stopBeforeGeneratingCode;
}
/// <summary>
/// Default ctor
/// </summary>
public TargetFramework(ITypeMapResolver resolver, AssemblyClassLoader assemblyClassLoader, DocModel xmlModel, Action<string> missingParamTypeReport, bool importAsStubs, bool importPublicOnly, IEnumerable<string> excludedPackages)
{
this.missingParamTypeReport = missingParamTypeReport;
this.importAsStubs = importAsStubs;
this.importPublicOnly = importPublicOnly;
XmlModel = xmlModel;
typeNameMap = new TypeNameMap(resolver, assemblyClassLoader);
this.excludedPackages = new HashSet<string>(excludedPackages);
}
/// <summary>
/// Default ctor
/// </summary>
public AssemblyCompiler(CompilationMode mode, List<AssemblyDefinition> assemblies, List<AssemblyDefinition> references, Table resources, NameConverter nameConverter, bool generateDebugInfo, AssemblyClassLoader assemblyClassLoader,
HashSet<string> rootClassNames, XModule module)
{
this.mode = mode;
this.assemblies = assemblies;
this.references = references;
this.resources = resources;
this.generateDebugInfo = generateDebugInfo;
this.assemblyClassLoader = assemblyClassLoader;
this.rootClassNames = rootClassNames;
this.module = module;
targetPackage = new Target.Dex.DexTargetPackage(nameConverter, this);
}
/// <summary>
/// TODO: the list of parameters has gotten way to long.
/// </summary>
public AssemblyCompiler(CompilationMode mode, List<AssemblyDefinition> assemblies,
List<AssemblyDefinition> references, Table resources, NameConverter nameConverter,
bool generateDebugInfo, AssemblyClassLoader assemblyClassLoader,
Func<AssemblyDefinition, string> assemblyToFilename, DexMethodBodyCompilerCache ccache,
HashSet<string> rootClassNames, XModule module, bool generateSetNextInstructionCode)
{
this.mode = mode;
this.assemblies = assemblies;
this.references = references;
this.resources = resources;
this.generateDebugInfo = generateDebugInfo;
this.assemblyClassLoader = assemblyClassLoader;
this.assemblyToFilename = assemblyToFilename;
this.rootClassNames = rootClassNames;
this.module = module;
this.generateSetNextInstructionCode = generateDebugInfo && generateSetNextInstructionCode;
targetPackage = new Target.Dex.DexTargetPackage(nameConverter, this);
methodBodyCompilerCache = ccache;
StopAtFirstError = true;
}
/// <summary>
/// Compile an assembly into a dex file.
/// </summary>
private static void CompileAssembly(CommandLineOptions options, NameConverter nsConverter)
{
// Load resource type usage info file
var usedTypeNames = LoadResourceTypeUsageInformation(options);
// Load assemblies
var assemblies = new List<AssemblyDefinition>();
var module = new XModule();
var classLoader = new AssemblyClassLoader(module.OnClassLoaded);
var resolver = new AssemblyResolver(options.ReferenceFolders, classLoader, module.OnAssemblyLoaded);
var readerParameters = new ReaderParameters(ReadingMode.Immediate)
{
AssemblyResolver = resolver,
SymbolReaderProvider = new SafeSymbolReaderProvider(),
ReadSymbols = true
};
foreach (var asmPath in options.Assemblies)
{
var asm = resolver.Load(asmPath, readerParameters);
module.OnAssemblyLoaded(asm);
classLoader.LoadAssembly(asm);
assemblies.Add(asm);
}
// Load references
var references = new List<AssemblyDefinition>();
foreach (var refPath in options.References)
{
var asm = resolver.Load(refPath, readerParameters);
module.OnAssemblyLoaded(asm);
classLoader.LoadAssembly(asm);
references.Add(asm);
}
// Load resources
Table table;
using (var stream = new FileStream(options.InputResources, FileMode.Open, FileAccess.Read))
{
table = new Table(stream);
}
// Create compiler
var compiler = new AssemblyCompiler(options.CompilationMode, assemblies, references, table, nsConverter, options.DebugInfo, classLoader, usedTypeNames, module);
compiler.Compile();
compiler.Save(options.OutputFolder, options.FreeAppsKeyPath);
}
/// <summary>
/// Create Dot42.dll
/// </summary>
private static void CreateFrameworkAssembly(JarFile jf, DocModel xmlModel, SourceProperties sourceProperties, string folder)
{
// Initialize all
MappedTypeBuilder.Initialize(CompositionContainer);
// Create java type wrappers
var module = new NetModule(AttributeConstants.Dot42Scope);
var classLoader = new AssemblyClassLoader(null);
var target = new TargetFramework(null, classLoader, xmlModel, LogMissingParamNamesType, true, false, Enumerable.Empty<string>());
List<TypeBuilder> typeBuilders;
using (Profiler.Profile(x => Console.WriteLine("Create took {0}ms", x.TotalMilliseconds)))
{
var classTypeBuilders = jf.ClassNames.SelectMany(n => StandardTypeBuilder.Create(jf.LoadClass(n), target));
var customTypeBuilder = CompositionContainer.GetExportedValues<ICustomTypeBuilder>().OrderBy(x => x.CustomTypeName).Select(x => x.AsTypeBuilder());
typeBuilders = classTypeBuilders.Concat(customTypeBuilder).OrderBy(x => x.Priority).ToList();
typeBuilders.ForEach(x => x.CreateType(null, module, target));
}
// Create JavaRef attribute
//JavaRefAttributeBuilder.Build(asm.MainModule);
// Implement and finalize types
using (Profiler.Profile(x => Console.WriteLine("Implement took {0}ms", x.TotalMilliseconds)))
{
JarImporter.Implement(typeBuilders, target);
}
// Save
using (Profiler.Profile(x => Console.WriteLine("Generate took {0}ms", x.TotalMilliseconds)))
{
CodeGenerator.Generate(folder, module.Types, new List<NetCustomAttribute>(), target, new FrameworkCodeGeneratorContext(), target);
}
// Create layout.xml
var doc = new XDocument(new XElement("layout"));
typeBuilders.ForEach(x => x.FillLayoutXml(jf, doc.Root));
doc.Save(Path.Combine(folder, "layout.xml"));
}
/// <summary>
/// Default ctor
/// </summary>
public TypeNameMap(ITypeMapResolver resolver, AssemblyClassLoader assemblyClassLoader)
{
this.resolver = resolver;
this.assemblyClassLoader = assemblyClassLoader;
}
/// <summary>
/// Compile an assembly into a dex file.
/// </summary>
private static void CompileAssembly(CommandLineOptions options, NameConverter nsConverter)
{
// Load resource type usage info file
var usedTypeNames = LoadResourceTypeUsageInformation(options);
// Load assemblies
List<AssemblyDefinition> assemblies = new List<AssemblyDefinition>();
List<AssemblyDefinition> references= new List<AssemblyDefinition>();
var dxJarCompiler = options.EnableDxJarCompilation
? new DxClassfileMethodBodyCompiler(options.OutputFolder, options.DebugInfo)
: null;
Action<ClassSource> jarLoaded = dxJarCompiler != null ? dxJarCompiler.PreloadJar : (Action<ClassSource>)null;
var module = new XModule();
var classLoader = new AssemblyClassLoader(module.OnClassLoaded);
var resolver = new AssemblyResolver(options.ReferenceFolders, classLoader, module.OnAssemblyLoaded);
// initialize compiler cache in background.
var ccache = options.EnableCompilerCache ? new DexMethodBodyCompilerCache(options.OutputFolder, resolver.GetFileName)
: new DexMethodBodyCompilerCache();
var readerParameters = new ReaderParameters
{
AssemblyResolver = resolver,
SymbolReaderProvider = new SafeSymbolReaderProvider(),
ReadSymbols = true,
ReadingMode = ReadingMode.Immediate
};
// load assemblies
var toLoad = options.Assemblies.Select(path => new {path, target = assemblies})
.Concat(options.References.Select(path => new {path, target = references}))
// Some micro optimizations...
// Our startup is IO bound until we have loaded first assembly from disk.
// So just load from smallest to largest.
.Select(load => new { load.path, load.target, length = new FileInfo(resolver.ResolvePath(load.path)).Length})
.OrderBy(load=>load.length)
.ToList();
using (AssemblyCompiler.Profile("for loading assemblies"))
{
toLoad.AsParallel().ForAll(
//toLoad.ForEach(
load =>
{
var assm = resolver.Load(load.path, readerParameters);
lock (load.target) load.target.Add(assm);
});
}
// Load resources
Table table;
using (var stream = new FileStream(options.InputResources, FileMode.Open, FileAccess.Read))
{
table = new Table(stream);
}
// Create compiler
var compiler = new AssemblyCompiler(options.CompilationMode, assemblies, references, table, nsConverter,
options.DebugInfo, classLoader, resolver.GetFileName, ccache,
usedTypeNames, module, options.GenerateSetNextInstructionCode);
compiler.DxClassfileMethodBodyCompiler = dxJarCompiler;
using (AssemblyCompiler.Profile("total compilation time", true))
compiler.Compile();
ccache.PrintStatistics();
using (AssemblyCompiler.Profile("saving results"))
compiler.Save(options.OutputFolder, options.FreeAppsKeyPath);
}
/// <summary>
/// Default ctor
/// </summary>
public AssemblyResolver(IEnumerable<string> referenceFolders, AssemblyClassLoader classLoader, Action<AssemblyDefinition> assemblyLoaded)
{
this.classLoader = classLoader;
this.assemblyLoaded = assemblyLoaded;
this.referenceFolders = referenceFolders.Select(ToFolder).Distinct().ToList();
}
