ShuriZma
/
BizHawk
mirror of https://github.com/TASEmulators/BizHawk.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

phase 1 of changing memory callback api to specify domain - require cores to specify which domains are available and have the domain passed in when creating callbacks. Still todo - cores need to pass in domain name on CallReads/Writes/Executes methods

This commit is contained in:
adelikat 2017-08-01 22:05:17 -05:00
parent b8d1a19d7e
commit 04ce66c397
26 changed files with 95 additions and 39 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

39
BizHawk.Client.Common/lua/EmuLuaLibrary.Events.cs
View File

@ -22,6 +22,9 @@ namespace BizHawk.Client.Common
[RequiredService]
private IEmulator Emulator { get; set; }
[OptionalService]
private IMemoryDomains Domains { get; set; }
private readonly LuaFunctionList _luaFunctions = new LuaFunctionList();
public EventLuaLibrary(Lua lua)
@ -210,7 +213,7 @@ namespace BizHawk.Client.Common
}
[LuaMethod("onmemoryexecute", "Fires after the given address is executed by the core")]
public string OnMemoryExecute(LuaFunction luaf, uint address, string name = null)
public string OnMemoryExecute(LuaFunction luaf, uint address, string name = null, string domain = null)
{
try
{
@ -225,8 +228,16 @@ namespace BizHawk.Client.Common
var nlf = new NamedLuaFunction(luaf, "OnMemoryExecute", LogOutputCallback, CurrentThread, name);
_luaFunctions.Add(nlf);
if (string.IsNullOrWhiteSpace(domain))
{
if (Domains != null && Domains.HasSystemBus)
{
domain = Domains.SystemBus.Name;
}
}
DebuggableCore.MemoryCallbacks.Add(
new MemoryCallback(MemoryCallbackType.Execute, "Lua Hook", nlf.Callback, address, null));
new MemoryCallback(domain, MemoryCallbackType.Execute, "Lua Hook", nlf.Callback, address, null));
return nlf.Guid.ToString();
}
}
@ -241,7 +252,7 @@ namespace BizHawk.Client.Common
}
[LuaMethod("onmemoryread", "Fires after the given address is read by the core. If no address is given, it will attach to every memory read")]
public string OnMemoryRead(LuaFunction luaf, uint? address = null, string name = null)
public string OnMemoryRead(LuaFunction luaf, uint? address = null, string name = null, string domain = null)
{
try
{
@ -255,8 +266,16 @@ namespace BizHawk.Client.Common
var nlf = new NamedLuaFunction(luaf, "OnMemoryRead", LogOutputCallback, CurrentThread, name);
_luaFunctions.Add(nlf);
if (string.IsNullOrWhiteSpace(domain))
{
if (Domains != null && Domains.HasSystemBus)
{
domain = Domains.SystemBus.Name;
}
}
DebuggableCore.MemoryCallbacks.Add(
new MemoryCallback(MemoryCallbackType.Read, "Lua Hook", nlf.Callback, address, null));
new MemoryCallback(domain, MemoryCallbackType.Read, "Lua Hook", nlf.Callback, address, null));
return nlf.Guid.ToString();
}
}
@ -271,7 +290,7 @@ namespace BizHawk.Client.Common
}
[LuaMethod("onmemorywrite", "Fires after the given address is written by the core. If no address is given, it will attach to every memory write")]
public string OnMemoryWrite(LuaFunction luaf, uint? address = null, string name = null)
public string OnMemoryWrite(LuaFunction luaf, uint? address = null, string name = null, string domain = null)
{
try
{
@ -285,8 +304,16 @@ namespace BizHawk.Client.Common
var nlf = new NamedLuaFunction(luaf, "OnMemoryWrite", LogOutputCallback, CurrentThread, name);
_luaFunctions.Add(nlf);
if (string.IsNullOrWhiteSpace(domain))
{
if (Domains != null && Domains.HasSystemBus)
{
domain = Domains.SystemBus.Name;
}
}
DebuggableCore.MemoryCallbacks.Add(
new MemoryCallback(MemoryCallbackType.Write, "Lua Hook", nlf.Callback, address, null));
new MemoryCallback(domain, MemoryCallbackType.Write, "Lua Hook", nlf.Callback, address, null));
return nlf.Guid.ToString();
}
}

