void processEnum(TypeDeclaration td, TNamespace ns)
{
Debug.Assert(td.ClassType == ClassType.Enum);
TEnum te = new TEnum();
te.name = td.Name;
var blist = td.BaseTypes;
foreach (var item in blist)
{
te.bases.Add(item.GetText());
}
var mlist = td.Descendants.OfType <EnumMemberDeclaration>().ToList();
foreach (var item in mlist)
{
var member = new TEnumMember();
var text = item.GetText();
var split = text.Split('=');
member.name = split[0];
if (split.Count() >= 2)
{
member.init = split[1];
}
te.members.Add(member);
}
ns.classes.Add(te);
}
public void Run(TNamespace ns)
{
foreach (var t in GetTransforms())
{
t.Run(ns);
}
}
// test ok
void processClass(TypeDeclaration td, TNamespace ns)
{
Debug.Assert(td.ClassType != ClassType.Enum);
TClass tc = new TClass();
tc.name = td.Name;
foreach (var item in td.BaseTypes)
{
tc.bases.Add(TypeToString(GetTypeRef(item)));
}
var flist = td.Descendants.OfType <FieldDeclaration>().ToList();
foreach (var item in flist)
{
processField(item, tc);
}
var plist = td.Descendants.OfType <PropertyDeclaration>().ToList();
foreach (var item in plist)
{
processProperty(item, tc);
}
var mlist = td.Descendants.OfType <MethodDeclaration>().ToList();
foreach (var item in mlist)
{
processMethod(item, tc);
}
var clist = td.Descendants.OfType <ConstructorDeclaration>().ToList();
foreach (var item in clist)
{
processConstructor(item, tc);
}
/*var dlist = td.Descendants.OfType<DestructorDeclaration>().ToList();
* foreach(var item in dlist)
* {
* processDestructor(item, tc);
* }*/
var ilist = td.Descendants.OfType <IndexerDeclaration>().ToList();
foreach (var item in ilist)
{
processIndexer(item, tc);
}
ns.classes.Add(tc);
}
public void Run(TNamespace ns)
{
foreach (var td in ns.classes)
{
var c = td as TClass;
if (c != null)
{
c.constructors.RemoveAll(item => item.body.text.Contains("LicenseManager"));
}
}
}
public void Run(TNamespace ns)
{
foreach (var td in ns.classes)
{
var c = td as TClass;
if (c != null)
{
c.fields.RemoveAll(item => (item.attributes != null) && (item.attributes.Contains("CompilerGenerated")));
}
}
}
public void Run(TNamespace ns)
{
foreach (var item in ns.classes)
{
TClass c = item as TClass;
if (c != null)
{
foreach (var p in c.indexers)
{
if (p.getter != null)
{
TMethod m = new TMethod();
m.name = "get" + p.name;
if (p.getter.isInternal || p.getter.isPrivate)
{
m.isPrivate = true;
}
else
{
m.isPublic = true;
}
m.type = p.type;
m.parameters.AddRange(p.parameters);
m.body.text = p.getter.body.text;
m.body.invokes.Clear();
m.body.invokes.AddRange(p.getter.body.invokes);
c.methods.Add(m);
}
if (p.setter != null)
{
TMethod m = new TMethod();
m.name = "set" + p.name;
if (p.setter.isInternal || p.setter.isPrivate)
{
m.isPrivate = true;
}
else
{
m.isPublic = true;
}
m.type = "void";
m.parameters.AddRange(p.parameters);
m.body.text = p.setter.body.text;
m.body.invokes.Clear();
m.body.invokes.AddRange(p.getter.body.invokes);
c.methods.Add(m);
}
}
}
c.indexers.Clear();
}
}
public void Run(TNamespace ns)
{
foreach (var item in ns.classes)
{
TClass c = item as TClass;
if (c != null)
{
foreach (var p in c.properties)
{
if (p.getter != null)
{
TMethod m = new TMethod();
m.name = "get" + p.name;
if (p.getter.isInternal || p.getter.isPrivate)
{
m.isPrivate = true;
}
else
{
m.isPublic = true;
}
m.type = p.type;
m.body = p.getter.body;
c.methods.Add(m);
}
if (p.setter != null)
{
TMethod m = new TMethod();
m.name = "set" + p.name;
if (p.setter.isInternal || p.setter.isPrivate)
{
m.isPrivate = true;
}
else
{
m.isPublic = true;
}
m.type = "void";
TParameter param = new TParameter();
param.type = p.type;
param.name = "value";
m.parameters.Add(param);
m.body = p.setter.body;
c.methods.Add(m);
}
}
}
c.properties.Clear();
}
}
void outputlua(TNamespace ns)
{
var transform = new LuaTransform();
transform.Run(ns);
output.WriteLine("namespace " + ns.name + "{");
foreach (var item in ns.classes)
{
var c = item as TClass;
if (c != null)
{
WriteClass(c);
}
else
{
WriteEnum(item as TEnum);
}
}
output.WriteLine("} // namespaec " + ns.name);
}
public void Run(TNamespace ns)
{
}
void WriteFilesInProject(ModuleDefinition module, DecompilationOptions options, HashSet <string> directories, TNamespace ns)
{
string dir = Path.Combine(options.SaveAsProjectDirectory, ns.name + "_lua");
Directory.CreateDirectory(dir);
foreach (var c in ns.classes)
{
string file = CleanUpName(c.name) + ".h";
using (StreamWriter w = new StreamWriter(Path.Combine(dir, file)))
{
WriteTypeAsHpp(new PlainTextOutput(w), c);
}
}
foreach (var c in ns.classes)
{
string file = CleanUpName(c.name) + ".cpp";
using (StreamWriter w = new StreamWriter(Path.Combine(dir, file)))
{
WriteTypeAsCpp(new PlainTextOutput(w), c);
}
}
}
void ModuleTransform(TNamespace root)
{
RunTransform(root);
}
void RunTransform(TNamespace ns)
{
var transform = new LuaTransform();
transform.Run(ns);
}
public override void DecompileAssembly(LoadedAssembly assembly, ITextOutput output, DecompilationOptions options)
{
if (options.FullDecompilation && options.SaveAsProjectDirectory != null)
{
HashSet <string> directories = new HashSet <string>(StringComparer.OrdinalIgnoreCase);
var nsList = new List <TNamespace>();
var dict = new Dictionary <string, TNamespace>();
ParserFilesInProject(assembly.ModuleDefinition, options, directories, nsList);
var default_key = "NULL";
var default_ns = new TNamespace();
default_ns.name = default_key;
dict.Add(default_ns.name, default_ns);
foreach (var ns in nsList)
{
string key;
if (ns.name == null)
{
key = default_key;
}
else
{
key = ns.name;
}
if (dict.ContainsKey(key))
{
var mns = dict[key];
foreach (var c in ns.classes)
{
mns.classes.Add(c);
}
}
else
{
dict[ns.name] = ns;
}
}
ModuleTransform(dict["SmartQuant"]);
WriteFilesInProject(assembly.ModuleDefinition, options, directories, dict["SmartQuant"]);
}
else
{
base.DecompileAssembly(assembly, output, options);
output.WriteLine();
ModuleDefinition mainModule = assembly.ModuleDefinition;
if (mainModule.EntryPoint != null)
{
output.Write("// Entry point: ");
output.WriteReference(mainModule.EntryPoint.DeclaringType.FullName + "." + mainModule.EntryPoint.Name, mainModule.EntryPoint);
output.WriteLine();
}
output.WriteLine("// Architecture: " + GetPlatformDisplayName(mainModule));
if ((mainModule.Attributes & ModuleAttributes.ILOnly) == 0)
{
output.WriteLine("// This assembly contains unmanaged code.");
}
switch (mainModule.Runtime)
{
case TargetRuntime.Net_1_0:
output.WriteLine("// Runtime: .NET 1.0");
break;
case TargetRuntime.Net_1_1:
output.WriteLine("// Runtime: .NET 1.1");
break;
case TargetRuntime.Net_2_0:
output.WriteLine("// Runtime: .NET 2.0");
break;
case TargetRuntime.Net_4_0:
output.WriteLine("// Runtime: .NET 4.0");
break;
}
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, onlyAssemblyLevel: !options.FullDecompilation);
codeDomBuilder.RunTransformations(transformAbortCondition);
GenerateCode(codeDomBuilder, output);
}
}
}
