public void Analyze(AssemblyDefinition assembly) { if (DebuggerOptions.Enabled) { assembly.Accept(this._documentsCollector); } }
private static IEnumerable <AssemblyDefinition> ResolveWindowsRuntimeReferences(AssemblyDefinition assembly) { TypeReferenceVisitor visitor = new TypeReferenceVisitor(assembly.MainModule); assembly.Accept(visitor); return(visitor.ResolvedAssemblies); }
/// <summary> /// Modifies the current <paramref name="target" /> to support third-party method call interception. /// </summary> /// <param name="target">The target object.</param> /// <param name="typeFilter">The filter that will determine the target types that will be modified.</param> /// <param name="hostMethodFilter">The filter that will determine the methods that will be modified on the target type.</param> /// <param name="methodCallFilter"> /// The filter that will determine which third-party methods will be intercepted on the /// target type. /// </param> public static void InterceptMethodCalls(this AssemblyDefinition target, Func <TypeReference, bool> typeFilter, Func <MethodReference, bool> hostMethodFilter, Func <MethodReference, bool> methodCallFilter) { var rewriter = new InterceptMethodCalls(hostMethodFilter, methodCallFilter); target.Accept(new ImplementModifiableType(typeFilter)); target.WeaveWith(rewriter); }
/// <summary> /// Intercepts all method bodies on the target item. /// </summary> /// <param name="target">The target to be modified.</param> /// <param name="methodFilter">The method filter that will determine the methods that will be modified.</param> public static void InterceptMethodBody(this AssemblyDefinition target, Func <MethodReference, bool> methodFilter) { var typeFilter = GetTypeFilter(); target.Accept(new ImplementModifiableType(typeFilter)); IMethodWeaver interceptMethodBody = new InterceptMethodBody(methodFilter); target.WeaveWith(interceptMethodBody); }
/// <summary> /// Modifies the current <paramref name="target" /> to support third-party method call interception for all method /// calls made inside the target. /// </summary> /// <param name="target">The target object.</param> /// <param name="methodCallFilter"> /// The <see cref="IMethodCallFilter" /> instance that determines the method calls that will /// be intercepted. /// </param> /// <param name="hostMethodFilter"> /// The <see cref="IMethodFilter" /> instance that determines the host method calls that /// will be modified /// </param> public static void InterceptMethodCalls(this AssemblyDefinition target, IMethodCallFilter methodCallFilter, IMethodFilter hostMethodFilter) { var module = target.MainModule; var methods = module.Types.Where(t => GetDefaultTypeFilter()(t)).SelectMany(t => t.Methods) .Where(hostMethodFilter.ShouldWeave).ToArray(); var rewriter = new InterceptMethodCalls(methodCallFilter); target.Accept(new ImplementModifiableType(GetDefaultTypeFilter())); target.WeaveWith(rewriter); }
public Engine(MethodInfo method) { Type type = method.DeclaringType; AssemblyDefinition asm = AssemblyFactory.GetAssembly(type.Assembly.Location); var finder = new MethodFinder(method); asm.Accept(finder); if (finder.Found) { this.EntryPoint = finder.Method; } else { throw new ArgumentException("Could not find the method"); } }
public void Link() { outputAssembly = AssemblyFactory.GetAssembly(Assemblies [0]); mainModule = outputAssembly.MainModule; if (mainModule.Name != MainModuleName) { Console.Error.WriteLine("Main module is not named \"" + MainModuleName + "\" in assembly " + outputAssembly.Name.FullName); Environment.Exit(1); } mainType = mainModule.Types [MainTypeName]; if (mainType == null) { Console.Error.WriteLine("Main module does not contain type \"" + MainTypeName + "\" in assembly " + outputAssembly.Name.FullName); Environment.Exit(1); } outputAssembly.Accept(new StructureMerger(this, outputAssembly, outputAssembly)); for (int i = 1; i < Assemblies.Count; i++) { AssemblyDefinition asm = AssemblyFactory.GetAssembly(Assemblies [i]); asm.Accept(new StructureMerger(this, outputAssembly, asm)); } FixReflectionAfterMerge fix = new FixReflectionAfterMerge(this, outputAssembly, outputAssembly); fix.Process(); nativeLibraries.AddExternalMethods(this); if (OutputIsExecutable) { outputAssembly.Kind = AssemblyKind.Console; outputAssembly.EntryPoint = InternalSymbols.EntryPoint; } else { outputAssembly.Kind = AssemblyKind.Dll; } AssemblyFactory.SaveAssembly(outputAssembly, OutputPath); }
public static void Copy(AssemblyDefinition source, AssemblyDefinition target, AssemblyDefinition nsubstitute, string[] typesToCopy) { var processTypeResolver = new ProcessTypeResolver(source); var typeDefinitions = processTypeResolver.Resolve(typesToCopy).ToList(); // Copy in two passes to be able to move references within individual classes to other faked types. // Note that this functionality is not currently in use, but could prove useful for a later stage, // and rather than extracting the logic now, it is better to design it for this purpose up front. foreach (var type in typeDefinitions) { CopyType(target, type); } foreach (var type in typeDefinitions) { var typeDefinition = target.MainModule.Types.Single(t => t.FullName == k_PrefixName + type.FullName); CopyTypeMembers(target, type, typeDefinition); } var visitor = new MockInjectorVisitor(nsubstitute, target.MainModule); target.Accept(visitor); }
static void Process(MergeContext context) { AssemblyDefinition primary = null; try { primary = AssemblyFactory.GetAssembly(context.Assemblies [0]); for (int i = 1; i < context.Assemblies.Count; i++) { AssemblyDefinition asm = AssemblyFactory.GetAssembly(context.Assemblies [i]); asm.Accept(new StructureMerger(context, primary, asm)); } } catch (FileNotFoundException e) { Error(e.Message); } FixReflectionAfterMerge fix = new FixReflectionAfterMerge(context, primary, primary); fix.Process(); AssemblyFactory.SaveAssembly(primary, context.OutputPath); ConfigMerger.Process(context.Assemblies, context.OutputPath); }