public void CastTest()
{
ModuleAddress addr = new ModuleAddress(_context, _context.BaseAddress);
Assert.AreEqual(addr.Value, addr);
Assert.AreEqual(addr.Value, _context.BaseAddress);
}
public async Task <bool> GetRunningStateAsync(ModuleAddress module, ModuleChannel channel)
{
byte[] requset;
if (channel == ModuleChannel.CH1)
{
requset = MakeRetriveDataFrame((byte)module, RetrieveCommand.GetCh1Control);
}
else if (channel == ModuleChannel.CH2)
{
requset = MakeRetriveDataFrame((byte)module, RetrieveCommand.GetCh2Control);
}
else
{
throw new InvalidOperationException();
}
var response = await _commDriver.SendByteAsync(requset);
var address = response[AddressFieldIndex];
var functionCode = response[FunctionFieldIndex];
// Error Check
if ((functionCode & ErrorFlag) == 1)
{
var errorCode = (ErrorCodes)response[3];
throw new Exception($"Error Code: {errorCode.ToString()}");
}
else
{
var isRunning = ExtractDataFromDataFrame(response) == 0;
return(isRunning);
}
}
public void ConversionTest()
{
Assert.AreEqual(ModuleAddress.FromImageAddress(_context, _context.ImageBaseAddress), _context.BaseAddress);
Assert.AreEqual(ModuleAddress.ToImageAddress(_context, _context.BaseAddress), _context.ImageBaseAddress);
ModuleAddress addr = new ModuleAddress(_context, _context.BaseAddress);
Assert.AreEqual(addr.ToImageAddress(), _context.ImageBaseAddress);
}
public void End()
{
var start = new ModuleAddress(0x70);
var segment = new DataSegment(start, new byte[0x20]);
Assert.AreEqual(new ModuleAddress(0x110), segment.End);
}
public void ConversionTest()
{
Assert.AreEqual(ModuleAddress.FromImageAddress(_context, _context.ImageBaseAddress), _context.BaseAddress);
Assert.AreEqual(ModuleAddress.ToImageAddress(_context, _context.BaseAddress), _context.ImageBaseAddress);
ModuleAddress addr = new ModuleAddress(_context, _context.BaseAddress);
Assert.AreEqual(addr.ToImageAddress(), _context.ImageBaseAddress);
}
private async Task <DataSegment> LoadSegment(ModuleAddress address, int size, CancellationToken token)
{
var timerToken = new CancellationTokenSource(TimeSpan.FromSeconds(1)).Token;
var effectiveToken = CancellationTokenSource.CreateLinkedTokenSource(token, timerToken).Token;
var data = await device.RequestDataAsync(address.DisplayValue, size, effectiveToken);
return(new DataSegment(address, data));
}
public void GetData_Simple()
{
var start = new ModuleAddress(0x10);
var segment = new DataSegment(start, new byte[] { 1, 2, 3 });
Assert.AreEqual(1, segment[start]);
Assert.AreEqual(2, segment[start + 1]);
Assert.AreEqual(3, segment[start + 2]);
}
private void Research(GameProcess game)
{
ModuleAddress fmodPatchAddress = new DefaultDictionary <GameVersion, ModuleAddress>(game.Version)
{
[GameVersion.Alpha] = ModuleAddress.FromImageAddress(game.ModuleContext, 0x140DA75),
[GameVersion.Latest] = ModuleAddress.FromImageAddress(game.ModuleContext, 0xFAA9E5)
};
game.Memory.WriteByte(fmodPatchAddress, 0x2);
}
protected override async Task <int> InvokeAsync(InvocationContext context, IStandardStreamWriter console, RolandMidiClient client)
{
var schema = ModuleSchema.KnownSchemas[ModuleIdentifier.AE10].Value;
var instrumentField = schema.PhysicalRoot.ResolveField("TemporaryStudioSet/Part[1]/Instrument");
var instrumentDataField = new EnumDataField((EnumField)instrumentField);
// Presets
client.SendData(0x01_00_00_05, new byte[] { 64 });
for (int i = 1; i <= 128; i++)
{
await ShowStudioSet('P', i);
}
// Preset 129 is in a different bank...
client.SendData(0x01_00_00_05, new byte[] { 65 });
for (int i = 129; i <= 129; i++)
{
await ShowStudioSet('P', i);
}
// User sets
client.SendData(0x01_00_00_05, new byte[] { 0 });
for (int i = 1; i <= 100; i++)
{
await ShowStudioSet('U', i);
}
async Task ShowStudioSet(char prefix, int index)
{
client.SendData(0x01_00_00_06, new byte[] { (byte)((index - 1) & 0x7f) });
await Task.Delay(50);
var common = await client.RequestDataAsync(0x18_00_00_00, 16, CancellationToken.None);
string name = Encoding.UTF8.GetString(common);
console.WriteLine($"{prefix}:{index:D3}: {name}");
for (int partIndex = 0; partIndex < 4; partIndex++)
{
var part = await client.RequestDataAsync(0x18_00_20_00 + partIndex * 0x1_00, 9, CancellationToken.None);
if (part[1] != 1)
{
continue;
}
// The address doesn't matter, as only the offset is passed.
var segment = new DataSegment(ModuleAddress.FromDisplayValue(0), part);
instrumentDataField.Load(segment);
console.WriteLine($"Part {partIndex + 1}: {instrumentDataField.Value}");
}
console.WriteLine();
}
return(0);
}
public void GetData_7BitBoundary()
{
var start = new ModuleAddress(0x70);
var segment = new DataSegment(start, Enumerable.Range(0, 0x20).Select(x => (byte)x).ToArray());
Assert.AreEqual(0, segment[new ModuleAddress(0x70)]);
Assert.AreEqual(0xf, segment[new ModuleAddress(0x7f)]);
// We skip 0x80-0xff.
Assert.AreEqual(0x10, segment[new ModuleAddress(0x100)]);
Assert.AreEqual(0x1f, segment[new ModuleAddress(0x10f)]);
}
/// <summary>
/// Creates a new snapshot with all the segments in this one, but relocated
/// such that the data is <paramref name="from"/> is moved to <paramref name="to"/>
/// (and all other data is offset by the same amount).
/// </summary>
internal ModuleDataSnapshot Relocated(ModuleAddress from, ModuleAddress to)
{
var offset = to.LogicalValue - from.LogicalValue;
var snapshot = new ModuleDataSnapshot();
foreach (var segment in Segments)
{
snapshot.Add(segment.WithAddress(segment.Address.PlusLogicalOffset(offset)));
}
return(snapshot);
}
private void btnScan_Click(object sender, EventArgs e)
{
txtResults.Clear();
lblStatus.ForeColor = Color.Red;
byte[] patternBytes;
try
{
patternBytes = HexStringToByteArray(txtPattern.Text.Trim());
}
catch
{
lblStatus.Text = "Invalid pattern format.";
return;
}
byte[] maskBytes = null;
try
{
if (txtMask.TextLength > 0)
{
maskBytes = HexStringToByteArray(txtMask.Text.Trim());
}
}
catch
{
lblStatus.Text = "Invalid mask format.";
return;
}
if (maskBytes != null && patternBytes.Length != maskBytes.Length)
{
lblStatus.Text = "Mask length must match pattern length when specified.";
return;
}
// TODO: in the better implementation check for too short of a pattern, or not enough mask bits, issuing a warning that too many results may be returned
var results = Scanner.SimpleScan(patternBytes, maskBytes);
StringBuilder sb = new StringBuilder();
foreach (var result in results)
{
uint imageAddress = ModuleAddress.ToImageAddress(Game.ModuleContext, result);
uint processAddress = result;
sb.AppendLine(string.Format("0x{0} | 0x{1}", Convert.ToString(imageAddress, 16).ToUpperInvariant().PadLeft(8, '0'),
Convert.ToString(processAddress, 16).ToUpperInvariant().PadLeft(8, '0')));
}
txtResults.Text = sb.ToString();
lblStatus.ResetForeColor();
lblStatus.Text = $"{results.Count} result{(results.Count == 1 ? string.Empty : "s")} found.";
}
public void Contains()
{
var start = new ModuleAddress(0x70);
var segment = new DataSegment(start, Enumerable.Range(0, 0x20).Select(x => (byte)x).ToArray());
Assert.IsFalse(segment.Contains(new ModuleAddress(0x6f)));
Assert.IsTrue(segment.Contains(new ModuleAddress(0x70)));
Assert.IsTrue(segment.Contains(new ModuleAddress(0x7f)));
Assert.IsTrue(segment.Contains(new ModuleAddress(0x100)));
Assert.IsTrue(segment.Contains(new ModuleAddress(0x10f)));
Assert.IsFalse(segment.Contains(new ModuleAddress(0x110)));
}
protected override async Task <int> InvokeAsync(InvocationContext context, IStandardStreamWriter console, RolandMidiClient client)
{
var address = ModuleAddress.FromDisplayValue(HexInt32.Parse(context.ParseResult.ValueForOption <string>("address")).Value);
var size = HexInt32.Parse(context.ParseResult.ValueForOption <string>("size")).Value;
var timeout = context.ParseResult.ValueForOption <int>("timeout");
// Wait up to 10 seconds to receive all the requested data...
int sizeReceived = 0;
var delayTask = Task.Delay(TimeSpan.FromSeconds(timeout));
var completeTaskCts = new TaskCompletionSource <int>();
client.DataSetMessageReceived += DumpMessage;
client.SendDataRequestMessage(address.DisplayValue, size);
await Task.WhenAny(delayTask, completeTaskCts.Task);
return(0);
void DumpMessage(object sender, DataSetMessage message)
{
ModuleAddress address = ModuleAddress.FromDisplayValue(message.Address);
console.WriteLine($"Address: {address} Length: {message.Length:x4}");
int index = 0;
while (index < message.Length)
{
var builder = new StringBuilder();
var textBuilder = new StringBuilder();
builder.Append(address);
builder.Append(" ");
for (int i = 0; i < 16 && index < message.Length; i++)
{
byte b = message.Data[index];
textBuilder.Append(b >= 32 && b < 127 ? (char)b : ' ');
builder.Append(b.ToString("x2"));
builder.Append(" ");
index++;
}
string text = builder.ToString().PadRight(9 + 16 * 3) + textBuilder;
console.WriteLine(text);
address = address.PlusLogicalOffset(16);
}
console.WriteLine();
if (Interlocked.Add(ref sizeReceived, message.Length) >= size)
{
completeTaskCts.SetResult(0);
}
}
}
public void CreationTest()
{
ModuleAddress addr = new ModuleAddress(_context, _context.BaseAddress);
Assert.AreEqual(addr.Context, _context);
Assert.AreEqual(addr.Value, _context.BaseAddress);
new ModuleAddress(_context, _context.BaseAddress + _context.Size);
try
{
new ModuleAddress(_context, _context.BaseAddress - 1);
Assert.Fail();
}
catch { /* before valid range */ }
try
{
new ModuleAddress(_context, _context.BaseAddress + _context.Size + 1);
Assert.Fail();
}
catch { /* past valid range */ }
try
{
new ModuleAddressContext(0x400000, 0x700000, 0);
Assert.Fail();
}
catch { /* zero size */ }
try
{
new ModuleAddressContext(uint.MaxValue - 1, 0, 10);
Assert.Fail();
}
catch { /* image address overflow */ }
try
{
new ModuleAddressContext(0, uint.MaxValue - 1, 10);
Assert.Fail();
}
catch { /* module address overflow */ }
}
public void CreationTest()
{
ModuleAddress addr = new ModuleAddress(_context, _context.BaseAddress);
Assert.AreEqual(addr.Context, _context);
Assert.AreEqual(addr.Value, _context.BaseAddress);
new ModuleAddress(_context, _context.BaseAddress + _context.Size);
try
{
new ModuleAddress(_context, _context.BaseAddress - 1);
Assert.Fail();
}
catch { /* before valid range */ }
try
{
new ModuleAddress(_context, _context.BaseAddress + _context.Size + 1);
Assert.Fail();
}
catch { /* past valid range */}
try
{
new ModuleAddressContext(0x400000, 0x700000, 0);
Assert.Fail();
}
catch { /* zero size */ }
try
{
new ModuleAddressContext(uint.MaxValue - 1, 0, 10);
Assert.Fail();
}
catch { /* image address overflow */ }
try
{
new ModuleAddressContext(0, uint.MaxValue - 1, 10);
Assert.Fail();
}
catch { /* module address overflow */ }
}
internal IEnumerable <IContainer> ToContainers(ModuleSchema schema, ModuleJson module, ModuleAddress parentAddress, string?parentPath, SchemaVariables variables)
{
variables = variables.WithVariables(ExtraVariables);
ModuleOffset offset = ModuleOffset.FromDisplayValue(Offset.Value);
if (Repeat is null)
{
yield return(resolvedContainer.ToContainer(schema, module, ResolvedName, ResolvedDescription,
parentAddress + offset, parentPath, variables));
}
else
{
int gap = ModuleOffset.FromDisplayValue(Repeat.Gap.Value).LogicalValue;
foreach (var tuple in module.GetRepeatSequence(Repeat.Items, variables))
{
var itemVariables = variables.WithVariable(Repeat.IndexVariable, tuple.index, Repeat.IndexTemplate);
var formattedDescription = tuple.variables.Replace(ResolvedDescription);
var formattedName = Invariant($"{ResolvedName}[{tuple.index}]");
yield return(resolvedContainer.ToContainer(schema, module, formattedName, formattedDescription,
parentAddress + offset, parentPath, itemVariables));
offset += gap;
}
}
}
public DataSegment(ModuleAddress address, byte[] data) => (Address, this.data) = (address, data);
private protected ContainerBase(ModuleSchema schema, string name, string description, ModuleAddress address, string path) => (Schema, Name, Description, Address, Path) = (schema, name, description, address, path);
protected override async Task <int> InvokeAsync(InvocationContext context, IStandardStreamWriter console, RolandMidiClient client)
{
using var writer = File.CreateText(context.ParseResult.ValueForOption <string>("file"));
int chunkSize = context.ParseResult.ValueForOption <int>("chunkSize");
TimeSpan timeout = TimeSpan.FromMilliseconds(context.ParseResult.ValueForOption <int>("timeout"));
var address = ModuleAddress.FromDisplayValue(0);
int messagesReceived = 0;
client.DataSetMessageReceived += DumpMessage;
// TODO: Make this tighter. But we're unlikely to really get here.
while (address.DisplayValue < 0x74_00_00_00)
{
int receivedAtStartOfChunk = messagesReceived;
client.SendDataRequestMessage(address.DisplayValue, chunkSize);
int receivedAtStartOfDelay;
do
{
receivedAtStartOfDelay = messagesReceived;
await Task.Delay(timeout);
} while (messagesReceived > receivedAtStartOfDelay);
int receivedForChunk = messagesReceived - receivedAtStartOfChunk;
console.WriteLine($"Received {receivedForChunk} messages in chunk at {address}");
writer.Flush();
address = address.PlusLogicalOffset(chunkSize);
}
return(0);
void DumpMessage(object sender, DataSetMessage message)
{
ModuleAddress address = ModuleAddress.FromDisplayValue(message.Address);
writer.WriteLine($"Address: {address} Length: {message.Length:x4}");
int index = 0;
while (index < message.Length)
{
var builder = new StringBuilder();
var textBuilder = new StringBuilder();
builder.Append(address);
builder.Append(" ");
for (int i = 0; i < 16 && index < message.Length; i++)
{
byte b = message.Data[index];
textBuilder.Append(b >= 32 && b < 127 ? (char)b : ' ');
builder.Append(b.ToString("x2"));
builder.Append(" ");
index++;
}
string text = builder.ToString().PadRight(9 + 16 * 3) + textBuilder;
writer.WriteLine(text);
address = address.PlusLogicalOffset(16);
}
writer.WriteLine();
Interlocked.Increment(ref messagesReceived);
}
}
public bool TryGetSegment(ModuleAddress address, out DataSegment segment) => segmentsByAddress.TryGetValue(address, out segment);
internal DataSegment this[ModuleAddress address] => segmentsByAddress[address];
public ValidationError(string path, ModuleAddress address, IField field, string message) => (Path, Address, Field, Message) = (path, address, field, message);
public void CastTest()
{
ModuleAddress addr = new ModuleAddress(_context, _context.BaseAddress);
Assert.AreEqual(addr.Value, addr);
Assert.AreEqual(addr.Value, _context.BaseAddress);
}
public IContainer ToContainer(ModuleSchema schema, ModuleJson module, string name, string description, ModuleAddress address, string?parentPath, SchemaVariables variables)
{
string path = PathUtilities.AppendPath(parentPath, name);
if (Fields is object)
{
var fieldList = requiresOverlayResolution ? resolvedFields.Select(FinalizeField) : resolvedFields;
var realSize = ModuleOffset.FromDisplayValue(Size.Value).LogicalValue;
return(new FieldContainer(schema, name, description, address, path, realSize, fieldList));
FieldBase FinalizeField(FieldBase field) =>
field is OverlayField overlay?overlay.WithPath(variables.Replace(overlay.SwitchPath)) : field;
}
else
{
var containers = new List <IContainer>();
foreach (var container in Containers)
{
containers.AddRange(container.ToContainers(schema, module, address, path, variables));
}
return(new ContainerContainer(schema, name, description, address, path, containers));
}
}
internal FieldContainer(ModuleSchema schema, string name, string description, ModuleAddress address, string path,
int size, IEnumerable <FieldBase> fields)
: base(schema, name, description, address, path)
{
Fields = fields.ToReadOnlyList(field => field.WithParent(this));
Size = size;
fieldsByName = Lazy.Create(() => Fields.ToDictionary(f => f.Name).AsReadOnly());
}
internal FieldContainer(ModuleSchema schema, string name, string description, ModuleAddress address, string path,
int size, IReadOnlyList <IField> fields)
: base(schema, name, description, address, path) =>
(Size, Fields, FieldsByName) = (size, fields, fields.ToDictionary(f => f.Name).AsReadOnly());
public FixedContainer(Container container, ModuleAddress address) => (Container, Address) = (container, address);
internal ContainerContainer(ModuleSchema schema, string name, string description, ModuleAddress address, string path, List <IContainer> containers)
: base(schema, name, description, address, path)
{
Containers = containers;
foreach (ContainerBase container in Containers)
{
container.Parent = this;
}
ContainersByName = Containers.ToDictionary(c => c.Name).AsReadOnly();
}
internal DataSegment ToModel() => new DataSegment(ModuleAddress.FromDisplayValue(Address), Data.ToByteArray());
