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)
{
int s = (int)u;
var s = (int)u;
s <<= 8 * (4 - size);
s >>= 8 * (4 - size);
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;
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;
}
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;
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;
}
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);
}
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);
}
#endregion
public string mainmemory_getname()
[LuaMethodAttributes(
"getname",
"TODO"
)]
public string GetName()
{
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 MM_R_U8(addr);
return ReadUnsignedByte(LuaInt(addr));
}
public LuaTable mainmemory_readbyterange(object address, object length)
[LuaMethodAttributes(
"readbyterange",
"TODO"
)]
public LuaTable ReadByteRange(object address, object length)
{
int l = LuaInt(length);
int addr = LuaInt(address);
int last_addr = l + addr;
var addr = LuaInt(address);
var lastAddr = LuaInt(length) + addr;
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 v = Global.Emulator.MemoryDomains.MainMemory.PeekByte(i);
var vs = String.Format("{0:X2}", (int)v);
table[a] = vs;
}
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);
uint val = Global.Emulator.MemoryDomains.MainMemory.PeekDWord(addr, bigendian);
var val = Global.Emulator.MemoryDomains.MainMemory.PeekDWord(LuaInt(addr), bigendian);
var bytes = BitConverter.GetBytes(val);
var _float = BitConverter.ToSingle(bytes, 0);
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);
var v = LuaUInt(lua_v);
MM_W_U8(addr, v);
WriteUnsignedByte(
LuaInt(addr),
LuaUInt(value)
);
}
public void mainmemory_writebyterange(LuaTable memoryblock)
[LuaMethodAttributes(
"writebyterange",
"TODO"
)]
public void WriteByteRange(LuaTable memoryblock)
{
foreach (var address in memoryblock.Keys)
{
int a = LuaInt(address);
int v = LuaInt(memoryblock[address]);
Global.Emulator.MemoryDomains.MainMemory.PokeByte(a, (byte)v);
Global.Emulator.MemoryDomains.MainMemory.PokeByte(
LuaInt(address),
(byte)LuaInt(memoryblock[address])
);
}
}
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 dv = (float)(double)lua_v;
var addr = LuaInt(address);
var dv = (float)(double)value;
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);
}
public int mainmemory_read_s8(object lua_addr)
[LuaMethodAttributes(
"read_s8",
"TODO"
)]
public int ReadS8(object addr)
{
var addr = LuaInt(lua_addr);
return (sbyte)MM_R_U8(addr);
return (sbyte)ReadUnsignedByte(LuaInt(addr));
}
public uint mainmemory_read_u8(object lua_addr)
[LuaMethodAttributes(
"read_u8",
"TODO"
)]
public uint ReadU8(object addr)
{
var addr = LuaInt(lua_addr);
return MM_R_U8(addr);
return ReadUnsignedByte(LuaInt(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 MM_R_S_LE(addr, 2);
return ReadSignedLittleCore(LuaInt(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 MM_R_S_LE(addr, 3);
return ReadSignedLittleCore(LuaInt(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 MM_R_S_LE(addr, 4);
return ReadSignedLittleCore(LuaInt(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 MM_R_U_LE(addr, 2);
return ReadSignedLittle(LuaInt(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 MM_R_U_LE(addr, 3);
return ReadSignedLittle(LuaInt(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 MM_R_U_LE(addr, 4);
return ReadSignedLittle(LuaInt(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 MM_R_S_BE(addr, 2);
return ReadSignedBig(LuaInt(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 MM_R_S_BE(addr, 3);
return ReadSignedBig(LuaInt(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 MM_R_S_BE(addr, 4);
return ReadSignedBig(LuaInt(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 MM_R_U_BE(addr, 2);
return ReadUnsignedBig(LuaInt(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 MM_R_U_BE(addr, 3);
return ReadUnsignedBig(LuaInt(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 MM_R_U_BE(addr, 4);
return ReadUnsignedBig(LuaInt(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);
var v = LuaInt(lua_v);
MM_W_U8(addr, (uint)v);
WriteUnsignedByte(
LuaInt(addr),
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);
var v = LuaUInt(lua_v);
MM_W_U8(addr, v);
WriteUnsignedByte(
LuaInt(addr),
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);
var v = LuaInt(lua_v);
MM_W_S_LE(addr, v, 2);
WriteSignedLittle(
LuaInt(addr),
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);
var v = LuaInt(lua_v);
MM_W_S_LE(addr, v, 3);
WriteSignedLittle(
LuaInt(addr),
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);
var v = LuaInt(lua_v);
MM_W_S_LE(addr, v, 4);
WriteSignedLittle(
LuaInt(addr),
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);
var v = LuaUInt(lua_v);
MM_W_U_LE(addr, v, 2);
WriteUnsignedLittle(
LuaInt(addr),
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);
var v = LuaUInt(lua_v);
MM_W_U_LE(addr, v, 3);
WriteUnsignedLittle(
LuaInt(addr),
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);
var v = LuaUInt(lua_v);
MM_W_U_LE(addr, v, 4);
WriteUnsignedLittle(
LuaInt(addr),
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);
var v = LuaInt(lua_v);
MM_W_S_BE(addr, v, 2);
WriteSignedBig(
LuaInt(addr),
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);
var v = LuaInt(lua_v);
MM_W_S_BE(addr, v, 3);
WriteSignedBig(
LuaInt(addr),
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);
var v = LuaInt(lua_v);
MM_W_S_BE(addr, v, 4);
WriteSignedBig(
LuaInt(addr),
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);
var v = LuaUInt(lua_v);
MM_W_U_BE(addr, v, 2);
WriteUnsignedBig(
LuaInt(addr),
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);
var v = LuaUInt(lua_v);
MM_W_U_BE(addr, v, 3);
WriteUnsignedBig(
LuaInt(addr),
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);
var v = LuaUInt(lua_v);
MM_W_U_BE(addr, v, 4);
WriteUnsignedBig(
LuaInt(addr),
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 JoypadLuaLibrary(_lua).LuaRegisterNew(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 NESLuaLibrary().LuaRegister(lua, Docs);
new SavestateLuaLibrary().LuaRegister(lua, Docs);