Lua: More conversion to lua::parameters

src/lua/gui-box.cpp

@@ -52,18 +52,18 @@ namespace
 		int32_t thickness;
 	};
 
-	lua::fnptr gui_box(lua_func_misc, "gui.box", [](lua::state& L, const std::string& fname) -> int {
+	lua::fnptr2 gui_box(lua_func_misc, "gui.box", [](lua::state& L, lua::parameters& P) -> int {
 		if(!lua_render_ctx)
 			return 0;
-		uint32_t thickness = 1;
+
-		int32_t x = L.get_numeric_argument<int32_t>(1, fname.c_str());
+		auto x = P.arg<int32_t>();
-		int32_t y = L.get_numeric_argument<int32_t>(2, fname.c_str());
+		auto y = P.arg<int32_t>();
-		uint32_t width = L.get_numeric_argument<uint32_t>(3, fname.c_str());
+		auto width = P.arg<uint32_t>();
-		uint32_t height = L.get_numeric_argument<uint32_t>(4, fname.c_str());
+		auto height = P.arg<uint32_t>();
-		L.get_numeric_argument<uint32_t>(5, thickness, fname.c_str());
+		uint32_t thickness = P.arg_opt<uint32_t>(1);
-		auto poutline1 = lua_get_fb_color(L, 6, fname, 0xFFFFFFU);
+		auto poutline1 = P.color(0xFFFFFFU);
-		auto poutline2 = lua_get_fb_color(L, 7, fname, 0x808080U);
+		auto poutline2 = P.color(0x808080U);
-		auto pfill = lua_get_fb_color(L, 8, fname, 0xC0C0C0U);
+		auto pfill = P.color(0xC0C0C0U);
 		lua_render_ctx->queue->create_add<render_object_box>(x, y, width, height, poutline1, poutline2,
 			pfill, thickness);
 		return 0;

src/lua/gui-circle.cpp

@@ -59,17 +59,16 @@ namespace
 		framebuffer::color fill;
 	};
 
-	lua::fnptr gui_rectangle(lua_func_misc, "gui.circle", [](lua::state& L, const std::string& fname)
+	lua::fnptr2 gui_rectangle(lua_func_misc, "gui.circle", [](lua::state& L, lua::parameters& P)
 		-> int {
 		if(!lua_render_ctx)
 			return 0;
-		uint32_t thickness = 1;
+		auto x = P.arg<int32_t>();
-		int32_t x = L.get_numeric_argument<int32_t>(1, fname.c_str());
+		auto y = P.arg<int32_t>();
-		int32_t y = L.get_numeric_argument<int32_t>(2, fname.c_str());
+		auto radius = P.arg<uint32_t>();
-		uint32_t radius = L.get_numeric_argument<uint32_t>(3, fname.c_str());
+		uint32_t thickness = P.arg_opt<uint32_t>(1);
-		L.get_numeric_argument<uint32_t>(4, thickness, fname.c_str());
+		auto poutline = P.color(0xFFFFFFU);
-		auto poutline = lua_get_fb_color(L, 5, fname, 0xFFFFFFU);
+		auto pfill = P.color(-1);
-		auto pfill = lua_get_fb_color(L, 6, fname, -1);
 		lua_render_ctx->queue->create_add<render_object_circle>(x, y, radius, poutline, pfill, thickness);
 		return 0;
 	});

src/lua/gui-core.cpp

@@ -49,29 +49,26 @@ namespace
 	lua_gui_set_gap<&lua_render_context::top_gap, true> dtg("gui.delta_top_gap");
 	lua_gui_set_gap<&lua_render_context::bottom_gap, true> dbg("gui.delta_bottom_gap");
 
-	lua::fnptr gui_repaint(lua_func_misc, "gui.repaint", [](lua::state& L, const std::string& fname)
+	lua::fnptr2 gui_repaint(lua_func_misc, "gui.repaint", [](lua::state& L, lua::parameters& P) -> int {
-		-> int {
 		lua_requests_repaint = true;
 		return 0;
 	});
 
-	lua::fnptr gui_sfupd(lua_func_misc, "gui.subframe_update", [](lua::state& L, const std::string& fname)
+	lua::fnptr2 gui_sfupd(lua_func_misc, "gui.subframe_update", [](lua::state& L, lua::parameters& P) -> int {
-		-> int {
+		lua_requests_subframe_paint = P.arg<bool>();
-		lua_requests_subframe_paint = L.get_bool(1, fname.c_str());
 		return 0;
 	});
 
-	lua::fnptr gui_color(lua_func_misc, "gui.color", [](lua::state& L, const std::string& fname)
+	lua::fnptr2 gui_color(lua_func_misc, "gui.color", [](lua::state& L, lua::parameters& P) -> int {
-		-> int {
+		if(P.is_string()) {
-		if(L.type(1) == LUA_TSTRING) {
+			framebuffer::color c(P.arg<std::string>());
-			L.pushnumber(lua_get_fb_color(L, 1, fname).asnumber());
+			L.pushnumber(c.asnumber());
 			return 1;
 		}
-		int64_t a = 256;
+		int64_t r = P.arg<int64_t>();
-		int64_t r = L.get_numeric_argument<uint32_t>(1, fname.c_str());
+		int64_t g = P.arg<int64_t>();
-		int64_t g = L.get_numeric_argument<uint32_t>(2, fname.c_str());
+		int64_t b = P.arg<int64_t>();
-		int64_t b = L.get_numeric_argument<uint32_t>(3, fname.c_str());
+		int64_t a = P.arg_opt<int64_t>(256);
-		L.get_numeric_argument<int64_t>(4, a, fname.c_str());
 		if(a > 0)
 			L.pushnumber(((256 - a) << 24) | (r << 16) | (g << 8) | b);
 		else
@@ -79,10 +76,9 @@ namespace
 		return 1;
 	});
 
-	lua::fnptr gui_status(lua_func_misc, "gui.status", [](lua::state& L, const std::string& fname)
+	lua::fnptr2 gui_status(lua_func_misc, "gui.status", [](lua::state& L, lua::parameters& P) -> int {
-		-> int {
+		auto name = P.arg<std::string>();
-		std::string name = L.get_string(1, fname.c_str());
+		auto value = P.arg<std::string>();
-		std::string value = L.get_string(2, fname.c_str());
 		auto& w = platform::get_emustatus();
 		if(value == "")
 			w.erase("L[" + name + "]");
@@ -91,12 +87,10 @@ namespace
 		return 1;
 	});
 
-	lua::fnptr gui_rainbow(lua_func_misc, "gui.rainbow", [](lua::state& L, const std::string& fname)
+	lua::fnptr2 gui_rainbow(lua_func_misc, "gui.rainbow", [](lua::state& L, lua::parameters& P) -> int {
-		-> int {
+		int64_t step = P.arg<int64_t>();
-		int64_t basecolor = 0x00FF0000;
+		int64_t steps = P.arg<int64_t>();
-		int64_t step = L.get_numeric_argument<uint64_t>(1, fname.c_str());
+		auto basecolor = P.color(0x00FF0000).asnumber();
-		int64_t steps = L.get_numeric_argument<int64_t>(2, fname.c_str());
-		basecolor = lua_get_fb_color(L, 3, fname).asnumber();
 		if(!steps)
 			throw std::runtime_error("Expected nonzero steps for gui.rainbow");
 		basecolor = framebuffer::color_rotate_hue(basecolor, step, steps);
@@ -104,17 +98,15 @@ namespace
 		return 1;
 	});
 
-	lua::fnptr gui_killframe(lua_func_misc, "gui.kill_frame", [](lua::state& L, const std::string& fname)
+	lua::fnptr2 gui_killframe(lua_func_misc, "gui.kill_frame", [](lua::state& L, lua::parameters& P) -> int {
-		-> int {
 		if(lua_kill_frame)
 			*lua_kill_frame = true;
 	});
 
-	lua::fnptr gui_setscale(lua_func_misc, "gui.set_video_scale", [](lua::state& L, const std::string& fname)
+	lua::fnptr2 gui_setscale(lua_func_misc, "gui.set_video_scale", [](lua::state& L, lua::parameters& P) -> int {
-		-> int {
 		if(lua_hscl && lua_vscl) {
-			uint32_t h = L.get_numeric_argument<uint32_t>(1, fname.c_str());
+			auto h = P.arg<uint32_t>();
-			uint32_t v = L.get_numeric_argument<uint32_t>(2, fname.c_str());
+			auto v = P.arg<uint32_t>();
 			*lua_hscl = h;
 			*lua_vscl = v;
 		}

src/lua/gui-crosshair.cpp

@@ -37,15 +37,14 @@ namespace
 		uint32_t length;
 	};
 
-	lua::fnptr gui_crosshair(lua_func_misc, "gui.crosshair", [](lua::state& L, const std::string& fname)
+	lua::fnptr2 gui_crosshair(lua_func_misc, "gui.crosshair", [](lua::state& L, lua::parameters& P)
 		-> int {
 		if(!lua_render_ctx)
 			return 0;
-		uint32_t length = 10;
+		auto x = P.arg<int32_t>();
-		int32_t x = L.get_numeric_argument<int32_t>(1, fname.c_str());
+		auto y = P.arg<int32_t>();
-		int32_t y = L.get_numeric_argument<int32_t>(2, fname.c_str());
+		auto length = P.arg_opt<uint32_t>(10);
-		L.get_numeric_argument<uint32_t>(3, length, fname.c_str());
+		auto pcolor = P.color(0xFFFFFFU);
-		auto pcolor = lua_get_fb_color(L, 4, fname, 0xFFFFFFU);
 		lua_render_ctx->queue->create_add<render_object_crosshair>(x, y, pcolor, length);
 		return 0;
 	});

src/lua/gui-line.cpp

@@ -90,14 +90,14 @@ nodraw2:
 		framebuffer::color color;
 	};
 
-	lua::fnptr gui_pixel(lua_func_misc, "gui.line", [](lua::state& L, const std::string& fname) -> int {
+	lua::fnptr2 gui_pixel(lua_func_misc, "gui.line", [](lua::state& L, lua::parameters& P) -> int {
 		if(!lua_render_ctx)
 			return 0;
-		int32_t x1 = L.get_numeric_argument<int32_t>(1, fname.c_str());
+		auto x1 = P.arg<int32_t>();
-		int32_t y1 = L.get_numeric_argument<int32_t>(2, fname.c_str());
+		auto y1 = P.arg<int32_t>();
-		int32_t x2 = L.get_numeric_argument<int32_t>(3, fname.c_str());
+		auto x2 = P.arg<int32_t>();
-		int32_t y2 = L.get_numeric_argument<int32_t>(4, fname.c_str());
+		auto y2 = P.arg<int32_t>();
-		auto pcolor = lua_get_fb_color(L, 5, fname, 0xFFFFFFU);
+		auto pcolor = P.color(0xFFFFFFU);
 		lua_render_ctx->queue->create_add<render_object_line>(x1, x2, y1, y2, pcolor);
 		return 0;
 	});

src/lua/gui-pixel.cpp

@@ -29,12 +29,12 @@ namespace
 		framebuffer::color color;
 	};
 
-	lua::fnptr gui_pixel(lua_func_misc, "gui.pixel", [](lua::state& L, const std::string& fname) -> int {
+	lua::fnptr2 gui_pixel(lua_func_misc, "gui.pixel", [](lua::state& L, lua::parameters& P) -> int {
 		if(!lua_render_ctx)
 			return 0;
-		int32_t x = L.get_numeric_argument<int32_t>(1, fname.c_str());
+		auto x = P.arg<int32_t>();
-		int32_t y = L.get_numeric_argument<int32_t>(2, fname.c_str());
+		auto y = P.arg<int32_t>();
-		auto pcolor = lua_get_fb_color(L, 3, fname, 0xFFFFFFU);
+		auto pcolor = P.color(0xFFFFFFU);
 		lua_render_ctx->queue->create_add<render_object_pixel>(x, y, pcolor);
 		return 0;
 	});

src/lua/gui-rectangle.cpp

@@ -47,18 +47,17 @@ namespace
 		int32_t thickness;
 	};
 
-	lua::fnptr gui_rectangle(lua_func_misc, "gui.rectangle", [](lua::state& L, const std::string& fname)
+	lua::fnptr2 gui_rectangle(lua_func_misc, "gui.rectangle", [](lua::state& L, lua::parameters& P)
 		-> int {
 		if(!lua_render_ctx)
 			return 0;
-		uint32_t thickness = 1;
+		auto x = P.arg<int32_t>();
-		int32_t x = L.get_numeric_argument<int32_t>(1, fname.c_str());
+		auto y = P.arg<int32_t>();
-		int32_t y = L.get_numeric_argument<int32_t>(2, fname.c_str());
+		auto width = P.arg<uint32_t>();
-		uint32_t width = L.get_numeric_argument<uint32_t>(3, fname.c_str());
+		auto height = P.arg<uint32_t>();
-		uint32_t height = L.get_numeric_argument<uint32_t>(4, fname.c_str());
+		auto thickness = P.arg_opt<uint32_t>(1);
-		L.get_numeric_argument<uint32_t>(5, thickness, fname.c_str());
+		auto poutline = P.color(0xFFFFFFU);
-		auto poutline = lua_get_fb_color(L, 6, fname, 0xFFFFFFU);
+		auto pfill = P.color(-1);
-		auto pfill = lua_get_fb_color(L, 7, fname, -1);
 		lua_render_ctx->queue->create_add<render_object_rectangle>(x, y, width, height, poutline, pfill,
 			thickness);
 		return 0;

src/lua/gui-text.cpp

@@ -30,33 +30,22 @@ namespace
 		bool vdbl;
 	};
 
-	int internal_gui_text(lua::state& L, const std::string& fname, bool hdbl, bool vdbl)
+	template<bool hdbl, bool vdbl>
+	int internal_gui_text(lua::state& L, lua::parameters& P)
 	{
 		if(!lua_render_ctx)
 			return 0;
-		int32_t _x = L.get_numeric_argument<int32_t>(1, fname.c_str());
+		auto _x = P.arg<int32_t>();
-		int32_t _y = L.get_numeric_argument<int32_t>(2, fname.c_str());
+		auto _y = P.arg<int32_t>();
-		auto fg = lua_get_fb_color(L, 4, fname, 0xFFFFFFU);
+		auto text = P.arg<std::string>();
-		auto bg = lua_get_fb_color(L, 5, fname, -1);
+		auto fg = P.color(0xFFFFFFU);
-		std::string text = L.get_string(3, fname.c_str());
+		auto bg = P.color(-1);
 		lua_render_ctx->queue->create_add<render_object_text>(_x, _y, text, fg, bg, hdbl, vdbl);
 		return 0;
 	}
 
-	lua::fnptr gui_text(lua_func_misc, "gui.text", [](lua::state& L, const std::string& fname) -> int {
+	lua::fnptr2 gui_text(lua_func_misc, "gui.text", internal_gui_text<false, false>);
-		return internal_gui_text(L, fname, false, false);
+	lua::fnptr2 gui_textH(lua_func_misc, "gui.textH", internal_gui_text<true, false>);
-	});
+	lua::fnptr2 gui_textV(lua_func_misc, "gui.textV", internal_gui_text<false, true>);
-
+	lua::fnptr2 gui_textHV(lua_func_misc, "gui.textHV", internal_gui_text<true, true>);
-	lua::fnptr gui_textH(lua_func_misc, "gui.textH", [](lua::state& L, const std::string& fname) -> int {
-		return internal_gui_text(L, fname, true, false);
-	});
-
-	lua::fnptr gui_textV(lua_func_misc, "gui.textV", [](lua::state& L, const std::string& fname) -> int {
-		return internal_gui_text(L, fname, false, true);
-	});
-
-	lua::fnptr gui_textHV(lua_func_misc, "gui.textHV", [](lua::state& L, const std::string& fname)
-		-> int {
-		return internal_gui_text(L, fname, true, true);
-	});
 }

src/lua/ibind.cpp

@@ -11,6 +11,7 @@ public:
 	{
 		return ikey.getname();
 	}
+	static int create(lua::state& L, lua::parameters& P);
 private:
 	keyboard::invbind ikey;
 };
@@ -60,6 +61,7 @@ public:
 		else
 			return a->get_name();
 	}
+	static int create(lua::state& L, lua::parameters& P);
 private:
 	lua_command_binding* a;
 	lua_command_binding* b;
@@ -89,11 +91,9 @@ lua_command_bind::~lua_command_bind()
 
 namespace
 {
-	lua::fnptr input_bindings(lua_func_misc, "list_bindings", [](lua::state& L, const std::string& fname)
+	lua::fnptr2 input_bindings(lua_func_misc, "list_bindings", [](lua::state& L, lua::parameters& P) -> int {
-		-> int {
+		auto target = P.arg_opt<std::string>("");
-		std::string target;
+
-		if(!L.isnoneornil(1))
-			target = L.get_string(1, fname.c_str());
 		L.newtable();
 		for(auto key : lsnes_mapper.get_bindings()) {
 			std::string _key = key;
@@ -121,45 +121,47 @@ namespace
 		return 1;
 	});
 
-	lua::fnptr get_alias(lua_func_misc, "get_alias", [](lua::state& L, const std::string& fname) -> int {
+	lua::fnptr2 get_alias(lua_func_misc, "get_alias", [](lua::state& L, lua::parameters& P) -> int {
-		std::string name = L.get_string(1, fname.c_str());
+		auto name = P.arg<std::string>();
 		std::string a = lsnes_cmd.get_alias_for(name);
 		if(a != "")
-			L.pushlstring(a.c_str(), a.length());
+			L.pushlstring(a);
 		else
 			L.pushnil();
 		return 1;
 	});
 
-	lua::fnptr set_alias(lua_func_misc, "set_alias", [](lua::state& L, const std::string& fname) -> int {
+	lua::fnptr2 set_alias(lua_func_misc, "set_alias", [](lua::state& L, lua::parameters& P) -> int {
-		std::string name = L.get_string(1, fname.c_str());
+		auto name = P.arg<std::string>();
-		std::string value;
+		auto value = P.arg_opt<std::string>("");
-		if(L.type(2) != LUA_TNIL)
-			value = L.get_string(2, fname.c_str());
 		lsnes_cmd.set_alias_for(name, value);
 		refresh_alias_binds();
 		return 0;
 	});
 
-	lua::fnptr create_ibind(lua_func_misc, "create_ibind", [](lua::state& L, const std::string& fname)
+	lua::_class<lua_inverse_bind> class_inverse_bind(lua_class_bind, "INVERSEBIND", {
-		-> int {
+		{"new", lua_inverse_bind::create},
-		std::string name = L.get_string(1, fname.c_str());
+	}, {});
-		std::string command = L.get_string(2, fname.c_str());
+	lua::_class<lua_command_bind> class_command_bind(lua_class_bind, "COMMANDBIND", {
-		lua_inverse_bind* b = lua::_class<lua_inverse_bind>::create(L, name, command);
+		{"new", lua_command_bind::create},
-		return 1;
+	}, {});
-	});
+}
-
+
-	lua::fnptr create_cmd(lua_func_misc, "create_command", [](lua::state& L, const std::string& fname)
+int lua_inverse_bind::create(lua::state& L, lua::parameters& P)
-		-> int {
+{
-		if(L.type(2) != LUA_TFUNCTION)
+	auto name = P.arg<std::string>();
-			throw std::runtime_error("Argument 2 of create_command must be function");
+	auto command = P.arg<std::string>();
-		if(L.type(3) != LUA_TFUNCTION && L.type(3) != LUA_TNIL && L.type(3) != LUA_TNONE)
+	lua_inverse_bind* b = lua::_class<lua_inverse_bind>::create(L, name, command);
-			throw std::runtime_error("Argument 2 of create_command must be function or nil");
+	return 1;
-		std::string name = L.get_string(1, fname.c_str());
+}
-		lua_command_bind* b = lua::_class<lua_command_bind>::create(L, name, 2, 3);
+
-		return 1;
+int lua_command_bind::create(lua::state& L, lua::parameters& P)
-	});
+{
-
+	auto name = P.arg<std::string>();
-	lua::_class<lua_inverse_bind> class_inverse_bind(lua_class_bind, "INVERSEBIND", {}, {});
+	if(!P.is_function())
-	lua::_class<lua_command_bind> class_command_bind(lua_class_bind, "COMMANDBIND", {}, {});
+		P.expected("function");
+	if(!P.is_function(3) && P.is_novalue(3))
+		P.expected("function or nil", 3);
+	lua_command_bind* b = lua::_class<lua_command_bind>::create(L, name, 2, 3);
+	return 1;
 }

src/lua/iconv.cpp

@@ -146,13 +146,10 @@ exit:
 		return 1;
 	}
 
-	lua::fnptr iconv_byteU(lua_func_bit, "_lsnes_string_byteU", [](lua::state& L, const std::string& fname)
+	lua::fnptr2 iconv_byteU(lua_func_bit, "_lsnes_string_byteU", [](lua::state& L, lua::parameters& P) -> int {
-		-> int {
+		auto _str = P.arg<std::string>();
-		std::string _str = L.get_string(1, fname.c_str());
+		size_t i = P.arg_opt<size_t>(1);
-		size_t i = 1;
+		size_t j = P.arg_opt<size_t>(i);
-		L.get_numeric_argument<size_t>(2, i, fname.c_str());
-		size_t j = i;
-		L.get_numeric_argument<size_t>(3, j, fname.c_str());
 		std::u32string str = utf8::to32(_str);
 		if(i == 0) i = 1;
 		size_t p = 0;
@@ -163,11 +160,10 @@ exit:
 		return p;
 	});
 
-	lua::fnptr iconv_charU(lua_func_bit, "_lsnes_string_charU", [](lua::state& L, const std::string& fname)
+	lua::fnptr2 iconv_charU(lua_func_bit, "_lsnes_string_charU", [](lua::state& L, lua::parameters& P) -> int {
-		-> int {
 		std::u32string str;
-		for(int i = 1; L.type(i) == LUA_TNUMBER; i++) {
+		while(P.more()) {
-			uint32_t cp = L.get_numeric_argument<uint32_t>(i, fname.c_str());
+			auto cp = P.arg<uint32_t>();
 			//Surrogates are not valid unicode.
 			if((cp & 0xD800) == 0xD800)
 				throw std::runtime_error("Invalid character");

src/lua/loadfile.cpp

@@ -253,12 +253,10 @@ namespace
 		}
 	}
 
-	void load_chunk(lua::state& L, const std::string& fname)
+	void load_chunk(lua::state& L, lua::parameters& P)
 	{
-		std::string file2;
+		auto file1 = P.arg<std::string>();
-		std::string file1 = L.get_string(1, fname.c_str());
+		auto file2 = P.arg_opt<std::string>("");
-		if(L.type(2) != LUA_TNIL && L.type(2) != LUA_TNONE)
-			file2 = L.get_string(2, fname.c_str());
 		std::string absfilename = zip::resolverel(file1, file2);
 		std::istream& file = zip::openrel(file1, file2);
 		std::string chunkname;
@@ -291,13 +289,13 @@ namespace
 	{
 	}
 
-	lua::fnptr loadfile2(lua_func_load, "loadfile2", [](lua::state& L, const std::string& fname) -> int {
+	lua::fnptr2 loadfile2(lua_func_load, "loadfile2", [](lua::state& L, lua::parameters& P) -> int {
-		load_chunk(L, fname);
+		load_chunk(L, P);
 		return 1;
 	});
 
-	lua::fnptr dofile2(lua_func_load, "dofile2", [](lua::state& L, const std::string& fname) -> int {
+	lua::fnptr2 dofile2(lua_func_load, "dofile2", [](lua::state& L, lua::parameters& P) -> int {
-		load_chunk(L, fname);
+		load_chunk(L, P);
 		int old_sp = lua_gettop(L.handle());
 		lua_call(L.handle(), 0, LUA_MULTRET);
 		int new_sp = lua_gettop(L.handle());

src/lua/random.cpp

@@ -28,23 +28,21 @@ namespace
 		}
 	}
 
-	lua::fnptr rboolean(lua_func_misc, "random.boolean", [](lua::state& L, const std::string& fname)
+	lua::fnptr2 rboolean(lua_func_misc, "random.boolean", [](lua::state& L, lua::parameters& P) -> int {
-		-> int {
 		L.pushboolean(randnum() % 2);
 		return 1;
 	});
 
-	lua::fnptr rinteger(lua_func_misc, "random.integer", [](lua::state& L, const std::string& fname)
+	lua::fnptr2 rinteger(lua_func_misc, "random.integer", [](lua::state& L, lua::parameters& P) -> int {
-		-> int {
+		auto low = P.arg<int64_t>();
-		int64_t low = 0;
 		int64_t high = 0;
-		if(L.type(2) == LUA_TNUMBER) {
+		if(P.is_number()) {
-			low = L.get_numeric_argument<int64_t>(1, fname.c_str());
+			high = P.arg<uint64_t>();
-			high = L.get_numeric_argument<int64_t>(2, fname.c_str());
 			if(low > high)
 				throw std::runtime_error("random.integer: high > low");
 		} else {
-			high = L.get_numeric_argument<int64_t>(1, fname.c_str()) - 1;
+			high = low - 1;
+			low = 0;
 			if(high < 0)
 				throw std::runtime_error("random.integer: high > low");
 		}
@@ -53,8 +51,7 @@ namespace
 		return 1;
 	});
 
-	lua::fnptr rfloat(lua_func_misc, "random.float", [](lua::state& L, const std::string& fname)
+	lua::fnptr2 rfloat(lua_func_misc, "random.float", [](lua::state& L, lua::parameters& P) -> int {
-		-> int {
 		double _bits = 0;
 		uint64_t* bits = (uint64_t*)&_bits;
 		*bits = randnum() & 0xFFFFFFFFFFFFFULL;
@@ -63,11 +60,12 @@ namespace
 		return 1;
 	});
 
-	lua::fnptr ramong(lua_func_misc, "random.among", [](lua::state& L, const std::string& fname)
+	lua::fnptr2 ramong(lua_func_misc, "random.among", [](lua::state& L, lua::parameters& P) -> int {
-	{
 		unsigned args = 1;
-		while(L.type(args) != LUA_TNONE)
+		while(P.more()) {
+			P.skip();
 			args++;
+		}
 		args--;
 		if(!args) {
 			L.pushnil();
@@ -78,10 +76,10 @@ namespace
 		return 1;
 	});
 
-	lua::fnptr ramongt(lua_func_misc, "random.amongtable", [](lua::state& L, const std::string& fname)
+	lua::fnptr2 ramongt(lua_func_misc, "random.amongtable", [](lua::state& L, lua::parameters& P)
 	{
-		if(L.type(1) != LUA_TTABLE)
+		if(!P.is_table())
-			throw std::runtime_error("random.amongtable: First argument must be table");
+			P.expected("table");
 		uint64_t size = 0;
 		L.pushnil();
 		while(L.next(1)) {

src/lua/screenshot.cpp

@@ -4,15 +4,15 @@
 
 namespace
 {
-	lua::fnptr lua_gui_screenshot(lua_func_misc, "gui.screenshot", [](lua::state& L,
+	lua::fnptr2 lua_gui_screenshot(lua_func_misc, "gui.screenshot", [](lua::state& L,
-		const std::string& fname) -> int {
+		lua::parameters& P) -> int {
-		std::string fn = L.get_string(1, fname.c_str());
+		auto fn = P.arg<std::string>();
 		take_screenshot(fn);
 		return 0;
 	});
 
-	lua::fnptr lua_gui_screenshot_b(lua_func_misc, "gui.screenshot_bitmap", [](lua::state& L,
+	lua::fnptr2 lua_gui_screenshot_b(lua_func_misc, "gui.screenshot_bitmap", [](lua::state& L,
-		const std::string& fname) -> int {
+		lua::parameters& P) -> int {
 		framebuffer::raw& _fb = render_get_latest_screen();
 		try {
 			auto osize = std::make_pair(_fb.get_width(), _fb.get_height());

src/lua/settings.cpp

@@ -3,9 +3,9 @@
 
 namespace
 {
-	lua::fnptr ss(lua_func_misc, "settings.set", [](lua::state& L, const std::string& fname) -> int {
+	lua::fnptr2 ss(lua_func_misc, "settings.set", [](lua::state& L, lua::parameters& P) -> int {
-		std::string name = L.get_string(1, fname.c_str());
+		auto name = P.arg<std::string>();
-		std::string value = L.get_string(2, fname.c_str());
+		auto value = P.arg<std::string>();
 		try {
 			lsnes_vsetc.set(name, value);
 		} catch(std::exception& e) {
@@ -17,8 +17,8 @@ namespace
 		return 1;
 	});
 
-	lua::fnptr sg(lua_func_misc, "settings.get", [](lua::state& L, const std::string& fname) -> int {
+	lua::fnptr2 sg(lua_func_misc, "settings.get", [](lua::state& L, lua::parameters& P) -> int {
-		std::string name = L.get_string(1, fname.c_str());
+		auto name = P.arg<std::string>();
 		try {
 			std::string value = lsnes_vsetc.get(name);
 			L.pushlstring(value.c_str(), value.length());

src/lua/subtitles.cpp

@@ -3,9 +3,8 @@
 
 namespace
 {
-	lua::fnptr enumerate(lua_func_misc, "subtitle.byindex", [](lua::state& L, const std::string& fname)
+	lua::fnptr2 enumerate(lua_func_misc, "subtitle.byindex", [](lua::state& L, lua::parameters& P) -> int {
-		-> int {
+		auto n = P.arg<uint64_t>();
-		uint64_t n = L.get_numeric_argument<uint64_t>(1, fname.c_str());
 		uint64_t j = 0;
 		for(auto i : get_subtitles()) {
 			if(j == n) {
@@ -18,25 +17,25 @@ namespace
 		return 0;
 	});
 
-	lua::fnptr sget(lua_func_misc, "subtitle.get", [](lua::state& L, const std::string& fname) -> int {
+	lua::fnptr2 sget(lua_func_misc, "subtitle.get", [](lua::state& L, lua::parameters& P) -> int {
-		uint64_t frame = L.get_numeric_argument<uint64_t>(1, fname.c_str());
+		auto frame = P.arg<uint64_t>();
-		uint64_t length = L.get_numeric_argument<uint64_t>(2, fname.c_str());
+		auto length = P.arg<uint64_t>();
 		std::string x = get_subtitle_for(frame, length);
 		L.pushstring(x.c_str());
 		return 1;
 	});
 
-	lua::fnptr sset(lua_func_misc, "subtitle.set", [](lua::state& L, const std::string& fname) -> int {
+	lua::fnptr2 sset(lua_func_misc, "subtitle.set", [](lua::state& L, lua::parameters& P) -> int {
-		uint64_t frame = L.get_numeric_argument<uint64_t>(1, fname.c_str());
+		auto frame = P.arg<uint64_t>();
-		uint64_t length = L.get_numeric_argument<uint64_t>(2, fname.c_str());
+		auto length = P.arg<uint64_t>();
-		std::string text = L.get_string(3, fname.c_str());
+		std::string text = P.arg<std::string>();
 		set_subtitle_for(frame, length, text);
 		return 0;
 	});
 
-	lua::fnptr sdel(lua_func_misc, "subtitle.delete", [](lua::state& L, const std::string& fname) -> int {
+	lua::fnptr2 sdel(lua_func_misc, "subtitle.delete", [](lua::state& L, lua::parameters& P) -> int {
-		uint64_t frame = L.get_numeric_argument<uint64_t>(1, fname.c_str());
+		auto frame = P.arg<uint64_t>();
-		uint64_t length = L.get_numeric_argument<uint64_t>(2, fname.c_str());
+		auto length = P.arg<uint64_t>();
 		set_subtitle_for(frame, length, "");
 		return 0;
 	});

src/lua/sysrc.lua

@@ -64,6 +64,8 @@ gui.palette_new=classes.PALETTE.new;
 gui.font_new = classes.CUSTOMFONT.new;
 gui.loadfont = classes.CUSTOMFONT.load;
 iconv_new = classes.ICONV.new;
+create_ibind = classes.INVERSEBIND.new;
+create_command = classes.COMMANDBIND.new;
 
 local do_arg_err = function(what, n, name)
 	error("Expected "..what.." as argument #"..n.." of "..name);

src/lua/zip.cpp

@@ -98,12 +98,10 @@ namespace
 		file_open = NULL;
 	}
 
-	lua::fnptr lua_enumerate_zip(lua_func_zip, "zip.enumerate", [](lua::state& L, const std::string& fname)
+	lua::fnptr2 lua_enumerate_zip(lua_func_zip, "zip.enumerate", [](lua::state& L, lua::parameters& P) -> int {
-		-> int {
+		auto filename = P.arg<std::string>();
-		std::string filename = L.get_string(1, fname.c_str());
+		auto invert = P.arg_opt<bool>(false);
-		bool invert = false;
+
-		if(L.type(2) != LUA_TNONE && L.type(2) != LUA_TNIL)
-			invert = L.toboolean(2);
 		zip::reader r(filename);
 		L.newtable();
 		size_t idx = 1;