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

Lua - new register system for Main Memory library and a bunch of cleanup for that lib

This commit is contained in:
adelikat 2014-01-26 01:48:32 +00:00
parent c6859a6d4f
commit 94d20e92f4
2 changed files with 287 additions and 149 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -65,327 +65,465 @@ 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 MM_R_S_LE(int addr, int size) private static int ReadSignedLittleCore(int addr, int size)
{ {
return U2S(MM_R_U_LE(addr, size), size); return U2S(ReadSignedLittle(addr, size), size);
} }
private uint MM_R_U_LE(int addr, int size) private static uint ReadSignedLittle(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 |= MM_R_U8(addr + i) << 8 * i; v |= ReadUnsignedByte(addr + i) << (8 * i);
} }
return v; return v;
} }
private int MM_R_S_BE(int addr, int size) private static int ReadSignedBig(int addr, int size)
{ {
return U2S(MM_R_U_BE(addr, size), size); return U2S(ReadUnsignedBig(addr, size), size);
} }
private uint MM_R_U_BE(int addr, int size) private static 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 |= MM_R_U8(addr + i) << 8 * (size - 1 - i); v |= ReadUnsignedByte(addr + i) << (8 * (size - 1 - i));
} }
return v; return v;
} }
private void MM_W_S_LE(int addr, int v, int size) private static void WriteSignedLittle(int addr, int v, int size)
{ {
MM_W_U_LE(addr, (uint)v, size); WriteUnsignedLittle(addr, (uint)v, size);
} }
private void MM_W_U_LE(int addr, uint v, int size) private static void WriteUnsignedLittle(int addr, uint v, int size)
{ {
for (int i = 0; i < size; ++i) for (var i = 0; i < size; ++i)
{ {
MM_W_U8(addr + i, (v >> (8 * i)) & 0xFF); WriteUnsignedByte(addr + i, (v >> (8 * i)) & 0xFF);
} }
} }
private void MM_W_S_BE(int addr, int v, int size) private static void WriteSignedBig(int addr, int v, int size)
{ {
MM_W_U_BE(addr, (uint)v, size); WriteUnsignedBig(addr, (uint)v, size);
} }
private void MM_W_U_BE(int addr, uint v, int size) private static void WriteUnsignedBig(int addr, uint v, int size)
{ {
for (int i = 0; i < size; ++i) for (var i = 0; i < size; ++i)
{ {
MM_W_U8(addr + i, (v >> (8 * (size - 1 - i))) & 0xFF); WriteUnsignedByte(addr + i, (v >> (8 * (size - 1 - i))) & 0xFF);
} }
} }
private uint MM_R_U8(int addr) private static uint ReadUnsignedByte(int addr)
{ {
return Global.Emulator.MemoryDomains.MainMemory.PeekByte(addr); return Global.Emulator.MemoryDomains.MainMemory.PeekByte(addr);
} }
private void MM_W_U8(int addr, uint v) private static void WriteUnsignedByte(int addr, uint v)
{ {
Global.Emulator.MemoryDomains.MainMemory.PokeByte(addr, (byte)v); Global.Emulator.MemoryDomains.MainMemory.PokeByte(addr, (byte)v);
} }
#endregion #endregion
public string mainmemory_getname() [LuaMethodAttributes(
"getname",
"TODO"
)]
public string GetName()
{ {
return Global.Emulator.MemoryDomains.MainMemory.Name; return Global.Emulator.MemoryDomains.MainMemory.Name;
} }
public uint mainmemory_readbyte(object lua_addr) [LuaMethodAttributes(
"readbyte",
"TODO"
)]
public uint ReadByte(object addr)
{ {
int addr = LuaInt(lua_addr); return ReadUnsignedByte(LuaInt(addr));
return MM_R_U8(addr);
} }
public LuaTable mainmemory_readbyterange(object address, object length) [LuaMethodAttributes(
"readbyterange",
"TODO"
)]
public LuaTable ReadByteRange(object address, object length)
{ {
int l = LuaInt(length); var addr = LuaInt(address);
int addr = LuaInt(address); var lastAddr = LuaInt(length) + addr;
int last_addr = l + addr;
var table = _lua.NewTable(); var table = _lua.NewTable();
for (int i = addr; i <= last_addr; i++) for (var i = addr; i <= lastAddr; i++)
{ {
var a = String.Format("{0:X2}", i); var a = String.Format("{0:X2}", i);
var v = Global.Emulator.MemoryDomains.MainMemory.PeekByte(i); var v = Global.Emulator.MemoryDomains.MainMemory.PeekByte(i);
var vs = String.Format("{0:X2}", (int)v); var vs = String.Format("{0:X2}", (int)v);
table[a] = vs; table[a] = vs;
} }
return table; return table;
} }
public float mainmemory_readfloat(object lua_addr, bool bigendian) [LuaMethodAttributes(
"readfloat",
"TODO"
)]
public float ReadFloat(object addr, bool bigendian)
{ {
var addr = LuaInt(lua_addr); var val = Global.Emulator.MemoryDomains.MainMemory.PeekDWord(LuaInt(addr), bigendian);
uint val = Global.Emulator.MemoryDomains.MainMemory.PeekDWord(addr, bigendian);
var bytes = BitConverter.GetBytes(val); var bytes = BitConverter.GetBytes(val);
var _float = BitConverter.ToSingle(bytes, 0); var _float = BitConverter.ToSingle(bytes, 0);
return _float; return _float;
} }
public void mainmemory_writebyte(object lua_addr, object lua_v) [LuaMethodAttributes(
"writebyte",
"TODO"
)]
public void WriteByte(object addr, object value)
{ {
var addr = LuaInt(lua_addr); WriteUnsignedByte(
var v = LuaUInt(lua_v); LuaInt(addr),
MM_W_U8(addr, v); LuaUInt(value)
);
} }
public void mainmemory_writebyterange(LuaTable memoryblock) [LuaMethodAttributes(
"writebyterange",
"TODO"
)]
public void WriteByteRange(LuaTable memoryblock)
{ {
foreach (var address in memoryblock.Keys) foreach (var address in memoryblock.Keys)
{ {
int a = LuaInt(address); Global.Emulator.MemoryDomains.MainMemory.PokeByte(
int v = LuaInt(memoryblock[address]); LuaInt(address),
(byte)LuaInt(memoryblock[address])
Global.Emulator.MemoryDomains.MainMemory.PokeByte(a, (byte)v); );
} }
} }
public void mainmemory_writefloat(object lua_addr, object lua_v, bool bigendian) [LuaMethodAttributes(
"writefloat",
"TODO"
)]
public void WriteFloat(object address, object value, bool bigendian)
{ {
var addr = LuaInt(lua_addr); var addr = LuaInt(address);
var dv = (float)(double)lua_v; var dv = (float)(double)value;
var bytes = BitConverter.GetBytes(dv); var bytes = BitConverter.GetBytes(dv);
uint v = BitConverter.ToUInt32(bytes, 0); var v = BitConverter.ToUInt32(bytes, 0);
Global.Emulator.MemoryDomains.MainMemory.PokeDWord(addr, v, bigendian); Global.Emulator.MemoryDomains.MainMemory.PokeDWord(addr, v, bigendian);
} }
[LuaMethodAttributes(
public int mainmemory_read_s8(object lua_addr) "read_s8",
"TODO"
)]
public int ReadS8(object addr)
{ {
var addr = LuaInt(lua_addr); return (sbyte)ReadUnsignedByte(LuaInt(addr));
return (sbyte)MM_R_U8(addr);
} }
public uint mainmemory_read_u8(object lua_addr) [LuaMethodAttributes(
"read_u8",
"TODO"
)]
public uint ReadU8(object addr)
{ {
var addr = LuaInt(lua_addr); return ReadUnsignedByte(LuaInt(addr));
return MM_R_U8(addr);
} }
public int mainmemory_read_s16_le(object lua_addr) [LuaMethodAttributes(
"read_s16_le",
"TODO"
)]
public int ReadS16Little(object addr)
{ {
var addr = LuaInt(lua_addr); return ReadSignedLittleCore(LuaInt(addr), 2);
return MM_R_S_LE(addr, 2);
} }
public int mainmemory_read_s24_le(object lua_addr) [LuaMethodAttributes(
"read_s24_le",
"TODO"
)]
public int ReadS24Little(object addr)
{ {
var addr = LuaInt(lua_addr); return ReadSignedLittleCore(LuaInt(addr), 3);
return MM_R_S_LE(addr, 3);
} }
public int mainmemory_read_s32_le(object lua_addr) [LuaMethodAttributes(
"read_s32_le",
"TODO"
)]
public int ReadS32Little(object addr)
{ {
var addr = LuaInt(lua_addr); return ReadSignedLittleCore(LuaInt(addr), 4);
return MM_R_S_LE(addr, 4);
} }
public uint mainmemory_read_u16_le(object lua_addr) [LuaMethodAttributes(
"read_u16_le",
"TODO"
)]
public uint ReadU16Little(object addr)
{ {
var addr = LuaInt(lua_addr); return ReadSignedLittle(LuaInt(addr), 2);
return MM_R_U_LE(addr, 2);
} }
public uint mainmemory_read_u24_le(object lua_addr) [LuaMethodAttributes(
"read_u16_le",
"TODO"
)]
public uint ReadU24Little(object addr)
{ {
var addr = LuaInt(lua_addr); return ReadSignedLittle(LuaInt(addr), 3);
return MM_R_U_LE(addr, 3);
} }
public uint mainmemory_read_u32_le(object lua_addr) [LuaMethodAttributes(
"read_u32_le",
"TODO"
)]
public uint ReadU32Little(object addr)
{ {
var addr = LuaInt(lua_addr); return ReadSignedLittle(LuaInt(addr), 4);
return MM_R_U_LE(addr, 4);
} }
public int mainmemory_read_s16_be(object lua_addr) [LuaMethodAttributes(
"read_s16_be",
"TODO"
)]
public int ReadS16Big(object addr)
{ {
var addr = LuaInt(lua_addr); return ReadSignedBig(LuaInt(addr), 2);
return MM_R_S_BE(addr, 2);
} }
public int mainmemory_read_s24_be(object lua_addr) [LuaMethodAttributes(
"read_s24_be",
"TODO"
)]
public int ReadS24Big(object addr)
{ {
var addr = LuaInt(lua_addr); return ReadSignedBig(LuaInt(addr), 3);
return MM_R_S_BE(addr, 3);
} }
public int mainmemory_read_s32_be(object lua_addr) [LuaMethodAttributes(
"read_s32_be",
"TODO"
)]
public int ReadS32Big(object addr)
{ {
var addr = LuaInt(lua_addr); return ReadSignedBig(LuaInt(addr), 4);
return MM_R_S_BE(addr, 4);
} }
public uint mainmemory_read_u16_be(object lua_addr) [LuaMethodAttributes(
"read_u16_be",
"TODO"
)]
public uint ReadU16Big(object addr)
{ {
var addr = LuaInt(lua_addr); return ReadUnsignedBig(LuaInt(addr), 2);
return MM_R_U_BE(addr, 2);
} }
public uint mainmemory_read_u24_be(object lua_addr) [LuaMethodAttributes(
"read_u24_be",
"TODO"
)]
public uint ReadU24Big(object addr)
{ {
var addr = LuaInt(lua_addr); return ReadUnsignedBig(LuaInt(addr), 3);
return MM_R_U_BE(addr, 3);
} }
public uint mainmemory_read_u32_be(object lua_addr) [LuaMethodAttributes(
"read_u32_be",
"TODO"
)]
public uint ReadU32Big(object addr)
{ {
var addr = LuaInt(lua_addr); return ReadUnsignedBig(LuaInt(addr), 4);
return MM_R_U_BE(addr, 4);
} }
public void mainmemory_write_s8(object lua_addr, object lua_v) [LuaMethodAttributes(
"write_s8",
"TODO"
)]
public void WriteS8(object addr, object value)
{ {
var addr = LuaInt(lua_addr); WriteUnsignedByte(
var v = LuaInt(lua_v); LuaInt(addr),
MM_W_U8(addr, (uint)v); LuaUInt(value)
);
} }
public void mainmemory_write_u8(object lua_addr, object lua_v) [LuaMethodAttributes(
"write_u8",
"TODO"
)]
public void WriteU8(object addr, object value)
{ {
var addr = LuaInt(lua_addr); WriteUnsignedByte(
var v = LuaUInt(lua_v); LuaInt(addr),
MM_W_U8(addr, v); LuaUInt(value)
);
} }
public void mainmemory_write_s16_le(object lua_addr, object lua_v) [LuaMethodAttributes(
"write_s16_le",
"TODO"
)]
public void WriteS16Little(object addr, object value)
{ {
var addr = LuaInt(lua_addr); WriteSignedLittle(
var v = LuaInt(lua_v); LuaInt(addr),
MM_W_S_LE(addr, v, 2); LuaInt(value),
2);
} }
public void mainmemory_write_s24_le(object lua_addr, object lua_v) [LuaMethodAttributes(
"write_s24_le",
"TODO"
)]
public void WriteS24Little(object addr, object value)
{ {
var addr = LuaInt(lua_addr); WriteSignedLittle(
var v = LuaInt(lua_v); LuaInt(addr),
MM_W_S_LE(addr, v, 3); LuaInt(value),
3);
} }
public void mainmemory_write_s32_le(object lua_addr, object lua_v) [LuaMethodAttributes(
"write_s32_le",
"TODO"
)]
public void WriteS32Little(object addr, object value)
{ {
var addr = LuaInt(lua_addr); WriteSignedLittle(
var v = LuaInt(lua_v); LuaInt(addr),
MM_W_S_LE(addr, v, 4); LuaInt(value),
4);
} }
public void mainmemory_write_u16_le(object lua_addr, object lua_v) [LuaMethodAttributes(
"write_u16_le",
"TODO"
)]
public void WriteU16Little(object addr, object value)
{ {
var addr = LuaInt(lua_addr); WriteUnsignedLittle(
var v = LuaUInt(lua_v); LuaInt(addr),
MM_W_U_LE(addr, v, 2); LuaUInt(value),
2);
} }
public void mainmemory_write_u24_le(object lua_addr, object lua_v) [LuaMethodAttributes(
"write_u24_le",
"TODO"
)]
public void WriteU24Little(object addr, object value)
{ {
var addr = LuaInt(lua_addr); WriteUnsignedLittle(
var v = LuaUInt(lua_v); LuaInt(addr),
MM_W_U_LE(addr, v, 3); LuaUInt(value),
3);
} }
public void mainmemory_write_u32_le(object lua_addr, object lua_v) [LuaMethodAttributes(
"write_u32_le",
"TODO"
)]
public void WriteU32Little(object addr, object value)
{ {
var addr = LuaInt(lua_addr); WriteUnsignedLittle(
var v = LuaUInt(lua_v); LuaInt(addr),
MM_W_U_LE(addr, v, 4); LuaUInt(value),
4);
} }
public void mainmemory_write_s16_be(object lua_addr, object lua_v) [LuaMethodAttributes(
"write_s16_be",
"TODO"
)]
public void WriteS16Big(object addr, object value)
{ {
var addr = LuaInt(lua_addr); WriteSignedBig(
var v = LuaInt(lua_v); LuaInt(addr),
MM_W_S_BE(addr, v, 2); LuaInt(value),
2);
} }
public void mainmemory_write_s24_be(object lua_addr, object lua_v) [LuaMethodAttributes(
"write_s24_be",
"TODO"
)]
public void WriteS24Big(object addr, object value)
{ {
var addr = LuaInt(lua_addr); WriteSignedBig(
var v = LuaInt(lua_v); LuaInt(addr),
MM_W_S_BE(addr, v, 3); LuaInt(value),
3);
} }
public void mainmemory_write_s32_be(object lua_addr, object lua_v) [LuaMethodAttributes(
"write_s32_be",
"TODO"
)]
public void WriteS32Big(object addr, object value)
{ {
var addr = LuaInt(lua_addr); WriteSignedBig(
var v = LuaInt(lua_v); LuaInt(addr),
MM_W_S_BE(addr, v, 4); LuaInt(value),
4);
} }
public void mainmemory_write_u16_be(object lua_addr, object lua_v) [LuaMethodAttributes(
"write_u16_be",
"TODO"
)]
public void WriteU16Big(object addr, object value)
{ {
var addr = LuaInt(lua_addr); WriteUnsignedBig(
var v = LuaUInt(lua_v); LuaInt(addr),
MM_W_U_BE(addr, v, 2); LuaUInt(value),
2);
} }
public void mainmemory_write_u24_be(object lua_addr, object lua_v) [LuaMethodAttributes(
"write_u24_be",
"TODO"
)]
public void WriteU24Big(object addr, object value)
{ {
var addr = LuaInt(lua_addr); WriteUnsignedBig(
var v = LuaUInt(lua_v); LuaInt(addr),
MM_W_U_BE(addr, v, 3); LuaUInt(value),
3);
} }
public void mainmemory_write_u32_be(object lua_addr, object lua_v) [LuaMethodAttributes(
"write_u32_be",
"TODO"
)]
public void WriteU32Big(object addr, object value)
{ {
var addr = LuaInt(lua_addr); WriteUnsignedBig(
var v = LuaUInt(lua_v); LuaInt(addr),
MM_W_U_BE(addr, v, 4); LuaUInt(value),
4);
} }
} }
} }

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

@ -96,7 +96,7 @@ namespace BizHawk.Client.EmuHawk
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().LuaRegister(lua, Docs);
new MainMemoryLuaLibrary(_lua).LuaRegister(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);
new SavestateLuaLibrary().LuaRegister(lua, Docs); new SavestateLuaLibrary().LuaRegister(lua, Docs);