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(); }