protected virtual void FormatTypeName(IDecompilerOutput output, TypeDef type)
{
if (type == null)
{
throw new ArgumentNullException(nameof(type));
}
output.Write(IdentifierEscaper.Escape(type.Name), MetadataTextColorProvider.GetColor(type));
}
internal static string GetFormattedIdentifier(string id)
{
if (isKeyword.Contains(id))
{
return(IDENTIFIER_ESCAPE + IdentifierEscaper.Escape(id));
}
return(IdentifierEscaper.Escape(id));
}
static void WriteIdentifier(ITextOutput output, string id, TextTokenKind tokenKind)
{
if (isKeyword.Contains(id))
{
output.Write("@", TextTokenKind.Operator);
}
output.Write(IdentifierEscaper.Escape(id), tokenKind);
}
protected virtual void FormatPropertyName(IDecompilerOutput output, PropertyDef property, bool?isIndexer = null)
{
if (property == null)
{
throw new ArgumentNullException(nameof(property));
}
output.Write(IdentifierEscaper.Escape(property.Name), MetadataTextColorProvider.GetColor(property));
}
static void WriteIdentifier(IDecompilerOutput output, string id, object tokenKind)
{
if (isKeyword.Contains(id))
{
output.Write("@", tokenKind);
}
output.Write(IdentifierEscaper.Escape(id), tokenKind);
}
protected virtual void FormatTypeName(ITextOutput output, TypeDef type)
{
if (type == null)
{
throw new ArgumentNullException("type");
}
output.Write(IdentifierEscaper.Escape(type.Name), TextTokenKindUtils.GetTextTokenType(type));
}
protected virtual void FormatPropertyName(ITextOutput output, PropertyDef property, bool?isIndexer = null)
{
if (property == null)
{
throw new ArgumentNullException("property");
}
output.Write(IdentifierEscaper.Escape(property.Name), TextTokenKindUtils.GetTextTokenType(property));
}
public virtual void WriteToolTip(ITextOutput output, IVariable variable, string name)
{
output.Write(variable is Local ? "(local variable)" : "(parameter)", TextTokenType.Text);
output.WriteSpace();
WriteToolTip(output, variable.Type.ToTypeDefOrRef(), variable is Parameter ? ((Parameter)variable).ParamDef : null);
output.WriteSpace();
output.Write(IdentifierEscaper.Escape(GetName(variable, name)), variable is Local ? TextTokenType.Local : TextTokenType.Parameter);
}
public static string CleanUpIdentifier(string id)
{
if (id == null)
{
return(id);
}
id = IdentifierEscaper.Escape(id);
return(CleanUpName(id));
}
/// <summary>
/// Cleans an identifier
/// </summary>
/// <param name="id">Identifier</param>
/// <returns></returns>
public static string?CleanIdentifier(string id)
{
if (id is null)
{
return(id);
}
id = IdentifierEscaper.Escape(id);
return(CleanName(id));
}
public override void WriteIdentifier(Identifier identifier, TextTokenType tokenType)
{
if (tokenType == TextTokenType.Text)
{
tokenType = TextTokenHelper.GetTextTokenType(identifier.AnnotationVT <TextTokenType>() ?? identifier.Annotation <object>());
}
if (tokenType != TextTokenType.Keyword && (identifier.IsVerbatim || CSharpOutputVisitor.IsKeyword(identifier.Name, identifier)))
{
output.Write('@', TextTokenType.Operator);
}
var definition = GetCurrentDefinition(identifier);
if (definition != null)
{
output.WriteDefinition(IdentifierEscaper.Escape(identifier.Name), definition, tokenType, false);
return;
}
object memberRef = GetCurrentMemberReference();
if (memberRef != null)
{
output.WriteReference(IdentifierEscaper.Escape(identifier.Name), memberRef, tokenType);
return;
}
definition = GetCurrentLocalDefinition();
if (definition != null)
{
output.WriteDefinition(IdentifierEscaper.Escape(identifier.Name), definition, tokenType);
return;
}
memberRef = GetCurrentLocalReference();
if (memberRef != null)
{
output.WriteReference(IdentifierEscaper.Escape(identifier.Name), memberRef, tokenType, true);
return;
}
if (firstUsingDeclaration)
{
output.MarkFoldStart(defaultCollapsed: true);
firstUsingDeclaration = false;
}
var s = identifier.Name;
if (identifier.Annotation <IdentifierFormatted>() == null)
{
s = IdentifierEscaper.Escape(s);
}
output.Write(s, tokenType);
}
void StartKeywordBlock(IDecompilerOutput output, string keyword, IMemberDef member)
{
output.Write(keyword, BoxedTextColor.Keyword);
output.Write(" ", BoxedTextColor.Text);
output.Write(IdentifierEscaper.Escape(member.Name), member, DecompilerReferenceFlags.Definition, TextColorHelper.GetColor(member));
output.Write(" ", BoxedTextColor.Text);
output.Write("{", BoxedTextColor.Punctuation);
output.WriteLine();
output.IncreaseIndent();
}
void StartKeywordBlock(ITextOutput output, string keyword, IMemberDef member)
{
output.Write(keyword, TextTokenKind.Keyword);
output.WriteSpace();
output.WriteDefinition(IdentifierEscaper.Escape(member.Name), member, TextTokenKindUtils.GetTextTokenType(member), false);
output.WriteSpace();
output.WriteLeftBrace();
output.WriteLine();
output.Indent();
}
public override void WriteIdentifier(Identifier identifier, TextTokenKind tokenKind)
{
if (tokenKind == TextTokenKind.Text)
{
tokenKind = TextTokenKindUtils.GetTextTokenType(identifier.AnnotationVT <TextTokenKind>() ?? identifier.Annotation <object>());
}
if (tokenKind != TextTokenKind.Keyword && (identifier.IsVerbatim || CSharpOutputVisitor.IsKeyword(identifier.Name, identifier)))
{
output.Write("@", TextTokenKind.Operator);
}
var definition = GetCurrentDefinition(identifier);
if (definition != null)
{
output.WriteDefinition(IdentifierEscaper.Escape(identifier.Name), definition, tokenKind, false);
return;
}
object memberRef = GetCurrentMemberReference();
if (memberRef != null)
{
output.WriteReference(IdentifierEscaper.Escape(identifier.Name), memberRef, tokenKind);
return;
}
definition = GetCurrentLocalDefinition();
if (definition != null)
{
output.WriteDefinition(IdentifierEscaper.Escape(identifier.Name), definition, tokenKind);
return;
}
memberRef = GetCurrentLocalReference();
if (memberRef != null)
{
output.WriteReference(IdentifierEscaper.Escape(identifier.Name), memberRef, tokenKind, true);
return;
}
if (firstUsingDeclaration)
{
firstUsingDeclaration = false;
}
var s = identifier.Name;
if (identifier.Annotation <IdentifierFormatted>() == null)
{
s = IdentifierEscaper.Escape(s);
}
output.Write(s, tokenKind);
}
void WriteFullTypeName(string fullName)
{
string ns, name;
SplitTypeName(fullName, out ns, out name);
if (!string.IsNullOrEmpty(ns))
{
output.WriteNamespace(ns);
output.Write(BoxedTextColor.Operator, ".");
}
output.Write(BoxedTextColor.Type, IdentifierEscaper.Escape(name));
}
void WriteFullTypeName(string fullName)
{
string ns, name;
SplitTypeName(fullName, out ns, out name);
if (!string.IsNullOrEmpty(ns))
{
output.WriteNamespace(ns);
output.Write(".", TextTokenKind.Operator);
}
output.Write(IdentifierEscaper.Escape(name), TextTokenKind.Type);
}
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);
}
}
}
BraceInfo StartKeywordBlock(IDecompilerOutput output, string keyword, IMemberDef member)
{
output.Write(keyword, BoxedTextColor.Keyword);
output.Write(" ", BoxedTextColor.Text);
output.Write(IdentifierEscaper.Escape(member.Name), member, DecompilerReferenceFlags.Definition, MetadataTextColorProvider.GetColor(member));
output.Write(" ", BoxedTextColor.Text);
var start = output.NextPosition;
output.Write("{", BoxedTextColor.Punctuation);
output.WriteLine();
output.IncreaseIndent();
return(new BraceInfo(start));
}
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, assemblyListTreeNode).Decompile(language, output, options);
}
foreach (var r in module.GetModuleRefs())
{
language.WriteCommentLine(output, IdentifierEscaper.Escape(r.Name));
}
}
public static string Escape(string identifier)
{
if (!MustEscape(identifier))
{
return(IdentifierEscaper.LimitIdentifierLength(identifier));
}
else
{
// The ECMA specification says that ' inside SQString should be ecaped using an octal escape sequence,
// but we follow Microsoft's ILDasm and use \'.
return("'" + IdentifierEscaper.LimitIdentifierLength(NRefactory.CSharp.TextWriterTokenWriter.ConvertString(identifier).Replace("'", "\\'")) + "'");
}
}
internal static void WriteNamespace(ITextOutput writer, string ns)
{
var parts = ns.Split('.');
for (int i = 0; i < parts.Length; i++)
{
if (i > 0)
{
writer.Write('.', TextTokenType.Operator);
}
writer.Write(IdentifierEscaper.Escape(parts[i]), TextTokenType.NamespacePart);
}
}
public virtual void DecompileNamespace(string @namespace, IEnumerable <TypeDef> types, IDecompilerOutput output, DecompilationContext ctx)
{
this.WriteCommentLine(output, string.IsNullOrEmpty(@namespace) ? string.Empty : IdentifierEscaper.Escape(@namespace));
this.WriteCommentLine(output, string.Empty);
this.WriteCommentLine(output, dnSpy_Decompiler_Resources.Decompile_Namespace_Types);
this.WriteCommentLine(output, string.Empty);
foreach (var type in types)
{
WriteCommentBegin(output, true);
output.Write(IdentifierEscaper.Escape(type.Name), type, DecompilerReferenceFlags.None, BoxedTextColor.Comment);
WriteCommentEnd(output, true);
output.WriteLine();
}
}
public virtual void DecompileNamespace(string @namespace, IEnumerable <TypeDef> types, ITextOutput output, DecompilationContext ctx)
{
this.WriteCommentLine(output, string.IsNullOrEmpty(@namespace) ? string.Empty : IdentifierEscaper.Escape(@namespace));
this.WriteCommentLine(output, string.Empty);
this.WriteCommentLine(output, Languages_Resources.Decompile_Namespace_Types);
this.WriteCommentLine(output, string.Empty);
foreach (var type in types)
{
this.WriteCommentBegin(output, true);
output.WriteReference(IdentifierEscaper.Escape(type.Name), type, TextTokenKind.Comment);
this.WriteCommentEnd(output, true);
output.WriteLine();
}
}
public override void Decompile(TypeDef type, IDecompilerOutput output, DecompilationContext ctx)
{
this.WriteCommentLine(output, $"Type: {type.FullName}");
if (type.BaseType != null)
{
WriteCommentBegin(output, true);
output.Write("Base type: ", BoxedTextColor.Comment);
output.Write(IdentifierEscaper.Escape(type.BaseType.FullName), type.BaseType, DecompilerReferenceFlags.None, BoxedTextColor.Comment);
WriteCommentEnd(output, true);
output.WriteLine();
}
foreach (var nested in type.NestedTypes)
{
Decompile(nested, output, ctx);
output.WriteLine();
}
int lastFieldPos = -1;
foreach (var field in type.Fields)
{
Decompile(field, output, ctx);
lastFieldPos = output.NextPosition;
output.WriteLine();
}
if (lastFieldPos >= 0)
{
output.AddLineSeparator(lastFieldPos);
output.WriteLine();
}
foreach (var property in type.Properties)
{
Decompile(property, output, ctx);
output.WriteLine();
}
foreach (var @event in type.Events)
{
Decompile(@event, output, ctx);
output.WriteLine();
}
foreach (var method in type.Methods)
{
Decompile(method, output, ctx);
output.WriteLine();
}
}
protected virtual void TypeToString(IDecompilerOutput output, ITypeDefOrRef type, bool includeNamespace, IHasCustomAttribute typeAttributes = null)
{
if (type == null)
{
return;
}
if (includeNamespace)
{
output.Write(IdentifierEscaper.Escape(type.FullName), MetadataTextColorProvider.GetColor(type));
}
else
{
output.Write(IdentifierEscaper.Escape(type.Name), MetadataTextColorProvider.GetColor(type));
}
}
public virtual void TypeToString(ITextOutput output, ITypeDefOrRef type, bool includeNamespace, IHasCustomAttribute typeAttributes = null)
{
if (type == null)
{
return;
}
if (includeNamespace)
{
output.Write(IdentifierEscaper.Escape(type.FullName), TextTokenHelper.GetTextTokenType(type));
}
else
{
output.Write(IdentifierEscaper.Escape(type.Name), TextTokenHelper.GetTextTokenType(type));
}
}
internal static void WriteNamespace(ITextOutput writer, string ns)
{
var parts = ns.Split('.');
for (int i = 0; i < parts.Length; i++)
{
if (i > 0)
{
writer.Write(".", TextTokenKind.Operator);
}
var nsPart = parts[i];
if (!string.IsNullOrEmpty(nsPart))
{
writer.Write(IdentifierEscaper.Escape(nsPart), TextTokenKind.NamespacePart);
}
}
}
public override void WriteIdentifier(Identifier identifier, TextTokenType tokenType)
{
if (tokenType == TextTokenType.Text)
{
tokenType = TextTokenHelper.GetTextTokenType(identifier.AnnotationVT <TextTokenType>() ?? identifier.Annotation <object>());
}
var definition = GetCurrentDefinition(identifier);
if (definition != null)
{
output.WriteDefinition(IdentifierEscaper.Escape(identifier.Name), definition, tokenType, false);
return;
}
object memberRef = GetCurrentMemberReference();
if (memberRef != null)
{
output.WriteReference(IdentifierEscaper.Escape(identifier.Name), memberRef, tokenType);
return;
}
definition = GetCurrentLocalDefinition();
if (definition != null)
{
output.WriteDefinition(IdentifierEscaper.Escape(identifier.Name), definition, tokenType);
return;
}
memberRef = GetCurrentLocalReference();
if (memberRef != null)
{
output.WriteReference(IdentifierEscaper.Escape(identifier.Name), memberRef, tokenType, true);
return;
}
if (firstUsingDeclaration)
{
output.MarkFoldStart(defaultCollapsed: true);
firstUsingDeclaration = false;
}
output.Write(IdentifierEscaper.Escape(identifier.Name), tokenType);
}
public static ITextOutput Write(ITextOutput output, string name)
{
if (name.Length == 0)
{
output.Write('-', TextTokenType.Operator);
}
else
{
var parts = name.Split('.');
for (int i = 0; i < parts.Length; i++)
{
if (i > 0)
{
output.Write('.', TextTokenType.Operator);
}
output.Write(IdentifierEscaper.Escape(parts[i]), TextTokenType.NamespacePart);
}
}
return(output);
}
void WriteAttributeId(BamlContext ctx, ushort id)
{
string declType;
string name;
if (id > 0x7fff)
{
var knownMember = ctx.KnownThings.Members((KnownMembers)(-id));
declType = knownMember.DeclaringType.FullName;
name = knownMember.Name;
}
else if (ctx.AttributeIdMap.ContainsKey(id))
{
var attrInfo = ctx.AttributeIdMap[id];
if (attrInfo.OwnerTypeId > 0x7fff)
{
declType = ctx.KnownThings.Types((KnownTypes)(-attrInfo.OwnerTypeId)).FullName;
}
else if (ctx.TypeIdMap.ContainsKey(attrInfo.OwnerTypeId))
{
declType = ctx.TypeIdMap[attrInfo.OwnerTypeId].TypeFullName;
}
else
{
declType = $"(0x{attrInfo.OwnerTypeId:x4})";
}
name = attrInfo.Name;
}
else
{
declType = name = null;
}
string reference = null;
if (declType is not null && name is not null)
{
reference = $"{IdentifierEscaper.Escape(declType)}::{IdentifierEscaper.Escape(name)}";
}
output.Write($"0x{id:x4}", BamlToolTipReference.Create(reference), DecompilerReferenceFlags.Local, BoxedTextColor.Number);
}
