empathicqubit/lsnes
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Lua: More refactoring

Browse source
This commit is contained in:
Ilari Liusvaara 2014-01-27 00:27:38 +02:00
parent 1800453c4f
commit ccb6d4b4be
4 changed files with 166 additions and 208 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
src/lua/bind.cpp
View file

@ -14,8 +14,7 @@ namespace
return 0;
});
lua::fnptr2 kunbind(lua_func_misc, "keyboard.unbind", [](lua::state& L, lua::parameters& P)
-> int {
lua::fnptr2 kunbind(lua_func_misc, "keyboard.unbind", [](lua::state& L, lua::parameters& P) -> int {
auto mod = P.arg<std::string>();
auto mask = P.arg<std::string>();
auto key = P.arg<std::string>();
@ -23,8 +22,7 @@ namespace
return 0;
});
lua::fnptr2 kalias(lua_func_misc, "keyboard.alias", [](lua::state& L, lua::parameters& P)
-> int {
lua::fnptr2 kalias(lua_func_misc, "keyboard.alias", [](lua::state& L, lua::parameters& P) -> int {
auto alias = P.arg<std::string>();
auto cmds = P.arg<std::string>();
lsnes_cmd.set_alias_for(alias, cmds);

129
src/lua/input.cpp
View file

@ -42,7 +42,7 @@ namespace
return 1;
}
int input_seta(lua::state& L, unsigned port, unsigned controller, uint64_t base, const char* fname)
int input_seta(lua::state& L, unsigned port, unsigned controller, uint64_t base, lua::parameters& P)
{
if(!lua_input_controllerdata)
return 0;
@ -54,7 +54,7 @@ namespace
return 0;
for(unsigned i = 0; i < pt.controller_info->controllers[controller].buttons.size(); i++) {
val = (base >> i) & 1;
L.get_numeric_argument<short>(i + base, val, fname);
val = P.arg_opt<short>(val);
lua_input_controllerdata->axis3(port, controller, i, val);
}
return 0;
@ -79,91 +79,92 @@ namespace
return pt.controller_info->controllers[controller].buttons.size() + 1;
}
lua::fnptr iset(lua_func_misc, "input.set", [](lua::state& L, const std::string& fname) -> int {
lua::fnptr2 iset(lua_func_misc, "input.set", [](lua::state& L, lua::parameters& P) -> int {
if(!lua_input_controllerdata)
return 0;
unsigned controller = L.get_numeric_argument<unsigned>(1, fname.c_str());
unsigned index = L.get_numeric_argument<unsigned>(2, fname.c_str());
short value = L.get_numeric_argument<short>(3, fname.c_str());
auto controller = P.arg<unsigned>();
auto index = P.arg<unsigned>();
auto value = P.arg<short>();
auto _controller = lua_input_controllerdata->porttypes().legacy_pcid_to_pair(controller);
return input_set(L, _controller.first, _controller.second, index, value);
});
lua::fnptr iset2(lua_func_misc, "input.set2", [](lua::state& L, const std::string& fname) -> int {
unsigned port = L.get_numeric_argument<unsigned>(1, fname.c_str());
unsigned controller = L.get_numeric_argument<unsigned>(2, fname.c_str());
unsigned index = L.get_numeric_argument<unsigned>(3, fname.c_str());
short value = L.get_numeric_argument<short>(4, fname.c_str());
lua::fnptr2 iset2(lua_func_misc, "input.set2", [](lua::state& L, lua::parameters& P) -> int {
auto port = P.arg<unsigned>();
auto controller = P.arg<unsigned>();
auto index = P.arg<unsigned>();
auto value = P.arg<short>();
return input_set(L, port, controller, index, value);
});
lua::fnptr iget(lua_func_misc, "input.get", [](lua::state& L, const std::string& fname) -> int {
lua::fnptr2 iget(lua_func_misc, "input.get", [](lua::state& L, lua::parameters& P) -> int {
if(!lua_input_controllerdata)
return 0;
unsigned controller = L.get_numeric_argument<unsigned>(1, fname.c_str());
unsigned index = L.get_numeric_argument<unsigned>(2, fname.c_str());
auto controller = P.arg<unsigned>();
auto index = P.arg<unsigned>();
auto _controller = lua_input_controllerdata->porttypes().legacy_pcid_to_pair(controller);
return input_get(L, _controller.first, _controller.second, index);
});
lua::fnptr iget2(lua_func_misc, "input.get2", [](lua::state& L, const std::string& fname) -> int {
unsigned port = L.get_numeric_argument<unsigned>(1, fname.c_str());
unsigned controller = L.get_numeric_argument<unsigned>(2, fname.c_str());
unsigned index = L.get_numeric_argument<unsigned>(3, fname.c_str());
lua::fnptr2 iget2(lua_func_misc, "input.get2", [](lua::state& L, lua::parameters& P) -> int {
auto port = P.arg<unsigned>();
auto controller = P.arg<unsigned>();
auto index = P.arg<unsigned>();
return input_get(L, port, controller, index);
});
lua::fnptr iseta(lua_func_misc, "input.seta", [](lua::state& L, const std::string& fname) -> int {
lua::fnptr2 iseta(lua_func_misc, "input.seta", [](lua::state& L, lua::parameters& P) -> int {
if(!lua_input_controllerdata)
return 0;
unsigned controller = L.get_numeric_argument<unsigned>(1, fname.c_str());
uint64_t base = L.get_numeric_argument<uint64_t>(2, fname.c_str());
auto controller = P.arg<unsigned>();
auto base = P.arg<uint64_t>();
auto _controller = lua_input_controllerdata->porttypes().legacy_pcid_to_pair(controller);
return input_seta(L, _controller.first, _controller.second, base, fname.c_str());
return input_seta(L, _controller.first, _controller.second, base, P);
});
lua::fnptr iseta2(lua_func_misc, "input.seta2", [](lua::state& L, const std::string& fname) -> int {
unsigned port = L.get_numeric_argument<unsigned>(1, fname.c_str());
unsigned controller = L.get_numeric_argument<unsigned>(2, fname.c_str());
uint64_t base = L.get_numeric_argument<uint64_t>(3, fname.c_str());
return input_seta(L, port, controller, base, fname.c_str());
lua::fnptr2 iseta2(lua_func_misc, "input.seta2", [](lua::state& L, lua::parameters& P) -> int {
auto port = P.arg<unsigned>();
auto controller = P.arg<unsigned>();
auto base = P.arg<uint64_t>();
return input_seta(L, port, controller, base, P);
});
lua::fnptr igeta(lua_func_misc, "input.geta", [](lua::state& L, const std::string& fname) -> int {
lua::fnptr2 igeta(lua_func_misc, "input.geta", [](lua::state& L, lua::parameters& P) -> int {
if(!lua_input_controllerdata)
return 0;
unsigned controller = L.get_numeric_argument<unsigned>(1, fname.c_str());
auto controller = P.arg<unsigned>();
auto _controller = lua_input_controllerdata->porttypes().legacy_pcid_to_pair(controller);
return input_geta(L, _controller.first, _controller.second);
});
lua::fnptr igeta2(lua_func_misc, "input.geta2", [](lua::state& L, const std::string& fname) -> int {
unsigned port = L.get_numeric_argument<unsigned>(1, fname.c_str());
unsigned controller = L.get_numeric_argument<unsigned>(2, fname.c_str());
lua::fnptr2 igeta2(lua_func_misc, "input.geta2", [](lua::state& L, lua::parameters& P) -> int {
auto port = P.arg<unsigned>();
auto controller = P.arg<unsigned>();
return input_geta(L, port, controller);
});
lua::fnptr igett(lua_func_misc, "input.controllertype", [](lua::state& L, const std::string& fname)
-> int {
unsigned controller = L.get_numeric_argument<unsigned>(1, fname.c_str());
lua::fnptr2 igett(lua_func_misc, "input.controllertype", [](lua::state& L, lua::parameters& P) -> int {
auto controller = P.arg<unsigned>();
auto& m = get_movie();
const port_type_set& s = m.read_subframe(m.get_current_frame(), 0).porttypes();
auto _controller = s.legacy_pcid_to_pair(controller);
return input_controllertype(L, _controller.first, _controller.second);
});
lua::fnptr igett2(lua_func_misc, "input.controllertype2", [](lua::state& L, const std::string& fname)
-> int {
unsigned port = L.get_numeric_argument<unsigned>(1, fname.c_str());
unsigned controller = L.get_numeric_argument<unsigned>(2, fname.c_str());
lua::fnptr2 igett2(lua_func_misc, "input.controllertype2", [](lua::state& L, lua::parameters& P) -> int {
auto port = P.arg<unsigned>();
auto controller = P.arg<unsigned>();
return input_controllertype(L, port, controller);
});
lua::fnptr ireset(lua_func_misc, "input.reset", [](lua::state& L, const std::string& fname) -> int {
lua::fnptr2 ireset(lua_func_misc, "input.reset", [](lua::state& L, lua::parameters& P) -> int {
if(!lua_input_controllerdata)
return 0;
long cycles = 0;
L.get_numeric_argument(1, cycles, fname.c_str());
auto cycles = P.arg<long>(0);
if(cycles < 0)
return 0;
short lo = cycles % 10000;
@ -174,7 +175,7 @@ namespace
return 0;
});
lua::fnptr iraw(lua_func_misc, "input.raw", [](lua::state& L, const std::string& fname) -> int {
lua::fnptr2 iraw(lua_func_misc, "input.raw", [](lua::state& L, lua::parameters& P) -> int {
L.newtable();
for(auto i : lsnes_kbd.all_keys()) {
L.pushlstring(i->get_name());
@ -193,10 +194,10 @@ namespace
} keyhook_listener;
std::set<std::string> hooked;
lua::fnptr ireq(lua_func_misc, "input.keyhook", [](lua::state& L, const std::string& fname) -> int {
bool state;
std::string x = L.get_string(1, fname.c_str());
state = L.get_bool(2, fname.c_str());
lua::fnptr2 ireq(lua_func_misc, "input.keyhook", [](lua::state& L, lua::parameters& P) -> int {
auto x = P.arg<std::string>();
auto state = P.arg<bool>();
keyboard::key* key = lsnes_kbd.try_lookup_key(x);
if(!key)
throw std::runtime_error("Invalid key name");
@ -213,8 +214,8 @@ namespace
return 0;
});
lua::fnptr ijget(lua_func_misc, "input.joyget", [](lua::state& L, const std::string& fname) -> int {
unsigned lcid = L.get_numeric_argument<unsigned>(1, fname.c_str());
lua::fnptr2 ijget(lua_func_misc, "input.joyget", [](lua::state& L, lua::parameters& P) -> int {
auto lcid = P.arg<unsigned>();
if(!lua_input_controllerdata)
return 0;
auto pcid = controls.lcid_to_pcid(lcid - 1);
@ -237,8 +238,8 @@ namespace
return 1;
});
lua::fnptr ijset(lua_func_misc, "input.joyset", [](lua::state& L, const std::string& fname) -> int {
unsigned lcid = L.get_numeric_argument<unsigned>(1, fname.c_str());
lua::fnptr2 ijset(lua_func_misc, "input.joyset", [](lua::state& L, lua::parameters& P) -> int {
auto lcid = P.arg<unsigned>();
if(L.type(2) != LUA_TTABLE)
throw std::runtime_error("Invalid type for input.joyset");
if(!lua_input_controllerdata)
@ -274,9 +275,8 @@ namespace
return 0;
});
lua::fnptr ijlcid_to_pcid(lua_func_misc, "input.lcid_to_pcid", [](lua::state& L,
const std::string& fname) -> int {
unsigned lcid = L.get_numeric_argument<unsigned>(1, fname.c_str());
lua::fnptr2 ijlcid_to_pcid(lua_func_misc, "input.lcid_to_pcid", [](lua::state& L, lua::parameters& P) -> int {
auto lcid = P.arg<unsigned>();
auto pcid = controls.lcid_to_pcid(lcid - 1);
if(pcid.first < 0)
return 0;
@ -302,9 +302,9 @@ namespace
//THE NEW API.
lua::fnptr ijlcid_to_pcid2(lua_func_misc, "input.lcid_to_pcid2", [](lua::state& L,
const std::string& fname) -> int {
unsigned lcid = L.get_numeric_argument<unsigned>(1, fname.c_str());
lua::fnptr2 ijlcid_to_pcid2(lua_func_misc, "input.lcid_to_pcid2", [](lua::state& L, lua::parameters& P)
-> int {
auto lcid = P.arg<unsigned>();
auto pcid = controls.lcid_to_pcid(lcid - 1);
if(pcid.first < 0)
return 0;
@ -313,9 +313,8 @@ namespace
return 2;
});
lua::fnptr iporttype(lua_func_misc, "input.port_type", [](lua::state& L, const std::string& fname)
-> int {
unsigned port = L.get_numeric_argument<unsigned>(1, fname.c_str());
lua::fnptr2 iporttype(lua_func_misc, "input.port_type", [](lua::state& L, lua::parameters& P) -> int {
auto port = P.arg<unsigned>();
auto& m = get_movie();
const port_type_set& s = m.read_subframe(m.get_current_frame(), 0).porttypes();
try {
@ -335,16 +334,14 @@ namespace
return p.controller_info;
}
lua::fnptr iveto(lua_func_misc, "input.veto_button", [](lua::state& L, const std::string& fname)
-> int {
lua::fnptr2 iveto(lua_func_misc, "input.veto_button", [](lua::state& L, lua::parameters& P) -> int {
if(lua_veto_flag) *lua_veto_flag = true;
return 0;
});
lua::fnptr ictrlinfo(lua_func_misc, "input.controller_info", [](lua::state& L,
const std::string& fname) -> int {
unsigned port = L.get_numeric_argument<unsigned>(1, fname.c_str());
unsigned controller = L.get_numeric_argument<unsigned>(2, fname.c_str());
lua::fnptr2 ictrlinfo(lua_func_misc, "input.controller_info", [](lua::state& L, lua::parameters& P) -> int {
auto port = P.arg<unsigned>();
auto controller = P.arg<unsigned>();
const port_controller_set* ps;
unsigned lcid = 0;
unsigned classnum = 1;

204
src/lua/memory.cpp
View file

@ -14,7 +14,7 @@
namespace
{
uint64_t get_vmabase(lua::state& L, const std::string& vma)
uint64_t get_vmabase(const std::string& vma)
{
for(auto i : lsnes_memory.get_regions())
if(i->name == vma)
@ -22,45 +22,31 @@ namespace
throw std::runtime_error("No such VMA");
}
uint64_t get_read_address(lua::state& L, int& base, const char* fn)
uint64_t get_read_address(lua::parameters& P)
{
uint64_t vmabase = 0;
if(L.type(base) == LUA_TSTRING) {
vmabase = get_vmabase(L, L.get_string(base, fn));
base++;
}
uint64_t addr = L.get_numeric_argument<uint64_t>(base++, fn) + vmabase;
return addr;
if(P.is_string())
vmabase = get_vmabase(P.arg<std::string>());
auto addr = P.arg<uint64_t>();
return addr + vmabase;
}
template<typename T, T (memory_space::*rfun)(uint64_t addr)>
class lua_read_memory : public lua::function
int lua_read_memory(lua::state& L, lua::parameters& P)
{
public:
lua_read_memory(const std::string& name) : lua::function(lua_func_misc, name) {}
int invoke(lua::state& L)
{
int base = 1;
uint64_t addr = get_read_address(L, base, "lua_read_memory");
L.pushnumber(static_cast<T>((lsnes_memory.*rfun)(addr)));
return 1;
}
};
auto addr = get_read_address(P);
L.pushnumber(static_cast<T>((lsnes_memory.*rfun)(addr)));
return 1;
}
template<typename T, bool (memory_space::*wfun)(uint64_t addr, T value)>
class lua_write_memory : public lua::function
int lua_write_memory(lua::state& L, lua::parameters& P)
{
public:
lua_write_memory(const std::string& name) : lua::function(lua_func_misc, name) {}
int invoke(lua::state& L)
{
int base = 1;
uint64_t addr = get_read_address(L, base, "lua_write_memory");
T value = L.get_numeric_argument<T>(base + 2, fname.c_str());
(lsnes_memory.*wfun)(addr, value);
return 0;
}
};
auto addr = get_read_address(P);
T value = P.arg<T>();
(lsnes_memory.*wfun)(addr, value);
return 0;
}
class mmap_base
{
@ -70,7 +56,6 @@ namespace
virtual void write(lua::state& L, uint64_t addr) = 0;
};
template<typename T, T (memory_space::*rfun)(uint64_t addr), bool (memory_space::*wfun)(uint64_t addr,
T value)>
class lua_mmap_memory_helper : public mmap_base
@ -265,23 +250,24 @@ namespace
lua_registerX(const std::string& name) : lua::function(lua_func_misc, name) {}
int invoke(lua::state& L)
{
lua::parameters P(L, fname);
uint64_t addr;
int base = 1;
if(L.type(1) == LUA_TNIL && type != DEBUG_TRACE) {
if(P.is_nil() && type != DEBUG_TRACE) {
addr = 0xFFFFFFFFFFFFFFFFULL;
base = 2;
P.skip();
} else if(type != DEBUG_TRACE)
addr = get_read_address(L, base, fname.c_str());
addr = get_read_address(P);
else
addr = L.get_numeric_argument<uint64_t>(base++, fname.c_str());
if(L.type(base) != LUA_TFUNCTION)
throw std::runtime_error("Expected last argument to " + fname + " to be function");
addr = P.arg<uint64_t>();
if(P.is_function())
P.expected("function");
int lfn = P.skip();
if(reg) {
handle_registerX(L, addr, base);
L.pushvalue(base);
handle_registerX(L, addr, lfn);
L.pushvalue(lfn);
return 1;
} else {
handle_unregisterX(L, addr, base);
handle_unregisterX(L, addr, lfn);
return 0;
}
}
@ -372,13 +358,13 @@ namespace
lua_mmap_memory(const std::string& name, mmap_base& _h) : lua::function(lua_func_misc, name), h(_h) {}
int invoke(lua::state& L)
{
if(L.isnoneornil(1)) {
lua::parameters P(L, fname);
if(P.is_novalue()) {
aperture_make_fun(L, 0, 0xFFFFFFFFFFFFFFFFULL, h);
return 1;
}
int base = 1;
uint64_t addr = get_read_address(L, base, "lua_mmap_memory");
uint64_t size = L.get_numeric_argument<uint64_t>(base, fname.c_str());
auto addr = get_read_address(P);
auto size = P.arg<uint64_t>();
if(!size)
throw std::runtime_error("Aperture with zero size is not valid");
aperture_make_fun(L, addr, size - 1, h);
@ -387,28 +373,25 @@ namespace
mmap_base& h;
};
lua::fnptr vmacount(lua_func_misc, "memory.vma_count", [](lua::state& L, const std::string& fname)
-> int {
lua::fnptr2 vmacount(lua_func_misc, "memory.vma_count", [](lua::state& L, lua::parameters& P) -> int {
L.pushnumber(lsnes_memory.get_regions().size());
return 1;
});
lua::fnptr cheat(lua_func_misc, "memory.cheat", [](lua::state& L, const std::string& fname)
-> int {
lua::fnptr2 cheat(lua_func_misc, "memory.cheat", [](lua::state& L, lua::parameters& P) -> int {
int base = 1;
uint64_t addr = get_read_address(L, base, fname.c_str());
if(L.type(base) == LUA_TNIL || L.type(base) == LUA_TNONE) {
auto addr = get_read_address(P);
if(P.is_novalue()) {
debug_clear_cheat(addr);
} else {
uint64_t value = L.get_numeric_argument<uint64_t>(base, fname.c_str());
auto value = P.arg<uint64_t>();
debug_set_cheat(addr, value);
}
return 0;
});
lua::fnptr xmask(lua_func_misc, "memory.setxmask", [](lua::state& L, const std::string& fname)
-> int {
uint64_t value = L.get_numeric_argument<uint64_t>(1, fname.c_str());
lua::fnptr2 xmask(lua_func_misc, "memory.setxmask", [](lua::state& L, lua::parameters& P) -> int {
auto value = P.arg<uint64_t>();
debug_setxmask(value);
return 0;
});
@ -443,10 +426,9 @@ namespace
return 1;
}
lua::fnptr readvma(lua_func_misc, "memory.read_vma", [](lua::state& L, const std::string& fname)
-> int {
lua::fnptr2 readvma(lua_func_misc, "memory.read_vma", [](lua::state& L, lua::parameters& P) -> int {
std::list<memory_region*> regions = lsnes_memory.get_regions();
uint32_t num = L.get_numeric_argument<uint32_t>(1, fname.c_str());
auto num = P.arg<uint32_t>();
uint32_t j = 0;
for(auto i = regions.begin(); i != regions.end(); i++, j++)
if(j == num)
@ -455,9 +437,8 @@ namespace
return 1;
});
lua::fnptr findvma(lua_func_misc, "memory.find_vma", [](lua::state& L, const std::string& fname)
-> int {
uint64_t addr = L.get_numeric_argument<uint64_t>(1, fname.c_str());
lua::fnptr2 findvma(lua_func_misc, "memory.find_vma", [](lua::state& L, lua::parameters& P) -> int {
auto addr = P.arg<uint64_t>();
auto r = lsnes_memory.lookup(addr);
if(r.first)
return handle_push_vma(L, *r.first);
@ -467,8 +448,7 @@ namespace
const char* hexes = "0123456789ABCDEF";
lua::fnptr hashstate(lua_func_misc, "memory.hash_state", [](lua::state& L, const std::string& fname)
-> int {
lua::fnptr2 hashstate(lua_func_misc, "memory.hash_state", [](lua::state& L, lua::parameters& P) -> int {
char hash[64];
auto x = our_rom.save_core_state();
size_t offset = x.size() - 32;
@ -478,12 +458,11 @@ namespace
#define BLOCKSIZE 256
lua::fnptr hashmemory(lua_func_misc, "memory.hash_region", [](lua::state& L, const std::string& fname)
-> int {
lua::fnptr2 hashmemory(lua_func_misc, "memory.hash_region", [](lua::state& L, lua::parameters& P) -> int {
std::string hash;
int base = 1;
uint64_t addr = get_read_address(L, base, fname.c_str());
uint64_t size = L.get_numeric_argument<uint64_t>(base, fname.c_str());
auto addr = get_read_address(P);
auto size = P.arg<uint64_t>();
char buffer[BLOCKSIZE];
sha256 h;
while(size > BLOCKSIZE) {
@ -501,12 +480,11 @@ namespace
return 1;
});
lua::fnptr readmemoryr(lua_func_misc, "memory.readregion", [](lua::state& L, const std::string& fname)
-> int {
lua::fnptr2 readmemoryr(lua_func_misc, "memory.readregion", [](lua::state& L, lua::parameters& P) -> int {
std::string hash;
int base = 1;
uint64_t addr = get_read_address(L, base, fname.c_str());
uint64_t size = L.get_numeric_argument<uint64_t>(base, fname.c_str());
auto addr = get_read_address(P);
auto size = P.arg<uint64_t>();
L.newtable();
char buffer[BLOCKSIZE];
uint64_t ctr = 0;
@ -524,12 +502,11 @@ namespace
return 1;
});
lua::fnptr writememoryr(lua_func_misc, "memory.writeregion", [](lua::state& L,
const std::string& fname) -> int {
lua::fnptr2 writememoryr(lua_func_misc, "memory.writeregion", [](lua::state& L, lua::parameters& P) -> int {
std::string hash;
int base = 1;
uint64_t addr = get_read_address(L, base, fname.c_str());
uint64_t size = L.get_numeric_argument<uint64_t>(base, fname.c_str());
auto addr = get_read_address(P);
auto size = P.arg<uint64_t>();
char buffer[BLOCKSIZE];
uint64_t ctr = 0;
while(size > 0) {
@ -547,7 +524,7 @@ namespace
return 1;
});
template<bool write, bool sign> int memory_scattergather(lua::state& L, const std::string& fname)
template<bool write, bool sign> int memory_scattergather(lua::state& L, lua::parameters& P)
{
uint64_t val = 0;
int ptr = 1;
@ -555,18 +532,18 @@ namespace
uint64_t addr = 0;
uint64_t vmabase = 0;
if(write)
val = L.get_numeric_argument<uint64_t>(ptr++, fname.c_str());
val = P.arg<uint64_t>();
while(L.type(ptr) != LUA_TNIL && L.type(ptr) != LUA_TNONE) {
if(L.type(ptr) == LUA_TBOOLEAN) {
if(L.toboolean(ptr++))
if(P.is_boolean()) {
if(P.arg<bool>())
addr++;
else
addr--;
} else if(L.type(ptr) == LUA_TSTRING) {
vmabase = get_vmabase(L, L.get_string(ptr++, fname.c_str()));
} else if(P.is_string()) {
vmabase = get_vmabase(P.arg<std::string>());
continue;
} else
addr = L.get_numeric_argument<uint64_t>(ptr++, fname.c_str());
addr = P.arg<uint64_t>();
if(write)
lsnes_memory.write<uint8_t>(addr + vmabase, val >> shift);
else
@ -581,40 +558,31 @@ namespace
return write ? 0 : 1;
}
lua::fnptr scattergather1(lua_func_misc, "memory.read_sg", [](lua::state& L, const std::string& fname)
-> int {
return memory_scattergather<false, false>(L, fname);
});
lua::fnptr scattergather2(lua_func_misc, "memory.sread_sg", [](lua::state& L,
const std::string& fname) -> int {
return memory_scattergather<false, true>(L, fname);
});
lua::fnptr scattergather3(lua_func_misc, "memory.write_sg", [](lua::state& L,
const std::string& fname) -> int {
return memory_scattergather<true, false>(L, fname);
});
lua_read_memory<uint8_t, &memory_space::read<uint8_t>> rub("memory.readbyte");
lua_read_memory<int8_t, &memory_space::read<int8_t>> rsb("memory.readsbyte");
lua_read_memory<uint16_t, &memory_space::read<uint16_t>> ruw("memory.readword");
lua_read_memory<int16_t, &memory_space::read<int16_t>> rsw("memory.readsword");
lua_read_memory<ss_uint24_t, &memory_space::read<ss_uint24_t>> ruh("memory.readhword");
lua_read_memory<ss_int24_t, &memory_space::read<ss_int24_t>> rsh("memory.readshword");
lua_read_memory<uint32_t, &memory_space::read<uint32_t>> rud("memory.readdword");
lua_read_memory<int32_t, &memory_space::read<int32_t>> rsd("memory.readsdword");
lua_read_memory<uint64_t, &memory_space::read<uint64_t>> ruq("memory.readqword");
lua_read_memory<int64_t, &memory_space::read<int64_t>> rsq("memory.readsqword");
lua_read_memory<float, &memory_space::read<float>> rf4("memory.readfloat");
lua_read_memory<double, &memory_space::read<double>> rf8("memory.readdouble");
lua_write_memory<uint8_t, &memory_space::write<uint8_t>> wb("memory.writebyte");
lua_write_memory<uint16_t, &memory_space::write<uint16_t>> ww("memory.writeword");
lua_write_memory<ss_uint24_t, &memory_space::write<ss_uint24_t>> wh("memory.writehword");
lua_write_memory<uint32_t, &memory_space::write<uint32_t>> wd("memory.writedword");
lua_write_memory<uint64_t, &memory_space::write<uint64_t>> wq("memory.writeqword");
lua_write_memory<float, &memory_space::write<float>> wf4("memory.writefloat");
lua_write_memory<double, &memory_space::write<double>> wf8("memory.writedouble");
lua::fnptr2 scattergather1(lua_func_misc, "memory.read_sg", memory_scattergather<false, false>);
lua::fnptr2 scattergather2(lua_func_misc, "memory.sread_sg", memory_scattergather<false, true>);
lua::fnptr2 scattergather3(lua_func_misc, "memory.write_sg", memory_scattergather<true, false>);
lua::fnptr2 rub(lua_func_misc, "memory.readbyte", lua_read_memory<uint8_t, &memory_space::read<uint8_t>>);
lua::fnptr2 rsb(lua_func_misc, "memory.readsbyte", lua_read_memory<int8_t, &memory_space::read<int8_t>>);
lua::fnptr2 ruw(lua_func_misc, "memory.readword", lua_read_memory<uint16_t, &memory_space::read<uint16_t>>);
lua::fnptr2 rsw(lua_func_misc, "memory.readsword", lua_read_memory<int16_t, &memory_space::read<int16_t>>);
lua::fnptr2 ruh(lua_func_misc, "memory.readhword", lua_read_memory<ss_uint24_t,
&memory_space::read<ss_uint24_t>>);
lua::fnptr2 rsh(lua_func_misc, "memory.readshword", lua_read_memory<ss_int24_t,
&memory_space::read<ss_int24_t>>);
lua::fnptr2 rud(lua_func_misc, "memory.readdword", lua_read_memory<uint32_t, &memory_space::read<uint32_t>>);
lua::fnptr2 rsd(lua_func_misc, "memory.readsdword", lua_read_memory<int32_t, &memory_space::read<int32_t>>);
lua::fnptr2 ruq(lua_func_misc, "memory.readqword", lua_read_memory<uint64_t, &memory_space::read<uint64_t>>);
lua::fnptr2 rsq(lua_func_misc, "memory.readsqword", lua_read_memory<int64_t, &memory_space::read<int64_t>>);
lua::fnptr2 rf4(lua_func_misc, "memory.readfloat", lua_read_memory<float, &memory_space::read<float>>);
lua::fnptr2 rf8(lua_func_misc, "memory.readdouble", lua_read_memory<double, &memory_space::read<double>>);
lua::fnptr2 wb(lua_func_misc, "memory.writebyte", lua_write_memory<uint8_t, &memory_space::write<uint8_t>>);
lua::fnptr2 ww(lua_func_misc, "memory.writeword", lua_write_memory<uint16_t, &memory_space::write<uint16_t>>);
lua::fnptr2 wh(lua_func_misc, "memory.writehword", lua_write_memory<ss_uint24_t,
&memory_space::write<ss_uint24_t>>);
lua::fnptr2 wd(lua_func_misc, "memory.writedword", lua_write_memory<uint32_t, &memory_space::write<uint32_t>>);
lua::fnptr2 wq(lua_func_misc, "memory.writeqword", lua_write_memory<uint64_t, &memory_space::write<uint64_t>>);
lua::fnptr2 wf4(lua_func_misc, "memory.writefloat", lua_write_memory<float, &memory_space::write<float>>);
lua::fnptr2 wf8(lua_func_misc, "memory.writedouble", lua_write_memory<double, &memory_space::write<double>>);
lua_mmap_memory_helper<uint8_t, &memory_space::read<uint8_t>, &memory_space::write<uint8_t>> mhub;
lua_mmap_memory_helper<int8_t, &memory_space::read<int8_t>, &memory_space::write<int8_t>> mhsb;
lua_mmap_memory_helper<uint16_t, &memory_space::read<uint16_t>, &memory_space::write<uint16_t>> mhuw;
@ -663,7 +631,7 @@ int lua_mmap_struct::map(lua::state& L, const std::string& fname)
int base = 0;
uint64_t vmabase = 0;
if(L.type(3) == LUA_TSTRING) {
vmabase = get_vmabase(L, L.get_string(3, fname.c_str()));
vmabase = get_vmabase(L.get_string(3, fname.c_str()));
base = 1;
}
uint64_t addr = L.get_numeric_argument<uint64_t>(base + 3, fname.c_str());

35
src/lua/movie.cpp
View file

@ -7,46 +7,43 @@
namespace
{
lua::fnptr mcurframe(lua_func_misc, "movie.currentframe", [](lua::state& L, const std::string& fname)
-> int {
lua::fnptr2 mcurframe(lua_func_misc, "movie.currentframe", [](lua::state& L, lua::parameters& P) -> int {
auto& m = get_movie();
L.pushnumber(m.get_current_frame());
return 1;
});
lua::fnptr mfc(lua_func_misc, "movie.framecount", [](lua::state& L, const std::string& fname) -> int {
lua::fnptr2 mfc(lua_func_misc, "movie.framecount", [](lua::state& L, lua::parameters& P) -> int {
auto& m = get_movie();
L.pushnumber(m.get_frame_count());
return 1;
});
lua::fnptr mrrs(lua_func_misc, "movie.rerecords", [](lua::state& L, const std::string& fname) -> int {
lua::fnptr2 mrrs(lua_func_misc, "movie.rerecords", [](lua::state& L, lua::parameters& P) -> int {
L.pushnumber(rrdata.count());
return 1;
});
lua::fnptr mro(lua_func_misc, "movie.readonly", [](lua::state& L, const std::string& fname) -> int {
lua::fnptr2 mro(lua_func_misc, "movie.readonly", [](lua::state& L, lua::parameters& P) -> int {
auto& m = get_movie();
L.pushboolean(m.readonly_mode() ? 1 : 0);
return 1;
});
lua::fnptr mrw(lua_func_misc, "movie.readwrite", [](lua::state& L, const std::string& fname) -> int {
lua::fnptr2 mrw(lua_func_misc, "movie.readwrite", [](lua::state& L, lua::parameters& P) -> int {
auto& m = get_movie();
m.readonly_mode(false);
return 0;
});
lua::fnptr mfs(lua_func_misc, "movie.frame_subframes", [](lua::state& L, const std::string& fname)
-> int {
lua::fnptr2 mfs(lua_func_misc, "movie.frame_subframes", [](lua::state& L, lua::parameters& P) -> int {
uint64_t frame = L.get_numeric_argument<uint64_t>(1, "movie.frame_subframes");
auto& m = get_movie();
L.pushnumber(m.frame_subframes(frame));
return 1;
});
lua::fnptr mrs(lua_func_misc, "movie.read_subframes", [](lua::state& L, const std::string& fname)
-> int {
lua::fnptr2 mrs(lua_func_misc, "movie.read_subframes", [](lua::state& L, lua::parameters& P) -> int {
uint64_t frame = L.get_numeric_argument<uint64_t>(1, "movie.frame_subframes");
uint64_t subframe = L.get_numeric_argument<uint64_t>(2, "movie.frame_subframes");
auto& m = get_movie();
@ -61,30 +58,28 @@ namespace
return 1;
});
lua::fnptr rrc(lua_func_misc, "movie.read_rtc", [](lua::state& L, const std::string& fname) -> int {
lua::fnptr2 rrc(lua_func_misc, "movie.read_rtc", [](lua::state& L, lua::parameters& P) -> int {
L.pushnumber(our_movie.rtc_second);
L.pushnumber(our_movie.rtc_subsecond);
return 2;
});
lua::fnptr musv(lua_func_misc, "movie.unsafe_rewind", [](lua::state& L, const std::string& fname)
-> int {
if(L.isnoneornil(1)) {
lua::fnptr2 musv(lua_func_misc, "movie.unsafe_rewind", [](lua::state& L, lua::parameters& P) -> int {
if(P.is_novalue()) {
//Start process to mark save.
mainloop_signal_need_rewind(NULL);
} else if(lua::_class<lua_unsaferewind>::is(L, 1)) {
} else if(P.is<lua_unsaferewind>()) {
//Load the save.
lua::objpin<lua_unsaferewind>* u = new lua::objpin<lua_unsaferewind>(
lua::_class<lua_unsaferewind>::pin(L, 1, fname.c_str()));
P.arg<lua::objpin<lua_unsaferewind>>());
mainloop_signal_need_rewind(u);
} else
throw std::runtime_error("movie.unsafe_rewind: Expected nil or UNSAFEREWIND as 1st argument");
P.expected("UNSAFEREWIND or nil");
return 0;
});
lua::fnptr movie_to_rewind(lua_func_misc, "movie.to_rewind", [](lua::state& L,
const std::string& fname) -> int {
std::string filename = L.get_string(1, fname.c_str());
lua::fnptr2 movie_to_rewind(lua_func_misc, "movie.to_rewind", [](lua::state& L, lua::parameters& P) -> int {
auto filename = P.arg<std::string>();
moviefile mfile(filename, *our_rom.rtype);
if(!mfile.is_savestate)
throw std::runtime_error("movie.to_rewind only allows savestates");