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(); } }
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 static ITextOutput Write(ITextOutput output, MethodDef method, Language language) { output.Write(UIUtils.CleanUpIdentifier(method.Name), TextTokenHelper.GetTextTokenType(method)); output.Write('(', TextTokenType.Operator); for (int i = 0; i < method.Parameters.Count; i++) { if (method.Parameters[i].IsHiddenThisParameter) continue; if (method.Parameters[i].MethodSigIndex > 0) { output.Write(',', TextTokenType.Operator); output.WriteSpace(); } language.TypeToString(output, method.Parameters[i].Type.ToTypeDefOrRef(), false, method.Parameters[i].ParamDef); } if (method.CallingConvention == CallingConvention.VarArg || method.CallingConvention == CallingConvention.NativeVarArg) { if (method.MethodSig.GetParamCount() > 0) { output.Write(',', TextTokenType.Operator); output.WriteSpace(); } output.Write("...", TextTokenType.Operator); } output.Write(')', TextTokenType.Operator); output.WriteSpace(); output.Write(':', TextTokenType.Operator); output.WriteSpace(); language.TypeToString(output, method.ReturnType.ToTypeDefOrRef(), false, method.Parameters.ReturnParameter.ParamDef); method.MDToken.WriteSuffixString(output); return output; }
public override void Decompile(Language language, ITextOutput output, DecompilationOptions options) { EnsureChildrenFiltered(); base.Decompile(language, output, options); if (stringTableEntries.Count != 0) { ISmartTextOutput smartOutput = output as ISmartTextOutput; if (null != smartOutput) { smartOutput.AddUIElement( delegate { var textView = options.DecompilerTextView; if (textView != null) return new ResourceStringTable(stringTableEntries, textView) { Cursor = Cursors.Arrow }; return new TextBlock { Text = "no active tab!" }; } ); } output.WriteLine(); output.WriteLine(); } if (otherEntries.Count != 0) { ISmartTextOutput smartOutput = output as ISmartTextOutput; if (null != smartOutput) { smartOutput.AddUIElement( delegate { var textView = options.DecompilerTextView; if (textView != null) return new ResourceObjectTable(otherEntries, textView) { Cursor = Cursors.Arrow }; return new TextBlock { Text = "no active tab!" }; } ); } output.WriteLine(); } }
public override void Decompile(Language language, ITextOutput output, DecompilationOptions options) { App.Current.Dispatcher.Invoke(DispatcherPriority.Normal, new Action(EnsureChildrenFiltered)); foreach (ILSpyTreeNode child in this.Children) { child.Decompile(language, output, options); } }
protected override void Write(ITextOutput output, Language language) { var isExe = analyzedAssembly.Assembly != null && analyzedAssembly.IsManifestModule && (analyzedAssembly.Characteristics & dnlib.PE.Characteristics.Dll) == 0; output.Write(UIUtils.CleanUpIdentifier(analyzedAssembly.Name), isExe ? TextTokenType.AssemblyExe : TextTokenType.Assembly); }
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 AcceptWriter(ITextOutput writer) { List<string> keyList = new List<string>(Values.Keys); int keyCount = keyList.Count; JsonValue jsonValue; bool isFirst = true; for (int i = 0; i < keyCount; i++) { if (isFirst) { writer.Write('{'); isFirst = false; } else { writer.Write(", "); } writer.Write('"'); writer.Write(keyList[i]); writer.Write('"'); writer.Write(':'); if (Values.TryGetValue(keyList[i], out jsonValue)) { jsonValue.AcceptWriter(writer); } } if (!isFirst) writer.Write('}'); }
public static void WriteTo(this Instruction instruction, ITextOutput writer, Func<OpCode, string> getOpCodeDocumentation) { writer.WriteDefinition(DnlibExtensions.OffsetToString(instruction.GetOffset()), instruction, TextTokenType.Label, false); writer.Write(':', TextTokenType.Operator); writer.WriteSpace(); writer.WriteReference(instruction.OpCode.Name, instruction.OpCode, TextTokenType.OpCode); if (instruction.Operand != null) { writer.WriteSpace(); if (instruction.OpCode == OpCodes.Ldtoken) { var member = instruction.Operand as IMemberRef; if (member != null && member.IsMethod) { writer.Write("method", TextTokenType.Keyword); writer.WriteSpace(); } else if (member != null && member.IsField) { writer.Write("field", TextTokenType.Keyword); writer.WriteSpace(); } } WriteOperand(writer, instruction.Operand); } if (getOpCodeDocumentation != null) { var doc = getOpCodeDocumentation(instruction.OpCode); if (doc != null) { writer.Write("\t", TextTokenType.Text); writer.Write("// " + doc, TextTokenType.Comment); } } }
static void WriteILOffset(ITextOutput output, uint offset) { // Offsets are always in hex if (offset <= ushort.MaxValue) output.Write(string.Format(GetHexFormatUInt16(), offset), TextTokenType.Number); else output.Write(string.Format(GetHexFormatUInt32(), offset), TextTokenType.Number); }
protected override void Write(ITextOutput output, Language language) { if (name != null) output.Write(name, TextTokenType.Keyword); else base.Write(output, language); }
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) { WriteCommentLine(output, TypeToString(method.DeclaringType, includeNamespace: true)); AstBuilder codeDomBuilder = CreateAstBuilder(options, currentType: method.DeclaringType, isSingleMember: true); codeDomBuilder.AddMethod(method); RunTransformsAndGenerateCode(codeDomBuilder, output, options, method.Module); }
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 VBTextOutputFormatter(ITextOutput output, VBFormattingOptions formattingPolicy) { if (output == null) throw new ArgumentNullException("output"); this.output = output; this.policy = formattingPolicy; }
public static void WriteTo(this ExceptionHandler exceptionHandler, ITextOutput writer, MethodDef method) { writer.Write("Try", TextTokenType.Keyword); writer.WriteSpace(); WriteOffsetReference(writer, exceptionHandler.TryStart, method); writer.Write('-', TextTokenType.Operator); WriteOffsetReference(writer, exceptionHandler.TryEnd, method); writer.WriteSpace(); writer.Write(exceptionHandler.HandlerType.ToString(), TextTokenType.Keyword); if (exceptionHandler.FilterStart != null) { writer.WriteSpace(); WriteOffsetReference(writer, exceptionHandler.FilterStart, method); writer.WriteSpace(); writer.Write("handler", TextTokenType.Keyword); writer.WriteSpace(); } if (exceptionHandler.CatchType != null) { writer.WriteSpace(); exceptionHandler.CatchType.WriteTo(writer); } writer.WriteSpace(); WriteOffsetReference(writer, exceptionHandler.HandlerStart, method); writer.Write('-', TextTokenType.Operator); WriteOffsetReference(writer, exceptionHandler.HandlerEnd, method); }
public override void DecompileMethod(MethodDefinition method, ITextOutput output, DecompilationOptions options) { WriteCommentLine(output, TypeToString(method.DeclaringType, includeNamespace: true)); AstBuilder codeDomBuilder = CreateAstBuilder(options, method.DeclaringType); codeDomBuilder.AddMethod(method); codeDomBuilder.GenerateCode(output, transformAbortCondition); }
public CppTextOutputFormatter(ITextOutput output) { if (output == null) throw new ArgumentNullException("output"); this.output = output; this.IndentationString = "\t"; }
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); }
void Decompile(ModuleDef module, BamlDocument document, ILanguage lang, ITextOutput output, out string ext, CancellationToken token) { var decompiler = new XamlDecompiler(); var xaml = decompiler.Decompile(module, document, token, BamlDecompilerOptions.Create(lang), null); output.Write(xaml.ToString(), TextTokenKind.Text); ext = ".xml"; }
public override void Decompile(Language language, ITextOutput output, DecompilationOptions options) { App.Current.Dispatcher.Invoke(DispatcherPriority.Normal, new Action(EnsureChildrenFiltered)); // Show metadata order of references foreach (var r in module.GetAssemblyRefs()) new AssemblyReferenceTreeNode(r, parentAssembly, dnSpyFileListTreeNode).Decompile(language, output, options); foreach (var r in module.GetModuleRefs()) language.WriteCommentLine(output, IdentifierEscaper.Escape(r.Name)); }
public MethodBodyDisassembler(ITextOutput output, bool detectControlStructure, Action verifyProgress) { if (output == null) throw new ArgumentNullException("output"); this.output = output; this.detectControlStructure = detectControlStructure; this.verifyProgress = verifyProgress; }
void Decompile(ModuleDef module, BamlDocument document, Language lang, ITextOutput output, out IHighlightingDefinition highlight, CancellationToken token) { var decompiler = new XamlDecompiler(); var xaml = decompiler.Decompile(module, document, token); output.Write(xaml.ToString(), TextTokenType.Text); highlight = HighlightingManager.Instance.GetDefinitionByExtension(".xml"); }
protected virtual void DecompileFields(ILanguage language, ITextOutput output) { foreach (var vm in HexVMs) { language.WriteCommentLine(output, string.Empty); language.WriteCommentLine(output, string.Format("{0}:", vm.Name)); foreach (var field in vm.HexFields) language.WriteCommentLine(output, string.Format("{0:X8} - {1:X8} {2} = {3}", field.StartOffset, field.EndOffset, field.FormattedValue, field.Name)); } }
public NodeDecompiler(Func<Func<object>, object> execInThread, ITextOutput output, ILanguage language, DecompilationContext decompilationContext, IDecompileNodeContext decompileNodeContext = null) { this.execInThread = execInThread; this.output = output; this.language = language; this.decompilationContext = decompilationContext; this.decompileNodeContext = decompileNodeContext; }
protected override void Decompile(DecompileContext ctx, ITextOutput output) { var opts = new DecompilePartialType(type, output, decompilationContext); foreach (var d in GetDefsToRemove()) opts.Definitions.Add(d); opts.InterfacesToRemove.Add(new TypeRefUser(type.Module, "System.Windows.Markup", "IComponentConnector", new AssemblyNameInfo("WindowsBase, Version=3.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35").ToAssemblyRef())); opts.InterfacesToRemove.Add(new TypeRefUser(type.Module, "System.Windows.Markup", "IComponentConnector", new AssemblyNameInfo("System.Xaml, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089").ToAssemblyRef())); language.Decompile(DecompilationType.PartialType, opts); }
public MethodBodyDisassembler(ITextOutput output, bool detectControlStructure, CancellationToken cancellationToken) { if (output == null) throw new ArgumentNullException("output"); this.output = output; this.detectControlStructure = detectControlStructure; this.cancellationToken = cancellationToken; }
public MethodBodyDisassembler(ITextOutput output, bool detectControlStructure, DisassemblerOptions options) { if (output == null) throw new ArgumentNullException("output"); this.output = output; this.detectControlStructure = detectControlStructure; this.options = options; }
public override void Decompile(Language language, ITextOutput output, DecompilationOptions options) { if (r.IsWindowsRuntime) { language.WriteCommentLine(output, r.Name + " [WinRT]"); } else { language.WriteCommentLine(output, r.FullName); } }
public override void Decompile(Language language, ITextOutput output, DecompilationOptions options) { if ((r.Attributes & (AssemblyAttributes)0x0200) != 0) { language.WriteCommentLine(output, r.Name + " [WinRT]"); } else { language.WriteCommentLine(output, r.FullName); } }
public override void TypeToString(ITextOutput output, ITypeDefOrRef t, bool includeNamespace, IHasCustomAttribute attributeProvider = null) { t.WriteTo(output, includeNamespace ? ILNameSyntax.TypeName : ILNameSyntax.ShortTypeName); }
public override void WriteTo(ITextOutput output) { if (Operand is ILVariable && ((ILVariable)Operand).IsGenerated) { if (Code == ILCode.Stloc && this.InferredType == null) { output.Write(((ILVariable)Operand).Name); output.Write(" = "); Arguments.First().WriteTo(output); return; } else if (Code == ILCode.Ldloc) { output.Write(((ILVariable)Operand).Name); if (this.InferredType != null) { output.Write(':'); this.InferredType.WriteTo(output, ILNameSyntax.ShortTypeName); if (this.ExpectedType != null && this.ExpectedType.FullName != this.InferredType.FullName) { output.Write("[exp:"); this.ExpectedType.WriteTo(output, ILNameSyntax.ShortTypeName); output.Write(']'); } } return; } } if (this.Prefixes != null) { foreach (var prefix in this.Prefixes) { output.Write(prefix.Code.GetName()); output.Write(". "); } } output.Write(Code.GetName()); if (this.InferredType != null) { output.Write(':'); this.InferredType.WriteTo(output, ILNameSyntax.ShortTypeName); if (this.ExpectedType != null && this.ExpectedType.FullName != this.InferredType.FullName) { output.Write("[exp:"); this.ExpectedType.WriteTo(output, ILNameSyntax.ShortTypeName); output.Write(']'); } } else if (this.ExpectedType != null) { output.Write("[exp:"); this.ExpectedType.WriteTo(output, ILNameSyntax.ShortTypeName); output.Write(']'); } output.Write('('); bool first = true; if (Operand != null) { if (Operand is ILLabel) { output.WriteReference(((ILLabel)Operand).Name, Operand); } else if (Operand is ILLabel[]) { ILLabel[] labels = (ILLabel[])Operand; for (int i = 0; i < labels.Length; i++) { if (i > 0) { output.Write(", "); } output.WriteReference(labels[i].Name, labels[i]); } } else if (Operand is MemberRef) { MemberRef member = (MemberRef)Operand; if (member.DeclaringType != null) { member.DeclaringType.WriteTo(output, ILNameSyntax.ShortTypeName); output.Write("::"); } output.WriteReference(member.Name, member); } else if (Operand is IMethod) { IMethod method = (IMethod)Operand; if (method.DeclaringType != null) { method.DeclaringType.WriteTo(output, ILNameSyntax.ShortTypeName); output.Write("::"); } output.WriteReference(method.Name, method); } else if (Operand is IField) { IField field = (IField)Operand; field.DeclaringType.WriteTo(output, ILNameSyntax.ShortTypeName); output.Write("::"); output.WriteReference(field.Name, field); } else { DisassemblerHelpers.WriteOperand(output, Operand); } first = false; } foreach (ILExpression arg in this.Arguments) { if (!first) { output.Write(", "); } arg.WriteTo(output); first = false; } output.Write(')'); }
public override void Decompile(Language language, ITextOutput output, DecompilationOptions options) { language.DecompileProperty(PropertyDefinition, output, options); }
public TextOutputWithRollback(ITextOutput target) { this.target = target; this.actions = new List <Action <ITextOutput> >(); }
protected abstract void Write(ITextOutput output);
public override void DecompileNamespace(string nameSpace, IEnumerable <TypeDef> types, ITextOutput output, DecompilationOptions options) { new ReflectionDisassembler(output, detectControlStructure, options.CancellationToken).DisassembleNamespace(nameSpace, types); }
private static ReflectionDisassembler CreateDisassembler(string assemblyPath, MetadataModule module, ITextOutput textOutput) { var dis = new ReflectionDisassembler(textOutput, CancellationToken.None) { DetectControlStructure = true, ShowSequencePoints = false, ShowMetadataTokens = true, ExpandMemberDefinitions = true, }; var resolver = new UniversalAssemblyResolver(assemblyPath, throwOnError: true, targetFramework: module.PEFile.Reader.DetectTargetFrameworkId()); dis.AssemblyResolver = resolver; dis.DebugInfo = null; return(dis); }
public override void Decompile(Language language, ITextOutput output, DecompilationOptions options) { language.DecompileNamespace(name, this.Children.OfType <TypeTreeNode>().Select(t => t.TypeDefinition), output, options); }
public override void DecompileField(FieldDef field, ITextOutput output, DecompilationOptions options) { var dis = CreateReflectionDisassembler(output, options, field); dis.DisassembleField(field); }
public override void DecompileField(FieldDef field, ITextOutput output, DecompilationOptions options) { var dis = new ReflectionDisassembler(output, detectControlStructure, options.CancellationToken); dis.DisassembleField(field); }
public static void WriteTo(this IMember member, ITextOutput output) { if (member is IMethod method && method.IsConstructor) { output.WriteReference(member, method.DeclaringType?.Name + "." + method.Name); }
public static void Write(this ITextOutput output, StackType stackType) { output.Write(stackType.ToString().ToLowerInvariant()); }
public static void WriteTo(this IType type, ITextOutput output) { output.WriteReference(type, type.ReflectionName); }
public override void DecompileType(TypeDef type, ITextOutput output, DecompilationOptions options) { var dis = new ReflectionDisassembler(output, detectControlStructure, options.CancellationToken); dis.DisassembleType(type); }
public static void Write(this ITextOutput output, PrimitiveType primitiveType) { output.Write(primitiveType.ToString().ToLowerInvariant()); }
public override void DecompileMethod(MethodDef method, ITextOutput output, DecompilationOptions options) { var dis = CreateReflectionDisassembler(output, options, method); dis.DisassembleMethod(method); }
public static void Write(this ITextOutput output, OpCode opCode) { output.Write(originalOpCodeNames[(int)opCode]); }
public override void WriteCommentLine(ITextOutput output, string comment) { output.WriteLine("; " + comment); }
protected sealed override void Write(ITextOutput output, Language language) { Write(output); }
public override ProjectId DecompileAssembly(LoadedAssembly assembly, ITextOutput output, DecompilationOptions options) { var module = assembly.GetPEFileOrNull(); if (options.FullDecompilation && options.SaveAsProjectDirectory != null) { var decompiler = new ILSpyWholeProjectDecompiler(assembly, options); return(decompiler.DecompileProject(module, options.SaveAsProjectDirectory, new TextOutputWriter(output), options.CancellationToken)); } else { AddReferenceAssemblyWarningMessage(module, output); AddReferenceWarningMessage(module, output); output.WriteLine(); base.DecompileAssembly(assembly, output, options); // don't automatically load additional assemblies when an assembly node is selected in the tree view using (options.FullDecompilation ? null : LoadedAssembly.DisableAssemblyLoad()) { IAssemblyResolver assemblyResolver = assembly.GetAssemblyResolver(); var typeSystem = new DecompilerTypeSystem(module, assemblyResolver, options.DecompilerSettings); var globalType = typeSystem.MainModule.TypeDefinitions.FirstOrDefault(); if (globalType != null) { output.Write("// Global type: "); output.WriteReference(globalType, globalType.FullName); output.WriteLine(); } var metadata = module.Metadata; var corHeader = module.Reader.PEHeaders.CorHeader; var entrypointHandle = MetadataTokenHelpers.EntityHandleOrNil(corHeader.EntryPointTokenOrRelativeVirtualAddress); if (!entrypointHandle.IsNil && entrypointHandle.Kind == HandleKind.MethodDefinition) { var entrypoint = typeSystem.MainModule.ResolveMethod(entrypointHandle, new Decompiler.TypeSystem.GenericContext()); if (entrypoint != null) { output.Write("// Entry point: "); output.WriteReference(entrypoint, entrypoint.DeclaringType.FullName + "." + entrypoint.Name); output.WriteLine(); } } output.WriteLine("// Architecture: " + GetPlatformDisplayName(module)); if ((corHeader.Flags & System.Reflection.PortableExecutable.CorFlags.ILOnly) == 0) { output.WriteLine("// This assembly contains unmanaged code."); } string runtimeName = GetRuntimeDisplayName(module); if (runtimeName != null) { output.WriteLine("// Runtime: " + runtimeName); } if ((corHeader.Flags & System.Reflection.PortableExecutable.CorFlags.StrongNameSigned) != 0) { output.WriteLine("// This assembly is signed with a strong name key."); } if (metadata.IsAssembly) { var asm = metadata.GetAssemblyDefinition(); if (asm.HashAlgorithm != AssemblyHashAlgorithm.None) { output.WriteLine("// Hash algorithm: " + asm.HashAlgorithm.ToString().ToUpper()); } if (!asm.PublicKey.IsNil) { output.Write("// Public key: "); var reader = metadata.GetBlobReader(asm.PublicKey); while (reader.RemainingBytes > 0) { output.Write(reader.ReadByte().ToString("x2")); } output.WriteLine(); } } var debugInfo = assembly.GetDebugInfoOrNull(); if (debugInfo != null) { output.WriteLine("// Debug info: " + debugInfo.Description); } output.WriteLine(); CSharpDecompiler decompiler = new CSharpDecompiler(typeSystem, options.DecompilerSettings); decompiler.CancellationToken = options.CancellationToken; SyntaxTree st; if (options.FullDecompilation) { st = decompiler.DecompileWholeModuleAsSingleFile(); } else { st = decompiler.DecompileModuleAndAssemblyAttributes(); } WriteCode(output, options.DecompilerSettings, st, decompiler.TypeSystem); } return(null); } }
public abstract void Decompile(Language language, ITextOutput output, DecompilationOptions options);
public static void WriteOperand(ITextOutput writer, object operand) { if (operand == null) { throw new ArgumentNullException("operand"); } Instruction targetInstruction = operand as Instruction; if (targetInstruction != null) { WriteOffsetReference(writer, targetInstruction); return; } Instruction[] targetInstructions = operand as Instruction[]; if (targetInstructions != null) { WriteLabelList(writer, targetInstructions); return; } VariableReference variableRef = operand as VariableReference; if (variableRef != null) { if (string.IsNullOrEmpty(variableRef.Name)) { writer.WriteReference(variableRef.Index.ToString(), variableRef); } else { writer.WriteReference(Escape(variableRef.Name), variableRef); } return; } ParameterReference paramRef = operand as ParameterReference; if (paramRef != null) { if (string.IsNullOrEmpty(paramRef.Name)) { writer.WriteReference(paramRef.Index.ToString(), paramRef); } else { writer.WriteReference(Escape(paramRef.Name), paramRef); } return; } MethodReference methodRef = operand as MethodReference; if (methodRef != null) { methodRef.WriteTo(writer); return; } TypeReference typeRef = operand as TypeReference; if (typeRef != null) { typeRef.WriteTo(writer, ILNameSyntax.TypeName); return; } FieldReference fieldRef = operand as FieldReference; if (fieldRef != null) { fieldRef.WriteTo(writer); return; } string s = operand as string; if (s != null) { writer.Write("\"" + NRefactory.CSharp.TextWriterTokenWriter.ConvertString(s) + "\""); } else if (operand is char) { writer.Write(((int)(char)operand).ToString()); } else if (operand is float) { float val = (float)operand; if (val == 0) { if (1 / val == float.NegativeInfinity) { // negative zero is a special case writer.Write('-'); } writer.Write("0.0"); } else if (float.IsInfinity(val) || float.IsNaN(val)) { byte[] data = BitConverter.GetBytes(val); writer.Write('('); for (int i = 0; i < data.Length; i++) { if (i > 0) { writer.Write(' '); } writer.Write(data[i].ToString("X2")); } writer.Write(')'); } else { writer.Write(val.ToString("R", System.Globalization.CultureInfo.InvariantCulture)); } } else if (operand is double) { double val = (double)operand; if (val == 0) { if (1 / val == double.NegativeInfinity) { // negative zero is a special case writer.Write('-'); } writer.Write("0.0"); } else if (double.IsInfinity(val) || double.IsNaN(val)) { byte[] data = BitConverter.GetBytes(val); writer.Write('('); for (int i = 0; i < data.Length; i++) { if (i > 0) { writer.Write(' '); } writer.Write(data[i].ToString("X2")); } writer.Write(')'); } else { writer.Write(val.ToString("R", System.Globalization.CultureInfo.InvariantCulture)); } } else if (operand is bool) { writer.Write((bool)operand ? "true" : "false"); } else { s = ToInvariantCultureString(operand); writer.Write(s); } }
public static void WriteOffsetReference(ITextOutput writer, Instruction instruction) { writer.WriteReference(CecilExtensions.OffsetToString(instruction.Offset), instruction); }
ReflectionDisassembler CreateReflectionDisassembler(ITextOutput output, DecompilationOptions options, IMemberDef member) { return(CreateReflectionDisassembler(output, options, member.Module)); }
public static void WriteTo(this TypeReference type, ITextOutput writer, ILNameSyntax syntax = ILNameSyntax.Signature) { ILNameSyntax syntaxForElementTypes = syntax == ILNameSyntax.SignatureNoNamedTypeParameters ? syntax : ILNameSyntax.Signature; if (type is PinnedType) { ((PinnedType)type).ElementType.WriteTo(writer, syntaxForElementTypes); writer.Write(" pinned"); } else if (type is ArrayType) { ArrayType at = (ArrayType)type; at.ElementType.WriteTo(writer, syntaxForElementTypes); writer.Write('['); writer.Write(string.Join(", ", at.Dimensions)); writer.Write(']'); } else if (type is GenericParameter) { writer.Write('!'); if (((GenericParameter)type).Owner.GenericParameterType == GenericParameterType.Method) { writer.Write('!'); } if (string.IsNullOrEmpty(type.Name) || type.Name[0] == '!' || syntax == ILNameSyntax.SignatureNoNamedTypeParameters) { writer.Write(((GenericParameter)type).Position.ToString()); } else { writer.Write(Escape(type.Name)); } } else if (type is ByReferenceType) { ((ByReferenceType)type).ElementType.WriteTo(writer, syntaxForElementTypes); writer.Write('&'); } else if (type is PointerType) { ((PointerType)type).ElementType.WriteTo(writer, syntaxForElementTypes); writer.Write('*'); } else if (type is GenericInstanceType) { type.GetElementType().WriteTo(writer, syntaxForElementTypes); writer.Write('<'); var arguments = ((GenericInstanceType)type).GenericArguments; for (int i = 0; i < arguments.Count; i++) { if (i > 0) { writer.Write(", "); } arguments[i].WriteTo(writer, syntaxForElementTypes); } writer.Write('>'); } else if (type is OptionalModifierType) { ((OptionalModifierType)type).ElementType.WriteTo(writer, syntax); writer.Write(" modopt("); ((OptionalModifierType)type).ModifierType.WriteTo(writer, ILNameSyntax.TypeName); writer.Write(") "); } else if (type is RequiredModifierType) { ((RequiredModifierType)type).ElementType.WriteTo(writer, syntax); writer.Write(" modreq("); ((RequiredModifierType)type).ModifierType.WriteTo(writer, ILNameSyntax.TypeName); writer.Write(") "); } else { string name = PrimitiveTypeName(type.FullName); if (syntax == ILNameSyntax.ShortTypeName) { if (name != null) { writer.Write(name); } else { writer.WriteReference(Escape(type.Name), type); } } else if ((syntax == ILNameSyntax.Signature || syntax == ILNameSyntax.SignatureNoNamedTypeParameters) && name != null) { writer.Write(name); } else { if (syntax == ILNameSyntax.Signature || syntax == ILNameSyntax.SignatureNoNamedTypeParameters) { writer.Write(type.IsValueType ? "valuetype " : "class "); } if (type.DeclaringType != null) { type.DeclaringType.WriteTo(writer, ILNameSyntax.TypeName); writer.Write('/'); writer.WriteReference(Escape(type.Name), type); } else { if (!type.IsDefinition && type.Scope != null && !(type is TypeSpecification)) { writer.Write("[{0}]", Escape(type.Scope.Name)); } writer.WriteReference(Escape(type.FullName), type); } } } }
protected override void Write(ITextOutput output, Language language) { Language.TypeToString(output, analyzedType, true); analyzedType.MDToken.WriteSuffixString(output); }
public abstract void WriteTo(ITextOutput output);
public OutputConverter(ITextOutput output) { this.output = output; }
public override void Decompile(Language language, ITextOutput output, DecompilationOptions options) { language.WriteCommentLine(output, "EventMap"); }
public override void DecompileType(TypeDef type, ITextOutput output, DecompilationOptions options) { var dis = CreateReflectionDisassembler(output, options, type); dis.DisassembleType(type); }