16
BizHawk.Client.EmuHawk/tools/Debugger/Breakpoint.cs
View File

@ -9,9 +9,9 @@ namespace BizHawk.Client.EmuHawk
{
public Action Callback { get; set; }
public void Add(IDebuggable core, uint address, uint mask, MemoryCallbackType type)
public void Add(IDebuggable core, string domain, uint address, uint mask, MemoryCallbackType type)
{
Add(new Breakpoint(core, Callback, address, mask, type));
Add(new Breakpoint(core, domain, Callback, address, mask, type));
}
public new void Clear()
@ -69,8 +69,9 @@ namespace BizHawk.Client.EmuHawk
private bool _active;
private readonly IDebuggable _core;
public Breakpoint(bool readOnly, IDebuggable core, Action callBack, uint address, uint mask, MemoryCallbackType type, bool enabled = true)
public Breakpoint(bool readOnly, IDebuggable core, string domain, Action callBack, uint address, uint mask, MemoryCallbackType type, bool enabled = true)
{
Domain = domain;
_core = core;
Type = type;
Callback = callBack;
@ -82,8 +83,9 @@ namespace BizHawk.Client.EmuHawk
ReadOnly = readOnly;
}
public Breakpoint(IDebuggable core, Action callBack, uint address, uint mask, MemoryCallbackType type, bool enabled = true)
public Breakpoint(IDebuggable core, string domain, Action callBack, uint address, uint mask, MemoryCallbackType type, bool enabled = true)
{
Domain = domain;
_core = core;
Type = type;
Callback = callBack;
@ -94,8 +96,9 @@ namespace BizHawk.Client.EmuHawk
Active = enabled;
}
public Breakpoint(string name, bool readOnly, IDebuggable core, Action callBack, uint address, uint mask, MemoryCallbackType type, bool enabled = true)
public Breakpoint(string name, bool readOnly, IDebuggable core, string domain, Action callBack, uint address, uint mask, MemoryCallbackType type, bool enabled = true)
{
Domain = domain;
_core = core;
Type = type;
Callback = callBack;
@ -107,6 +110,7 @@ namespace BizHawk.Client.EmuHawk
ReadOnly = readOnly;
}
public string Domain { get; }
public Action Callback { get; }
public uint? Address { get; set; }
public uint? AddressMask { get; set; }
@ -159,7 +163,7 @@ namespace BizHawk.Client.EmuHawk
private void AddCallback()
{
_core.MemoryCallbacks.Add(new MemoryCallback(Type, Name, Callback, Address, AddressMask));
_core.MemoryCallbacks.Add(new MemoryCallback(Domain, Type, Name, Callback, Address, AddressMask));
}
private void RemoveCallback()

8
BizHawk.Client.EmuHawk/tools/Debugger/BreakpointControl.cs
View File

@ -144,7 +144,7 @@ namespace BizHawk.Client.EmuHawk
public void AddBreakpoint(uint address, uint mask, MemoryCallbackType type)
{
_breakpoints.Add(Core, address, mask, type);
_breakpoints.Add(Core, MemoryDomains.SystemBus.Name, address, mask, type);
BreakpointView.ItemCount = _breakpoints.Count;
UpdateBreakpointRemoveButton();
@ -157,7 +157,7 @@ namespace BizHawk.Client.EmuHawk
if (b.ShowHawkDialog() == DialogResult.OK)
{
_breakpoints.Add(Core, b.Address, b.AddressMask, b.BreakType);
_breakpoints.Add(Core, MemoryDomains.SystemBus.Name, b.Address, b.AddressMask, b.BreakType);
}
BreakpointView.ItemCount = _breakpoints.Count;
@ -170,7 +170,7 @@ namespace BizHawk.Client.EmuHawk
public void AddSeekBreakpoint(uint pcVal, int pcBitSize)
{
var name = SeekName + pcVal.ToHexString(pcBitSize / 4);
_breakpoints.Add(new Breakpoint(name, true, Core, SeekCallback, pcVal, 0xFFFFFFFF, MemoryCallbackType.Execute));
_breakpoints.Add(new Breakpoint(name, true, Core, MemoryDomains.SystemBus.Name, SeekCallback, pcVal, 0xFFFFFFFF, MemoryCallbackType.Execute));
}
public void RemoveCurrentSeek()
@ -284,7 +284,7 @@ namespace BizHawk.Client.EmuHawk
if (b.ShowHawkDialog() == DialogResult.OK)
{
_breakpoints.Add(new Breakpoint(Core, breakpoint.Callback, b.Address, b.AddressMask, b.BreakType, breakpoint.Active));
_breakpoints.Add(new Breakpoint(Core, MemoryDomains.SystemBus.Name, breakpoint.Callback, b.Address, b.AddressMask, b.BreakType, breakpoint.Active));
}
}

2
BizHawk.Client.EmuHawk/tools/Debugger/GenericDebugger.IToolForm.cs
View File

@ -15,7 +15,7 @@ namespace BizHawk.Client.EmuHawk
[OptionalService]
private IDisassemblable Disassembler { get; set; }
[OptionalService]
[RequiredService]
private IMemoryDomains MemoryDomains { get; set; }
private IMemoryCallbackSystem MemoryCallbacks { get { return Debuggable.MemoryCallbacks; } }

2
BizHawk.Emulation.Common/Base Implementations/CallbackBasedTraceBuffer.cs
View File

@ -94,6 +94,8 @@ namespace BizHawk.Emulation.Common
public uint? Address => null;
public uint? AddressMask => null;
public string Domain => ""; // This will be relevant if/when the trace logger can trace anything other than the system bus
}
}
}

