public override void DecompileAssembly(AssemblyDefinition assembly, string fileName, ITextOutput output, DecompilationOptions options) { output.WriteLine("// " + fileName); output.WriteLine(); new ReflectionDisassembler(output, detectControlStructure, options.CancellationToken).WriteAssemblyHeader(assembly); }
public override void Decompile(Language language, ITextOutput output, DecompilationOptions options) { EnsureLazyChildren(); base.Decompile(language, output, options); if (stringTableEntries.Count != 0) { ISmartTextOutput smartOutput = output as ISmartTextOutput; if (null != smartOutput) { smartOutput.AddUIElement( delegate { return new ResourceStringTable(stringTableEntries, new System.Windows.Size(MainWindow.Instance.mainPane.ActualWidth - 45, MainWindow.Instance.mainPane.ActualHeight)); } ); } output.WriteLine(); output.WriteLine(); } if (otherEntries.Count != 0) { ISmartTextOutput smartOutput = output as ISmartTextOutput; if (null != smartOutput) { smartOutput.AddUIElement( delegate { return new ResourceObjectTable(otherEntries, new System.Windows.Size(MainWindow.Instance.mainPane.ActualWidth - 45, MainWindow.Instance.mainPane.ActualHeight)); } ); } output.WriteLine(); } }
public override void DecompileMethod(MethodDefinition method, ITextOutput output, DecompilationOptions options) { if (!method.HasBody) { return; } ILAstBuilder astBuilder = new ILAstBuilder(); ILBlock ilMethod = new ILBlock(); ilMethod.Body = astBuilder.Build(method, inlineVariables); if (abortBeforeStep != null) { DecompilerContext context = new DecompilerContext(method.Module) { CurrentType = method.DeclaringType, CurrentMethod = method }; new ILAstOptimizer().Optimize(context, ilMethod, abortBeforeStep.Value); } var allVariables = ilMethod.GetSelfAndChildrenRecursive<ILExpression>().Select(e => e.Operand as ILVariable) .Where(v => v != null && !v.IsParameter).Distinct(); foreach (ILVariable v in allVariables) { output.WriteDefinition(v.Name, v); if (v.Type != null) { output.Write(" : "); if (v.IsPinned) output.Write("pinned "); v.Type.WriteTo(output, ILNameSyntax.ShortTypeName); } output.WriteLine(); } output.WriteLine(); foreach (ILNode node in ilMethod.Body) { node.WriteTo(output); output.WriteLine(); } }
public override void DecompileMethod(ilspy::Mono.Cecil.MethodDefinition method, ITextOutput output, DecompilationOptions options) { var xMethod = GetXMethodDefinition(method); var ilMethod = xMethod as XBuilder.ILMethodDefinition; CompiledMethod cmethod; if (ilMethod == null || !ilMethod.OriginalMethod.HasBody) { output.Write(""); output.WriteLine("// not an il method or method without body."); return; } var methodSource = new MethodSource(xMethod, ilMethod.OriginalMethod); var target = (DexTargetPackage) AssemblyCompiler.TargetPackage; var dMethod = (MethodDefinition)xMethod.GetReference(target); DexMethodBodyCompiler.TranslateToRL(AssemblyCompiler, target, methodSource, dMethod, GenerateSetNextInstructionCode, out cmethod); var rlBody = cmethod.RLBody; // Optimize RL code string lastApplied = RLTransformations.Transform(target.DexFile, rlBody, StopOptimizationAfter == -1?int.MaxValue:StopOptimizationAfter); if(lastApplied != null) output.WriteLine("// Stop after " + lastApplied); PrintMethod(cmethod, output, options); }
public override void DecompileMethod(MethodDef method, ITextOutput output, DecompilationOptions options) { WriteComment(output, "Method: "); output.WriteDefinition(IdentifierEscaper.Escape(method.FullName), method, TextTokenType.Comment, false); output.WriteLine(); if (!method.HasBody) { return; } StartKeywordBlock(output, ".body", method); ILAstBuilder astBuilder = new ILAstBuilder(); ILBlock ilMethod = new ILBlock(); DecompilerContext context = new DecompilerContext(method.Module) { CurrentType = method.DeclaringType, CurrentMethod = method }; ilMethod.Body = astBuilder.Build(method, inlineVariables, context); if (abortBeforeStep != null) { new ILAstOptimizer().Optimize(context, ilMethod, abortBeforeStep.Value); } if (context.CurrentMethodIsAsync) { output.Write("async", TextTokenType.Keyword); output.Write('/', TextTokenType.Operator); output.WriteLine("await", TextTokenType.Keyword); } var allVariables = ilMethod.GetSelfAndChildrenRecursive<ILExpression>().Select(e => e.Operand as ILVariable) .Where(v => v != null && !v.IsParameter).Distinct(); foreach (ILVariable v in allVariables) { output.WriteDefinition(IdentifierEscaper.Escape(v.Name), v, v.IsParameter ? TextTokenType.Parameter : TextTokenType.Local); if (v.Type != null) { output.WriteSpace(); output.Write(':', TextTokenType.Operator); output.WriteSpace(); if (v.IsPinned) { output.Write("pinned", TextTokenType.Keyword); output.WriteSpace(); } v.Type.WriteTo(output, ILNameSyntax.ShortTypeName); } if (v.IsGenerated) { output.WriteSpace(); output.Write('[', TextTokenType.Operator); output.Write("generated", TextTokenType.Keyword); output.Write(']', TextTokenType.Operator); } output.WriteLine(); } var memberMapping = new MemberMapping(method); foreach (ILNode node in ilMethod.Body) { node.WriteTo(output, memberMapping); if (!node.WritesNewLine) output.WriteLine(); } output.AddDebugSymbols(memberMapping); EndKeywordBlock(output); }
public override void DecompileAssembly(LoadedAssembly assembly, ITextOutput output, DecompilationOptions options) { if (options.FullDecompilation && options.SaveAsProjectDirectory != null) { HashSet<string> directories = new HashSet<string>(StringComparer.OrdinalIgnoreCase); var files = WriteCodeFilesInProject(assembly.AssemblyDefinition, options, directories).ToList(); files.AddRange(WriteResourceFilesInProject(assembly, options, directories)); WriteProjectFile(new TextOutputWriter(output), files, assembly.AssemblyDefinition.MainModule); } else { base.DecompileAssembly(assembly, output, options); output.WriteLine(); ModuleDefinition mainModule = assembly.AssemblyDefinition.MainModule; if (mainModule.EntryPoint != null) { output.Write("' Entry point: "); output.WriteReference(mainModule.EntryPoint.DeclaringType.FullName + "." + mainModule.EntryPoint.Name, mainModule.EntryPoint); output.WriteLine(); } switch (mainModule.Architecture) { case TargetArchitecture.I386: if ((mainModule.Attributes & ModuleAttributes.Required32Bit) == ModuleAttributes.Required32Bit) WriteCommentLine(output, "Architecture: x86"); else WriteCommentLine(output, "Architecture: AnyCPU"); break; case TargetArchitecture.AMD64: WriteCommentLine(output, "Architecture: x64"); break; case TargetArchitecture.IA64: WriteCommentLine(output, "Architecture: Itanium-64"); break; } if ((mainModule.Attributes & ModuleAttributes.ILOnly) == 0) { WriteCommentLine(output, "This assembly contains unmanaged code."); } switch (mainModule.Runtime) { case TargetRuntime.Net_1_0: WriteCommentLine(output, "Runtime: .NET 1.0"); break; case TargetRuntime.Net_1_1: WriteCommentLine(output, "Runtime: .NET 1.1"); break; case TargetRuntime.Net_2_0: WriteCommentLine(output, "Runtime: .NET 2.0"); break; case TargetRuntime.Net_4_0: WriteCommentLine(output, "Runtime: .NET 4.0"); break; } output.WriteLine(); // don't automatically load additional assemblies when an assembly node is selected in the tree view using (options.FullDecompilation ? null : LoadedAssembly.DisableAssemblyLoad()) { AstBuilder codeDomBuilder = CreateAstBuilder(options, currentModule: assembly.AssemblyDefinition.MainModule); codeDomBuilder.AddAssembly(assembly.AssemblyDefinition, onlyAssemblyLevel: !options.FullDecompilation); RunTransformsAndGenerateCode(codeDomBuilder, output, options); } } OnDecompilationFinished(null); }
public override void DecompileAssembly(LoadedAssembly assembly, ITextOutput output, DecompilationOptions options) { if (options.FullDecompilation && options.SaveAsProjectDirectory != null) { var decompiler = new VBProjectDecompiler(); decompiler.Decompile(this, assembly, output, options); } else { base.DecompileAssembly(assembly, output, options); output.WriteLine(); ModuleDefinition mainModule = assembly.ModuleDefinition; if (mainModule.EntryPoint != null) { output.Write("' Entry point: "); output.WriteReference(mainModule.EntryPoint.DeclaringType.FullName + "." + mainModule.EntryPoint.Name, mainModule.EntryPoint); output.WriteLine(); } WriteCommentLine(output, "Architecture: " + CSharpLanguage.GetPlatformDisplayName(mainModule)); if ((mainModule.Attributes & ModuleAttributes.ILOnly) == 0) { WriteCommentLine(output, "This assembly contains unmanaged code."); } switch (mainModule.Runtime) { case TargetRuntime.Net_1_0: WriteCommentLine(output, "Runtime: .NET 1.0"); break; case TargetRuntime.Net_1_1: WriteCommentLine(output, "Runtime: .NET 1.1"); break; case TargetRuntime.Net_2_0: WriteCommentLine(output, "Runtime: .NET 2.0"); break; case TargetRuntime.Net_4_0: if (assembly.IsNet45()) { WriteCommentLine(output, "Runtime: .NET 4.5"); } else { WriteCommentLine(output, "Runtime: .NET 4.0"); } break; } output.WriteLine(); // don't automatically load additional assemblies when an assembly node is selected in the tree view using (options.FullDecompilation ? null : LoadedAssembly.DisableAssemblyLoad()) { AstBuilder codeDomBuilder = CreateAstBuilder(options, currentModule: assembly.ModuleDefinition); codeDomBuilder.AddAssembly(assembly.ModuleDefinition, onlyAssemblyLevel: !options.FullDecompilation); RunTransformsAndGenerateCode(codeDomBuilder, output, options, assembly.ModuleDefinition); } } }
public AssemblyCompiler AssemblyCompiler { get { return compiler.AssemblyCompiler; } } public MapFileLookup MapFile { get { return compiler.MapFile; } } public static bool GenerateSetNextInstructionCode { get { return compiler.GenerateSetNextInstructionCode; } set { compiler.GenerateSetNextInstructionCode = value; } } public override void DecompileAssembly(LoadedAssembly assembly, ITextOutput output, DecompilationOptions options) { compiler.CompileIfRequired(assembly.AssemblyDefinition);
public override void Decompile(Language language, ITextOutput output, DecompilationOptions options) { App.Current.Dispatcher.Invoke(DispatcherPriority.Normal, new Action(EnsureChildrenFiltered)); foreach (ResourceTreeNode child in this.Children) { child.Decompile(language, output); output.WriteLine(); } }
void DoDisassemble(IDnlibDef item, ITextOutput output, ReflectionDisassembler disassembler) { if (item is ModuleDef) { var module = (ModuleDef)item; disassembler.WriteAssemblyReferences(module); if (module.Assembly != null) disassembler.WriteAssemblyHeader(module.Assembly); output.WriteLine(); disassembler.WriteModuleHeader(module); } else if (item is TypeDef) { disassembler.DisassembleType((TypeDef)item); } else if (item is MethodDef) { disassembler.DisassembleMethod((MethodDef)item); } else if (item is FieldDef) { disassembler.DisassembleField((FieldDef)item); } else if (item is PropertyDef) { disassembler.DisassembleProperty((PropertyDef)item); } else if (item is EventDef) { disassembler.DisassembleEvent((EventDef)item); } }
public override void DecompileProperty(PropertyDefinition property, ITextOutput output, DecompilationOptions options) { ReflectionDisassembler rd = new ReflectionDisassembler(output, detectControlStructure, options.CancellationToken); rd.DisassembleProperty(property); if (property.GetMethod != null) { output.WriteLine(); rd.DisassembleMethod(property.GetMethod); } if (property.SetMethod != null) { output.WriteLine(); rd.DisassembleMethod(property.SetMethod); } foreach (var m in property.OtherMethods) { output.WriteLine(); rd.DisassembleMethod(m); } }
public override void DecompileType(TypeDefinition type, ITextOutput output, DecompilationOptions options) { var xType = GetXTypeDefinition(type); output.WriteLine("class " + type.Name); output.WriteLine("{"); foreach (var field in xType.Fields) { if (!field.IsReachable) continue; output.WriteLine("\t{0} {1};", field.FieldType.Name, field.Name); } output.WriteLine(); foreach (var method in xType.Methods) { var ilMethod = method as XBuilder.ILMethodDefinition; if (ilMethod != null && !ilMethod.OriginalMethod.IsReachable) continue; output.Write("\t{0} {1}(", method.ReturnType.Name, method.Name); List<string> parms = method.Parameters.Select(p => string.Format("{0}{1} {2}", KindToStringAndSpace(p.Kind), p.ParameterType.Name, p.Name)) .ToList(); if (method.NeedsGenericInstanceTypeParameter) parms.Add("Type[] git"); if (method.NeedsGenericInstanceMethodParameter) parms.Add("Type[] gim"); output.Write(string.Join(", ", parms)); output.WriteLine(")"); output.WriteLine("\t{"); DecompileMethod(method, output, 2); output.WriteLine("\t}"); output.WriteLine(); } output.WriteLine("}"); }
private void PrintMethod(CompiledMethod cmethod, ITextOutput output, DecompilationOptions options) { if ((cmethod != null) && (cmethod.RLBody != null)) { var body = cmethod.RLBody; var basicBlocks = BasicBlock.Find(body); foreach (var block in basicBlocks) { output.Write(string.Format("D_{0:X4}:", block.Entry.Index)); output.WriteLine(); output.Indent(); foreach (var ins in block.Instructions) { if (ShowHasSeqPoint) { if (ins.SequencePoint != null) output.Write(ins.SequencePoint.IsSpecial ? "!" : "~"); } output.Write(ins.ToString()); output.WriteLine(); } output.Unindent(); } if (body.Exceptions.Any()) { output.WriteLine(); output.Write("Exception handlers:"); output.WriteLine(); output.Indent(); foreach (var handler in body.Exceptions) { output.Write(string.Format("{0:x4}-{1:x4}", handler.TryStart.Index, handler.TryEnd.Index)); output.WriteLine(); output.Indent(); foreach (var c in handler.Catches) { output.Write(string.Format("{0} => {1:x4}", c.Type, c.Instruction.Index)); output.WriteLine(); } if (handler.CatchAll != null) { output.Write(string.Format("{0} => {1:x4}", "<any>", handler.CatchAll.Index)); output.WriteLine(); } output.Unindent(); } output.Unindent(); } } else { output.Write("Method not found in dex"); output.WriteLine(); } }
public override void DecompileAssembly(LoadedAssembly assembly, ITextOutput output, DecompilationOptions options) { output.WriteLine("// " + assembly.FileName); output.WriteLine(); ReflectionDisassembler rd = new ReflectionDisassembler(output, detectControlStructure, options.CancellationToken); //if (options.FullDecompilation) // rd.WriteAssemblyReferences(assembly.ModuleDefinition); if (assembly.AssemblyDefinition != null) rd.WriteAssemblyHeader(assembly.AssemblyDefinition); output.WriteLine(); rd.WriteModuleHeader(assembly.ModuleDefinition); if (options.FullDecompilation) { output.WriteLine(); output.WriteLine(); rd.WriteModuleContents(assembly.ModuleDefinition); } }
public override void Decompile(Language language, ITextOutput output, DecompilationOptions options) { language.WriteCommentLine(output, string.Format("{0} ({1}, {2})", r.Name, r.ResourceType, r.Attributes)); ISmartTextOutput smartOutput = output as ISmartTextOutput; if (smartOutput != null && r is EmbeddedResource) { smartOutput.AddButton(Images.Save, "Save", delegate { Save(null); }); output.WriteLine(); } }
private void Run(ConsoleOptions options, ITextOutput output) { var stopWatch = new Stopwatch(); stopWatch.Start(); var crapRunner = GetContainer().Resolve<CrapRunner>(); crapRunner.Run(options.codeCoverage, options.codeMetrics, options.crapThreshold); crapRunner.WriteOutput(output); if (options.HasXmlOutput) crapRunner.WriteXmlOutput(options.xml, output); stopWatch.Stop(); output.WriteLine(string.Format("Took {0:0.00}s to execute", stopWatch.Elapsed.TotalSeconds)); }
// There are several methods available to override; in this sample, we deal with methods only public override void DecompileMethod(MethodDefinition method, ITextOutput output, DecompilationOptions options) { if (method.Body != null) { output.WriteLine("Size of method: {0} bytes", method.Body.CodeSize); ISmartTextOutput smartOutput = output as ISmartTextOutput; if (smartOutput != null) { // when writing to the text view (but not when writing to a file), we can even add UI elements such as buttons: smartOutput.AddButton(null, "Click me!", (sender, e) => (sender as Button).Content = "I was clicked!"); smartOutput.WriteLine(); } // ICSharpCode.Decompiler.Ast.AstBuilder can be used to decompile to C# AstBuilder b = new AstBuilder(new DecompilerContext(method.Module) { Settings = options.DecompilerSettings, CurrentType = method.DeclaringType }); b.AddMethod(method); b.RunTransformations(); output.WriteLine("Decompiled AST has {0} nodes", b.CompilationUnit.DescendantsAndSelf.Count()); } }
private static void FallbackFormatting(ITextOutput output, CompiledMethod cmethod) { var body = cmethod.DexMethod.Body; body.UpdateInstructionOffsets(); var targetInstructions = body.Instructions.Select(x => x.Operand).OfType<Instruction>().ToList(); targetInstructions.AddRange(body.Exceptions.Select(x => x.TryStart)); targetInstructions.AddRange(body.Exceptions.Select(x => x.TryEnd)); targetInstructions.AddRange(body.Exceptions.SelectMany(x => x.Catches, (h, y) => y.Instruction)); targetInstructions.AddRange(body.Exceptions.Select(x => x.CatchAll)); foreach (var ins in body.Instructions) { if (targetInstructions.Contains(ins) || (ins.Offset == 0)) { output.Write(string.Format("D_{0:X4}:", ins.Offset)); output.WriteLine(); } output.Indent(); output.Write(ins.ToString()); output.WriteLine(); output.Unindent(); } if (body.Exceptions.Any()) { output.WriteLine(); output.Write("Exception handlers:"); output.WriteLine(); output.Indent(); foreach (var handler in body.Exceptions) { output.Write(string.Format("{0:x4}-{1:x4}", handler.TryStart.Offset, handler.TryEnd.Offset)); output.WriteLine(); output.Indent(); foreach (var c in handler.Catches) { output.Write(string.Format("{0} => {1:x4}", c.Type, c.Instruction.Offset)); output.WriteLine(); } if (handler.CatchAll != null) { output.Write(string.Format("{0} => {1:x4}", "<any>", handler.CatchAll.Offset)); output.WriteLine(); } output.Unindent(); } output.Unindent(); } }
public override void Decompile(Language language, ITextOutput output, DecompilationOptions options) { EnsureLazyChildren(); base.Decompile(language, output, options); if (stringTableEntries.Count != 0) { ISmartTextOutput smartOutput = output as ISmartTextOutput; if (null != smartOutput) { smartOutput.AddUIElement( delegate { return(new ResourceStringTable(stringTableEntries, new System.Windows.Size(MainWindow.Instance.mainPane.ActualWidth - 45, MainWindow.Instance.mainPane.ActualHeight))); } ); } output.WriteLine(); output.WriteLine(); } if (otherEntries.Count != 0) { ISmartTextOutput smartOutput = output as ISmartTextOutput; if (null != smartOutput) { smartOutput.AddUIElement( delegate { return(new ResourceObjectTable(otherEntries, new System.Windows.Size(MainWindow.Instance.mainPane.ActualWidth - 45, MainWindow.Instance.mainPane.ActualHeight))); } ); } output.WriteLine(); } }
public override void DecompileAssembly(LoadedAssembly assembly, ITextOutput output, DecompilationOptions options, DecompileAssemblyFlags flags = DecompileAssemblyFlags.AssemblyAndModule) { bool decompileAsm = (flags & DecompileAssemblyFlags.Assembly) != 0; bool decompileMod = (flags & DecompileAssemblyFlags.Module) != 0; output.WriteLine("// " + assembly.FileName, TextTokenType.Comment); if (decompileMod || decompileAsm) PrintEntryPoint(assembly, output); output.WriteLine(); ReflectionDisassembler rd = CreateReflectionDisassembler(output, options, assembly.ModuleDefinition); if (decompileMod && options.FullDecompilation) rd.WriteAssemblyReferences(assembly.ModuleDefinition as ModuleDefMD); if (decompileAsm && assembly.AssemblyDefinition != null) rd.WriteAssemblyHeader(assembly.AssemblyDefinition); if (decompileMod) { output.WriteLine(); rd.WriteModuleHeader(assembly.ModuleDefinition); if (options.FullDecompilation) { output.WriteLine(); output.WriteLine(); rd.WriteModuleContents(assembly.ModuleDefinition); } } }
private static void FallbackFormatting(ITextOutput output, CompiledMethod cmethod) { var body = cmethod.DexMethod.Body; body.UpdateInstructionOffsets(); var targetInstructions = body.Instructions.Select(x => x.Operand).OfType <Instruction>().ToList(); targetInstructions.AddRange(body.Exceptions.Select(x => x.TryStart)); targetInstructions.AddRange(body.Exceptions.Select(x => x.TryEnd)); targetInstructions.AddRange(body.Exceptions.SelectMany(x => x.Catches, (h, y) => y.Instruction)); targetInstructions.AddRange(body.Exceptions.Select(x => x.CatchAll)); foreach (var ins in body.Instructions) { if (targetInstructions.Contains(ins) || (ins.Offset == 0)) { output.Write(string.Format("D_{0:X4}:", ins.Offset)); output.WriteLine(); } output.Indent(); output.Write(ins.ToString()); output.WriteLine(); output.Unindent(); } if (body.Exceptions.Any()) { output.WriteLine(); output.Write("Exception handlers:"); output.WriteLine(); output.Indent(); foreach (var handler in body.Exceptions) { output.Write(string.Format("{0:x4}-{1:x4}", handler.TryStart.Offset, handler.TryEnd.Offset)); output.WriteLine(); output.Indent(); foreach (var c in handler.Catches) { output.Write(string.Format("{0} => {1:x4}", c.Type, c.Instruction.Offset)); output.WriteLine(); } if (handler.CatchAll != null) { output.Write(string.Format("{0} => {1:x4}", "<any>", handler.CatchAll.Offset)); output.WriteLine(); } output.Unindent(); } output.Unindent(); } }
public override void DecompileAssembly(LoadedAssembly assembly, ITextOutput output, DecompilationOptions options) { output.WriteLine("// " + assembly.FileName); output.WriteLine(); ReflectionDisassembler rd = new ReflectionDisassembler(output, detectControlStructure, options.CancellationToken); if (options.FullDecompilation) { rd.WriteAssemblyReferences(assembly.ModuleDefinition); } if (assembly.AssemblyDefinition != null) { rd.WriteAssemblyHeader(assembly.AssemblyDefinition); } output.WriteLine(); rd.WriteModuleHeader(assembly.ModuleDefinition); if (options.FullDecompilation) { output.WriteLine(); output.WriteLine(); rd.WriteModuleContents(assembly.ModuleDefinition); } }
public override void DecompileAssembly(LoadedAssembly assembly, ITextOutput output, DecompilationOptions options) { output.WriteLine("// " + assembly.FileName); output.WriteLine(); var dis = CreateDisassembler(output, options); if (options.FullDecompilation) { dis.WriteAssemblyReferences(assembly.ModuleDefinition); } if (assembly.AssemblyDefinition != null) { dis.WriteAssemblyHeader(assembly.AssemblyDefinition); } output.WriteLine(); dis.WriteModuleHeader(assembly.ModuleDefinition); if (options.FullDecompilation) { output.WriteLine(); output.WriteLine(); dis.WriteModuleContents(assembly.ModuleDefinition); } }
void DecompileNodes(DecompilationContext context, ITextOutput textOutput) { var nodes = context.TreeNodes; for (int i = 0; i < nodes.Length; i++) { if (i > 0) { textOutput.WriteLine(); } context.Options.CancellationToken.ThrowIfCancellationRequested(); nodes[i].Decompile(context.Language, textOutput, context.Options); } }
public override void DecompileAssembly(LoadedAssembly assembly, ITextOutput output, DecompilationOptions options) { if (options.FullDecompilation && options.SaveAsProjectDirectory != null) { HashSet <string> directories = new HashSet <string>(StringComparer.OrdinalIgnoreCase); var files = WriteCodeFilesInProject(assembly.ModuleDefinition, options, directories).ToList(); files.AddRange(WriteResourceFilesInProject(assembly, options, directories)); WriteProjectFile(new TextOutputWriter(output), files, assembly.ModuleDefinition); } else { base.DecompileAssembly(assembly, output, options); output.WriteLine(); ModuleDef mainModule = assembly.ModuleDefinition; if (mainModule.EntryPoint != null) { output.Write("' Entry point: "); output.WriteReference(mainModule.EntryPoint.DeclaringType.FullName + "." + mainModule.EntryPoint.Name, mainModule.EntryPoint); output.WriteLine(); } WriteCommentLine(output, "Architecture: " + CSharpLanguage.GetPlatformDisplayName(mainModule)); if (!mainModule.IsILOnly) { WriteCommentLine(output, "This assembly contains unmanaged code."); } output.WriteLine("// Runtime: " + mainModule.RuntimeVersion); output.WriteLine(); // don't automatically load additional assemblies when an assembly node is selected in the tree view using (options.FullDecompilation ? null : LoadedAssembly.DisableAssemblyLoad()) { AstBuilder codeDomBuilder = CreateAstBuilder(options, currentModule: assembly.ModuleDefinition); codeDomBuilder.AddAssembly(assembly.ModuleDefinition, onlyAssemblyLevel: !options.FullDecompilation); RunTransformsAndGenerateCode(codeDomBuilder, output, options, assembly.ModuleDefinition); } } }
protected void WriteHiddenStart(ITextOutput output, MemberMapping memberMapping, IEnumerable <ILRange> extraIlRanges = null) { var location = output.Location; output.WriteLeftBrace(); var ilr = new List <ILRange>(ILRanges); if (extraIlRanges != null) { ilr.AddRange(extraIlRanges); } UpdateMemberMapping(memberMapping, location, output.Location, ilr); output.WriteLine(); output.Indent(); }
bool FormatExceptions(App.ExceptionData[] exceptions, ITextOutput output) { if (exceptions.Length == 0) { return(false); } bool first = true; foreach (var item in exceptions) { if (first) { first = false; } else { output.WriteLine("-------------------------------------------------"); } output.WriteLine("Error(s) loading plugin: " + item.PluginName); if (item.Exception is System.Reflection.ReflectionTypeLoadException) { var e = (System.Reflection.ReflectionTypeLoadException)item.Exception; foreach (var ex in e.LoaderExceptions) { output.WriteLine(ex.ToString()); output.WriteLine(); } } else { output.WriteLine(item.Exception.ToString()); } } return(true); }
static void WriteFieldAsMethod(FieldDefinition field, ITextOutput output, bool isGetter) { var info = InfoUtil.Info(field); if (isGetter) { bool isValueType; string type = Util.TypeString(field.FieldType, out isValueType); output.Write(type); output.Write(" "); output.Write(info.GetterMethodName); output.WriteLine("() const"); } else { bool isValueType; string type = Util.TypeString(field.FieldType, out isValueType); output.Write("void "); output.Write(info.SetterMethodName); output.Write("("); output.Write(type); output.WriteLine(" value)"); } }
public override void Decompile(Language language, ITextOutput output, DecompilationOptions options) { language.WriteCommentLine(output, $"Detected Target-Framework-Id: {parentAssembly.LoadedAssembly.GetTargetFrameworkIdAsync().Result}"); App.Current.Dispatcher.Invoke(DispatcherPriority.Normal, new Action(EnsureLazyChildren)); output.WriteLine(); language.WriteCommentLine(output, "Referenced assemblies (in metadata order):"); // Show metadata order of references foreach (var r in module.AssemblyReferences) { new AssemblyReferenceTreeNode(r, parentAssembly).Decompile(language, output, options); } foreach (var r in module.ModuleReferences) { language.WriteCommentLine(output, r.Name); } }
public override void DecompileAssembly(LoadedAssembly assembly, ITextOutput output, DecompilationOptions options) { if (options.FullDecompilation && options.SaveAsProjectDirectory != null) { HashSet <string> directories = new HashSet <string>(StringComparer.OrdinalIgnoreCase); var files = WriteCodeFilesInProject(assembly.ModuleDefinition, options, directories).ToList(); files.AddRange(WriteResourceFilesInProject(assembly, options, directories)); WriteProjectFile(new TextOutputWriter(output), files, assembly.ModuleDefinition, options, assembly.ProjectGuid); } else { base.DecompileAssembly(assembly, output, options); output.WriteLine(); ModuleDefinition mainModule = assembly.ModuleDefinition; if (mainModule.Types.Count > 0) { output.Write("// Global type: "); output.WriteReference(mainModule.Types[0].FullName, mainModule.Types[0]); output.WriteLine(); } if (mainModule.EntryPoint != null) { output.Write("// Entry point: "); output.WriteReference(mainModule.EntryPoint.DeclaringType.FullName + "." + mainModule.EntryPoint.Name, mainModule.EntryPoint); output.WriteLine(); } output.WriteLine("// Architecture: " + GetPlatformDisplayName(mainModule)); if ((mainModule.Attributes & ModuleAttributes.ILOnly) == 0) { output.WriteLine("// This assembly contains unmanaged code."); } string runtimeName = GetRuntimeDisplayName(mainModule); if (runtimeName != null) { output.WriteLine("// Runtime: " + runtimeName); } output.WriteLine(); // don't automatically load additional assemblies when an assembly node is selected in the tree view using (options.FullDecompilation ? null : LoadedAssembly.DisableAssemblyLoad()) { AstBuilder codeDomBuilder = CreateAstBuilder(options, currentModule: assembly.ModuleDefinition); codeDomBuilder.AddAssembly(assembly.ModuleDefinition, onlyAssemblyLevel: !options.FullDecompilation); codeDomBuilder.RunTransformations(transformAbortCondition); codeDomBuilder.GenerateCode(output); } } }
static void WriteAddCppMethod(TypeDefinition def, ITextOutput output) { if (def.IsInterface) { return; } output.WriteLine("~" + def.Name + "();"); output.WriteLine(); output.WriteLine(def.Name + " &operator=(const " + def.Name + " &other);"); output.Unindent(); output.WriteLine("#ifdef Q_COMPILER_RVALUE_REFS"); output.Indent(); output.WriteLine("inline " + def.Name + " &operator=(" + def.Name + " &&other) { qSwap(d_ptr, other.d_ptr); return *this; }"); //output.WriteLine(def.Name + " &operator=(" + def.Name + " &&other) { swap(other); return *this; }"); output.Unindent(); output.WriteLine("#endif"); output.Indent(); //output.WriteLine("void swap(" + def.Name + " &other) { d_ptr.swap(other.d_ptr); }"); output.WriteLine("inline void swap(" + def.Name + " &other) { qSwap(d_ptr, other.d_ptr); }"); output.WriteLine("inline bool operator==(const " + def.Name + " &other) const { return d_ptr == other.d_ptr; }"); output.WriteLine("inline bool operator!=(const " + def.Name + " &other) const { return !(this->operator==(other)); }"); }
public void WriteHeader(ITextOutput output) { var cols = tablesStreamVM.TableInfo.Columns; output.Write("RID\tToken\tOffset", TextTokenType.Comment); for (int i = 0; i < cols.Count; i++) { output.Write('\t', TextTokenType.Comment); output.Write(tablesStreamVM.GetColumnName(i), TextTokenType.Comment); } if (tablesStreamVM.HasInfo) { output.Write('\t', TextTokenType.Comment); output.Write(tablesStreamVM.InfoName, TextTokenType.Comment); } output.WriteLine(); }
public override void DecompileEvent(EventDefinition ev, ITextOutput output, DecompilationOptions options) { ReflectionDisassembler rd = new ReflectionDisassembler(output, detectControlStructure, options.CancellationToken); rd.DisassembleEvent(ev); if (ev.AddMethod != null) { output.WriteLine(); rd.DisassembleMethod(ev.AddMethod); } if (ev.RemoveMethod != null) { output.WriteLine(); rd.DisassembleMethod(ev.RemoveMethod); } foreach (var m in ev.OtherMethods) { output.WriteLine(); rd.DisassembleMethod(m); } }
public void WriteHeader(ITextOutput output) { var cols = tablesStreamVM.TableInfo.Columns; output.Write(string.Format("{0}\t{1}\t{2}", dnSpy_AsmEditor_Resources.RowIdentifier, dnSpy_AsmEditor_Resources.Token, dnSpy_AsmEditor_Resources.Offset), TextTokenKind.Comment); for (int i = 0; i < cols.Count; i++) { output.Write("\t", TextTokenKind.Comment); output.Write(tablesStreamVM.GetColumnName(i), TextTokenKind.Comment); } if (tablesStreamVM.HasInfo) { output.Write("\t", TextTokenKind.Comment); output.Write(tablesStreamVM.InfoName, TextTokenKind.Comment); } output.WriteLine(); }
static void WriteEqualFunction(TypeDefinition def, ITextOutput output) { output.WriteLine("bool " + def.Name + "::operator==(const " + def.Name + " &other) const"); output.WriteLine("{"); output.Indent(); output.WriteLine("if(d && other.d)"); output.Indent(); output.WriteLine("return (*d == *other.d);"); output.Unindent(); output.WriteLine("else"); output.Indent(); output.WriteLine("return (d==other.d)"); output.Unindent(); output.Unindent(); output.WriteLine("}"); }
public void OpenBrace(BraceStyle style, out TextPosition?start, out TextPosition?end) { if (braceLevelWithinType >= 0 || nodeStack.Peek() is TypeDeclaration) { braceLevelWithinType++; } output.WriteLine(); start = output.Location; output.WriteLeftBrace(); end = output.Location; output.WriteLine(); output.Indent(); }
public override void Decompile(Language language, ITextOutput output, DecompilationOptions options) { base.Decompile(language, output, options); if (filteredEntries.Count == 0) { return; } ISmartTextOutput smartOutput = output as ISmartTextOutput; if (null != smartOutput) { smartOutput.AddUIElement( delegate { return(new ResourceStringTable(filteredEntries)); } ); } output.WriteLine(); }
protected override void WriteInstruction(ITextOutput output, Instruction instruction) { int index = sequencePoints.BinarySearch(instruction.Offset, seq => seq.Offset); if (index >= 0) { var info = sequencePoints[index]; var highlightingOutput = output as ISmartTextOutput; if (!info.IsHidden) { for (int line = info.StartLine; line <= info.EndLine; line++) { if (highlightingOutput != null) { string text = codeLines[line - 1]; int startColumn = 1; int endColumn = text.Length + 1; if (line == info.StartLine) { startColumn = info.StartColumn; } if (line == info.EndLine) { endColumn = info.EndColumn; } WriteHighlightedCommentLine(highlightingOutput, text, startColumn - 1, endColumn - 1, info.StartLine == info.EndLine); } else { WriteCommentLine(output, codeLines[line - 1]); } } } else { output.Write("// "); highlightingOutput?.BeginSpan(gray); output.WriteLine("(no C# code)"); highlightingOutput?.EndSpan(); } } base.WriteInstruction(output, instruction); }
public override void Decompile(Language language, ITextOutput output, DecompilationOptions options) { void HandleException(Exception ex, string message) { language.WriteCommentLine(output, message); output.WriteLine(); output.MarkFoldStart("Exception details", true); output.Write(ex.ToString()); output.MarkFoldEnd(); } try { LoadedAssembly.WaitUntilLoaded(); // necessary so that load errors are passed on to the caller } catch (AggregateException ex) { language.WriteCommentLine(output, LoadedAssembly.FileName); switch (ex.InnerException) { case BadImageFormatException badImage: HandleException(badImage, "This file does not contain a managed assembly."); return; case FileNotFoundException fileNotFound: HandleException(fileNotFound, "The file was not found."); return; case DirectoryNotFoundException dirNotFound: HandleException(dirNotFound, "The directory was not found."); return; case PEFileNotSupportedException notSupported: HandleException(notSupported, notSupported.Message); return; default: throw; } } language.DecompileAssembly(LoadedAssembly, output, options); }
public void OpenBrace(BraceStyle style) { if (braceLevelWithinType >= 0 || nodeStack.Peek() is TypeDeclaration) { braceLevelWithinType++; } if (nodeStack.OfType <BlockStatement>().Count() <= 1 || FoldBraces) { output.MarkFoldStart(defaultCollapsed: braceLevelWithinType == 1); } output.WriteLine(); output.WriteLine("{"); output.Indent(); }
public void Resolve(ITextOutput outputWriter) { Position currentPosition = GetStartPoint(); _currentDirection = Direction.Right; while (true) { bool wasMovePossible = Move(ref currentPosition); if (currentPosition == GetFinishPoint()) { outputWriter.WriteLine("YEAH"); break; } if (!wasMovePossible) { ChangeDirection(currentPosition); } else { _moveCounter++; } #region Debug if (_moveCounter == 100) { } //temporary to test if (_moveCounter > 300) { break; } #endregion } PrintPath(PathType.Orginal, outputWriter); //PrintPath(PathType.Optimized, outputWriter); }
public override void DecompileMethod(IMethod method, ITextOutput output, DecompilationOptions options) { PEFile module = method.ParentModule.PEFile; R2RReaderCacheEntry r2rReaderCacheEntry = GetReader(module.GetLoadedAssembly(), module); if (r2rReaderCacheEntry.r2rReader == null) { WriteCommentLine(output, r2rReaderCacheEntry.failureReason); } else { R2RReader reader = r2rReaderCacheEntry.r2rReader; int bitness = -1; if (reader.Machine == Machine.Amd64) { bitness = 64; } else { Debug.Assert(reader.Machine == Machine.I386); bitness = 32; } foreach (var m in reader.R2RMethods) { if (m.MethodHandle == method.MetadataToken) { // TODO: Indexing foreach (RuntimeFunction runtimeFunction in m.RuntimeFunctions) { WriteCommentLine(output, m.SignatureString); byte[] code = new byte[runtimeFunction.Size]; for (int i = 0; i < runtimeFunction.Size; i++) { code[i] = reader.Image[reader.GetOffset(runtimeFunction.StartAddress) + i]; } Disassemble(output, code, bitness, (ulong)runtimeFunction.StartAddress); output.WriteLine(); } } } } }
void DecompileNodes(DecompilationContext context, ITextOutput textOutput) { // reset debug information DebugInformation.CodeMappings = null; var nodes = context.TreeNodes; for (int i = 0; i < nodes.Length; i++) { if (i > 0) { textOutput.WriteLine(); } context.Options.CancellationToken.ThrowIfCancellationRequested(); nodes[i].Decompile(context.Language, textOutput, context.Options); } OnDecompilationFinished(textOutput); }
public override void DecompileAssembly(LoadedAssembly assembly, ITextOutput output, DecompilationOptions options, DecompileAssemblyFlags flags = DecompileAssemblyFlags.AssemblyAndModule) { if (options.FullDecompilation && options.SaveAsProjectDirectory != null) { HashSet<string> directories = new HashSet<string>(StringComparer.OrdinalIgnoreCase); var files = WriteCodeFilesInProject(assembly.ModuleDefinition, options, directories).ToList(); files.AddRange(WriteResourceFilesInProject(assembly, options, directories)); WriteProjectFile(new TextOutputWriter(output), files, assembly, options); } else { bool decompileAsm = (flags & DecompileAssemblyFlags.Assembly) != 0; bool decompileMod = (flags & DecompileAssemblyFlags.Module) != 0; base.DecompileAssembly(assembly, output, options, flags); output.WriteLine(); ModuleDef mainModule = assembly.ModuleDefinition; if (decompileMod && mainModule.Types.Count > 0) { output.Write("' Global type: ", TextTokenType.Comment); output.WriteReference(IdentifierEscaper.Escape(mainModule.GlobalType.FullName), mainModule.GlobalType, TextTokenType.Comment); output.WriteLine(); } if (decompileMod || decompileAsm) PrintEntryPoint(assembly, output); if (decompileMod) { WriteCommentLine(output, "Architecture: " + CSharpLanguage.GetPlatformDisplayName(mainModule)); if (!mainModule.IsILOnly) { WriteCommentLine(output, "This assembly contains unmanaged code."); } string runtimeName = ICSharpCode.ILSpy.CSharpLanguage.GetRuntimeDisplayName(mainModule); if (runtimeName != null) { WriteCommentLine(output, "Runtime: " + runtimeName); } } if (decompileMod || decompileAsm) output.WriteLine(); // don't automatically load additional assemblies when an assembly node is selected in the tree view using (options.FullDecompilation ? null : LoadedAssembly.DisableAssemblyLoad()) { AstBuilder codeDomBuilder = CreateAstBuilder(options, currentModule: assembly.ModuleDefinition); codeDomBuilder.AddAssembly(assembly.ModuleDefinition, !options.FullDecompilation, decompileAsm, decompileMod); RunTransformsAndGenerateCode(codeDomBuilder, output, options, assembly.ModuleDefinition); } } }
public void Write(ITextOutput output, MetaDataTableRecordVM mdVM) { var cols = tablesStreamVM.TableInfo.Columns; output.Write(mdVM.RidString, TextTokenKind.Comment); output.Write("\t", TextTokenKind.Comment); output.Write(mdVM.TokenString, TextTokenKind.Comment); output.Write("\t", TextTokenKind.Comment); output.Write(mdVM.OffsetString, TextTokenKind.Comment); for (int j = 0; j < cols.Count; j++) { output.Write("\t", TextTokenKind.Comment); output.Write(mdVM.GetField(j).DataFieldVM.StringValue, TextTokenKind.Comment); } if (tablesStreamVM.HasInfo) { output.Write("\t", TextTokenKind.Comment); output.Write(mdVM.Info, TextTokenKind.Comment); } output.WriteLine(); }
protected void PrintEntryPoint(LoadedAssembly assembly, ITextOutput output) { var ep = GetEntryPoint(assembly.ModuleDefinition); if (ep is uint) { WriteCommentLine(output, string.Format("Native Entry point: 0x{0:x8}", (uint)ep)); } else if (ep is MethodDef) { var epMethod = (MethodDef)ep; WriteComment(output, "Entry point: "); if (epMethod.DeclaringType != null) { output.WriteReference(IdentifierEscaper.Escape(epMethod.DeclaringType.FullName), epMethod.DeclaringType, TextTokenType.Comment); output.Write('.', TextTokenType.Comment); } output.WriteReference(IdentifierEscaper.Escape(epMethod.Name), epMethod, TextTokenType.Comment); output.WriteLine(); } }
public List <ILExpression> Values; // null for the default case public override void WriteTo(ITextOutput output) { if (this.Values != null) { foreach (var i in this.Values) { output.Write("case "); i.WriteTo(output); output.Write(": "); } } else { output.Write("default: "); } // make sure there is a writeline if (!base.Body.WriteNodes(output, true, false)) { output.WriteLine(); } }
public override void Decompile(Language language, ITextOutput output) { var smartOutput = output as ISmartTextOutput; if (smartOutput != null) { language.WriteComment(output, string.Empty); output.WriteOffsetComment(this); smartOutput.AddUIElement(() => { return(new Image { Source = ImageSource, }); }); output.Write(" = ", TextTokenType.Comment); output.WriteDefinition(UIUtils.CleanUpName(Name), this, TextTokenType.Comment); output.WriteLine(); return; } base.Decompile(language, output); }
public override void WriteShort(ITextOutput output, ILanguage language, bool showOffset) { var smartOutput = output as ISmartTextOutput; if (smartOutput != null) { language.WriteCommentBegin(output, true); output.WriteOffsetComment(this, showOffset); smartOutput.AddUIElement(() => { return(new System.Windows.Controls.Image { Source = imageSource, }); }); output.Write(" = ", TextTokenKind.Comment); output.WriteDefinition(NameUtils.CleanName(Name), this, TextTokenKind.Comment); language.WriteCommentEnd(output, true); output.WriteLine(); return; } base.WriteShort(output, language, showOffset); }
public void OpenBrace(BraceStyle style, out TextLocation?start, out TextLocation?end) { if (braceLevelWithinType >= 0 || nodeStack.Peek() is TypeDeclaration) { braceLevelWithinType++; } if (nodeStack.OfType <BlockStatement>().Count() <= 1) { output.MarkFoldStart(defaultCollapsed: braceLevelWithinType == 1); } output.WriteLine(); start = output.Location; output.WriteLeftBrace(); end = output.Location; output.WriteLine(); output.Indent(); }
bool FormatExceptions(App.ExceptionData[] exceptions, ITextOutput output) { if (exceptions.Length == 0) return false; bool first = true; foreach (var item in exceptions) { if (first) first = false; else output.WriteLine("-------------------------------------------------"); output.WriteLine("Error(s) loading plugin: " + item.PluginName); if (item.Exception is System.Reflection.ReflectionTypeLoadException) { var e = (System.Reflection.ReflectionTypeLoadException)item.Exception; foreach (var ex in e.LoaderExceptions) { output.WriteLine(ex.ToString()); output.WriteLine(); } } else output.WriteLine(item.Exception.ToString()); } return true; }
public override void DecompileType(TypeDef type, ITextOutput output, DecompilationOptions options) { WriteCommentLine(output, string.Format("Type: {0}", type.FullName)); if (type.BaseType != null) { WriteComment(output, string.Format("Base type: ")); output.WriteReference(IdentifierEscaper.Escape(type.BaseType.FullName), type.BaseType, TextTokenType.Comment); output.WriteLine(); } foreach (var nested in type.NestedTypes) { DecompileType(nested, output, options); output.WriteLine(); } foreach (var field in type.Fields) { DecompileField(field, output, options); output.WriteLine(); } foreach (var property in type.Properties) { DecompileProperty(property, output, options); output.WriteLine(); } foreach (var @event in type.Events) { DecompileEvent(@event, output, options); output.WriteLine(); } foreach (var method in type.Methods) { DecompileMethod(method, output, options); output.WriteLine(); } }
void EndKeywordBlock(ITextOutput output) { output.Unindent(); output.WriteRightBrace(); output.WriteLine(); }
void StartKeywordBlock(ITextOutput output, string keyword, IMemberDef member) { output.Write(keyword, TextTokenType.Keyword); output.WriteSpace(); output.WriteDefinition(IdentifierEscaper.Escape(member.Name), member, TextTokenHelper.GetTextTokenType(member), false); output.WriteSpace(); output.WriteLeftBrace(); output.WriteLine(); output.Indent(); }
public override void DecompileProperty(PropertyDef property, ITextOutput output, DecompilationOptions options) { ReflectionDisassembler rd = CreateReflectionDisassembler(output, options, property); rd.DisassembleProperty(property); if (property.GetMethod != null) { output.WriteLine(); rd.DisassembleMethod(property.GetMethod); } if (property.SetMethod != null) { output.WriteLine(); rd.DisassembleMethod(property.SetMethod); } foreach (var m in property.OtherMethods) { output.WriteLine(); rd.DisassembleMethod(m); } }
public override void DecompileEvent(EventDef ev, ITextOutput output, DecompilationOptions options) { ReflectionDisassembler rd = CreateReflectionDisassembler(output, options, ev); rd.DisassembleEvent(ev); if (ev.AddMethod != null) { output.WriteLine(); rd.DisassembleMethod(ev.AddMethod); } if (ev.RemoveMethod != null) { output.WriteLine(); rd.DisassembleMethod(ev.RemoveMethod); } foreach (var m in ev.OtherMethods) { output.WriteLine(); rd.DisassembleMethod(m); } }
public virtual void WriteCommentLine(ITextOutput output, string comment) { output.WriteLine("// " + comment); }
protected override void DecompileFields(Language language, ITextOutput output) { var cols = tablesStreamVM.TableInfo.Columns; language.WriteCommentLine(output, string.Empty); language.WriteComment(output, string.Empty); output.Write("RID\tToken\tOffset", TextTokenType.Comment); for (int i = 0; i < cols.Count; i++) { output.Write('\t', TextTokenType.Comment); output.Write(tablesStreamVM.GetColumnName(i), TextTokenType.Comment); } if (tablesStreamVM.HasInfo) { output.Write('\t', TextTokenType.Comment); output.Write(tablesStreamVM.InfoName, TextTokenType.Comment); } output.WriteLine(); for (int i = 0; i < (int)tablesStreamVM.Rows; i++) { var obj = tablesStreamVM.Get(i); language.WriteComment(output, string.Empty); output.Write(obj.RidString, TextTokenType.Comment); output.Write('\t', TextTokenType.Comment); output.Write(obj.TokenString, TextTokenType.Comment); output.Write('\t', TextTokenType.Comment); output.Write(obj.OffsetString, TextTokenType.Comment); for (int j = 0; j < cols.Count; j++) { output.Write('\t', TextTokenType.Comment); output.Write(obj.GetField(j).DataFieldVM.StringValue, TextTokenType.Comment); } if (tablesStreamVM.HasInfo) { output.Write('\t', TextTokenType.Comment); output.Write(obj.Info, TextTokenType.Comment); } output.WriteLine(); } }
public override void Decompile(Language language, ITextOutput output, DecompilationOptions options) { language.WriteCommentLine(output, "List: " + assemblyList.ListName); output.WriteLine(); foreach (AssemblyTreeNode asm in this.Children) { language.WriteCommentLine(output, new string('-', 60)); output.WriteLine(); asm.Decompile(language, output, options); } }