public static async Task<string> GetSourceCode(MethodDefinition methodDefinition, ILWeaver weaver = null)
{
return await Task.Run(() =>
{
try
{
if (weaver != null) weaver.Apply(methodDefinition.Body);
var settings = new DecompilerSettings { UsingDeclarations = false };
var context = new DecompilerContext(methodDefinition.Module)
{
CurrentType = methodDefinition.DeclaringType,
Settings = settings
};
var astBuilder = new AstBuilder(context);
astBuilder.AddMethod(methodDefinition);
var textOutput = new PlainTextOutput();
astBuilder.GenerateCode(textOutput);
return textOutput.ToString();
}
catch (Exception ex)
{
return "Error in creating source code from IL: " + ex.Message + Environment.NewLine + ex.StackTrace;
}
finally
{
if (weaver != null) methodDefinition.Body = null;
}
});
}
public static bool MemberIsHidden(MemberReference member, DecompilerSettings settings)
{
MethodDefinition method = member as MethodDefinition;
if (method != null) {
if (method.IsGetter || method.IsSetter || method.IsAddOn || method.IsRemoveOn)
return true;
if (settings.AnonymousMethods && method.Name.StartsWith("<", StringComparison.Ordinal) && method.IsCompilerGenerated())
return true;
}
TypeDefinition type = member as TypeDefinition;
if (type != null && type.DeclaringType != null) {
if (settings.AnonymousMethods && type.Name.StartsWith("<>c__DisplayClass", StringComparison.Ordinal) && type.IsCompilerGenerated())
return true;
if (settings.YieldReturn && YieldReturnDecompiler.IsCompilerGeneratorEnumerator(type))
return true;
}
FieldDefinition field = member as FieldDefinition;
if (field != null && field.IsCompilerGenerated()) {
if (settings.AnonymousMethods && field.Name.StartsWith("CS$<>", StringComparison.Ordinal))
return true;
if (settings.AutomaticProperties && field.Name.StartsWith("<", StringComparison.Ordinal) && field.Name.EndsWith("BackingField", StringComparison.Ordinal))
return true;
}
// event-fields are not [CompilerGenerated]
if (field != null && settings.AutomaticEvents && field.DeclaringType.Events.Any(ev => ev.Name == field.Name))
return true;
return false;
}
public static DecompilerSettings LoadDecompilerSettings(ILSpySettings settings)
{
XElement e = settings["DecompilerSettings"];
DecompilerSettings s = new DecompilerSettings();
s.AnonymousMethods = (bool?)e.Attribute("anonymousMethods") ?? s.AnonymousMethods;
s.YieldReturn = (bool?)e.Attribute("yieldReturn") ?? s.YieldReturn;
return s;
}
public static DecompilerSettings LoadDecompilerSettings(ILSpySettings settings)
{
XElement e = settings["DecompilerSettings"];
DecompilerSettings s = new DecompilerSettings();
s.AnonymousMethods = (bool?)e.Attribute("anonymousMethods") ?? s.AnonymousMethods;
s.YieldReturn = (bool?)e.Attribute("yieldReturn") ?? s.YieldReturn;
s.QueryExpressions = (bool?)e.Attribute("queryExpressions") ?? s.QueryExpressions;
s.UseDebugSymbols = (bool?)e.Attribute("useDebugSymbols") ?? s.UseDebugSymbols;
return s;
}
public void Reset()
{
this.CurrentModule = null;
this.CancellationToken = CancellationToken.None;
this.CurrentType = null;
this.CurrentMethod = null;
this.Settings = new DecompilerSettings();
this.CurrentMethodIsAsync = false;
this.Cache.Reset();
}
public void Decompile()
{
AssemblyDefinition assembly = AssemblyDefinition.ReadAssembly("Salient.JsonSchemaUtilities.dll");
DecompilerSettings settings = new DecompilerSettings();
settings.FullyQualifyAmbiguousTypeNames = false;
AstBuilder decompiler = new AstBuilder(new DecompilerContext(assembly.MainModule) { Settings = settings });
decompiler.AddAssembly(assembly);
//new Helpers.RemoveCompilerAttribute().Run(decompiler.CompilationUnit);
StringWriter output = new StringWriter();
decompiler.GenerateCode(new PlainTextOutput(output));
var code = output.ToString();
}
public static DecompilerSettings LoadDecompilerSettings(ILSpySettings settings)
{
XElement e = settings["DecompilerSettings"];
DecompilerSettings s = new DecompilerSettings();
s.AnonymousMethods = (bool?)e.Attribute("anonymousMethods") ?? s.AnonymousMethods;
s.YieldReturn = (bool?)e.Attribute("yieldReturn") ?? s.YieldReturn;
s.AsyncAwait = (bool?)e.Attribute("asyncAwait") ?? s.AsyncAwait;
s.QueryExpressions = (bool?)e.Attribute("queryExpressions") ?? s.QueryExpressions;
s.UseDebugSymbols = (bool?)e.Attribute("useDebugSymbols") ?? s.UseDebugSymbols;
s.ShowXmlDocumentation = (bool?)e.Attribute("xmlDoc") ?? s.ShowXmlDocumentation;
s.FoldBraces = (bool?)e.Attribute("foldBraces") ?? s.FoldBraces;
return s;
}
public static string ToSource(MethodDefinition methodDefinition)
{
var settings = new DecompilerSettings { UsingDeclarations = false };
var context = new DecompilerContext(methodDefinition.Module)
{
CurrentType = methodDefinition.DeclaringType,
Settings = settings,
};
var astBuilder = new AstBuilder(context);
astBuilder.AddMethod(methodDefinition);
var textOutput = new PlainTextOutput();
astBuilder.GenerateCode(textOutput);
return textOutput.ToString();
}
public DecompilationOptions(LanguageVersion version, Decompiler.DecompilerSettings settings, Options.DisplaySettings displaySettings)
{
if (!Enum.TryParse(version.Version, out Decompiler.CSharp.LanguageVersion languageVersion))
{
languageVersion = Decompiler.CSharp.LanguageVersion.Latest;
}
var newSettings = this.DecompilerSettings = settings.Clone();
newSettings.SetLanguageVersion(languageVersion);
newSettings.ExpandMemberDefinitions = displaySettings.ExpandMemberDefinitions;
newSettings.ExpandUsingDeclarations = displaySettings.ExpandUsingDeclarations;
newSettings.FoldBraces = displaySettings.FoldBraces;
newSettings.ShowDebugInfo = displaySettings.ShowDebugInfo;
newSettings.CSharpFormattingOptions.IndentationString = GetIndentationString(displaySettings);
}
public void Save(XElement root)
{
DecompilerSettings s = (DecompilerSettings)this.DataContext;
XElement section = new XElement("DecompilerSettings");
section.SetAttributeValue("anonymousMethods", s.AnonymousMethods);
section.SetAttributeValue("yieldReturn", s.YieldReturn);
XElement existingElement = root.Element("DecompilerSettings");
if (existingElement != null)
existingElement.ReplaceWith(section);
else
root.Add(section);
currentDecompilerSettings = null; // invalidate cached settings
}
public static DecompilerSettings LoadDecompilerSettings(ILSpySettings settings)
{
XElement e = settings["DecompilerSettings"];
DecompilerSettings s = new DecompilerSettings();
s.AnonymousMethods = (bool?)e.Attribute("anonymousMethods") ?? s.AnonymousMethods;
s.YieldReturn = (bool?)e.Attribute("yieldReturn") ?? s.YieldReturn;
s.AsyncAwait = (bool?)e.Attribute("asyncAwait") ?? s.AsyncAwait;
s.QueryExpressions = (bool?)e.Attribute("queryExpressions") ?? s.QueryExpressions;
s.ExpressionTrees = (bool?)e.Attribute("expressionTrees") ?? s.ExpressionTrees;
s.UseDebugSymbols = (bool?)e.Attribute("useDebugSymbols") ?? s.UseDebugSymbols;
s.ShowXmlDocumentation = (bool?)e.Attribute("xmlDoc") ?? s.ShowXmlDocumentation;
s.AddILComments = (bool?)e.Attribute("addILComments") ?? s.AddILComments;
s.RemoveEmptyDefaultConstructors = (bool?)e.Attribute("removeEmptyDefaultConstructors") ?? s.RemoveEmptyDefaultConstructors;
return s;
}
public void DecompileMethod(MethodDefinition method, ITextOutput output)
{
DecompilerSettings settings = new DecompilerSettings();
//WriteCommentLine(output, TypeToString(method.DeclaringType, includeNamespace: true));
AstBuilder codeDomBuilder = CreateAstBuilder(settings, currentType: method.DeclaringType, isSingleMember: true);
if (method.IsConstructor && !method.IsStatic && !method.DeclaringType.IsValueType)
{
// also fields and other ctors so that the field initializers can be shown as such
AddFieldsAndCtors(codeDomBuilder, method.DeclaringType, method.IsStatic);
RunTransformsAndGenerateCode(codeDomBuilder, output, settings, new SelectCtorTransform(method));
}
else
{
codeDomBuilder.AddMethod(method);
RunTransformsAndGenerateCode(codeDomBuilder, output, settings);
}
}
public void Save(XElement root)
{
DecompilerSettings s = (DecompilerSettings)this.DataContext;
XElement section = new XElement("DecompilerSettings");
section.SetAttributeValue("anonymousMethods", s.AnonymousMethods);
section.SetAttributeValue("yieldReturn", s.YieldReturn);
section.SetAttributeValue("queryExpressions", s.QueryExpressions);
section.SetAttributeValue("useDebugSymbols", s.UseDebugSymbols);
section.SetAttributeValue("xmlDoc", s.ShowXmlDocumentation);
XElement existingElement = root.Element("DecompilerSettings");
if (existingElement != null)
existingElement.ReplaceWith(section);
else
root.Add(section);
currentDecompilerSettings = null; // invalidate cached settings
}
AstBuilder CreateAstBuilder(DecompilerSettings settings, ModuleDefinition currentModule = null, TypeDefinition currentType = null, bool isSingleMember = false)
{
if (currentModule == null)
currentModule = currentType.Module;
if (isSingleMember)
{
settings = settings.Clone();
settings.UsingDeclarations = false;
}
return new AstBuilder(
new DecompilerContext(currentModule)
{
//CancellationToken = options.CancellationToken,
CurrentType = currentType,
Settings = settings
});
}
/// <summary>
/// Returns the code for a specific algorithm.
/// </summary>
/// <returns>The algorithm code.</returns>
/// <param name="algorithmType">Algorithm type.</param>
public static MethodDeclaration GetMethodCode(Type algorithmType, out AstBuilder astBuilder, string methodName)
{
var resolver = new DefaultAssemblyResolver();
resolver.AddSearchDirectory(new FileInfo(Assembly.GetExecutingAssembly().Location).Directory.FullName);
var parameters = new ReaderParameters
{
AssemblyResolver = resolver,
};
// Load Tychaia.ProceduralGeneration into Mono.Cecil.
var module = AssemblyDefinition.ReadAssembly(
Assembly.GetExecutingAssembly().Location,
parameters).MainModule;
// Now we have a reference to the method we want to decompile.
TypeDefinition cecilType;
MethodDefinition processCell;
FindMethodName(module, algorithmType, methodName, out processCell, out cecilType);
var decompilerSettings = new DecompilerSettings();
astBuilder =
new AstBuilder(new DecompilerContext(module) { CurrentType = cecilType, Settings = decompilerSettings });
astBuilder.AddMethod(processCell);
try
{
astBuilder.RunTransformations();
}
catch (AssemblyResolutionException ex)
{
throw new Exception(
"Unable to decompile algorithm source code for " + algorithmType.FullName + ".",
ex);
}
astBuilder.CompilationUnit.AcceptVisitor(new InsertParenthesesVisitor
{
InsertParenthesesForReadability = true
});
// Return.
return
astBuilder.CompilationUnit.Members.Where(v => v is MethodDeclaration).Cast<MethodDeclaration>().First();
}
private static string Decompile(string name, MethodDefinition mtd)
{
var decompilerSettings = new ICSharpCode.Decompiler.DecompilerSettings {
ShowXmlDocumentation = false,
UsingDeclarations = false,
};
var output = new ICSharpCode.Decompiler.PlainTextOutput();
var method = mtd;
var astBuilder = new AstBuilder(new DecompilerContext(method.DeclaringType.Module)
{
CancellationToken = new CancellationToken(),
CurrentType = method.DeclaringType,
Settings = decompilerSettings,
});
astBuilder.AddMethod(method);
astBuilder.GenerateCode(output);
var methodCode = output.ToString();
// remove top comment line
//if (methodCode.StartsWith("//")) {
// methodCode = methodCode.Substring(methodCode.IndexOf('\n') + 1);
//}
var attrRE = new Regex(@"^(?:\[[^]]+]\s*){1,}");
methodCode = attrRE.Replace(methodCode, "", 1);
// change the method name to the mod's name for the method, and replace parameter names with game names
var methodName = mtd.Name;
var nameLocation = methodCode.IndexOf(" " + methodName) + 1;
var nameEnd = nameLocation + methodName.Length;
// Prepend "void " if this was a constructor (since methodCode won't have a return type)
var correctName = mtd.IsConstructor ? ("void " + name) : name;
methodCode = methodCode.Substring(0, nameLocation) + correctName + methodCode.Substring(nameEnd);
return(methodCode);
}
public static async Task<string> GetSourceCode(TypeDefinition typeDefinition)
{
return await Task.Run(() =>
{
try
{
var settings = new DecompilerSettings { UsingDeclarations = true };
var context = new DecompilerContext(typeDefinition.Module)
{
CurrentType = typeDefinition,
Settings = settings
};
var astBuilder = new AstBuilder(context);
var textOutput = new PlainTextOutput();
astBuilder.GenerateCode(textOutput);
return textOutput.ToString();
}
catch (Exception ex)
{
return "Error in creating source code from Type: " + ex.Message + ex.Message + Environment.NewLine + ex.StackTrace;
}
});
}
public static DecompilerSettings LoadDecompilerSettings(ILSpySettings settings)
{
XElement e = settings["DecompilerSettings"];
DecompilerSettings s = new DecompilerSettings();
s.AnonymousMethods = (bool?)e.Attribute("anonymousMethods") ?? s.AnonymousMethods;
s.YieldReturn = (bool?)e.Attribute("yieldReturn") ?? s.YieldReturn;
s.AsyncAwait = (bool?)e.Attribute("asyncAwait") ?? s.AsyncAwait;
s.QueryExpressions = (bool?)e.Attribute("queryExpressions") ?? s.QueryExpressions;
s.ExpressionTrees = (bool?)e.Attribute("expressionTrees") ?? s.ExpressionTrees;
s.UseDebugSymbols = (bool?)e.Attribute("useDebugSymbols") ?? s.UseDebugSymbols;
s.ShowXmlDocumentation = (bool?)e.Attribute("xmlDoc") ?? s.ShowXmlDocumentation;
s.ShowILComments = (bool?)e.Attribute("showILComments") ?? s.ShowILComments;
s.RemoveEmptyDefaultConstructors = (bool?)e.Attribute("removeEmptyDefaultConstructors") ?? s.RemoveEmptyDefaultConstructors;
s.ShowTokenAndRvaComments = (bool?)e.Attribute("showTokenAndRvaComments") ?? s.ShowTokenAndRvaComments;
s.ShowILBytes = (bool?)e.Attribute("showILBytes") ?? s.ShowILBytes;
s.DecompilationObject0 = (DecompilationObject)((int?)e.Attribute("decompilationObject0") ?? (int)s.DecompilationObject0);
s.DecompilationObject1 = (DecompilationObject)((int?)e.Attribute("decompilationObject1") ?? (int)s.DecompilationObject1);
s.DecompilationObject2 = (DecompilationObject)((int?)e.Attribute("decompilationObject2") ?? (int)s.DecompilationObject2);
s.DecompilationObject3 = (DecompilationObject)((int?)e.Attribute("decompilationObject3") ?? (int)s.DecompilationObject3);
s.DecompilationObject4 = (DecompilationObject)((int?)e.Attribute("decompilationObject4") ?? (int)s.DecompilationObject4);
s.SortMembers = (bool?)e.Attribute("sortMembers") ?? s.SortMembers;
return s;
}
private static string Decompile(string name, MethodDefinition mtd) {
var decompilerSettings = new ICSharpCode.Decompiler.DecompilerSettings {
ShowXmlDocumentation = false,
UsingDeclarations = false,
};
var output = new ICSharpCode.Decompiler.PlainTextOutput();
var method = mtd;
var astBuilder = new AstBuilder(new DecompilerContext(method.DeclaringType.Module) {
CancellationToken = new CancellationToken(),
CurrentType = method.DeclaringType,
Settings = decompilerSettings,
});
astBuilder.AddMethod(method);
astBuilder.GenerateCode(output);
var methodCode = output.ToString();
// remove top comment line
//if (methodCode.StartsWith("//")) {
// methodCode = methodCode.Substring(methodCode.IndexOf('\n') + 1);
//}
var attrRE = new Regex(@"^(?:\[[^]]+]\s*){1,}");
methodCode = attrRE.Replace(methodCode, "", 1);
// change the method name to the mod's name for the method, and replace parameter names with game names
var methodName = mtd.Name;
var nameLocation = methodCode.IndexOf(" " + methodName) + 1;
var nameEnd = nameLocation + methodName.Length;
// Prepend "void " if this was a constructor (since methodCode won't have a return type)
var correctName = mtd.IsConstructor ? ("void " + name) : name;
methodCode = methodCode.Substring(0, nameLocation) + correctName + methodCode.Substring(nameEnd);
return methodCode;
}
public DecompileRun(DecompilerSettings settings)
{
this.Settings = settings ?? throw new ArgumentNullException(nameof(settings));
}
public DecompilationOptions()
{
this.DecompilerSettings = DecompilerSettingsPanel.CurrentDecompilerSettings;
}
void RunTransformsAndGenerateCode(AstBuilder astBuilder, ITextOutput output, DecompilerSettings settings, IAstTransform additionalTransform = null)
{
astBuilder.RunTransformations();//transformAbortCondition);
if (additionalTransform != null)
{
additionalTransform.Run(astBuilder.CompilationUnit);
}
if (settings.ShowXmlDocumentation)
{
//AddXmlDocTransform.Run(astBuilder.CompilationUnit);
}
astBuilder.GenerateCode(output);
}
public List<ReferenceSegment> Decompile (TextEditorData data, ITreeNavigator navigator, bool publicOnly)
{
if (DomMethodNodeBuilder.HandleSourceCodeEntity (navigator, data))
return null;
var type = CecilLoader.GetCecilObject ((IUnresolvedTypeDefinition)navigator.DataItem);
if (type == null)
return null;
var types = DesktopService.GetMimeTypeInheritanceChain (data.Document.MimeType);
var codePolicy = MonoDevelop.Projects.Policies.PolicyService.GetDefaultPolicy<MonoDevelop.CSharp.Formatting.CSharpFormattingPolicy> (types);
var settings = new DecompilerSettings () {
AnonymousMethods = true,
AutomaticEvents = true,
AutomaticProperties = true,
ForEachStatement = true,
LockStatement = true,
CSharpFormattingOptions = codePolicy.CreateOptions (),
HideNonPublicMembers = publicOnly
};
return DomMethodNodeBuilder.Decompile (data, DomMethodNodeBuilder.GetModule (navigator), type, builder => {
builder.AddType (type);
}, settings);
}
public CSharpVBDecompilerSettings(DecompilerSettings decompilerSettings = null) {
this.decompilerSettings = decompilerSettings ?? new DecompilerSettings();
options = CreateOptions().ToArray();
}
public override void Load(ILSpySettings settings) {
this.settings = LoadDecompilerSettings(settings);
}
public override RefreshFlags Save(XElement root) {
DecompilerSettings s = this.settings;
var flags = RefreshFlags.None;
if (CurrentDecompilerSettings.AnonymousMethods != s.AnonymousMethods) flags |= RefreshFlags.ILAst | RefreshFlags.TreeViewNodes;
if (CurrentDecompilerSettings.ExpressionTrees != s.ExpressionTrees) flags |= RefreshFlags.ILAst;
if (CurrentDecompilerSettings.YieldReturn != s.YieldReturn) flags |= RefreshFlags.ILAst | RefreshFlags.TreeViewNodes;
if (CurrentDecompilerSettings.AsyncAwait != s.AsyncAwait) flags |= RefreshFlags.ILAst | RefreshFlags.TreeViewNodes;
if (CurrentDecompilerSettings.AutomaticProperties != s.AutomaticProperties) flags |= RefreshFlags.CSharp | RefreshFlags.TreeViewNodes;
if (CurrentDecompilerSettings.AutomaticEvents != s.AutomaticEvents) flags |= RefreshFlags.CSharp | RefreshFlags.TreeViewNodes;
if (CurrentDecompilerSettings.UsingStatement != s.UsingStatement) flags |= RefreshFlags.CSharp;
if (CurrentDecompilerSettings.ForEachStatement != s.ForEachStatement) flags |= RefreshFlags.CSharp;
if (CurrentDecompilerSettings.LockStatement != s.LockStatement) flags |= RefreshFlags.CSharp;
if (CurrentDecompilerSettings.SwitchStatementOnString != s.SwitchStatementOnString) flags |= RefreshFlags.CSharp | RefreshFlags.TreeViewNodes;
if (CurrentDecompilerSettings.UsingDeclarations != s.UsingDeclarations) flags |= RefreshFlags.CSharp;
if (CurrentDecompilerSettings.QueryExpressions != s.QueryExpressions) flags |= RefreshFlags.CSharp;
if (CurrentDecompilerSettings.FullyQualifyAmbiguousTypeNames != s.FullyQualifyAmbiguousTypeNames) flags |= RefreshFlags.CSharp;
if (CurrentDecompilerSettings.UseDebugSymbols != s.UseDebugSymbols) flags |= RefreshFlags.DecompileAll;
if (CurrentDecompilerSettings.ObjectOrCollectionInitializers != s.ObjectOrCollectionInitializers) flags |= RefreshFlags.ILAst;
if (CurrentDecompilerSettings.ShowXmlDocumentation != s.ShowXmlDocumentation) flags |= RefreshFlags.DecompileAll;
if (CurrentDecompilerSettings.ShowILComments != s.ShowILComments) flags |= RefreshFlags.IL;
if (CurrentDecompilerSettings.RemoveEmptyDefaultConstructors != s.RemoveEmptyDefaultConstructors) flags |= RefreshFlags.CSharp;
if (CurrentDecompilerSettings.IntroduceIncrementAndDecrement != s.IntroduceIncrementAndDecrement) flags |= RefreshFlags.ILAst;
if (CurrentDecompilerSettings.MakeAssignmentExpressions != s.MakeAssignmentExpressions) flags |= RefreshFlags.ILAst;
if (CurrentDecompilerSettings.AlwaysGenerateExceptionVariableForCatchBlocks != s.AlwaysGenerateExceptionVariableForCatchBlocks) flags |= RefreshFlags.ILAst;
if (CurrentDecompilerSettings.ShowTokenAndRvaComments != s.ShowTokenAndRvaComments) flags |= RefreshFlags.DecompileAll;
if (CurrentDecompilerSettings.ShowILBytes != s.ShowILBytes) flags |= RefreshFlags.IL;
if (CurrentDecompilerSettings.DecompilationObject0 != s.DecompilationObject0) flags |= RefreshFlags.CSharp;
if (CurrentDecompilerSettings.DecompilationObject1 != s.DecompilationObject1) flags |= RefreshFlags.CSharp;
if (CurrentDecompilerSettings.DecompilationObject2 != s.DecompilationObject2) flags |= RefreshFlags.CSharp;
if (CurrentDecompilerSettings.DecompilationObject3 != s.DecompilationObject3) flags |= RefreshFlags.CSharp;
if (CurrentDecompilerSettings.DecompilationObject4 != s.DecompilationObject4) flags |= RefreshFlags.CSharp;
if (CurrentDecompilerSettings.SortMembers != s.SortMembers) flags |= RefreshFlags.IL | RefreshFlags.CSharp;
if (CurrentDecompilerSettings.ForceShowAllMembers != s.ForceShowAllMembers) flags |= RefreshFlags.CSharp | RefreshFlags.TreeViewNodes;
if (CurrentDecompilerSettings.SortSystemUsingStatementsFirst != s.SortSystemUsingStatementsFirst) flags |= RefreshFlags.CSharp;
XElement section = new XElement("DecompilerSettings");
section.SetAttributeValue("anonymousMethods", s.AnonymousMethods);
section.SetAttributeValue("yieldReturn", s.YieldReturn);
section.SetAttributeValue("asyncAwait", s.AsyncAwait);
section.SetAttributeValue("queryExpressions", s.QueryExpressions);
section.SetAttributeValue("expressionTrees", s.ExpressionTrees);
section.SetAttributeValue("useDebugSymbols", s.UseDebugSymbols);
section.SetAttributeValue("xmlDoc", s.ShowXmlDocumentation);
section.SetAttributeValue("showILComments", s.ShowILComments);
section.SetAttributeValue("removeEmptyDefaultConstructors", s.RemoveEmptyDefaultConstructors);
section.SetAttributeValue("showTokenAndRvaComments", s.ShowTokenAndRvaComments);
section.SetAttributeValue("showILBytes", s.ShowILBytes);
section.SetAttributeValue("decompilationObject0", (int)s.DecompilationObject0);
section.SetAttributeValue("decompilationObject1", (int)s.DecompilationObject1);
section.SetAttributeValue("decompilationObject2", (int)s.DecompilationObject2);
section.SetAttributeValue("decompilationObject3", (int)s.DecompilationObject3);
section.SetAttributeValue("decompilationObject4", (int)s.DecompilationObject4);
section.SetAttributeValue("sortMembers", s.SortMembers);
section.SetAttributeValue("forceShowAllMembers", s.ForceShowAllMembers);
section.SetAttributeValue("sortSystemUsingStatementsFirst", s.SortSystemUsingStatementsFirst);
XElement existingElement = root.Element("DecompilerSettings");
if (existingElement != null)
existingElement.ReplaceWith(section);
else
root.Add(section);
currentDecompilerSettings = null; // invalidate cached settings
return flags;
}
public DecompilationOptions()
{
this.DecompilerSettings = new DecompilerSettings();
}
public List<ReferenceSegment> Decompile (TextEditorData data, ITreeNavigator navigator, bool publicOnly)
{
if (DomMethodNodeBuilder.HandleSourceCodeEntity (navigator, data))
return null;
var type = CecilLoader.GetCecilObject ((IUnresolvedTypeDefinition)navigator.DataItem);
if (type == null)
return null;
var settings = new DecompilerSettings () {
AnonymousMethods = true,
AutomaticEvents = true,
AutomaticProperties = true,
ForEachStatement = true,
LockStatement = true,
HideNonPublicMembers = publicOnly
};
return DomMethodNodeBuilder.Decompile (data, DomMethodNodeBuilder.GetModule (navigator), type, builder => {
builder.AddType (type);
}, settings);
}
public static bool praseDecompileSetting(char c, DecompilerSettings ds)
{
switch (c) {
case 'a':
ds.YieldReturn = false;
break;
case 'b':
ds.AnonymousMethods = false;
break;
case 'c':
ds.AsyncAwait = false;
break;
case 'd':
ds.AutomaticEvents = false;
break;
case 'e':
ds.ExpressionTrees = false;
break;
case 'f':
ds.AutomaticProperties = false;
break;
case 'g':
ds.UsingStatement = false;
break;
case 'h':
ds.ForEachStatement = false;
break;
case 'i':
ds.LockStatement = false;
break;
case 'j':
ds.SwitchStatementOnString = false;
break;
case 'k':
ds.UsingDeclarations = false;
break;
case 'r':
ds.QueryExpressions = false;
break;
case 's':
ds.FullyQualifyAmbiguousTypeNames = false;
break;
case 'p':
ds.UseDebugSymbols = false;
break;
case 'x':
ds.ObjectOrCollectionInitializers = false;
break;
case 'y':
ds.ShowXmlDocumentation = false;
break;
case 'z':
ds.FoldBraces = true;
break;
default:
return false;
}
return true;
}
/// <summary>
/// Gets/sets an optional state of a decompiler text view.
/// </summary>
/// <remarks>
/// This state is used to restore test view's state when decompilation is started by Go Back/Forward action.
/// </remarks>
//public ICSharpCode.ILSpy.TextView.DecompilerTextViewState TextViewState { get; set; }
public DecompilationOptions()
{
//this.DecompilerSettings = DecompilerSettingsPanel.CurrentDecompilerSettings;
DecompilerSettings = new DecompilerSettings();
FullDecompilation = false;
}
public static List<ReferenceSegment> Decompile (TextEditorData data, ModuleDefinition module, TypeDefinition currentType, Action<AstBuilder> setData)
{
var types = DesktopService.GetMimeTypeInheritanceChain (data.Document.MimeType);
var codePolicy = MonoDevelop.Projects.Policies.PolicyService.GetDefaultPolicy<MonoDevelop.CSharp.Formatting.CSharpFormattingPolicy> (types);
DecompilerSettings settings = new DecompilerSettings () {
AnonymousMethods = true,
AutomaticEvents = true,
AutomaticProperties = true,
ForEachStatement = true,
LockStatement = true,
ShowXmlDocumentation = true,
CSharpFormattingOptions = codePolicy.CreateOptions ()
};
return Decompile (data, module, currentType, setData, settings);
}
public static List<ReferenceSegment> Decompile (TextEditorData data, ModuleDefinition module, TypeDefinition currentType, Action<AstBuilder> setData, DecompilerSettings settings)
{
try {
var context = new DecompilerContext (module);
var source = new CancellationTokenSource ();
context.CancellationToken = source.Token;
context.CurrentType = currentType;
context.Settings = settings;
AstBuilder astBuilder = new AstBuilder (context);
setData (astBuilder);
astBuilder.RunTransformations (o => false);
GeneratedCodeSettings.Default.Apply (astBuilder.CompilationUnit);
var output = new ColoredCSharpFormatter (data.Document);
astBuilder.GenerateCode (output);
output.SetDocumentData ();
return output.ReferencedSegments;
} catch (Exception e) {
data.Text = "Decompilation failed: \n" + e;
}
return null;
}
public static void Main (string[] args)
{
string appPath = null;
string slnName = null;
string libPath = null;
string expOpt = null;
string outLanguageType = LAN_TYPE_CSHARP;
DecompilerSettings ds = new DecompilerSettings ();
ds.AnonymousMethods = true;
ds.AsyncAwait = true;
ds.YieldReturn = true;
string onlyDecomileClassName = null;
List<string> onlyDecompilingFileNameList = new List<string> ();
//parsing args
foreach (string x in args) {
if (x.StartsWith ("-")) {
switch (x) {
case "-n":
case "-l":
case "-t":
case "-C":
case "-D":
expOpt = x;
continue;
default:
if (x.StartsWith ("-")) {
if (x.Length < 2) {
Console.WriteLine (" Unexpected options " + x);
showUsage ();
return;
}
for (int i = 0; i < x.Length; i++) {
if (!praseDecompileSetting (x [i], ds)) {
Console.WriteLine (" Unexpected options " + x);
showUsage ();
return;
}
}
continue;
}
break;
}
} else if (expOpt != null) {
switch (expOpt) {
case "-n":
slnName = x;
expOpt = null;
break;
case "-l":
libPath = x;
expOpt = null;
break;
case "-t":
if (x != LAN_TYPE_CSHARP && x != LAN_TYPE_IL) {
Console.WriteLine (" Unexpected Output language type: " + x);
showUsage ();
return;
}
outLanguageType = x;
expOpt = null;
break;
case "-C":
onlyDecomileClassName = x;
expOpt = null;
break;
case "-D":
onlyDecompilingFileNameList.Add (x);
break;
default:
showUsage ();
expOpt = null;
return;
}
} else {
if (appPath == null) {
appPath = x;
continue;
} else {
Console.WriteLine (" Unexpected options " + x);
showUsage ();
return;
}
}
}
if (appPath == null) {
Console.WriteLine ("directory/to/all/your/dll missing");
showUsage ();
return;
}
if (slnName == null && outLanguageType==LAN_TYPE_CSHARP) {
Console.WriteLine ("Solution Name missing");
showUsage ();
return;
}
Console.WriteLine ("Decompiling all dll in " + appPath);
Console.WriteLine ("Please wait...");
DirectoryInfo di = new DirectoryInfo(appPath);
appPath = di.FullName;
FileInfo[] dllFileInfoList = di.GetFiles("*.dll");
FileInfo[] exeFileInfoList = di.GetFiles ("*.exe");
AssemblyList asmlist = new AssemblyList ("mylistname");
foreach (var dllfile in dllFileInfoList)
{
bool bDecompile = isDecompilingFile (dllfile.FullName, onlyDecompilingFileNameList);
asmlist.OpenAssembly (dllfile.FullName,!bDecompile);
}
foreach (var dllfile in exeFileInfoList)
{
bool bDecompile = isDecompilingFile (dllfile.FullName, onlyDecompilingFileNameList);
asmlist.OpenAssembly (dllfile.FullName,!bDecompile);
}
if (libPath != null) {
di = new DirectoryInfo(libPath);
libPath = di.FullName;
dllFileInfoList = di.GetFiles("*.dll");
foreach (var dllfile in dllFileInfoList) {
asmlist.OpenAssembly (dllfile.FullName,true);
}
}
StringBuilder projSln = new StringBuilder ();
projSln.Append ("Microsoft Visual Studio Solution File, Format Version 11.00\n# Visual Studio 2010\n");
StringBuilder globSec = new StringBuilder ();
Guid slnProjGuid = Guid.NewGuid();
int num = 0;
LoadedAssembly [] ls = asmlist.GetAssemblies ();
var decompilationOptions = new DecompilationOptions ();
decompilationOptions.FullDecompilation = true;
decompilationOptions.assenmlyList = asmlist;
decompilationOptions.DecompilerSettings = ds;
decompilationOptions.IncludedClassName = onlyDecomileClassName;
if(outLanguageType==LAN_TYPE_CSHARP)
{
foreach (LoadedAssembly asm in ls) {
if (asm.IsAutoLoaded)
continue;
string projectPath = appPath + "/"+ asm.ShortName;
if(!Directory.Exists(projectPath))
{
Directory.CreateDirectory (projectPath);
}
string projectFileName = projectPath + "/" + asm.ShortName + ".csproj";
asm.ProjectGuid = Guid.NewGuid();
asm.ProjectFileName = projectFileName;
}
}
foreach (LoadedAssembly asm in ls) {
num++;
Console.WriteLine(asm.FileName + " " + num+"/"+ls.Length);
if (asm.IsAutoLoaded)
continue;
if(outLanguageType==LAN_TYPE_CSHARP)
{
var csharpLanguage = new CSharpLanguage ();
var textOutput = new PlainTextOutput ();
decompilationOptions.SaveAsProjectDirectory = appPath + "/"+ asm.ShortName;
csharpLanguage.DecompileAssembly (asm, textOutput, decompilationOptions);
File.WriteAllText (asm.ProjectFileName, textOutput.ToString ());
Guid createdProjGuid = asm.ProjectGuid;
projSln.Append(" Project(\"{");
projSln.Append (slnProjGuid.ToString());
projSln.Append ("}\") = \"");
projSln.Append (asm.ShortName);
projSln.Append ("\", \"");
projSln.Append (asm.ShortName+"/"+ asm.ShortName + ".csproj");
projSln.Append ("\", \"{");
projSln.Append (createdProjGuid.ToString());
projSln.Append ("}\"\n");
projSln.Append("EndProject\n");
globSec.Append (" {"+createdProjGuid.ToString()+"}.Debug|Any CPU.ActiveCfg = Debug|Any CPU\n");
globSec.Append (" {"+createdProjGuid.ToString()+"}.Debug|Any CPU.Build.0 = Debug|Any CPU\n");
globSec.Append (" {"+createdProjGuid.ToString()+"}.Release|Any CPU.ActiveCfg = Release|Any CPU\n");
globSec.Append (" {"+createdProjGuid.ToString()+"}.Release|Any CPU.Build.0 = Release|Any CPU\n");
}
else
{
var ilLanguage = new ILLanguage(true);
var textOutput = new PlainTextOutput ();
ilLanguage.DecompileAssembly (asm, textOutput, decompilationOptions);
string ilFileName = appPath + "/"+ asm.ShortName+".il";
File.WriteAllText(ilFileName,textOutput.ToString());
}
}
if (outLanguageType == LAN_TYPE_CSHARP) {
projSln.Append ("Global\n");
projSln.Append ("GlobalSection(SolutionConfigurationPlatforms) = preSolution\n");
projSln.Append ("\t\t\t\tDebug|Any CPU = Debug|Any CPU\n");
projSln.Append ("\t\t\t\tRelease|Any CPU = Release|Any CPU\n");
projSln.Append ("EndGlobalSection\n");
projSln.Append ("GlobalSection(ProjectConfigurationPlatforms) = postSolution\n");
projSln.Append (globSec.ToString ());
projSln.Append ("EndGlobalSection\n");
projSln.Append ("GlobalSection(MonoDevelopProperties) = preSolution\n");
projSln.Append ("\nEndGlobalSection\n");
projSln.Append ("EndGlobal\n\t\t");
string slnFileName = appPath + "/" + slnName + ".sln";
File.WriteAllText (slnFileName, projSln.ToString ());
}
}
