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

ditto for Memory library

This commit is contained in:
adelikat 2014-01-26 02:43:28 +00:00
parent 94d20e92f4
commit 988ed03198
3 changed files with 298 additions and 156 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
BizHawk.Client.Common/lua/EmuLuaLibrary.MainMemory.cs
View File

@ -225,11 +225,10 @@ namespace BizHawk.Client.Common
)] )]
public void WriteFloat(object address, object value, bool bigendian) public void WriteFloat(object address, object value, bool bigendian)
{ {
var addr = LuaInt(address);
var dv = (float)(double)value; var dv = (float)(double)value;
var bytes = BitConverter.GetBytes(dv); var bytes = BitConverter.GetBytes(dv);
var v = BitConverter.ToUInt32(bytes, 0); var v = BitConverter.ToUInt32(bytes, 0);
Global.Emulator.MemoryDomains.MainMemory.PokeDWord(addr, v, bigendian); Global.Emulator.MemoryDomains.MainMemory.PokeDWord(LuaInt(address), v, bigendian);
} }
[LuaMethodAttributes( [LuaMethodAttributes(
@ -366,7 +365,7 @@ namespace BizHawk.Client.Common
{ {
WriteUnsignedByte( WriteUnsignedByte(
LuaInt(addr), LuaInt(addr),
LuaUInt(value) (uint)LuaInt(value)
); );
} }

447
BizHawk.Client.Common/lua/EmuLuaLibrary.Memory.cs
View File

@ -59,133 +59,164 @@ namespace BizHawk.Client.Common
private static int U2S(uint u, int size) private static int U2S(uint u, int size)
{ {
int s = (int)u; var s = (int)u;
s <<= 8 * (4 - size); s <<= 8 * (4 - size);
s >>= 8 * (4 - size); s >>= 8 * (4 - size);
return s; return s;
} }
private int M_R_S_LE(int addr, int size) private int ReadSignedLittleCore(int addr, int size)
{ {
return U2S(M_R_U_LE(addr, size), size); return U2S(ReadUnsignedLittle(addr, size), size);
} }
private uint M_R_U_LE(int addr, int size) private uint ReadUnsignedLittle(int addr, int size)
{ {
uint v = 0; uint v = 0;
for (int i = 0; i < size; ++i) for (var i = 0; i < size; ++i)
v |= M_R_U8(addr + i) << 8 * i; {
v |= ReadUnsignedByte(addr + i) << (8 * i);
}
return v; return v;
} }
private int M_R_S_BE(int addr, int size) private int ReadSignedBig(int addr, int size)
{ {
return U2S(M_R_U_BE(addr, size), size); return U2S(ReadUnsignedBig(addr, size), size);
} }
private uint M_R_U_BE(int addr, int size) private uint ReadUnsignedBig(int addr, int size)
{ {
uint v = 0; uint v = 0;
for (int i = 0; i < size; ++i) for (var i = 0; i < size; ++i)
{ {
v |= M_R_U8(addr + i) << 8 * (size - 1 - i); v |= ReadUnsignedByte(addr + i) << (8 * (size - 1 - i));
} }
return v; return v;
} }
private void M_W_S_LE(int addr, int v, int size) private void WriteSignedLittle(int addr, int v, int size)
{ {
M_W_U_LE(addr, (uint)v, size); WriteUnsignedLittle(addr, (uint)v, size);
} }
private void M_W_U_LE(int addr, uint v, int size) private void WriteUnsignedLittle(int addr, uint v, int size)
{ {
for (int i = 0; i < size; ++i) for (var i = 0; i < size; ++i)
{ {
M_W_U8(addr + i, (v >> (8 * i)) & 0xFF); WriteUnsignedByte(addr + i, (v >> (8 * i)) & 0xFF);
} }
} }
private void M_W_S_BE(int addr, int v, int size) private void WriteSignedBig(int addr, int v, int size)
{ {
M_W_U_BE(addr, (uint)v, size); WriteUnsignedBig(addr, (uint)v, size);
} }
private void M_W_U_BE(int addr, uint v, int size) private void WriteUnsignedBig(int addr, uint v, int size)
{ {
for (int i = 0; i < size; ++i) for (var i = 0; i < size; ++i)
M_W_U8(addr + i, (v >> (8 * (size - 1 - i))) & 0xFF); {
WriteUnsignedByte(addr + i, (v >> (8 * (size - 1 - i))) & 0xFF);
}
} }
private uint M_R_U8(int addr) private uint ReadUnsignedByte(int addr)
{ {
return Global.Emulator.MemoryDomains[_currentMemoryDomain].PeekByte(addr); return Global.Emulator.MemoryDomains[_currentMemoryDomain].PeekByte(addr);
} }
private void M_W_U8(int addr, uint v) private void WriteUnsignedByte(int addr, uint v)
{ {
Global.Emulator.MemoryDomains[_currentMemoryDomain].PokeByte(addr, (byte)v); Global.Emulator.MemoryDomains[_currentMemoryDomain].PokeByte(addr, (byte)v);
} }
#endregion #endregion
public string memory_getmemorydomainlist() [LuaMethodAttributes(
"getmemorydomainlist",
"TODO"
)]
public string GetMemoryDomainList()
{ {
return Global.Emulator.MemoryDomains.Aggregate("", (current, t) => current + (t.Name + '\n')); return Global.Emulator.MemoryDomains.Aggregate(String.Empty, (current, t) => current + (t.Name + '\n'));
} }
public string memory_getcurrentmemorydomain() [LuaMethodAttributes(
"getcurrentmemorydomain",
"TODO"
)]
public string GetCurrentMemoryDomain()
{ {
return Global.Emulator.MemoryDomains[_currentMemoryDomain].Name; return Global.Emulator.MemoryDomains[_currentMemoryDomain].Name;
} }
public int memory_getcurrentmemorydomainsize() [LuaMethodAttributes(
"getcurrentmemorydomainsize",
"TODO"
)]
public int GetCurrentMemoryDomainSize()
{ {
return Global.Emulator.MemoryDomains[_currentMemoryDomain].Size; return Global.Emulator.MemoryDomains[_currentMemoryDomain].Size;
} }
public uint memory_readbyte(object lua_addr) [LuaMethodAttributes(
"readbyte",
"TODO"
)]
public uint ReadByte(object addr)
{ {
int addr = LuaInt(lua_addr); return ReadUnsignedByte(LuaInt(addr));
return M_R_U8(addr);
} }
public float memory_readfloat(object lua_addr, bool bigendian) [LuaMethodAttributes(
"readfloat",
"TODO"
)]
public float ReadFloat(object addr, bool bigendian)
{ {
int addr = LuaInt(lua_addr); var val = Global.Emulator.MemoryDomains[_currentMemoryDomain].PeekDWord(LuaInt(addr), bigendian);
uint val = Global.Emulator.MemoryDomains[_currentMemoryDomain].PeekDWord(addr, bigendian); var bytes = BitConverter.GetBytes(val);
return BitConverter.ToSingle(bytes, 0);
byte[] bytes = BitConverter.GetBytes(val);
float _float = BitConverter.ToSingle(bytes, 0);
return _float;
} }
public void memory_writebyte(object lua_addr, object lua_v) [LuaMethodAttributes(
"writebyte",
"TODO"
)]
public void WriteByte(object addr, object value)
{ {
int addr = LuaInt(lua_addr); WriteUnsignedByte(
uint v = LuaUInt(lua_v); LuaInt(addr),
M_W_U8(addr, v); LuaUInt(value)
);
} }
public void memory_writefloat(object lua_addr, object lua_v, bool bigendian) [LuaMethodAttributes(
"writefloat",
"TODO"
)]
public void WriteFloat(object addr, object value, bool bigendian)
{ {
int addr = LuaInt(lua_addr); var dv = (float)(double)value;
float dv = (float)(double)lua_v; var bytes = BitConverter.GetBytes(dv);
byte[] bytes = BitConverter.GetBytes(dv); var v = BitConverter.ToUInt32(bytes, 0);
uint v = BitConverter.ToUInt32(bytes, 0); Global.Emulator.MemoryDomains[_currentMemoryDomain].PokeDWord(LuaInt(addr), v, bigendian);
Global.Emulator.MemoryDomains[_currentMemoryDomain].PokeDWord(addr, v, bigendian);
} }
public bool memory_usememorydomain(object lua_input) [LuaMethodAttributes(
"usememorydomain",
"TODO"
)]
public bool UseMemoryDomain(string domain)
{ {
if (lua_input.GetType() != typeof(string)) for (var i = 0; i < Global.Emulator.MemoryDomains.Count; i++)
return false;
for (int x = 0; x < Global.Emulator.MemoryDomains.Count; x++)
{ {
if (Global.Emulator.MemoryDomains[x].Name == lua_input.ToString()) if (Global.Emulator.MemoryDomains[i].Name == domain)
{ {
_currentMemoryDomain = x; _currentMemoryDomain = i;
return true; return true;
} }
} }
@ -193,186 +224,298 @@ namespace BizHawk.Client.Common
return false; return false;
} }
public int memory_read_s8(object lua_addr) [LuaMethodAttributes(
"read_s8",
"TODO"
)]
public int ReadS8(object addr)
{ {
int addr = LuaInt(lua_addr); return (sbyte)ReadUnsignedByte(LuaInt(addr));
return (sbyte)M_R_U8(addr);
} }
public uint memory_read_u8(object lua_addr) [LuaMethodAttributes(
"read_u8",
"TODO"
)]
public uint ReadU8(object addr)
{ {
int addr = LuaInt(lua_addr); return ReadUnsignedByte(LuaInt(addr));
return M_R_U8(addr);
} }
public int memory_read_s16_le(object lua_addr) [LuaMethodAttributes(
"read_s16_le",
"TODO"
)]
public int ReadS16Little(object addr)
{ {
int addr = LuaInt(lua_addr); return ReadSignedLittleCore(LuaInt(addr), 2);
return M_R_S_LE(addr, 2);
} }
public int memory_read_s24_le(object lua_addr) [LuaMethodAttributes(
"read_s24_le",
"TODO"
)]
public int ReadS24Little(object addr)
{ {
int addr = LuaInt(lua_addr); return ReadSignedLittleCore(LuaInt(addr), 3);
return M_R_S_LE(addr, 3);
} }
public int memory_read_s32_le(object lua_addr) [LuaMethodAttributes(
"read_s32_le",
"TODO"
)]
public int ReadS32Little(object addr)
{ {
int addr = LuaInt(lua_addr); return ReadSignedLittleCore(LuaInt(addr), 4);
return M_R_S_LE(addr, 4);
} }
public uint memory_read_u16_le(object lua_addr) [LuaMethodAttributes(
"read_u16_le",
"TODO"
)]
public uint ReadU16Little(object addr)
{ {
int addr = LuaInt(lua_addr); return ReadUnsignedLittle(LuaInt(addr), 2);
return M_R_U_LE(addr, 2);
} }
public uint memory_read_u24_le(object lua_addr) [LuaMethodAttributes(
"read_u24_le",
"TODO"
)]
public uint ReadU24Little(object addr)
{ {
int addr = LuaInt(lua_addr); return ReadUnsignedLittle(LuaInt(addr), 3);
return M_R_U_LE(addr, 3);
} }
public uint memory_read_u32_le(object lua_addr) [LuaMethodAttributes(
"read_u32_le",
"TODO"
)]
public uint ReadU32Little(object addr)
{ {
int addr = LuaInt(lua_addr); return ReadUnsignedLittle(LuaInt(addr), 4);
return M_R_U_LE(addr, 4);
} }
public int memory_read_s16_be(object lua_addr) [LuaMethodAttributes(
"read_s16_be",
"TODO"
)]
public int ReadS16Big(object addr)
{ {
int addr = LuaInt(lua_addr); return ReadSignedBig(LuaInt(addr), 2);
return M_R_S_BE(addr, 2);
} }
public int memory_read_s24_be(object lua_addr) [LuaMethodAttributes(
"read_s24_be",
"TODO"
)]
public int ReadS24Big(object addr)
{ {
int addr = LuaInt(lua_addr); return ReadSignedBig(LuaInt(addr), 3);
return M_R_S_BE(addr, 3);
} }
public int memory_read_s32_be(object lua_addr) [LuaMethodAttributes(
"read_s32_be",
"TODO"
)]
public int ReadS32Big(object addr)
{ {
int addr = LuaInt(lua_addr); return ReadSignedBig(LuaInt(addr), 4);
return M_R_S_BE(addr, 4);
} }
public uint memory_read_u16_be(object lua_addr) [LuaMethodAttributes(
"read_u16_be",
"TODO"
)]
public uint ReadU16Big(object addr)
{ {
int addr = LuaInt(lua_addr); return ReadUnsignedBig(LuaInt(addr), 2);
return M_R_U_BE(addr, 2);
} }
public uint memory_read_u24_be(object lua_addr) [LuaMethodAttributes(
"read_u24_be",
"TODO"
)]
public uint ReadU24Big(object addr)
{ {
int addr = LuaInt(lua_addr); return ReadUnsignedBig(LuaInt(addr), 3);
return M_R_U_BE(addr, 3);
} }
public uint memory_read_u32_be(object lua_addr) [LuaMethodAttributes(
"u32_be",
"TODO"
)]
public uint ReadU32Big(object addr)
{ {
int addr = LuaInt(lua_addr); return ReadUnsignedBig(LuaInt(addr), 4);
return M_R_U_BE(addr, 4);
} }
public void memory_write_s8(object lua_addr, object lua_v) [LuaMethodAttributes(
"write_s8",
"TODO"
)]
public void WriteS8(object addr, object value)
{ {
int addr = LuaInt(lua_addr); WriteUnsignedByte(
int v = LuaInt(lua_v); LuaInt(addr),
M_W_U8(addr, (uint)v); (uint)LuaInt(value)
);
} }
public void memory_write_u8(object lua_addr, object lua_v) [LuaMethodAttributes(
"write_s8",
"TODO"
)]
public void WriteU8(object addr, object value)
{ {
int addr = LuaInt(lua_addr); WriteUnsignedByte(
uint v = LuaUInt(lua_v); LuaInt(addr),
M_W_U8(addr, v); LuaUInt(value)
);
} }
public void memory_write_s16_le(object lua_addr, object lua_v) [LuaMethodAttributes(
"write_s16_le",
"TODO"
)]
public void WriteS16Little(object addr, object value)
{ {
int addr = LuaInt(lua_addr); WriteSignedLittle(
int v = LuaInt(lua_v); LuaInt(addr),
M_W_S_LE(addr, v, 2); LuaInt(value),
2);
} }
public void memory_write_s24_le(object lua_addr, object lua_v) [LuaMethodAttributes(
"write_s24_le",
"TODO"
)]
public void WriteS24Little(object addr, object value)
{ {
int addr = LuaInt(lua_addr); WriteSignedLittle(
int v = LuaInt(lua_v); LuaInt(addr),
M_W_S_LE(addr, v, 3); LuaInt(value),
3);
} }
public void memory_write_s32_le(object lua_addr, object lua_v) [LuaMethodAttributes(
"write_s32_le",
"TODO"
)]
public void WriteS32Little(object addr, object value)
{ {
int addr = LuaInt(lua_addr); WriteSignedLittle(
int v = LuaInt(lua_v); LuaInt(addr),
M_W_S_LE(addr, v, 4); LuaInt(value),
4);
} }
public void memory_write_u16_le(object lua_addr, object lua_v) [LuaMethodAttributes(
"write_u16_le",
"TODO"
)]
public void WriteU16Little(object addr, object value)
{ {
int addr = LuaInt(lua_addr); WriteUnsignedLittle(
uint v = LuaUInt(lua_v); LuaInt(addr),
M_W_U_LE(addr, v, 2); LuaUInt(value),
2);
} }
public void memory_write_u24_le(object lua_addr, object lua_v) [LuaMethodAttributes(
"write_u24_le",
"TODO"
)]
public void WriteU24Little(object addr, object value)
{ {
int addr = LuaInt(lua_addr); WriteUnsignedLittle(
uint v = LuaUInt(lua_v); LuaInt(addr),
M_W_U_LE(addr, v, 3); LuaUInt(value),
3);
} }
public void memory_write_u32_le(object lua_addr, object lua_v) [LuaMethodAttributes(
"write_u32_le",
"TODO"
)]
public void WriteU32Little(object addr, object value)
{ {
int addr = LuaInt(lua_addr); WriteUnsignedLittle(
uint v = LuaUInt(lua_v); LuaInt(addr),
M_W_U_LE(addr, v, 4); LuaUInt(value),
4);
} }
public void memory_write_s16_be(object lua_addr, object lua_v) [LuaMethodAttributes(
"write_s16_be",
"TODO"
)]
public void WriteS16Big(object addr, object value)
{ {
int addr = LuaInt(lua_addr); WriteSignedBig(
int v = LuaInt(lua_v); LuaInt(addr),
M_W_S_BE(addr, v, 2); LuaInt(value),
2);
} }
public void memory_write_s24_be(object lua_addr, object lua_v) [LuaMethodAttributes(
"write_s24_be",
"TODO"
)]
public void WriteS24Big(object addr, object value)
{ {
int addr = LuaInt(lua_addr); WriteSignedBig(
int v = LuaInt(lua_v); LuaInt(addr),
M_W_S_BE(addr, v, 3); LuaInt(value),
3);
} }
public void memory_write_s32_be(object lua_addr, object lua_v) [LuaMethodAttributes(
"write_s32_be",
"TODO"
)]
public void WriteS32Big(object addr, object value)
{ {
int addr = LuaInt(lua_addr); WriteSignedBig(
int v = LuaInt(lua_v); LuaInt(addr),
M_W_S_BE(addr, v, 4); LuaInt(value),
4);
} }
public void memory_write_u16_be(object lua_addr, object lua_v) [LuaMethodAttributes(
"write_u16_be",
"TODO"
)]
public void WriteU16Big(object addr, object value)
{ {
int addr = LuaInt(lua_addr); WriteUnsignedBig(
uint v = LuaUInt(lua_v); LuaInt(addr),
M_W_U_BE(addr, v, 2); LuaUInt(value),
2);
} }
public void memory_write_u24_be(object lua_addr, object lua_v) [LuaMethodAttributes(
"write_u24_be",
"TODO"
)]
public void WriteU24Big(object addr, object value)
{ {
int addr = LuaInt(lua_addr); WriteUnsignedBig(
uint v = LuaUInt(lua_v); LuaInt(addr),
M_W_U_BE(addr, v, 3); LuaUInt(value),
3);
} }
public void memory_write_u32_be(object lua_addr, object lua_v) [LuaMethodAttributes(
"write_u32_be",
"TODO"
)]
public void WriteU32Big(object addr, object value)
{ {
int addr = LuaInt(lua_addr); WriteUnsignedBig(
uint v = LuaUInt(lua_v); LuaInt(addr),
M_W_U_BE(addr, v, 4); LuaUInt(value),
4);
} }
} }
} }

2
BizHawk.Client.EmuHawk/tools/Lua/Libraries/EmuLuaLibrary.cs
View File

@ -95,7 +95,7 @@ namespace BizHawk.Client.EmuHawk
_guiLibrary.LuaRegister(lua, Docs); _guiLibrary.LuaRegister(lua, Docs);
new InputLuaLibrary(_lua).LuaRegister(lua, Docs); new InputLuaLibrary(_lua).LuaRegister(lua, Docs);
new JoypadLuaLibrary(_lua).LuaRegisterNew(lua, Docs); new JoypadLuaLibrary(_lua).LuaRegisterNew(lua, Docs);
new MemoryLuaLibrary().LuaRegister(lua, Docs); new MemoryLuaLibrary().LuaRegisterNew(lua, Docs);
new MainMemoryLuaLibrary(_lua).LuaRegisterNew(lua, Docs); new MainMemoryLuaLibrary(_lua).LuaRegisterNew(lua, Docs);
new MovieLuaLibrary(_lua).LuaRegister(lua, Docs); new MovieLuaLibrary(_lua).LuaRegister(lua, Docs);
new NESLuaLibrary().LuaRegister(lua, Docs); new NESLuaLibrary().LuaRegister(lua, Docs);