public Decompiler(string spbFileUrl)
{
bank = SymbolBank.Instance;
FileStream fs = new FileStream(spbFileUrl, FileMode.Open);
reader = new BinaryReader(fs);
}
public TypeDef(XmlNode node)
: base(node)
{
// to resolve
SymbolBank bank = SymbolBank.Instance;
// find binding
foreach (XmlNode son in node.ChildNodes)
{
if (son.Name.Equals("binding"))
{
foreach (XmlNode bindingSon in son.ChildNodes)
{
if (bindingSon.Name.Equals("member"))
{
XmlAttributeCollection attrs = bindingSon.Attributes;
string memberTypeName = attrs["type"].Value;
string memberName = attrs["name"].Value;
if (memberTypeName != null)
{
TypeDef memberType = bank.LookupType(memberTypeName);
BindingMember member = new BindingMember(memberName, null);
}
}
}
// get binding type
mBindingType = son.Attributes["type"].Value;
}
}
}
public SymbolDef(string dirName, XmlNode node)
: base(node)
{
SymbolBank bank = SymbolBank.Instance;
foreach (XmlNode son in node.ChildNodes)
{
string sonName = son.Name;
if (sonName.Equals("SymbolInclude"))
{
string symbolFile = son.Attributes["filename"].Value;
bank.AddSymbolDefinitionFile(dirName + "\\" + symbolFile);
}
if (sonName.Equals("TypeDefs"))
{
// parse types
foreach (XmlNode typeNode in son.ChildNodes)
{
if (typeNode.Name.Equals("TypeDef"))
{
TypeDef type = new TypeDef(typeNode);
bank.AddType(type);
}
}
}
if (sonName.Equals("PropertyDefs"))
{
// parse properties
foreach (XmlNode propNode in son.ChildNodes)
{
if (propNode.Name.Equals("PropertyDef"))
{
PropertyDef prop = new PropertyDef(propNode);
prop.SymbolContext = this;
bank.AddProperty(prop);
}
}
}
if (sonName.Equals("SetDefs"))
{
// parse types
foreach (XmlNode setNode in son.ChildNodes)
{
if (setNode.Name.Equals("SetDef"))
{
SetDef set = new SetDef(setNode);
set.Parent = this;
bank.AddSet(set);
}
}
}
}
}
public PropertyDef(XmlNode node)
: base(node)
{
SymbolBank bank = SymbolBank.Instance;
// just the attribute
XmlAttribute attr = node.Attributes["xml_io"];
if (attr != null)
{
if ("attribute".Equals(attr.Value, StringComparison.InvariantCultureIgnoreCase))
{
mIsAttribute = true;
}
}
attr = node.Attributes["type"];
if (attr != null)
{
Type = bank.LookupType(attr.Value);
}
attr = node.Attributes["Type"];
if (attr != null)
{
Type = bank.LookupType(attr.Value);
}
foreach (XmlNode son in node.ChildNodes)
{
if (son.Name.Equals("EnumDef"))
{
mEnum = new EnumDef(son);
// set type to enu
}
}
}
static void Main(string[] args)
{
string simPropSearchPath = null;
string file = null;
string outFileName = null;
string modelsDescName = null;
bool verbose = false;
// big command line loop
for (int i = 0; i < args.Length; i++)
{
string s = args[i];
if ("-h".Equals(s, StringComparison.InvariantCultureIgnoreCase))
{
PrintHelp();
return;
}
else if ("-s".Equals(s, StringComparison.InvariantCultureIgnoreCase))
{
if (i == (args.Length - 1))
{
Console.WriteLine("Error: must specify simprop search path");
return;
}
simPropSearchPath = args[++i];
}
else if ("-m".Equals(s, StringComparison.InvariantCultureIgnoreCase))
{
if (i == (args.Length - 1))
{
Console.WriteLine("Error: must library models file path");
return;
}
modelsDescName = args[++i];
}
else if ("-v".Equals(s))
{
verbose = true;
}
else if (file == null)
{
file = s;
}
else if (outFileName == null)
{
outFileName = s;
}
else
{
Console.WriteLine("Error: unexpected argument {0}", s);
return;
}
}
//
// init simprop data
//
var cacheFn = "propdefs.cache";
var exeDir = AppDomain.CurrentDomain.BaseDirectory;
var cachePath = Path.Combine(exeDir, cacheFn);
if (File.Exists(cachePath))
{
Console.WriteLine("Search property definition files from cache");
using (var f = File.OpenRead(cachePath))
{
var sb = (SymbolBank) new BinaryFormatter().Deserialize(f);
SymbolBank.Instance = sb;
}
}
else
{
if (simPropSearchPath is null)
{
#if DEBUG
simPropSearchPath = @"g:\MSFS Base\Packages\fs-base-propdefs\Propdefs\1.0\";
#else
Console.WriteLine("Error: MSFS not found, you should specify simprop search path with -s");
return;
#endif
}
Console.WriteLine("Search property definition files in {0}", simPropSearchPath);
//
// parse all propdefs
//
SymbolBank sb = SymbolBank.Instance;
DirectoryInfo cdi = new DirectoryInfo(simPropSearchPath);
foreach (FileInfo fi in cdi.GetFiles("*.xml"))
{
if (verbose)
{
Console.WriteLine("Add property definition file {0}", fi.Name);
}
try
{
sb.AddSymbolDefinitionFile(fi.FullName);
}
catch (Exception ex)
{
Console.WriteLine("Warning: Cannot parse property definition file {0}", fi.FullName);
if (verbose)
{
Console.WriteLine("\t {0}", ex.Message);
}
}
}
using (var f = File.Create(cachePath))
{
new BinaryFormatter().Serialize(f, SymbolBank.Instance);
}
}
Console.WriteLine();
//
// force culture to us (better printing)
//
Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US");
//
// models bank
//
ModelBank mb = null;
if (modelsDescName != null)
{
try
{
mb = new ModelBank(modelsDescName);
if (verbose)
{
Console.WriteLine("Read {0} models descriptions", mb.Size());
}
}
catch (Exception e)
{
if (verbose)
{
Console.WriteLine("Cannot read models bank file: {0}", e.Message);
}
}
}
if (file is null)
{
foreach (var f in Directory.GetFiles(".", "*.spb", SearchOption.AllDirectories))
{
Decompile(f, null);
}
}
else
{
Decompile(file, outFileName);
}
void Decompile(string f, string outFN)
{
//
// ok for the real thing
//
try
{
if (outFN == null)
{
// guess it from name
int i = f.LastIndexOf('.');
if (i != -1)
{
outFN = f.Substring(0, i) + ".xml";
}
else
{
outFN = f + ".xml";
}
}
using (Stream output = new FileStream(outFN, FileMode.Create))
{
Decompiler dec = new Decompiler(f);
if (mb != null)
{
dec.SetModels(mb);
}
dec.Decompile(output);
}
if (outFN != null)
{
Console.WriteLine("Wrote to {0}", outFN);
}
}
catch (Exception e)
{
Console.WriteLine("Error: cannot decompile file {0} ({1})", f, e.Message);
if (outFN != null)
{
File.Delete(outFN);
}
}
}
}
