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 string Disassemble(this MethodBody body)
{
var writer = new PlainTextOutput();
var dasm = new MethodBodyDisassembler(writer);
dasm.Disassemble(body);
return writer.ToString();
}
public void Execute(CommandExecutionContext context)
{
_context = context;
_output = new PlainTextOutput();
if (!String.IsNullOrEmpty(AssemblyName))
{
ClrModule module = context.Runtime.Modules.SingleOrDefault(
m => Path.GetFileNameWithoutExtension(m.FileName).Equals(
Path.GetFileNameWithoutExtension(AssemblyName),
StringComparison.InvariantCultureIgnoreCase
)
);
if (module == null)
{
context.WriteErrorLine("Could not find the assembly '{0}'.", AssemblyName);
return;
}
if (!String.IsNullOrEmpty(TypeName))
{
DecompileTypeFromModule(TypeName, module.FileName);
}
else
{
DecompileModule(module);
}
}
else if (!String.IsNullOrEmpty(TypeName))
{
ClrType type = context.Heap.GetTypeByName(TypeName);
if (type == null)
{
context.WriteErrorLine(
"Could not find the type '{0}' on the heap. Try specifying the assembly name.",
TypeName);
return;
}
if (!String.IsNullOrEmpty(MethodName))
{
var methods = type.Methods.Where(m => m.Name == MethodName).ToArray();
if (methods.Length == 0)
{
context.WriteErrorLine("Could not find the method '{0}'.", MethodName);
return;
}
DecompileMethods(methods);
}
else
{
DecompileType(type);
}
}
else
{
context.WriteErrorLine("At least one of --assembly or --type must be specified.");
}
}
UISyntaxHighlighter(bool highlight) {
if (highlight) {
this.simpleHighlighter = new SimpleHighlighter();
this.output = null;
}
else {
this.simpleHighlighter = null;
this.output = new PlainTextOutput();
}
}
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();
}
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;
}
});
}
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;
}
private string GetCSharpCode(IMemberDefinition member, bool debug)
{
PlainTextOutput output = new PlainTextOutput();
CSharpLanguage csharp = new CSharpLanguage();
DecompilationOptions options = new DecompilationOptions();
options.DecompilerSettings = LoadDecompilerSettings();
if (member is TypeDefinition)
{
DecomplieType(csharp, (TypeDefinition)member, output, options);
return output.ToString();
}
else
{
MessageBox.Show("Not TypeDefinition");
}
return null;
}
void Run(Config config)
{
if (config.ShowHelp) {
Console.WriteLine ("Netjs compiler, Copyright 2014 Frank A. Krueger");
Console.WriteLine ("netjs [options] assembly-file");
return;
}
if (string.IsNullOrEmpty (config.MainAssembly)) {
throw new Exception ("No assembly specified.");
}
var asmPath = Path.GetFullPath (config.MainAssembly);
asmDir = Path.GetDirectoryName (asmPath);
var outPath = Path.ChangeExtension (asmPath, ".ts");
Step ("Reading IL");
var parameters = new ReaderParameters {
AssemblyResolver = this,
};
var asm = AssemblyDefinition.ReadAssembly (asmPath, parameters);
mscorlib = AssemblyDefinition.ReadAssembly (typeof(String).Assembly.Location, parameters);
system = AssemblyDefinition.ReadAssembly (typeof(INotifyPropertyChanged).Assembly.Location, parameters);
systemCore = AssemblyDefinition.ReadAssembly (typeof(Enumerable).Assembly.Location, parameters);
Step ("Decompiling IL to C#");
var context = new DecompilerContext (asm.MainModule);
context.Settings.ForEachStatement = false;
context.Settings.ObjectOrCollectionInitializers = false;
context.Settings.UsingStatement = false;
context.Settings.AsyncAwait = false;
context.Settings.AutomaticProperties = true;
context.Settings.AutomaticEvents = true;
context.Settings.QueryExpressions = false;
context.Settings.AlwaysGenerateExceptionVariableForCatchBlocks = true;
context.Settings.UsingDeclarations = false;
context.Settings.FullyQualifyAmbiguousTypeNames = true;
context.Settings.YieldReturn = false;
var builder = new AstBuilder (context);
builder.AddAssembly (asm);
foreach (var a in referencedAssemblies.Values) {
if (a != null)
builder.AddAssembly (a);
}
builder.RunTransformations ();
Step ("Translating C# to TypeScript");
new CsToTs ().Run (builder.SyntaxTree);
Step ("Writing");
using (var outputWriter = new StreamWriter (outPath)) {
var output = new PlainTextOutput (outputWriter);
builder.GenerateCode (output, (s, e) => new TsOutputVisitor (s, e));
}
Step ("Done");
}
public string getSourceCode(MethodDefinition methodDefinition)
{
try
{
var csharpLanguage = new CSharpLanguage();
var textOutput = new PlainTextOutput();
var decompilationOptions = new DecompilationOptions();
decompilationOptions.FullDecompilation = true;
csharpLanguage.DecompileMethod(methodDefinition, textOutput, decompilationOptions);
return textOutput.ToString();
/* ILanguage language = CSharp.GetLanguage(CSharpVersion.V1);
language.GetWriter(new PlainTextFormatter(writer)).Write(method);
MemoryStream stream = new MemoryStream();
StreamWriter writer3 = new StreamWriter(stream);
language.GetWriter(new PlainTextFormatter(writer3)).Write(method);
stream.Flush();*/
}
catch (Exception exception)
{
PublicDI.log.error("in getSourceCode: {0}", new object[] { exception.Message });
return ("Error in creating source code from IL: " + exception.Message);
}
}
public string getSourceCode(TypeDefinition typeDefinition)
{
try
{
var csharpLanguage = new CSharpLanguage();
var textOutput = new PlainTextOutput();
var decompilationOptions = new DecompilationOptions();
decompilationOptions.FullDecompilation = true;
csharpLanguage.DecompileType(typeDefinition, textOutput, decompilationOptions);
return textOutput.ToString();
}
catch (Exception exception)
{
PublicDI.log.error("in getSourceCode: {0}", new object[] { exception.Message });
return ("Error in creating source code from Type: " + exception.Message);
}
}
public bool Compile()
{
LogLine(1, "Compiling Xaml");
LogLine(1, "\nAssembly: {0}", Assembly);
if (!string.IsNullOrEmpty(DependencyPaths))
LogLine(1, "DependencyPaths: \t{0}", DependencyPaths);
if (!string.IsNullOrEmpty(ReferencePath))
LogLine(1, "ReferencePath: \t{0}", ReferencePath.Replace("//", "/"));
LogLine(3, "DebugSymbols:\"{0}\"", DebugSymbols);
var skipassembly = true; //change this to false to enable XamlC by default
bool success = true;
if (!File.Exists(Assembly))
{
LogLine(1, "Assembly file not found. Skipping XamlC.");
return true;
}
var resolver = new XamlCAssemblyResolver();
if (!string.IsNullOrEmpty(DependencyPaths))
{
foreach (var dep in DependencyPaths.Split(';'))
{
LogLine(3, "Adding searchpath {0}", dep);
resolver.AddSearchDirectory(dep);
}
}
if (!string.IsNullOrEmpty(ReferencePath))
{
var paths = ReferencePath.Replace("//", "/").Split(';');
foreach (var p in paths)
{
var searchpath = Path.GetDirectoryName(p);
LogLine(3, "Adding searchpath {0}", searchpath);
resolver.AddSearchDirectory(searchpath);
// LogLine (3, "Referencing {0}", p);
// resolver.AddAssembly (p);
}
}
var assemblyDefinition = AssemblyDefinition.ReadAssembly(Path.GetFullPath(Assembly), new ReaderParameters
{
AssemblyResolver = resolver,
ReadSymbols = DebugSymbols
});
CustomAttribute xamlcAttr;
if (assemblyDefinition.HasCustomAttributes &&
(xamlcAttr =
assemblyDefinition.CustomAttributes.FirstOrDefault(
ca => ca.AttributeType.FullName == "Xamarin.Forms.Xaml.XamlCompilationAttribute")) != null)
{
var options = (XamlCompilationOptions)xamlcAttr.ConstructorArguments[0].Value;
if ((options & XamlCompilationOptions.Skip) == XamlCompilationOptions.Skip)
skipassembly = true;
if ((options & XamlCompilationOptions.Compile) == XamlCompilationOptions.Compile)
skipassembly = false;
}
foreach (var module in assemblyDefinition.Modules)
{
var skipmodule = skipassembly;
if (module.HasCustomAttributes &&
(xamlcAttr =
module.CustomAttributes.FirstOrDefault(
ca => ca.AttributeType.FullName == "Xamarin.Forms.Xaml.XamlCompilationAttribute")) != null)
{
var options = (XamlCompilationOptions)xamlcAttr.ConstructorArguments[0].Value;
if ((options & XamlCompilationOptions.Skip) == XamlCompilationOptions.Skip)
skipmodule = true;
if ((options & XamlCompilationOptions.Compile) == XamlCompilationOptions.Compile)
skipmodule = false;
}
LogLine(2, " Module: {0}", module.Name);
var resourcesToPrune = new List<EmbeddedResource>();
foreach (var resource in module.Resources.OfType<EmbeddedResource>())
{
Log(2, " Resource: {0}... ", resource.Name);
string classname;
if (!resource.IsXaml(out classname))
{
LogLine(2, "skipped.");
continue;
}
TypeDefinition typeDef = module.GetType(classname);
if (typeDef == null)
{
LogLine(2, "no type found... skipped.");
continue;
}
var skiptype = skipmodule;
if (typeDef.HasCustomAttributes &&
(xamlcAttr =
typeDef.CustomAttributes.FirstOrDefault(
ca => ca.AttributeType.FullName == "Xamarin.Forms.Xaml.XamlCompilationAttribute")) != null)
{
var options = (XamlCompilationOptions)xamlcAttr.ConstructorArguments[0].Value;
if ((options & XamlCompilationOptions.Skip) == XamlCompilationOptions.Skip)
skiptype = true;
if ((options & XamlCompilationOptions.Compile) == XamlCompilationOptions.Compile)
skiptype = false;
}
if (skiptype)
{
LogLine(2, "Has XamlCompilationAttribute set to Skip and not Compile... skipped");
continue;
}
var initComp = typeDef.Methods.FirstOrDefault(md => md.Name == "InitializeComponent");
if (initComp == null)
{
LogLine(2, "no InitializeComponent found... skipped.");
continue;
}
LogLine(2, "");
Log(2, " Parsing Xaml... ");
var rootnode = ParseXaml(resource.GetResourceStream(), typeDef);
if (rootnode == null)
{
LogLine(2, "failed.");
continue;
}
LogLine(2, "done.");
hasCompiledXamlResources = true;
try
{
Log(2, " Replacing {0}.InitializeComponent ()... ", typeDef.Name);
var body = new MethodBody(initComp);
var il = body.GetILProcessor();
il.Emit(OpCodes.Nop);
var visitorContext = new ILContext(il, body);
rootnode.Accept(new XamlNodeVisitor((node, parent) => node.Parent = parent), null);
rootnode.Accept(new ExpandMarkupsVisitor(visitorContext), null);
rootnode.Accept(new CreateObjectVisitor(visitorContext), null);
rootnode.Accept(new SetNamescopesAndRegisterNamesVisitor(visitorContext), null);
rootnode.Accept(new SetFieldVisitor(visitorContext), null);
rootnode.Accept(new SetResourcesVisitor(visitorContext), null);
rootnode.Accept(new SetPropertiesVisitor(visitorContext, true), null);
il.Emit(OpCodes.Ret);
initComp.Body = body;
}
catch (XamlParseException xpe)
{
LogLine(2, "failed.");
LogError(null, null, null, resource.Name, xpe.XmlInfo.LineNumber, xpe.XmlInfo.LinePosition, 0, 0, xpe.Message,
xpe.HelpLink, xpe.Source);
LogLine(4, xpe.StackTrace);
success = false;
continue;
}
catch (XmlException xe)
{
LogLine(2, "failed.");
LogError(null, null, null, resource.Name, xe.LineNumber, xe.LinePosition, 0, 0, xe.Message, xe.HelpLink, xe.Source);
LogLine(4, xe.StackTrace);
success = false;
continue;
}
catch (Exception e)
{
LogLine(2, "failed.");
LogError(null, null, null, resource.Name, 0, 0, 0, 0, e.Message, e.HelpLink, e.Source);
LogLine(4, e.StackTrace);
success = false;
continue;
}
LogLine(2, "done.");
if (OptimizeIL)
{
Log(2, " Optimizing IL... ");
initComp.Body.OptimizeMacros();
LogLine(2, "done");
}
if (OutputGeneratedILAsCode)
{
var filepath = Path.Combine(Path.GetDirectoryName(Assembly), typeDef.FullName + ".decompiled.cs");
Log(2, " Decompiling {0} into {1}...", typeDef.FullName, filepath);
var decompilerContext = new DecompilerContext(module);
using (var writer = new StreamWriter(filepath))
{
var output = new PlainTextOutput(writer);
var codeDomBuilder = new AstBuilder(decompilerContext);
codeDomBuilder.AddType(typeDef);
codeDomBuilder.GenerateCode(output);
}
LogLine(2, "done");
}
resourcesToPrune.Add(resource);
}
if (!KeepXamlResources)
{
if (resourcesToPrune.Any())
LogLine(2, " Removing compiled xaml resources");
foreach (var resource in resourcesToPrune)
{
Log(2, " Removing {0}... ", resource.Name);
module.Resources.Remove(resource);
LogLine(2, "done");
}
}
LogLine(2, "");
}
if (!hasCompiledXamlResources)
{
LogLine(1, "No compiled resources. Skipping writing assembly.");
return success;
}
Log(1, "Writing the assembly... ");
try
{
assemblyDefinition.Write(Assembly, new WriterParameters
{
WriteSymbols = DebugSymbols
});
LogLine(1, "done.");
}
catch (Exception e)
{
LogLine(1, "failed.");
LogError(null, null, null, null, 0, 0, 0, 0, e.Message, e.HelpLink, e.Source);
LogLine(4, e.StackTrace);
success = false;
}
return success;
}
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 ());
}
}
public override string TypeToString(TypeReference t, bool includeNamespace, ICustomAttributeProvider attributeProvider = null)
{
PlainTextOutput output = new PlainTextOutput();
t.WriteTo(output, includeNamespace ? ILNameSyntax.TypeName : ILNameSyntax.ShortTypeName);
return output.ToString();
}
private static CudafyModule DoCudafy(CudafyModule cm, params Type[] types)
{
MemoryStream output = new MemoryStream();
var outputSw = new StreamWriter(output);
MemoryStream structs = new MemoryStream();
var structsSw = new StreamWriter(structs);
var structsPto = new PlainTextOutput(structsSw);
MemoryStream declarations = new MemoryStream();
var declarationsSw = new StreamWriter(declarations);
var declarationsPto = new PlainTextOutput(declarationsSw);
MemoryStream code = new MemoryStream();
var codeSw = new StreamWriter(code);
var codePto = new PlainTextOutput(codeSw);
bool isDummy = false;
eCudafyDummyBehaviour behaviour = eCudafyDummyBehaviour.Default;
Dictionary<string, ModuleDefinition> modules = new Dictionary<string,ModuleDefinition>();
var compOpts = new DecompilationOptions { FullDecompilation = true };
CUDALanguage.Reset();
bool firstPass = true;
if(cm == null)
cm = new CudafyModule();// #######!!!
else
firstPass = false;
// Test structs
//foreach (var strct in types.Where(t => !t.IsClass))
// if (strct.GetCustomAttributes(typeof(CudafyAttribute), false).Length == 0)
// throw new CudafyLanguageException(CudafyLanguageException.csCUDAFY_ATTRIBUTE_IS_MISSING_ON_X, strct.Name);
IEnumerable<Type> typeList = GetWithNestedTypes(types);
foreach (var type in typeList)
{
if(!modules.ContainsKey(type.Assembly.Location))
modules.Add(type.Assembly.Location, ModuleDefinition.ReadModule(type.Assembly.Location));
}
// Additional loop to compile in order
foreach (var requestedType in typeList)
{
foreach (var kvp in modules)
{
foreach (var td in kvp.Value.Types)
{
List<TypeDefinition> tdList = new List<TypeDefinition>();
tdList.Add(td);
tdList.AddRange(td.NestedTypes);
Type type = null;
foreach (var t in tdList)
{
//type = typeList.Where(tt => tt.FullName.Replace("+", "") == t.FullName.Replace("/", "")).FirstOrDefault();
// Only select type if this matches the requested type (to ensure order is maintained).
type = requestedType.FullName.Replace("+", "") == t.FullName.Replace("/", "") ? requestedType : null;
if (type == null)
continue;
Debug.WriteLine(t.FullName);
// Types
var attr = t.GetCudafyType(out isDummy, out behaviour);
if (attr != null)
{
_cl.DecompileType(t, structsPto, compOpts);
if (firstPass)
cm.Types.Add(type.FullName.Replace("+", ""), new KernelTypeInfo(type, isDummy, behaviour));// #######!!!
}
else if (t.Name == td.Name)
{
// Fields
foreach (var fi in td.Fields)
{
attr = fi.GetCudafyType(out isDummy, out behaviour);
if (attr != null)
{
VerifyMemberName(fi.Name);
System.Reflection.FieldInfo fieldInfo = type.GetField(fi.Name, BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
if (fieldInfo == null)
throw new CudafyLanguageException(CudafyLanguageException.csX_ARE_NOT_SUPPORTED, "Non-static fields");
int[] dims = _cl.GetFieldInfoDimensions(fieldInfo);
_cl.DecompileCUDAConstantField(fi, dims, codePto, compOpts);
var kci = new KernelConstantInfo(fi.Name, fieldInfo, isDummy);
if (firstPass)
cm.Constants.Add(fi.Name, kci);// #######!!!
CUDALanguage.AddConstant(kci);
}
}
#warning TODO Only Global Methods can be called from host
#warning TODO For OpenCL may need to do Methods once all Constants have been handled
// Methods
foreach (var med in td.Methods)
{
attr = med.GetCudafyType(out isDummy, out behaviour);
if (attr != null)
{
if (!med.IsStatic)
throw new CudafyLanguageException(CudafyLanguageException.csX_ARE_NOT_SUPPORTED, "Non-static methods");
_cl.DecompileMethodDeclaration(med, declarationsPto, new DecompilationOptions { FullDecompilation = false });
_cl.DecompileMethod(med, codePto, compOpts);
MethodInfo mi = type.GetMethod(med.Name, BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
if (mi == null)
continue;
VerifyMemberName(med.Name);
eKernelMethodType kmt = eKernelMethodType.Device;
kmt = GetKernelMethodType(attr, mi);
if (firstPass)
cm.Functions.Add(med.Name, new KernelMethodInfo(type, mi, kmt, isDummy, behaviour, cm));// #######!!!
}
}
}
}
}
}
}
codeSw.Flush();
if (CudafyTranslator.Language == eLanguage.OpenCL)
{
outputSw.WriteLine("#if defined(cl_khr_fp64)");
outputSw.WriteLine("#pragma OPENCL EXTENSION cl_khr_fp64: enable");
outputSw.WriteLine("#elif defined(cl_amd_fp64)");
outputSw.WriteLine("#pragma OPENCL EXTENSION cl_amd_fp64: enable");
outputSw.WriteLine("#endif");
}
foreach (var oh in CUDALanguage.OptionalHeaders)
{
if (oh.Used && !oh.AsResource)
outputSw.WriteLine(oh.IncludeLine);
else if (oh.Used)
outputSw.WriteLine(GetResourceString(oh.IncludeLine));
}
foreach (var oh in CUDALanguage.OptionalFunctions)
{
if (oh.Used)
outputSw.WriteLine(oh.Code);
}
declarationsSw.WriteLine();
declarationsSw.Flush();
structsSw.WriteLine();
structsSw.Flush();
foreach (var def in cm.GetDummyDefines())
outputSw.WriteLine(def);
foreach (var inc in cm.GetDummyStructIncludes())
outputSw.WriteLine(inc);
foreach (var inc in cm.GetDummyIncludes())
outputSw.WriteLine(inc);
outputSw.Flush();
output.Write(structs.GetBuffer(), 0, (int)structs.Length);
output.Write(declarations.GetBuffer(), 0, (int)declarations.Length);
output.Write(code.GetBuffer(), 0, (int)code.Length);
outputSw.Flush();
#if DEBUG
using (FileStream fs = new FileStream("output.cu", FileMode.Create))
{
fs.Write(output.GetBuffer(), 0, (int)output.Length);
}
#endif
String s = Encoding.UTF8.GetString(output.GetBuffer(), 0, (int)output.Length);
//cm.SourceCode = s;// #######!!!
var scf = new SourceCodeFile(s, Language, _architecture);
cm.AddSourceCodeFile(scf);
return cm;
}
public override string TypeToString(TypeReference t)
{
PlainTextOutput output = new PlainTextOutput();
t.WriteTo(output, true, true);
return output.ToString();
}
void Run(Config config)
{
if (config.AssembliesToDecompile.Count == 0) {
config.ShowHelp = true;
}
if (config.ShowHelp) {
Console.WriteLine ("Netjs compiler, Copyright 2014-2016 Frank A. Krueger");
Console.WriteLine ("netjs [options] assembly-files");
Console.WriteLine (" --help, -h Show usage information");
Console.WriteLine (" --includerefs, -r Decompile referenced assemblies");
return;
}
string outPath = "";
var asmPaths = new List<string> ();
foreach (var asmRelPath in config.AssembliesToDecompile) {
var asmPath = Path.GetFullPath (asmRelPath);
asmPaths.Add (asmPath);
if (string.IsNullOrEmpty (outPath)) {
outPath = Path.ChangeExtension (asmPath, ".ts");
}
var asmDir = Path.GetDirectoryName (asmPath);
if (!asmSearchPaths.Exists (x => x.Item1 == asmDir)) {
asmSearchPaths.Add (Tuple.Create (asmDir, config.IncludeRefs));
}
}
Step ("Reading IL");
globalReaderParameters.AssemblyResolver = this;
globalReaderParameters.ReadingMode = ReadingMode.Immediate;
var libDir = Path.GetDirectoryName (typeof (String).Assembly.Location);
asmSearchPaths.Add (Tuple.Create(libDir, false));
asmSearchPaths.Add (Tuple.Create(Path.Combine (libDir, "Facades"), false));
AssemblyDefinition firstAsm = null;
foreach (var asmPath in asmPaths) {
var asm = AssemblyDefinition.ReadAssembly (asmPath, globalReaderParameters);
if (firstAsm == null)
firstAsm = asm;
referencedAssemblies[asm.Name.Name] = asm;
decompileAssemblies.Add (asm);
}
Step ("Decompiling IL to C#");
var context = new DecompilerContext (firstAsm.MainModule);
context.Settings.ForEachStatement = false;
context.Settings.ObjectOrCollectionInitializers = false;
context.Settings.UsingStatement = false;
context.Settings.AsyncAwait = false;
context.Settings.AutomaticProperties = true;
context.Settings.AutomaticEvents = true;
context.Settings.QueryExpressions = false;
context.Settings.AlwaysGenerateExceptionVariableForCatchBlocks = true;
context.Settings.UsingDeclarations = false;
context.Settings.FullyQualifyAmbiguousTypeNames = true;
context.Settings.YieldReturn = false;
var builder = new AstBuilder (context);
var decompiled = new HashSet<string> ();
for (;;) {
var a = decompileAssemblies.FirstOrDefault (x => !decompiled.Contains (x.FullName));
if (a != null) {
Info (" Decompiling {0}", a.FullName);
builder.AddAssembly (a);
decompiled.Add (a.FullName);
}
else {
break;
}
}
builder.RunTransformations ();
Step ("Translating C# to TypeScript");
new CsToTs ().Run (builder.SyntaxTree);
Step ("Writing");
using (var outputWriter = new StreamWriter (outPath)) {
var output = new PlainTextOutput (outputWriter);
builder.GenerateCode (output, (s, e) => new TsOutputVisitor (s, e));
}
Step ("Done");
}
public override string TypeToString(TypeReference t, bool includeNamespace, ICustomAttributeProvider attributeProvider)
{
PlainTextOutput output = new PlainTextOutput();
t.WriteTo(output, true, shortName: !includeNamespace);
return output.ToString();
}
/// <summary>
/// Converts a type reference into a string. This method is used by the member tree node for parameter and return types.
/// </summary>
public string TypeToString(ITypeDefOrRef type, bool includeNamespace, IHasCustomAttribute typeAttributes = null)
{
var writer = new StringWriter();
var output = new PlainTextOutput(writer);
TypeToString(output, type, includeNamespace, typeAttributes);
return writer.ToString();
}
private void SetupDecompilerAndOriginalSource(MethodDefinition method)
{
_cSharpDecompiler = new CSharpLanguage();
var decompilationOutput = new PlainTextOutput();
_decompilationOptions = new DecompilationOptions();
_cSharpDecompiler.DecompileMethod(method, decompilationOutput, _decompilationOptions);
_oldText = decompilationOutput.ToString();
_differ = new SideBySideDiffBuilder(new Differ());
}
public string ToString(Language language)
{
var output = new PlainTextOutput();
Write(output, language);
return output.ToString();
}
private string ConstructEstimateCodeDiff(MethodDefinition method)
{
var decompilationOutput = new PlainTextOutput();
try
{
_cSharpDecompiler.DecompileMethod(method, decompilationOutput, _decompilationOptions);
}
catch
{
return "\t\tNo decompilation available for mutated version.\n";
}
string newText = decompilationOutput.ToString();
var model = _differ.BuildDiffModel(_oldText, newText);
string diffOutput = "\t\tApproximate source code difference from IL decompilation:\n";
var lines = new SortedSet<int>();
for (int i = 0; i < Math.Max(model.OldText.Lines.Count, model.NewText.Lines.Count); i++)
{
if ((i < model.OldText.Lines.Count && model.OldText.Lines[i].Type != ChangeType.Unchanged)
|| (i < model.NewText.Lines.Count && model.NewText.Lines[i].Type != ChangeType.Unchanged))
{
lines.Add(i - 2);
lines.Add(i - 1);
lines.Add(i);
lines.Add(i + 1);
lines.Add(i + 2);
}
}
int lastLine = -1;
string adds = "";
string takes = "";
foreach (var line in lines)
{
if (line < 0) continue;
if (line > lastLine + 1)
{
diffOutput += string.Format("{1}{2}\t\t@@ {0} @@\n", line,
takes, adds);
takes = "";
adds = "";
}
if (line < model.OldText.Lines.Count)
{
takes += string.Format("\t\t- {0}\n",
(model.OldText.Lines[line].Text ?? "").Replace("\t", " "));
}
if (line < model.NewText.Lines.Count)
{
adds += string.Format("\t\t+ {0}\n",
(model.NewText.Lines[line].Text ?? "").Replace("\t", " "));
}
lastLine = line;
}
if (!string.IsNullOrEmpty(adds) || !string.IsNullOrEmpty(takes))
{
diffOutput += takes + adds;
}
return diffOutput;
}
public string GetClass(TypeIdentity identity)
{
// Before we attempt to fetch it just try a decompilation.
GetAssembly(identity.AssemblyPath);
ModuleDefinition moduleDef;
if (!this.loadedModules.TryGetValue(identity.AssemblyPath, out moduleDef))
{
// Can't find the assembly, just return nothing.
return string.Empty;
}
TypeDefinition typeDef = moduleDef.GetType(identity.FullyQualifiedName);
if (typeDef == null)
{
// If we can't find our type just return as well.
return string.Empty;
}
DecompilerContext context = new DecompilerContext(moduleDef);
AstBuilder astBuilder = new AstBuilder(context);
astBuilder.AddType(typeDef);
PlainTextOutput textOutput = new PlainTextOutput();
astBuilder.GenerateCode(textOutput);
return textOutput.ToString();
}