19
BizHawk.Emulation.Common/Base Implementations/MemoryCallbackSystem.cs
View File

@ -14,8 +14,14 @@ namespace BizHawk.Emulation.Common
/// <seealso cref="IMemoryCallbackSystem" />
public class MemoryCallbackSystem : IMemoryCallbackSystem
{
public MemoryCallbackSystem()
public MemoryCallbackSystem(string[] availableDomains)
{
if (availableDomains == null)
{
availableDomains = new[] { "System Bus" };
}
AvailableDomains = availableDomains;
ExecuteCallbacksAvailable = true;
_reads.CollectionChanged += OnCollectionChanged;
@ -35,8 +41,15 @@ namespace BizHawk.Emulation.Common
public bool ExecuteCallbacksAvailable { get; }
public string[] AvailableDomains { get; }
public void Add(IMemoryCallback callback)
{
if (!AvailableDomains.Contains(callback.Domain))
{
throw new InvalidOperationException($"{callback.Domain} is not currently supported for callbacks");
}
switch (callback.Type)
{
case MemoryCallbackType.Execute:
@ -273,7 +286,7 @@ namespace BizHawk.Emulation.Common
public class MemoryCallback : IMemoryCallback
{
public MemoryCallback(MemoryCallbackType type, string name, Action callback, uint? address, uint? mask)
public MemoryCallback(string domain, MemoryCallbackType type, string name, Action callback, uint? address, uint? mask)
{
if (type == MemoryCallbackType.Execute && !address.HasValue)
{
@ -285,6 +298,7 @@ namespace BizHawk.Emulation.Common
Callback = callback;
Address = address;
AddressMask = mask ?? 0xFFFFFFFF;
Domain = domain;
}
public MemoryCallbackType Type { get; }
@ -292,5 +306,6 @@ namespace BizHawk.Emulation.Common
public Action Callback { get; }
public uint? Address { get; }
public uint? AddressMask { get; }
public string Domain { get; }
}
}

8
BizHawk.Emulation.Common/Interfaces/IMemoryCallbackSystem.cs
View File

@ -42,6 +42,7 @@ namespace BizHawk.Emulation.Common
/// If no address is specified the callback will be hooked to all addresses
/// Note: an execute callback can not be added without an address, else an InvalidOperationException will occur
/// </summary>
/// <exception cref="InvalidCastException">Thrown when the <see cref="IMemoryCallback.Domain"/> property of the <see cref="IMemoryCallback"/> is not in the <see cref="AvailableDomains"/></exception>
void Add(IMemoryCallback callback);
/// <summary>
@ -73,6 +74,12 @@ namespace BizHawk.Emulation.Common
/// Removes all read,write, and execute callbacks
/// </summary>
void Clear();
/// <summary>
/// A list of available memory domains that a the <see cref="IMemoryCallback.Domain"/> property of the <see cref="IMemoryCallback"/> can have
/// Passing a <see cref="IMemoryCallback"/> into the <see cref="Add(IMemoryCallback)"/> method that is not in this list will result in an <seealso cref="InvalidOperationException"/>
/// </summary>
string[] AvailableDomains { get; }
}
/// <summary>
@ -86,6 +93,7 @@ namespace BizHawk.Emulation.Common
Action Callback { get; }
uint? Address { get; }
uint? AddressMask { get; }
string Domain { get; }
}
public enum MemoryCallbackType

2
BizHawk.Emulation.Cores/Calculator/TI83.IDebuggable.cs
View File

@ -120,7 +120,7 @@ namespace BizHawk.Emulation.Cores.Calculators
}
}
public IMemoryCallbackSystem MemoryCallbacks { get; } = new MemoryCallbackSystem();
public IMemoryCallbackSystem MemoryCallbacks { get; } = new MemoryCallbackSystem(new[] { "System Bus" });
[FeatureNotImplemented]
public void Step(StepType type)

