public void UpdateMemory(VICERemoteDebugger.RequestData Request, GR.Memory.ByteBuffer Data)
{
int Offset = Request.Parameter1;
for (int i = 0; i < Data.Length; ++i)
{
byte ramByte = Data.ByteAt(i);
if (Request.Reason != VICERemoteDebugger.RequestReason.MEMORY_FETCH)
{
if (ramByte != m_ActiveMemory.RAM.ByteAt(Offset + i))
{
m_ActiveMemory.RAMChanged[Offset + i] = true;
hexView.SelectedByteProvider.SetByteSelectionState(Offset + i, true);
}
else
{
m_ActiveMemory.RAMChanged[Offset + i] = false;
hexView.SelectedByteProvider.SetByteSelectionState(Offset + i, false);
}
}
m_ActiveMemory.RAM.SetU8At(Offset + i, ramByte);
hexView.ByteProvider.WriteByte(Offset + i, ramByte);
}
ValidateMemory(Offset, (int)Data.Length);
hexView.Invalidate();
}
internal void UpdateMemory(VICERemoteDebugger.RequestData Request, ByteBuffer Data)
{
int Offset = Request.Parameter1;
for (int i = 0; i < Data.Length; ++i)
{
byte ramByte = Data.ByteAt(i);
if (Request.Reason != VICERemoteDebugger.RequestReason.MEMORY_FETCH)
{
if (ramByte != Core.Debugging.ActiveMemory.RAM.ByteAt(Offset + i))
{
Core.Debugging.ActiveMemory.RAMChanged[Offset + i] = true;
}
else
{
Core.Debugging.ActiveMemory.RAMChanged[Offset + i] = false;
}
}
Core.Debugging.ActiveMemory.RAM.SetU8At(Offset + i, ramByte);
}
ValidateMemory(Offset, (int)Data.Length);
foreach (var debugView in MemoryViews)
{
debugView.UpdateMemory(Request, Data);
}
}
public void UpdateValue(VICERemoteDebugger.RequestData WatchData, GR.Memory.ByteBuffer Data)
{
int delta = WatchData.AdjustedStartAddress - WatchData.Parameter1;
int expectedSize = (int)Data.Length;
if ((WatchData.MemDumpOffsetX) ||
(WatchData.MemDumpOffsetY))
{
delta -= WatchData.AppliedOffset;
}
if (WatchData.Parameter2 != -1)
{
expectedSize = WatchData.Parameter2 - WatchData.Parameter1 + 1;
}
if (delta > 0)
{
// offset had to be adjusted due to VICE weird binary offset/end offset format
if (delta < Data.Length)
{
UpdateValue(WatchData.Info, WatchData.MemDumpOffsetX, WatchData.MemDumpOffsetY, Data.SubBuffer(delta, expectedSize));
}
}
else if (expectedSize < Data.Length)
{
UpdateValue(WatchData.Info, WatchData.MemDumpOffsetX, WatchData.MemDumpOffsetY, Data.SubBuffer(0, expectedSize));
}
else
{
UpdateValue(WatchData.Info, WatchData.MemDumpOffsetX, WatchData.MemDumpOffsetY, Data);
}
}
public bool OnVirtualBreakpointReached(Types.Breakpoint Breakpoint)
{
Debug.Log("OnVirtualBreakpointReached");
bool addedRequest = false;
VICERemoteDebugger.RequestData prevRequest = null;
foreach (var virtualBP in Breakpoint.Virtual)
{
if (!virtualBP.IsVirtual)
{
continue;
}
var tokenInfos = Core.Compiling.ParserASM.ParseTokenInfo(virtualBP.Expression, 0, virtualBP.Expression.Length);
if (Core.Compiling.ParserASM.HasError())
{
Core.AddToOutput("Failed to ParseTokenInfo" + System.Environment.NewLine);
continue;
}
int result = -1;
if (!Core.Compiling.ParserASM.EvaluateTokens(-1, tokenInfos, out result))
{
Core.AddToOutput("Failed to evaluate " + virtualBP.Expression + System.Environment.NewLine);
continue;
}
if ((result < 0) ||
(result >= 65536))
{
Core.AddToOutput("Evaluated address out of range " + result + System.Environment.NewLine);
continue;
}
if (prevRequest != null)
{
prevRequest.LastInGroup = false;
}
int traceSize = 1;
var requData = Debugger.RefreshTraceMemory(result, result + traceSize - 1, virtualBP.Expression, virtualBP, Breakpoint);
if (requData.Parameter2 >= 0x10000)
{
requData.Parameter2 = 0xffff;
}
prevRequest = requData;
addedRequest = true;
}
if (!addedRequest)
{
// and auto-go on with debugging
Debugger.Run();
return(false);
}
return(true);
}
