1 files changed, 396 insertions, 0 deletions
diff --git a/src/ext/timeouts/lua/timeout-lua.c b/src/ext/timeouts/lua/timeout-lua.c
new file mode 100644
index 0000000000..4d4e54cba6
--- /dev/null
+++ b/src/ext/timeouts/lua/timeout-lua.c
@@ -0,0 +1,396 @@
+#include <assert.h>
+#include <string.h>
+
+#include <lua.h>
+#include <lualib.h>
+#include <lauxlib.h>
+
+#if LUA_VERSION_NUM != 503
+#error only Lua 5.3 supported
+#endif
+
+#define TIMEOUT_PUBLIC static
+#include "timeout.h"
+#include "timeout.c"
+
+#define TIMEOUT_METANAME "struct timeout"
+#define TIMEOUTS_METANAME "struct timeouts*"
+
+static struct timeout *
+to_checkudata(lua_State *L, int index)
+{
+	return luaL_checkudata(L, index, TIMEOUT_METANAME);
+}
+
+static struct timeouts *
+tos_checkudata(lua_State *L, int index)
+{
+	return *(struct timeouts **)luaL_checkudata(L, index, TIMEOUTS_METANAME);
+}
+
+static void
+tos_bind(lua_State *L, int tos_index, int to_index)
+{
+	lua_getuservalue(L, tos_index);
+	lua_pushlightuserdata(L, to_checkudata(L, to_index));
+	lua_pushvalue(L, to_index);
+	lua_rawset(L, -3);
+	lua_pop(L, 1);
+}
+
+static void
+tos_unbind(lua_State *L, int tos_index, int to_index)
+{
+	lua_getuservalue(L, tos_index);
+	lua_pushlightuserdata(L, to_checkudata(L, to_index));
+	lua_pushnil(L);
+	lua_rawset(L, -3);
+	lua_pop(L, 1);
+}
+
+static int
+to__index(lua_State *L)
+{
+	struct timeout *to = to_checkudata(L, 1);
+
+	if (lua_type(L, 2 == LUA_TSTRING)) {
+		const char *key = lua_tostring(L, 2);
+
+		if (!strcmp(key, "flags")) {
+			lua_pushinteger(L, to->flags);
+
+			return 1;
+		} else if (!strcmp(key, "expires")) {
+			lua_pushinteger(L, to->expires);
+
+			return 1;
+		}
+	}
+
+	if (LUA_TNIL != lua_getuservalue(L, 1)) {
+		lua_pushvalue(L, 2);
+		if (LUA_TNIL != lua_rawget(L, -2))
+			return 1;
+	}
+
+	lua_pushvalue(L, 2);
+	if (LUA_TNIL != lua_rawget(L, lua_upvalueindex(1)))
+		return 1;
+
+	return 0;
+}
+
+static int
+to__newindex(lua_State *L)
+{
+	if (LUA_TNIL == lua_getuservalue(L, 1)) {
+		lua_newtable(L);
+		lua_pushvalue(L, -1);
+		lua_setuservalue(L, 1);
+	}
+
+	lua_pushvalue(L, 2);
+	lua_pushvalue(L, 3);
+	lua_rawset(L, -3);
+
+	return 0;
+}
+
+static int
+to__gc(lua_State *L)
+{
+	struct timeout *to = to_checkudata(L, 1);
+
+	/*
+	 * NB: On script exit it's possible for a timeout to still be
+	 * associated with a timeouts object, particularly when the timeouts
+	 * object was created first.
+	 */
+	timeout_del(to);
+
+	return 0;
+}
+
+static int
+to_new(lua_State *L)
+{
+	int flags = luaL_optinteger(L, 1, 0);
+	struct timeout *to;
+
+	to = lua_newuserdata(L, sizeof *to);
+	timeout_init(to, flags);
+	luaL_setmetatable(L, TIMEOUT_METANAME);
+
+	return 1;
+}
+
+static const luaL_Reg to_methods[] = {
+	{ NULL,  NULL },
+};
+
+static const luaL_Reg to_metatable[] = {
+	{ "__index",    &to__index },
+	{ "__newindex", &to__newindex },
+	{ "__gc",       &to__gc },
+	{ NULL,         NULL },
+};
+
+static const luaL_Reg to_globals[] = {
+	{ "new", &to_new },
+	{ NULL,  NULL },
+};
+
+static void
+to_newmetatable(lua_State *L)
+{
+	if (luaL_newmetatable(L, TIMEOUT_METANAME)) {
+		/*
+		 * fill metamethod table, capturing the methods table as an
+		 * upvalue for use by __index metamethod
+		 */
+		luaL_newlib(L, to_methods);
+		luaL_setfuncs(L, to_metatable, 1);
+	}
+}
+
+int
+luaopen_timeout(lua_State *L)
+{
+	to_newmetatable(L);
+
+	luaL_newlib(L, to_globals);
+	lua_pushinteger(L, TIMEOUT_INT);
+	lua_setfield(L, -2, "INT");
+	lua_pushinteger(L, TIMEOUT_ABS);
+	lua_setfield(L, -2, "ABS");
+
+	return 1;
+}
+
+static int
+tos_update(lua_State *L)
+{
+	struct timeouts *T = tos_checkudata(L, 1);
+	lua_Number n = luaL_checknumber(L, 2);
+
+	timeouts_update(T, timeouts_f2i(T, n));
+
+	lua_pushvalue(L, 1);
+
+	return 1;
+}
+
+static int
+tos_step(lua_State *L)
+{
+	struct timeouts *T = tos_checkudata(L, 1);
+	lua_Number n = luaL_checknumber(L, 2);
+
+	timeouts_step(T, timeouts_f2i(T, n));
+
+	lua_pushvalue(L, 1);
+
+	return 1;
+}
+
+static int
+tos_timeout(lua_State *L)
+{
+	struct timeouts *T = tos_checkudata(L, 1);
+
+	lua_pushnumber(L, timeouts_i2f(T, timeouts_timeout(T)));
+
+	return 1;
+}
+
+static int
+tos_add(lua_State *L)
+{
+	struct timeouts *T = tos_checkudata(L, 1);
+	struct timeout *to = to_checkudata(L, 2);
+	lua_Number timeout = luaL_checknumber(L, 3);
+
+	tos_bind(L, 1, 2);
+	timeouts_addf(T, to, timeout);
+
+	return lua_pushvalue(L, 1), 1;
+}
+
+static int
+tos_del(lua_State *L)
+{
+	struct timeouts *T = tos_checkudata(L, 1);
+	struct timeout *to = to_checkudata(L, 2);
+
+	timeouts_del(T, to);
+	tos_unbind(L, 1, 2);
+
+	return lua_pushvalue(L, 1), 1;
+}
+
+static int
+tos_get(lua_State *L)
+{
+	struct timeouts *T = tos_checkudata(L, 1);
+	struct timeout *to;
+
+	if (!(to = timeouts_get(T)))
+		return 0;
+
+	lua_getuservalue(L, 1);
+	lua_rawgetp(L, -1, to);
+
+	if (!timeout_pending(to))
+		tos_unbind(L, 1, lua_absindex(L, -1));
+
+	return 1;
+}
+
+static int
+tos_pending(lua_State *L)
+{
+	struct timeouts *T = tos_checkudata(L, 1);
+
+	lua_pushboolean(L, timeouts_pending(T));
+
+	return 1;
+}
+
+static int
+tos_expired(lua_State *L)
+{
+	struct timeouts *T = tos_checkudata(L, 1);
+
+	lua_pushboolean(L, timeouts_expired(T));
+
+	return 1;
+}
+
+static int
+tos_check(lua_State *L)
+{
+	struct timeouts *T = tos_checkudata(L, 1);
+
+	lua_pushboolean(L, timeouts_check(T, NULL));
+
+	return 1;
+}
+
+static int
+tos__next(lua_State *L)
+{
+	struct timeouts *T = tos_checkudata(L, lua_upvalueindex(1));
+	struct timeouts_it *it = lua_touserdata(L, lua_upvalueindex(2));
+	struct timeout *to;
+
+	if (!(to = timeouts_next(T, it)))
+		return 0;
+
+	lua_getuservalue(L, lua_upvalueindex(1));
+	lua_rawgetp(L, -1, to);
+
+	return 1;
+}
+
+static int
+tos_timeouts(lua_State *L)
+{
+	int flags = luaL_checkinteger(L, 2);
+	struct timeouts_it *it;
+
+	tos_checkudata(L, 1);
+	lua_pushvalue(L, 1);
+	it = lua_newuserdata(L, sizeof *it);
+	TIMEOUTS_IT_INIT(it, flags);
+	lua_pushcclosure(L, &tos__next, 2);
+
+	return 1;
+}
+
+static int
+tos__gc(lua_State *L)
+{
+	struct timeouts **tos = luaL_checkudata(L, 1, TIMEOUTS_METANAME);
+	struct timeout *to;
+
+	TIMEOUTS_FOREACH(to, *tos, TIMEOUTS_ALL) {
+		timeouts_del(*tos, to);
+	}
+
+	timeouts_close(*tos);
+	*tos = NULL;
+
+	return 0;
+}
+
+static int
+tos_new(lua_State *L)
+{
+	timeout_t hz = luaL_optinteger(L, 1, 0);
+	struct timeouts **T;
+	int error;
+	
+	T = lua_newuserdata(L, sizeof *T);
+	luaL_setmetatable(L, TIMEOUTS_METANAME);
+
+	lua_newtable(L);
+	lua_setuservalue(L, -2);
+
+	if (!(*T = timeouts_open(hz, &error)))
+		return luaL_error(L, "%s", strerror(error));
+
+	return 1;
+}
+
+static const luaL_Reg tos_methods[] = {
+	{ "update",   &tos_update },
+	{ "step",     &tos_step },
+	{ "timeout",  &tos_timeout },
+	{ "add",      &tos_add },
+	{ "del",      &tos_del },
+	{ "get",      &tos_get },
+	{ "pending",  &tos_pending },
+	{ "expired",  &tos_expired },
+	{ "check",    &tos_check },
+	{ "timeouts", &tos_timeouts },
+	{ NULL,       NULL },
+};
+
+static const luaL_Reg tos_metatable[] = {
+	{ "__gc", &tos__gc },
+	{ NULL,   NULL },
+};
+
+static const luaL_Reg tos_globals[] = {
+	{ "new", &tos_new },
+	{ NULL,  NULL },
+};
+
+static void
+tos_newmetatable(lua_State *L)
+{
+	if (luaL_newmetatable(L, TIMEOUTS_METANAME)) {
+		luaL_setfuncs(L, tos_metatable, 0);
+		luaL_newlib(L, tos_methods);
+		lua_setfield(L, -2, "__index");
+	}
+}
+
+int
+luaopen_timeouts(lua_State *L)
+{
+	to_newmetatable(L);
+	tos_newmetatable(L);
+
+	luaL_newlib(L, tos_globals);
+	lua_pushinteger(L, TIMEOUTS_PENDING);
+	lua_setfield(L, -2, "PENDING");
+	lua_pushinteger(L, TIMEOUTS_EXPIRED);
+	lua_setfield(L, -2, "EXPIRED");
+	lua_pushinteger(L, TIMEOUTS_ALL);
+	lua_setfield(L, -2, "ALL");
+	lua_pushinteger(L, TIMEOUTS_CLEAR);
+	lua_setfield(L, -2, "CLEAR");
+
+	return 1;
+}