2
BizHawk.Emulation.Cores/Computers/AppleII/AppleII.IDebuggable.cs
View File

@ -73,7 +73,7 @@ namespace BizHawk.Emulation.Cores.Computers.AppleII
}
}
public IMemoryCallbackSystem MemoryCallbacks { get; } = new MemoryCallbackSystem();
public IMemoryCallbackSystem MemoryCallbacks { get; } = new MemoryCallbackSystem(new[] { "System Bus" });
public bool CanStep(StepType type)
{

2
BizHawk.Emulation.Cores/Computers/Commodore64/C64.cs
View File

@ -32,7 +32,7 @@ namespace BizHawk.Emulation.Cores.Computers.Commodore64
Init(SyncSettings.VicType, Settings.BorderType, SyncSettings.SidType, SyncSettings.TapeDriveType, SyncSettings.DiskDriveType);
_cyclesPerFrame = _board.Vic.CyclesPerFrame;
_memoryCallbacks = new MemoryCallbackSystem();
_memoryCallbacks = new MemoryCallbackSystem(new[] { "System Bus" });
HardReset();

2
BizHawk.Emulation.Cores/Computers/Commodore64/MOS/Chip6510.IDebuggable.cs
View File

@ -148,6 +148,6 @@ namespace BizHawk.Emulation.Cores.Computers.Commodore64.MOS
private const byte JsrSize = 3;
IMemoryCallbackSystem IDebuggable.MemoryCallbacks { get; } = new MemoryCallbackSystem();
IMemoryCallbackSystem IDebuggable.MemoryCallbacks { get; } = new MemoryCallbackSystem(new[] { "System Bus" });
}
}

2
BizHawk.Emulation.Cores/Consoles/Atari/2600/Atari2600.IDebuggable.cs
View File

