internal static Tuple <MethodInfo, MethodDeclaration>[] GetTestMethodsWithDecompiled(CSharpDecompiler decompiler, Tuple <Type, MethodInfo[]>[] testTypeMethods)
{
var testMethods = new List <Tuple <MethodInfo, MethodDeclaration> >();
foreach ((Type testType, MethodInfo[] testMethodInfos) in testTypeMethods)
{
var fullTypeName = new FullTypeName(testType.FullName);
var syntaxTree = decompiler.DecompileType(fullTypeName);
var astNodes = syntaxTree.Descendants.Where(x => x.NodeType == NodeType.Member).ToArray();
foreach (var testMethodInfo in testMethodInfos)
{
foreach (var astNode in astNodes)
{
if (!(astNode is MethodDeclaration methodDeclaration))
{
continue;
}
if (!methodDeclaration.Name.Equals(testMethodInfo.Name, StringComparison.Ordinal))
{
continue;
}
testMethods.Add(new Tuple <MethodInfo, MethodDeclaration>(testMethodInfo, methodDeclaration));
}
}
}
return(testMethods.ToArray());
}
public IEnumerable <EcsFile> Generate(IEnumerable <TypeDefinition> types, string assemblyName)
{
var files = new List <EcsFile>();
m_settings = new DecompilerSettings();
m_settings.ShowXmlDocumentation = false;
m_settings.NamedArguments = false;
m_settings.NonTrailingNamedArguments = false;
m_settings.OptionalArguments = false;
m_decompiler = CreateDecompiler(assemblyName, m_settings);
m_decompiler.ILTransforms.Insert(0, new RefCounting());
m_decompiler.ILTransforms.Remove(m_decompiler.ILTransforms.Single(x => x.GetType() == typeof(AssignVariableNames)));
m_decompiler.AstTransforms.Add(new AddBaseStruct());
m_decompiler.AstTransforms.Add(new RemoveStaticMemberAccess());
foreach (var t in types)
{
var syntaxTree = new Lazy <SyntaxTree>(() => m_decompiler.DecompileType(new FullTypeName(t.FullName)));
files.Add(GenerateCodeFile(t, syntaxTree, OutputMode.Header));
files.Add(GenerateCodeFile(t, syntaxTree, OutputMode.Source));
}
return(files);
}
public static void Main(string[] args)
{
using (var host = WebHost.Start((IRouteBuilder router)
=> router.MapGet("api/decompile/csharp", async(req, res, data) =>
{
if (req.Query.TryGetValue("assemblyFileName", out var assemblyFileName) &&
req.Query.TryGetValue("typeName", out var typeName))
{
var decompiler = new CSharpDecompiler(assemblyFileName, new DecompilerSettings {
ThrowOnAssemblyResolveErrors = true
});
var decompiledType = decompiler.DecompileType(new FullTypeName(typeName));
await res.WriteAsync(decompiledType.ToString());
}
else
{
res.StatusCode = 400;
await res.WriteAsync($"Missing query string parameters: '{nameof(assemblyFileName)}', '{nameof(typeName)}'.");
}
})))
{
host.WaitForShutdown();
}
}
public static ICSharpCode.Decompiler.CSharp.Syntax.SyntaxTree Decompile(this Assembly assembly, string typeName)
{
string path = GetPath(assembly);
var settings = new DecompilerSettings();
var decompiler = new CSharpDecompiler(path, settings);
var name = new FullTypeName(typeName);
var syntaxTree = decompiler.DecompileType(name);
return(syntaxTree);
}
private string GetStructCode(Type structInstance)
{
string assemblyPath = structInstance.Assembly.Location;
CSharpDecompiler cSharpDecompiler
= new CSharpDecompiler(assemblyPath, new Amplifier.Decompiler.DecompilerSettings()
{
ThrowOnAssemblyResolveErrors = false, ForEachStatement = false
});
var tree = cSharpDecompiler.DecompileType(new FullTypeName(structInstance.FullName));
string code = cSharpDecompiler.DecompileTypeAsString(new FullTypeName(structInstance.FullName));
return(CodeTranslator.Translate(code).Trim() + ";");
}
public static string GetSourceDecompiled <T>(Predicate <T> match)
{
string module_path = match.Method.Module.FullyQualifiedName;
var settings = new DecompilerSettings();
settings.AnonymousMethods = false; //disable anonymous methods inlining
var decompiler = new CSharpDecompiler(module_path, settings);
//decompile type that contains method
SyntaxTree tree = decompiler.DecompileType(
new ICSharpCode.Decompiler.TypeSystem.FullTypeName(match.Method.DeclaringType.FullName)
);
//find method in syntax tree
var children = tree.Children.ToList();
AstNode res = null;
foreach (var x in children)
{
res = FindNode(x, match.Method.Name);
if (res != null)
{
break;
}
}
string s = "";
if (res != null)
{
s = res.ToString();
}
return(s);
}
static int Main(string[] args)
{
var assemblyFilenameOption = new Option <FileInfo>(
new[] { "--assembly", "-a" },
description: "The assembly to decompile into XML.");
var verboseOption = new Option <bool>(
new[] { "--verbose", "-v" },
description: "Provide output as code is running.");
var outputOption = new Option <DirectoryInfo>(
new[] { "--output", "-o" },
description: "The root directory where the XML files will be written. The directory must exist.");
var rootCommand = new RootCommand
{
assemblyFilenameOption,
verboseOption,
outputOption,
};
rootCommand.Description = "Command to extract C# code into XML suitable for reasoning.";
rootCommand.SetHandler((FileInfo assemblyFile, bool verbose, DirectoryInfo outputDirectory) =>
{
if (assemblyFile == null)
{
Console.Error.WriteLine("No assembly provided to extract");
return;
}
if (outputDirectory == null)
{
Console.Error.WriteLine("No target directory provided");
return;
}
// Set up the preferences for the decompilation of the IL into source.
var settings = new DecompilerSettings()
{
AlwaysUseBraces = true,
ShowXmlDocumentation = true
};
settings.CSharpFormattingOptions.IndentationString = " ";
var decompiler = new CSharpDecompiler(assemblyFile.FullName, settings);
// Traverse all the types in the assembly
foreach (var typeDefinition in decompiler.TypeSystem.MainModule.TopLevelTypeDefinitions)
{
if (typeDefinition.Name.StartsWith("<"))
{
continue;
}
if (verbose)
{
Console.WriteLine($"Extracting {typeDefinition.FullName}.");
}
var syntaxTree = decompiler.DecompileType(typeDefinition.FullTypeName);
// This is needed to get the locations correctly set in the AST.
StringWriter w = new StringWriter();
var q = new TextWriterTokenWriter(w);
q.IndentationString = " ";
TokenWriter tokenWriter = q;
tokenWriter = TokenWriter.WrapInWriterThatSetsLocationsInAST(tokenWriter);
syntaxTree.AcceptVisitor(new CSharpOutputVisitor(tokenWriter, settings.CSharpFormattingOptions));
var source = w.ToString();
var generator = new XmlGeneratorVisitor(assemblyFile.FullName, source);
syntaxTree.AcceptVisitor(generator);
File.WriteAllText(Path.Combine(outputDirectory.FullName, typeDefinition.FullTypeName.Name) + ".xml", generator.Document.ToString());
}
},
assemblyFilenameOption, verboseOption, outputOption);
return(rootCommand.Invoke(args));
}
public string CompileGlsl()
{
var decompiler = new CSharpDecompiler(GetType().Assembly.Location, new DecompilerSettings());
var td = decompiler.TypeSystem.MainModule.Compilation.FindType(GetType()).GetDefinition();
var usings = decompiler.DecompileType(new FullTypeName(GetType().FullName)).Members
.Where(x => x is UsingDeclaration).Select(x => ((UsingDeclaration)x).Namespace)
.Concat(new[] { GetType().Namespace }).ToList();
GlslAst[] TransformBody(SyntaxTree func) =>
func.Members.First(x => x.NodeType == NodeType.Member).Children
.First(x => x.NodeType == NodeType.Statement)
.Children.Select(x => Transform(x)).Where(x => x != null).ToArray();
Type ToType(AstType astType)
{
var t = astType.ToTypeReference()
.Resolve(new CSharpTypeResolveContext(decompiler.TypeSystem.MainModule));
return(new[] { t.Namespace }.Concat(usings).Select(ns => AppDomain.CurrentDomain.GetAssemblies()
.Select(x => x.GetType(ns == null ? t.FullName : $"{ns}.{t.Name}"))
.FirstOrDefault(x => x != null)).FirstOrDefault(x => x != null));
}
string Format(float value)
{
var str = value.ToString(CultureInfo.InvariantCulture);
return(str.Contains(".") ? str + "f" : str + ".0f");
}
GlslAst ToLiteral(object value) =>
new GlslAst.InlineExpression
{
Code = value switch {
Vec2 v => $"vec2({Format(v.x)}, {Format(v.y)})",
Vec3 v => $"vec3({Format(v.x)}, {Format(v.y)}, {Format(v.z)})",
Vec4 v => $"vec4({Format(v.x)}, {Format(v.y)}, {Format(v.z)}, {Format(v.w)})",
_ => throw new NotImplementedException($"Unknown type for GLSL literal {value.GetType()}: {value}")
}
};
GlslAst EnsureStmt(GlslAst node) =>
node is GlslAst.Expression expr
? new GlslAst.ExpressionStatement
{
Expression = expr
}
: node;
GlslAst MatchIntrinsic(AstNode node)
{
GlslAst VectorStatics()
{
if (!(node is MemberReferenceExpression mre))
{
return(null);
}
if (!(mre.Target is TypeReferenceExpression tre))
{
return(null);
}
var ctype = ToType(tre.Type);
var member = ctype.GetMember(mre.MemberName).First();
object value;
if (member is FieldInfo fi)
{
if (!fi.IsStatic || !fi.IsInitOnly)
{
return(null);
}
value = fi.GetValue(null);
}
else if (member is PropertyInfo pi)
{
if (pi.SetMethod != null || !pi.GetMethod.IsStatic)
{
return(null);
}
value = pi.GetValue(null);
}
else
{
return(null);
}
return(ToLiteral(value));
}
GlslAst MatrixTransform()
{
if (!(node is InvocationExpression ie))
{
return(null);
}
if (!(ie.Target is MemberReferenceExpression mre))
{
return(null);
}
if (mre.MemberName != "Transform" || !mre.Target.ToString().StartsWith("Vector"))
{
return(null);
}
return(new GlslAst.BinaryOperatorExpression {
Left = Transform(ie.Arguments.Skip(1).First()),
Right = Transform(ie.Arguments.First()),
Operator = "*"
});
}
var ifuncs = new List <Func <GlslAst> > {
VectorStatics, MatrixTransform
};
return(ifuncs.Select(x => x()).FirstOrDefault(x => x != null));
}
GlslAst Transform(AstNode node, bool bareExpr = false)
{
var intrinsic = MatchIntrinsic(node);
if (intrinsic != null)
{
return(intrinsic);
}
switch (node)
{
case DefaultValueExpression _: return(null);
case VariableDeclarationStatement decl:
return(new GlslAst.DeclareStatement
{
Name = decl.Variables.First().Name, Type = ToType(decl.Type),
Value = Transform(decl.Variables.First().Initializer)
});
case ReturnStatement ret:
return(new GlslAst.ReturnStatement {
Expression = Transform(ret.Expression)
});
case IdentifierExpression id:
return(new GlslAst.IdentifierExpression {
Name = id.Identifier
});
case ExpressionStatement expr:
var tf = Transform(expr.Expression);
if (bareExpr)
{
return(tf);
}
return(tf is GlslAst.Expression e ? new GlslAst.ExpressionStatement {
Expression = e
} : tf);
case AssignmentExpression ass:
var right = Transform(ass.Right);
if (right == null)
{
return(null);
}
return(new GlslAst.AssignExpression
{
Target = Transform(ass.Left), Value = right
});
case MemberReferenceExpression mre:
return(new GlslAst.MemberAccessExpression
{
Base = Transform(mre.Target), Member = mre.MemberName
});
case PrimitiveExpression pe:
return(pe.Value switch {
int i => (GlslAst) new GlslAst.IntExpression {
Value = i
}, // TODO: Report Rider bug
float f => new GlslAst.FloatExpression {
Value = f
},
_ => throw new NotImplementedException($"Unhandled primitive type {pe.Value.GetType()}")
});
