public string GetInfo(int indent, RolandMemory memory = null)
{
string pad = "";
for (var i = 0; i < indent; i++)
{
pad = pad + " ";
}
var desc = $"{GetTypeName()} {Name} ({Type})";
var data = GetDumpData(memory);
var dataStr = "";
if (data != null)
{
dataStr = $"Data: {data}";
}
var sizeFlag = "[O]";
if (IsAutoCalculatedSize)
{
sizeFlag = "[A]";
}
return($"{pad}{desc}".PadRight(60) + $"{ValuePath.PadRight(40)}" +
$"0x{StringUtils.Int32ToHexString(StartAddress)} - 0x{StringUtils.Int32ToHexString(EndAddress)} (Len {sizeFlag} 0x{Size:x8} FileAddr: 0x{FileAddress:x8} FileLen: 0x{FileSize:x4} {dataStr}");
}
public int GetValue(RolandMemory memory)
{
var val = memory.Get(StartAddress, GetPrimitiveTypeLength());
var intValue = GetValue(val, _primitiveTypeBits * (int)_primitiveTypeLength, 0);
return(intValue);
}
public virtual void DumpToPatchFile(RolandMemory memory, MemoryStream ms, RolandExportConfig exportConfig)
{
foreach (var subStruct in Structs)
{
subStruct.DumpToPatchFile(memory, ms, exportConfig);
}
foreach (var value in Values)
{
value.DumpToPatchFile(memory, ms, exportConfig);
}
}
public (bool, string) CompareAgainstFile(RolandMemory memory)
{
if (_primitiveTypeName == "string")
{
return(true, "");
}
var memVal = 0;
var retString = $"{Name} ";
if (memory.Has(StartAddress, GetPrimitiveTypeLength()))
{
var val = memory.Get(StartAddress, GetPrimitiveTypeLength());
memVal = GetValue(val, _primitiveTypeBits * (int)_primitiveTypeLength, 0);
retString += $"MemVal: 0x{memVal:x2} ";
}
else
{
if (int.TryParse(DefaultValue, out int defaultInt))
{
memVal = defaultInt;
retString += $"DefaultVal: 0x{memVal:x2} ";
}
else
{
retString += "NoDefaultVal/NoMemoryVal";
return(false, retString);
}
}
var data = memory.GetFromFile(FileAddress, _primitiveTypeLength);
if (data == null)
{
return(false, "file value does not exist");
}
var fileVal = RolandValueStruct.DecodeValueAsInt(data, _primitiveTypeLength, _primitiveTypeBits);
if (fileVal == memVal)
{
return(true, "");
}
else
{
retString += $" fileVal 0x{fileVal:x2}";
return(false, retString);
}
}
private string DumpInternal(int indent, RolandMemory memory = null)
{
var sb = new StringBuilder();
sb.AppendLine(GetInfo(indent, memory));
var dumpStuff = new Dictionary <int, List <string> >();
foreach (var subStruct in Structs)
{
if (!dumpStuff.ContainsKey(subStruct.StartAddress))
{
dumpStuff.Add(subStruct.StartAddress, new List <string>());
}
var dumpStr = subStruct.DumpInternal(indent + 1, memory);
dumpStuff[subStruct.StartAddress].Add(dumpStr);
}
foreach (var value in Values)
{
if (!dumpStuff.ContainsKey(value.StartAddress))
{
dumpStuff.Add(value.StartAddress, new List <string>());
}
var dumpStr = value.DumpInternal(indent + 1, memory);
dumpStuff[value.StartAddress].Add(dumpStr);
}
var addresses = dumpStuff.Keys.ToList();
addresses.Sort();
foreach (var address in addresses)
{
foreach (var dumpStr in dumpStuff[address])
{
sb.Append(dumpStr);
}
}
return(sb.ToString());
}
public List <string> CompareAgainstFileMemory(RolandMemory memory)
{
var errors = new List <string>();
foreach (var subStruct in Structs)
{
errors.AddRange(subStruct.CompareAgainstFileMemory(memory));
}
foreach (var value in Values)
{
var result = value.CompareAgainstFile(memory);
if (!result.Item1)
{
errors.Add(result.Item2);
}
}
return(errors);
}
public override void DumpToPatchFile(RolandMemory memory, MemoryStream ms, RolandExportConfig exportConfig)
{
/*if (!exportConfig.ExportZeroForInt1X7 && Type == "int1x7" && memVal == 0)
* {
*
* return;
* }*/
if (!exportConfig.ShouldExport(ValuePath))
{
return;
}
var rvs = ToRolandValueStruct();
var result = rvs.ConvertMemoryValue(memory);
if (result.address != null && result.data != null)
{
ms.Write(result.address, 0, 4);
ms.Write(result.data, 0, 4);
}
}
public virtual string GetDumpData(RolandMemory memory = null)
{
return(null);
}
public string GetInfo(RolandMemory memory = null)
{
return(GetInfo(0, memory));
}
public string Dump(RolandMemory memory = null)
{
return(DumpInternal(0, memory));
}
public bool HasValue(RolandMemory memory)
{
return(memory.Has(StartAddress, GetPrimitiveTypeLength()));
}
public override string GetDumpData(RolandMemory memory = null)
{
if (memory == null)
{
return(null);
}
var fileValueStr = "";
var valueStr = "";
var defaultStr = "";
var equalStr = "";
if (_primitiveTypeName == "int")
{
int?memVal = null;
int?fileVal = null;
int?defVal = null;
if (memory.Has(StartAddress, GetPrimitiveTypeLength()))
{
var val = memory.Get(StartAddress, GetPrimitiveTypeLength());
memVal = GetValue(val, _primitiveTypeBits * (int)_primitiveTypeLength, 0);
valueStr = $"MemVal: 0x{memVal:X} ({memVal})";
}
var data = memory.GetFromFile(FileAddress, _primitiveTypeLength);
if (data != null)
{
fileVal = RolandValueStruct.DecodeValueAsInt(data, _primitiveTypeLength, _primitiveTypeBits);
fileValueStr = $"FileVal: 0x{fileVal:X} ({fileVal})";
}
if (int.TryParse(DefaultValue, out int defaultInt))
{
defVal = defaultInt;
defaultStr = $"DefVal: 0x{defaultInt:X} ({defaultInt})";
}
if (fileVal != null)
{
if (memVal != null)
{
if (fileVal == memVal)
{
equalStr = "EQ";
}
}
else
{
if (fileVal == 0)
{
equalStr = "EQ?";
}
if (defVal != null)
{
if (fileVal == defVal)
{
equalStr = "EQ";
}
}
else
{
equalStr = "NODEFAULT";
}
}
}
return($"{valueStr.PadRight(25)} {fileValueStr.PadRight(25)} {defaultStr.PadRight(25)} {equalStr}");
}
return("");
throw new Exception(
$"RolandValue.GetDumpData: Don't know how to handle the primitive {_primitiveTypeName} for {Type}");
}