@ -56,7 +56,7 @@ namespace BizHawk.Emulation.Cores.Atari.Atari2600
}
}
public IMemoryCallbackSystem MemoryCallbacks { get; } = new MemoryCallbackSystem();
public IMemoryCallbackSystem MemoryCallbacks { get; } = new MemoryCallbackSystem(new[] { "System Bus" });
public bool CanStep(StepType type)
{

2
BizHawk.Emulation.Cores/Consoles/Atari/A7800Hawk/A7800Hawk.IDebuggable.cs
View File

@ -54,7 +54,7 @@ namespace BizHawk.Emulation.Cores.Atari.A7800Hawk
}
}
public IMemoryCallbackSystem MemoryCallbacks { get; } = new MemoryCallbackSystem();
public IMemoryCallbackSystem MemoryCallbacks { get; } = new MemoryCallbackSystem(new[] { "System Bus" });
public bool CanStep(StepType type)
{

2
BizHawk.Emulation.Cores/Consoles/Coleco/ColecoVision.cs
View File

@ -17,7 +17,7 @@ namespace BizHawk.Emulation.Cores.ColecoVision
{
var ser = new BasicServiceProvider(this);
ServiceProvider = ser;
MemoryCallbacks = new MemoryCallbackSystem();
MemoryCallbacks = new MemoryCallbackSystem(new[] { "System Bus" });
CoreComm = comm;
_syncSettings = (ColecoSyncSettings)syncSettings ?? new ColecoSyncSettings();
bool skipbios = _syncSettings.SkipBiosIntro;

2
BizHawk.Emulation.Cores/Consoles/Intellivision/Intellivision.IDebuggable.cs
View File

@ -82,7 +82,7 @@ namespace BizHawk.Emulation.Cores.Intellivision
}
}
public IMemoryCallbackSystem MemoryCallbacks { get; } = new MemoryCallbackSystem();
public IMemoryCallbackSystem MemoryCallbacks { get; } = new MemoryCallbackSystem(new[] { "System Bus" });
public bool CanStep(StepType type)
{

2
BizHawk.Emulation.Cores/Consoles/Nintendo/GBA/VBANext.IDebuggable.cs
View File

@ -23,7 +23,7 @@ namespace BizHawk.Emulation.Cores.Nintendo.GBA
return false;
}
private readonly MemoryCallbackSystem _memorycallbacks = new MemoryCallbackSystem();
private readonly MemoryCallbackSystem _memorycallbacks = new MemoryCallbackSystem(new[] { "System Bus" });
public IMemoryCallbackSystem MemoryCallbacks => _memorycallbacks;
[FeatureNotImplemented]

2
BizHawk.Emulation.Cores/Consoles/Nintendo/Gameboy/Gambatte.IDebuggable.cs
View File

@ -56,7 +56,7 @@ namespace BizHawk.Emulation.Cores.Nintendo.Gameboy
private LibGambatte.MemoryCallback _writecb;
private LibGambatte.MemoryCallback _execcb;
private MemoryCallbackSystem _memorycallbacks = new MemoryCallbackSystem();
private MemoryCallbackSystem _memorycallbacks = new MemoryCallbackSystem(new[] { "System Bus" });
/// <summary>
/// for use in dual core

2
BizHawk.Emulation.Cores/Consoles/Nintendo/Gameboy/GambatteLink.IDebuggable.cs
View File

@ -50,6 +50,6 @@ namespace BizHawk.Emulation.Cores.Nintendo.Gameboy
get { throw new NotImplementedException(); }
}
private readonly MemoryCallbackSystem _memorycallbacks = new MemoryCallbackSystem();
private readonly MemoryCallbackSystem _memorycallbacks = new MemoryCallbackSystem(new[] { "System Bus" });
}
}

2
BizHawk.Emulation.Cores/Consoles/Nintendo/N64/N64.IDebuggable.cs
View File

@ -82,7 +82,7 @@ namespace BizHawk.Emulation.Cores.Nintendo.N64
get { return _memorycallbacks; }
}
private readonly MemoryCallbackSystem _memorycallbacks = new MemoryCallbackSystem();
private readonly MemoryCallbackSystem _memorycallbacks = new MemoryCallbackSystem(new[] { "System Bus" });
public bool CanStep(StepType type)
{

2
BizHawk.Emulation.Cores/Consoles/Nintendo/NES/NES.cs
View File

@ -36,7 +36,7 @@ namespace BizHawk.Emulation.Cores.Nintendo.NES
ControllerSettings = SyncSettings.Controls;
CoreComm = comm;
MemoryCallbacks = new MemoryCallbackSystem();
MemoryCallbacks = new MemoryCallbackSystem(new[] { "System Bus" });
BootGodDB.Initialize();
videoProvider = new MyVideoProvider(this);
Init(game, rom, fdsbios);

2
BizHawk.Emulation.Cores/Consoles/Nintendo/SNES/LibsnesCore.IDebuggable.cs
View File

@ -55,7 +55,7 @@ namespace BizHawk.Emulation.Cores.Nintendo.SNES
throw new NotImplementedException();
}
public IMemoryCallbackSystem MemoryCallbacks { get; } = new MemoryCallbackSystem();
public IMemoryCallbackSystem MemoryCallbacks { get; } = new MemoryCallbackSystem(new[] { "System Bus" });
public bool CanStep(StepType type)
{

4
BizHawk.Emulation.Cores/Consoles/PC Engine/PCEngine.cs
View File

@ -22,7 +22,7 @@ namespace BizHawk.Emulation.Cores.PCEngine
[CoreConstructor("PCE", "SGX")]
public PCEngine(CoreComm comm, GameInfo game, byte[] rom, object settings, object syncSettings)
{
MemoryCallbacks = new MemoryCallbackSystem();
MemoryCallbacks = new MemoryCallbackSystem(new[] { "System Bus" });
CoreComm = comm;
switch (game.System)
@ -53,7 +53,7 @@ namespace BizHawk.Emulation.Cores.PCEngine
public PCEngine(CoreComm comm, GameInfo game, Disc disc, object Settings, object syncSettings)
{
CoreComm = comm;
MemoryCallbacks = new MemoryCallbackSystem();
MemoryCallbacks = new MemoryCallbackSystem(new[] { "System Bus" });
DriveLightEnabled = true;
SystemId = "PCECD";
Type = NecSystemType.TurboCD;

2
BizHawk.Emulation.Cores/Consoles/Sega/SMS/SMS.cs
View File

@ -33,7 +33,7 @@ namespace BizHawk.Emulation.Cores.Sega.MasterSystem
Settings = (SMSSettings)settings ?? new SMSSettings();
SyncSettings = (SMSSyncSettings)syncSettings ?? new SMSSyncSettings();
CoreComm = comm;
MemoryCallbacks = new MemoryCallbackSystem();
MemoryCallbacks = new MemoryCallbackSystem(new[] { "System Bus" });
IsGameGear = game.System == "GG";
IsSG1000 = game.System == "SG";

2
BizHawk.Emulation.Cores/Consoles/Sega/gpgx64/GPGX.IDebuggable.cs
View File

@ -52,7 +52,7 @@ namespace BizHawk.Emulation.Cores.Consoles.Sega.gpgx
get { throw new NotImplementedException(); }
}
private readonly MemoryCallbackSystem _memoryCallbacks = new MemoryCallbackSystem();
private readonly MemoryCallbackSystem _memoryCallbacks = new MemoryCallbackSystem(new[] { "M68K BUS" });
private LibGPGX.mem_cb ExecCallback;
private LibGPGX.mem_cb ReadCallback;

2
BizHawk.Emulation.Cores/Consoles/Sony/PSX/Octoshock.IDebuggable.cs
View File

@ -80,7 +80,7 @@ namespace BizHawk.Emulation.Cores.Sony.PSX
OctoshockDll.shock_SetRegister_CPU(psx, index, (uint)value);
}
private readonly MemoryCallbackSystem _memoryCallbacks = new MemoryCallbackSystem();
private readonly MemoryCallbackSystem _memoryCallbacks = new MemoryCallbackSystem(new[] { "System Bus" }); // Note: there is no system bus memory domain, but there's also no hard rule that the memory callback system domains have to correspond to actual domains in MemoryDomains, that could be good, or bad, but something to be careful about
public IMemoryCallbackSystem MemoryCallbacks { get { return _memoryCallbacks; } }
public bool CanStep(StepType type) { return false; }

2
BizHawk.Emulation.Cores/Consoles/WonderSwan/WonderSwan.cs
View File

@ -104,7 +104,7 @@ namespace BizHawk.Emulation.Cores.WonderSwan
private readonly InputCallbackSystem _inputCallbacks = new InputCallbackSystem();
public IInputCallbackSystem InputCallbacks { get { return _inputCallbacks; } }
private readonly MemoryCallbackSystem _memorycallbacks = new MemoryCallbackSystem();
private readonly MemoryCallbackSystem _memorycallbacks = new MemoryCallbackSystem(new[] { "System Bus" }); // This isn't an actual memory domain in this core (yet), but there's nothing that enforces that it has to be
public IMemoryCallbackSystem MemoryCallbacks { get { return _memorycallbacks; } }
public IDictionary<string, RegisterValue> GetCpuFlagsAndRegisters()