sweet-moon 0.0.1

data/logic/signatures/signatures_542.rb

@@ -0,0 +1,591 @@
+module Logic
+  module V542
+    Signatures = {
+      functions: [{ source: 'LUALIB_API char *(luaL_buffinitsize) (lua_State *L, luaL_Buffer *B, size_t sz);',
+                    ffi: [:luaL_buffinitsize, %i[pointer pointer ulong], :pointer] },
+                  { source: 'LUALIB_API char *(luaL_prepbuffsize) (luaL_Buffer *B, size_t sz);',
+                    ffi: [:luaL_prepbuffsize, %i[pointer ulong], :pointer] },
+                  { source: 'LUALIB_API const char *(luaL_checklstring) (lua_State *L, int arg, size_t *l);',
+                    ffi: [:luaL_checklstring, %i[pointer int pointer], :pointer] },
+                  { source: 'LUALIB_API const char *(luaL_gsub) (lua_State *L, const char *s, const char *p, const char *r);',
+                    ffi: [:luaL_gsub, %i[pointer pointer pointer pointer], :pointer] },
+                  { source: 'LUALIB_API const char *(luaL_optlstring) (lua_State *L, int arg, const char *def, size_t *l);',
+                    ffi: [:luaL_optlstring, %i[pointer int pointer pointer], :pointer] },
+                  { source: 'LUALIB_API const char *(luaL_tolstring) (lua_State *L, int idx, size_t *len);',
+                    ffi: [:luaL_tolstring, %i[pointer int pointer], :pointer] },
+                  { source: 'LUALIB_API int (luaL_argerror) (lua_State *L, int arg, const char *extramsg);',
+                    ffi: [:luaL_argerror, %i[pointer int pointer], :int] },
+                  { source: 'LUALIB_API int (luaL_callmeta) (lua_State *L, int obj, const char *e);',
+                    ffi: [:luaL_callmeta, %i[pointer int pointer], :int] },
+                  { source: 'LUALIB_API int (luaL_checkoption) (lua_State *L, int arg, const char *def, const char *const lst[]);',
+                    ffi: [:luaL_checkoption, %i[pointer int pointer pointer], :int] },
+                  { source: 'LUALIB_API int (luaL_error) (lua_State *L, const char *fmt, ...);',
+                    ffi: [:luaL_error, %i[pointer pointer varargs], :int] },
+                  { source: 'LUALIB_API int (luaL_execresult) (lua_State *L, int stat);',
+                    ffi: [:luaL_execresult, %i[pointer int], :int] },
+                  { source: 'LUALIB_API int (luaL_fileresult) (lua_State *L, int stat, const char *fname);',
+                    ffi: [:luaL_fileresult, %i[pointer int pointer], :int] },
+                  { source: 'LUALIB_API int (luaL_getmetafield) (lua_State *L, int obj, const char *e);',
+                    ffi: [:luaL_getmetafield, %i[pointer int pointer], :int] },
+                  { source: 'LUALIB_API int (luaL_getsubtable) (lua_State *L, int idx, const char *fname);',
+                    ffi: [:luaL_getsubtable, %i[pointer int pointer], :int] },
+                  { source: 'LUALIB_API int (luaL_loadbufferx) (lua_State *L, const char *buff, size_t sz, const char *name, const char *mode);',
+                    ffi: [:luaL_loadbufferx,
+                          %i[pointer pointer ulong pointer pointer],
+                          :int] },
+                  { source: 'LUALIB_API int (luaL_loadfilex) (lua_State *L, const char *filename, const char *mode);',
+                    ffi: [:luaL_loadfilex, %i[pointer pointer pointer], :int] },
+                  { source: 'LUALIB_API int (luaL_loadstring) (lua_State *L, const char *s);',
+                    ffi: [:luaL_loadstring, %i[pointer pointer], :int] },
+                  { source: 'LUALIB_API int (luaL_newmetatable) (lua_State *L, const char *tname);',
+                    ffi: [:luaL_newmetatable, %i[pointer pointer], :int] },
+                  { source: 'LUALIB_API int (luaL_ref) (lua_State *L, int t);',
+                    ffi: [:luaL_ref, %i[pointer int], :int] },
+                  { source: 'LUALIB_API int (luaL_typeerror) (lua_State *L, int arg, const char *tname);',
+                    ffi: [:luaL_typeerror, %i[pointer int pointer], :int] },
+                  { source: 'LUALIB_API lua_Integer (luaL_checkinteger) (lua_State *L, int arg);',
+                    ffi: [:luaL_checkinteger, %i[pointer int], :int] },
+                  { source: 'LUALIB_API lua_Integer (luaL_len) (lua_State *L, int idx);',
+                    ffi: [:luaL_len, %i[pointer int], :int] },
+                  { source: 'LUALIB_API lua_Integer (luaL_optinteger) (lua_State *L, int arg, lua_Integer def);',
+                    ffi: [:luaL_optinteger, %i[pointer int int], :int] },
+                  { source: 'LUALIB_API lua_Number (luaL_checknumber) (lua_State *L, int arg);',
+                    ffi: [:luaL_checknumber, %i[pointer int], :double] },
+                  { source: 'LUALIB_API lua_Number (luaL_optnumber) (lua_State *L, int arg, lua_Number def);',
+                    ffi: [:luaL_optnumber, %i[pointer int double], :double] },
+                  { source: 'LUALIB_API lua_State *(luaL_newstate) (void);',
+                    ffi: [:luaL_newstate, [], :pointer] },
+                  { source: 'LUALIB_API void (luaL_addlstring) (luaL_Buffer *B, const char *s, size_t l);',
+                    ffi: [:luaL_addlstring, %i[pointer pointer ulong], :void] },
+                  { source: 'LUALIB_API void (luaL_addstring) (luaL_Buffer *B, const char *s);',
+                    ffi: [:luaL_addstring, %i[pointer pointer], :void] },
+                  { source: 'LUALIB_API void (luaL_addvalue) (luaL_Buffer *B);',
+                    ffi: [:luaL_addvalue, [:pointer], :void] },
+                  { source: 'LUALIB_API void (luaL_buffinit) (lua_State *L, luaL_Buffer *B);',
+                    ffi: [:luaL_buffinit, %i[pointer pointer], :void] },
+                  { source: 'LUALIB_API void (luaL_checkany) (lua_State *L, int arg);',
+                    ffi: [:luaL_checkany, %i[pointer int], :void] },
+                  { source: 'LUALIB_API void (luaL_checkstack) (lua_State *L, int sz, const char *msg);',
+                    ffi: [:luaL_checkstack, %i[pointer int pointer], :void] },
+                  { source: 'LUALIB_API void (luaL_checktype) (lua_State *L, int arg, int t);',
+                    ffi: [:luaL_checktype, %i[pointer int int], :void] },
+                  { source: 'LUALIB_API void (luaL_checkversion_) (lua_State *L, lua_Number ver, size_t sz);',
+                    ffi: [:luaL_checkversion_, %i[pointer double ulong], :void] },
+                  { source: 'LUALIB_API void (luaL_openlibs) (lua_State *L);',
+                    ffi: [:luaL_openlibs, [:pointer], :void] },
+                  { source: 'LUALIB_API void (luaL_pushresult) (luaL_Buffer *B);',
+                    ffi: [:luaL_pushresult, [:pointer], :void] },
+                  { source: 'LUALIB_API void (luaL_pushresultsize) (luaL_Buffer *B, size_t sz);',
+                    ffi: [:luaL_pushresultsize, %i[pointer ulong], :void] },
+                  { source: 'LUALIB_API void (luaL_requiref) (lua_State *L, const char *modname, lua_CFunction openf, int glb);',
+                    ffi: [:luaL_requiref, %i[pointer pointer int int], :void] },
+                  { source: 'LUALIB_API void (luaL_setfuncs) (lua_State *L, const luaL_Reg *l, int nup);',
+                    ffi: [:luaL_setfuncs, %i[pointer pointer int], :void] },
+                  { source: 'LUALIB_API void (luaL_setmetatable) (lua_State *L, const char *tname);',
+                    ffi: [:luaL_setmetatable, %i[pointer pointer], :void] },
+                  { source: 'LUALIB_API void (luaL_traceback) (lua_State *L, lua_State *L1, const char *msg, int level);',
+                    ffi: [:luaL_traceback, %i[pointer pointer pointer int], :void] },
+                  { source: 'LUALIB_API void (luaL_unref) (lua_State *L, int t, int ref);',
+                    ffi: [:luaL_unref, %i[pointer int int], :void] },
+                  { source: 'LUALIB_API void (luaL_where) (lua_State *L, int lvl);',
+                    ffi: [:luaL_where, %i[pointer int], :void] },
+                  { source: 'LUALIB_API void *(luaL_checkudata) (lua_State *L, int ud, const char *tname);',
+                    ffi: [:luaL_checkudata, %i[pointer int pointer], :pointer] },
+                  { source: 'LUALIB_API void *(luaL_testudata) (lua_State *L, int ud, const char *tname);',
+                    ffi: [:luaL_testudata, %i[pointer int pointer], :pointer] },
+                  { source: 'LUALIB_API void luaL_addgsub (luaL_Buffer *b, const char *s, const char *p, const char *r);',
+                    ffi: [:luaL_addgsub, %i[pointer pointer pointer pointer], :void] },
+                  { source: 'LUAMOD_API int (luaopen_base) (lua_State *L);',
+                    ffi: [:luaopen_base, [:pointer], :int] },
+                  { source: 'LUAMOD_API int (luaopen_coroutine) (lua_State *L);',
+                    ffi: [:luaopen_coroutine, [:pointer], :int] },
+                  { source: 'LUAMOD_API int (luaopen_debug) (lua_State *L);',
+                    ffi: [:luaopen_debug, [:pointer], :int] },
+                  { source: 'LUAMOD_API int (luaopen_io) (lua_State *L);',
+                    ffi: [:luaopen_io, [:pointer], :int] },
+                  { source: 'LUAMOD_API int (luaopen_math) (lua_State *L);',
+                    ffi: [:luaopen_math, [:pointer], :int] },
+                  { source: 'LUAMOD_API int (luaopen_os) (lua_State *L);',
+                    ffi: [:luaopen_os, [:pointer], :int] },
+                  { source: 'LUAMOD_API int (luaopen_package) (lua_State *L);',
+                    ffi: [:luaopen_package, [:pointer], :int] },
+                  { source: 'LUAMOD_API int (luaopen_string) (lua_State *L);',
+                    ffi: [:luaopen_string, [:pointer], :int] },
+                  { source: 'LUAMOD_API int (luaopen_table) (lua_State *L);',
+                    ffi: [:luaopen_table, [:pointer], :int] },
+                  { source: 'LUAMOD_API int (luaopen_utf8) (lua_State *L);',
+                    ffi: [:luaopen_utf8, [:pointer], :int] },
+                  { source: 'LUA_API const char *(lua_getlocal) (lua_State *L, const lua_Debug *ar, int n);',
+                    ffi: [:lua_getlocal, %i[pointer pointer int], :pointer] },
+                  { source: 'LUA_API const char *(lua_getupvalue) (lua_State *L, int funcindex, int n);',
+                    ffi: [:lua_getupvalue, %i[pointer int int], :pointer] },
+                  { source: 'LUA_API const char *(lua_pushfstring) (lua_State *L, const char *fmt, ...);',
+                    ffi: [:lua_pushfstring, %i[pointer pointer varargs], :pointer] },
+                  { source: 'LUA_API const char *(lua_pushlstring) (lua_State *L, const char *s, size_t len);',
+                    ffi: [:lua_pushlstring, %i[pointer pointer ulong], :pointer] },
+                  { source: 'LUA_API const char *(lua_pushstring) (lua_State *L, const char *s);',
+                    ffi: [:lua_pushstring, %i[pointer pointer], :pointer] },
+                  { source: 'LUA_API const char *(lua_pushvfstring) (lua_State *L, const char *fmt, va_list argp);',
+                    ffi: [:lua_pushvfstring, %i[pointer pointer varargs], :pointer] },
+                  { source: 'LUA_API const char *(lua_setlocal) (lua_State *L, const lua_Debug *ar, int n);',
+                    ffi: [:lua_setlocal, %i[pointer pointer int], :pointer] },
+                  { source: 'LUA_API const char *(lua_setupvalue) (lua_State *L, int funcindex, int n);',
+                    ffi: [:lua_setupvalue, %i[pointer int int], :pointer] },
+                  { source: 'LUA_API const char *(lua_tolstring) (lua_State *L, int idx, size_t *len);',
+                    ffi: [:lua_tolstring, %i[pointer int pointer], :pointer] },
+                  { source: 'LUA_API const char *(lua_typename) (lua_State *L, int tp);',
+                    ffi: [:lua_typename, %i[pointer int], :pointer] },
+                  { source: 'LUA_API const void *(lua_topointer) (lua_State *L, int idx);',
+                    ffi: [:lua_topointer, %i[pointer int], :pointer] },
+                  { source: 'LUA_API int (lua_absindex) (lua_State *L, int idx);',
+                    ffi: [:lua_absindex, %i[pointer int], :int] },
+                  { source: 'LUA_API int (lua_checkstack) (lua_State *L, int n);',
+                    ffi: [:lua_checkstack, %i[pointer int], :int] },
+                  { source: 'LUA_API int (lua_compare) (lua_State *L, int idx1, int idx2, int op);',
+                    ffi: [:lua_compare, %i[pointer int int int], :int] },
+                  { source: 'LUA_API int (lua_dump) (lua_State *L, lua_Writer writer, void *data, int strip);',
+                    ffi: [:lua_dump, %i[pointer int pointer int], :int] },
+                  { source: 'LUA_API int (lua_error) (lua_State *L);',
+                    ffi: [:lua_error, [:pointer], :int] },
+                  { source: 'LUA_API int (lua_gc) (lua_State *L, int what, ...);',
+                    ffi: [:lua_gc, %i[pointer int varargs], :int] },
+                  { source: 'LUA_API int (lua_getfield) (lua_State *L, int idx, const char *k);',
+                    ffi: [:lua_getfield, %i[pointer int pointer], :int] },
+                  { source: 'LUA_API int (lua_getglobal) (lua_State *L, const char *name);',
+                    ffi: [:lua_getglobal, %i[pointer pointer], :int] },
+                  { source: 'LUA_API int (lua_gethookcount) (lua_State *L);',
+                    ffi: [:lua_gethookcount, [:pointer], :int] },
+                  { source: 'LUA_API int (lua_gethookmask) (lua_State *L);',
+                    ffi: [:lua_gethookmask, [:pointer], :int] },
+                  { source: 'LUA_API int (lua_geti) (lua_State *L, int idx, lua_Integer n);',
+                    ffi: [:lua_geti, %i[pointer int int], :int] },
+                  { source: 'LUA_API int (lua_getinfo) (lua_State *L, const char *what, lua_Debug *ar);',
+                    ffi: [:lua_getinfo, %i[pointer pointer pointer], :int] },
+                  { source: 'LUA_API int (lua_getiuservalue) (lua_State *L, int idx, int n);',
+                    ffi: [:lua_getiuservalue, %i[pointer int int], :int] },
+                  { source: 'LUA_API int (lua_getmetatable) (lua_State *L, int objindex);',
+                    ffi: [:lua_getmetatable, %i[pointer int], :int] },
+                  { source: 'LUA_API int (lua_getstack) (lua_State *L, int level, lua_Debug *ar);',
+                    ffi: [:lua_getstack, %i[pointer int pointer], :int] },
+                  { source: 'LUA_API int (lua_gettable) (lua_State *L, int idx);',
+                    ffi: [:lua_gettable, %i[pointer int], :int] },
+                  { source: 'LUA_API int (lua_gettop) (lua_State *L);',
+                    ffi: [:lua_gettop, [:pointer], :int] },
+                  { source: 'LUA_API int (lua_iscfunction) (lua_State *L, int idx);',
+                    ffi: [:lua_iscfunction, %i[pointer int], :int] },
+                  { source: 'LUA_API int (lua_isinteger) (lua_State *L, int idx);',
+                    ffi: [:lua_isinteger, %i[pointer int], :int] },
+                  { source: 'LUA_API int (lua_isnumber) (lua_State *L, int idx);',
+                    ffi: [:lua_isnumber, %i[pointer int], :int] },
+                  { source: 'LUA_API int (lua_isstring) (lua_State *L, int idx);',
+                    ffi: [:lua_isstring, %i[pointer int], :int] },
+                  { source: 'LUA_API int (lua_isuserdata) (lua_State *L, int idx);',
+                    ffi: [:lua_isuserdata, %i[pointer int], :int] },
+                  { source: 'LUA_API int (lua_isyieldable) (lua_State *L);',
+                    ffi: [:lua_isyieldable, [:pointer], :int] },
+                  { source: 'LUA_API int (lua_load) (lua_State *L, lua_Reader reader, void *dt, const char *chunkname, const char *mode);',
+                    ffi: [:lua_load, %i[pointer char pointer pointer pointer], :int] },
+                  { source: 'LUA_API int (lua_next) (lua_State *L, int idx);',
+                    ffi: [:lua_next, %i[pointer int], :int] },
+                  { source: 'LUA_API int (lua_pcallk) (lua_State *L, int nargs, int nresults, int errfunc, lua_KContext ctx, lua_KFunction k);',
+                    ffi: [:lua_pcallk, %i[pointer int int int int int], :int] },
+                  { source: 'LUA_API int (lua_pushthread) (lua_State *L);',
+                    ffi: [:lua_pushthread, [:pointer], :int] },
+                  { source: 'LUA_API int (lua_rawequal) (lua_State *L, int idx1, int idx2);',
+                    ffi: [:lua_rawequal, %i[pointer int int], :int] },
+                  { source: 'LUA_API int (lua_rawget) (lua_State *L, int idx);',
+                    ffi: [:lua_rawget, %i[pointer int], :int] },
+                  { source: 'LUA_API int (lua_rawgeti) (lua_State *L, int idx, lua_Integer n);',
+                    ffi: [:lua_rawgeti, %i[pointer int int], :int] },
+                  { source: 'LUA_API int (lua_rawgetp) (lua_State *L, int idx, const void *p);',
+                    ffi: [:lua_rawgetp, %i[pointer int pointer], :int] },
+                  { source: 'LUA_API int (lua_resetthread) (lua_State *L);',
+                    ffi: [:lua_resetthread, [:pointer], :int] },
+                  { source: 'LUA_API int (lua_resume) (lua_State *L, lua_State *from, int narg, int *nres);',
+                    ffi: [:lua_resume, %i[pointer pointer int pointer], :int] },
+                  { source: 'LUA_API int (lua_setcstacklimit) (lua_State *L, unsigned int limit);',
+                    ffi: [:lua_setcstacklimit, %i[pointer int], :int] },
+                  { source: 'LUA_API int (lua_setiuservalue) (lua_State *L, int idx, int n);',
+                    ffi: [:lua_setiuservalue, %i[pointer int int], :int] },
+                  { source: 'LUA_API int (lua_setmetatable) (lua_State *L, int objindex);',
+                    ffi: [:lua_setmetatable, %i[pointer int], :int] },
+                  { source: 'LUA_API int (lua_status) (lua_State *L);',
+                    ffi: [:lua_status, [:pointer], :int] },
+                  { source: 'LUA_API int (lua_toboolean) (lua_State *L, int idx);',
+                    ffi: [:lua_toboolean, %i[pointer int], :int] },
+                  { source: 'LUA_API int (lua_type) (lua_State *L, int idx);',
+                    ffi: [:lua_type, %i[pointer int], :int] },
+                  { source: 'LUA_API int (lua_yieldk) (lua_State *L, int nresults, lua_KContext ctx, lua_KFunction k);',
+                    ffi: [:lua_yieldk, %i[pointer int int int], :int] },
+                  { source: 'LUA_API lua_Alloc (lua_getallocf) (lua_State *L, void **ud);',
+                    ffi: [:lua_getallocf, %i[pointer pointer], :void] },
+                  { source: 'LUA_API lua_CFunction (lua_atpanic) (lua_State *L, lua_CFunction panicf);',
+                    ffi: [:lua_atpanic, %i[pointer int], :int] },
+                  { source: 'LUA_API lua_CFunction (lua_tocfunction) (lua_State *L, int idx);',
+                    ffi: [:lua_tocfunction, %i[pointer int], :int] },
+                  { source: 'LUA_API lua_Hook (lua_gethook) (lua_State *L);',
+                    ffi: [:lua_gethook, [:pointer], :void] },
+                  { source: 'LUA_API lua_Integer (lua_tointegerx) (lua_State *L, int idx, int *isnum);',
+                    ffi: [:lua_tointegerx, %i[pointer int pointer], :int] },
+                  { source: 'LUA_API lua_Number (lua_tonumberx) (lua_State *L, int idx, int *isnum);',
+                    ffi: [:lua_tonumberx, %i[pointer int pointer], :double] },
+                  { source: 'LUA_API lua_Number (lua_version) (lua_State *L);',
+                    ffi: [:lua_version, [:pointer], :double] },
+                  { source: 'LUA_API lua_State *(lua_newstate) (lua_Alloc f, void *ud);',
+                    ffi: [:lua_newstate, %i[void pointer], :pointer] },
+                  { source: 'LUA_API lua_State *(lua_newthread) (lua_State *L);',
+                    ffi: [:lua_newthread, [:pointer], :pointer] },
+                  { source: 'LUA_API lua_State *(lua_tothread) (lua_State *L, int idx);',
+                    ffi: [:lua_tothread, %i[pointer int], :pointer] },
+                  { source: 'LUA_API lua_Unsigned (lua_rawlen) (lua_State *L, int idx);',
+                    ffi: [:lua_rawlen, %i[pointer int], :uint] },
+                  { source: 'LUA_API size_t (lua_stringtonumber) (lua_State *L, const char *s);',
+                    ffi: [:lua_stringtonumber, %i[pointer pointer], :ulong] },
+                  { source: 'LUA_API void (lua_arith) (lua_State *L, int op);',
+                    ffi: [:lua_arith, %i[pointer int], :void] },
+                  { source: 'LUA_API void (lua_callk) (lua_State *L, int nargs, int nresults, lua_KContext ctx, lua_KFunction k);',
+                    ffi: [:lua_callk, %i[pointer int int int int], :void] },
+                  { source: 'LUA_API void (lua_close) (lua_State *L);',
+                    ffi: [:lua_close, [:pointer], :void] },
+                  { source: 'LUA_API void (lua_concat) (lua_State *L, int n);',
+                    ffi: [:lua_concat, %i[pointer int], :void] },
+                  { source: 'LUA_API void (lua_copy) (lua_State *L, int fromidx, int toidx);',
+                    ffi: [:lua_copy, %i[pointer int int], :void] },
+                  { source: 'LUA_API void (lua_createtable) (lua_State *L, int narr, int nrec);',
+                    ffi: [:lua_createtable, %i[pointer int int], :void] },
+                  { source: 'LUA_API void (lua_len) (lua_State *L, int idx);',
+                    ffi: [:lua_len, %i[pointer int], :void] },
+                  { source: 'LUA_API void (lua_pushboolean) (lua_State *L, int b);',
+                    ffi: [:lua_pushboolean, %i[pointer int], :void] },
+                  { source: 'LUA_API void (lua_pushcclosure) (lua_State *L, lua_CFunction fn, int n);',
+                    ffi: [:lua_pushcclosure, %i[pointer int int], :void] },
+                  { source: 'LUA_API void (lua_pushinteger) (lua_State *L, lua_Integer n);',
+                    ffi: [:lua_pushinteger, %i[pointer int], :void] },
+                  { source: 'LUA_API void (lua_pushlightuserdata) (lua_State *L, void *p);',
+                    ffi: [:lua_pushlightuserdata, %i[pointer pointer], :void] },
+                  { source: 'LUA_API void (lua_pushnil) (lua_State *L);',
+                    ffi: [:lua_pushnil, [:pointer], :void] },
+                  { source: 'LUA_API void (lua_pushnumber) (lua_State *L, lua_Number n);',
+                    ffi: [:lua_pushnumber, %i[pointer double], :void] },
+                  { source: 'LUA_API void (lua_pushvalue) (lua_State *L, int idx);',
+                    ffi: [:lua_pushvalue, %i[pointer int], :void] },
+                  { source: 'LUA_API void (lua_rawset) (lua_State *L, int idx);',
+                    ffi: [:lua_rawset, %i[pointer int], :void] },
+                  { source: 'LUA_API void (lua_rawseti) (lua_State *L, int idx, lua_Integer n);',
+                    ffi: [:lua_rawseti, %i[pointer int int], :void] },
+                  { source: 'LUA_API void (lua_rawsetp) (lua_State *L, int idx, const void *p);',
+                    ffi: [:lua_rawsetp, %i[pointer int pointer], :void] },
+                  { source: 'LUA_API void (lua_rotate) (lua_State *L, int idx, int n);',
+                    ffi: [:lua_rotate, %i[pointer int int], :void] },
+                  { source: 'LUA_API void (lua_setallocf) (lua_State *L, lua_Alloc f, void *ud);',
+                    ffi: [:lua_setallocf, %i[pointer void pointer], :void] },
+                  { source: 'LUA_API void (lua_setfield) (lua_State *L, int idx, const char *k);',
+                    ffi: [:lua_setfield, %i[pointer int pointer], :void] },
+                  { source: 'LUA_API void (lua_setglobal) (lua_State *L, const char *name);',
+                    ffi: [:lua_setglobal, %i[pointer pointer], :void] },
+                  { source: 'LUA_API void (lua_sethook) (lua_State *L, lua_Hook func, int mask, int count);',
+                    ffi: [:lua_sethook, %i[pointer void int int], :void] },
+                  { source: 'LUA_API void (lua_seti) (lua_State *L, int idx, lua_Integer n);',
+                    ffi: [:lua_seti, %i[pointer int int], :void] },
+                  { source: 'LUA_API void (lua_settable) (lua_State *L, int idx);',
+                    ffi: [:lua_settable, %i[pointer int], :void] },
+                  { source: 'LUA_API void (lua_settop) (lua_State *L, int idx);',
+                    ffi: [:lua_settop, %i[pointer int], :void] },
+                  { source: 'LUA_API void (lua_setwarnf) (lua_State *L, lua_WarnFunction f, void *ud);',
+                    ffi: [:lua_setwarnf, %i[pointer void pointer], :void] },
+                  { source: 'LUA_API void (lua_toclose) (lua_State *L, int idx);',
+                    ffi: [:lua_toclose, %i[pointer int], :void] },
+                  { source: 'LUA_API void (lua_upvaluejoin) (lua_State *L, int fidx1, int n1, int fidx2, int n2);',
+                    ffi: [:lua_upvaluejoin, %i[pointer int int int int], :void] },
+                  { source: 'LUA_API void (lua_warning) (lua_State *L, const char *msg, int tocont);',
+                    ffi: [:lua_warning, %i[pointer pointer int], :void] },
+                  { source: 'LUA_API void (lua_xmove) (lua_State *from, lua_State *to, int n);',
+                    ffi: [:lua_xmove, %i[pointer pointer int], :void] },
+                  { source: 'LUA_API void *(lua_newuserdatauv) (lua_State *L, size_t sz, int nuvalue);',
+                    ffi: [:lua_newuserdatauv, %i[pointer ulong int], :pointer] },
+                  { source: 'LUA_API void *(lua_touserdata) (lua_State *L, int idx);',
+                    ffi: [:lua_touserdata, %i[pointer int], :pointer] },
+                  { source: 'LUA_API void *(lua_upvalueid) (lua_State *L, int fidx, int n);',
+                    ffi: [:lua_upvalueid, %i[pointer int int], :pointer] }],
+      macros: [{ source: '#define luaC_barrier(L,p,v) ( \\ (iscollectable(v) && isblack(p) && iswhite(gcvalue(v))) ? \\ luaC_barrier_(L,obj2gco(p),gcvalue(v)) : cast_void(0))',
+                 name: 'luaC_barrier',
+                 input: %w[L p v] },
+               { source: '#define luaC_barrierback(L,p,v) ( \\ (iscollectable(v) && isblack(p) && iswhite(gcvalue(v))) ? \\ luaC_barrierback_(L,p) : cast_void(0))',
+                 name: 'luaC_barrierback',
+                 input: %w[L p v] },
+               { source: '#define luaC_checkGC(L) luaC_condGC(L,(void)0,(void)0)',
+                 name: 'luaC_checkGC',
+                 input: ['L'] },
+               { source: '#define luaC_objbarrier(L,p,o) ( \\ (isblack(p) && iswhite(o)) ? \\ luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0))',
+                 name: 'luaC_objbarrier',
+                 input: %w[L p o] },
+               { source: '#define luaC_white(g) cast_byte((g)->currentwhite & WHITEBITS)',
+                 name: 'luaC_white',
+                 input: ['g'] },
+               { source: '#define luaD_checkstack(L,n) luaD_checkstackaux(L,n,(void)0,(void)0)',
+                 name: 'luaD_checkstack',
+                 input: %w[L n] },
+               { source: '#define luaK_codeABC(fs,o,a,b,c) luaK_codeABCk(fs,o,a,b,c,0)',
+                 name: 'luaK_codeABC',
+                 input: %w[fs o a b c] },
+               { source: '#define luaK_jumpto(fs,t) luaK_patchlist(fs, luaK_jump(fs), t)',
+                 name: 'luaK_jumpto',
+                 input: %w[fs t] },
+               { source: '#define luaK_setmultret(fs,e) luaK_setreturns(fs, e, LUA_MULTRET)',
+                 name: 'luaK_setmultret',
+                 input: %w[fs e] },
+               { source: '#define luaL_addsize(B,s) ((B)->n += (s))',
+                 name: 'luaL_addsize',
+                 input: %w[B s] },
+               { source: '#define luaL_buffsub(B,s) ((B)->n -= (s))',
+                 name: 'luaL_buffsub',
+                 input: %w[B s] },
+               { source: '#define luaL_checkint(L,n) ((int)luaL_checkinteger(L, (n)))',
+                 name: 'luaL_checkint',
+                 input: %w[L n] },
+               { source: '#define luaL_checklong(L,n) ((long)luaL_checkinteger(L, (n)))',
+                 name: 'luaL_checklong',
+                 input: %w[L n] },
+               { source: '#define luaL_checkstring(L,n) (luaL_checklstring(L, (n), NULL))',
+                 name: 'luaL_checkstring',
+                 input: %w[L n] },
+               { source: '#define luaL_checkunsigned(L,a) ((lua_Unsigned)luaL_checkinteger(L,a))',
+                 name: 'luaL_checkunsigned',
+                 input: %w[L a] },
+               { source: '#define luaL_getmetatable(L,n) (lua_getfield(L, LUA_REGISTRYINDEX, (n)))',
+                 name: 'luaL_getmetatable',
+                 input: %w[L n] },
+               { source: '#define luaL_loadbuffer(L,s,sz,n) luaL_loadbufferx(L,s,sz,n,NULL)',
+                 name: 'luaL_loadbuffer',
+                 input: %w[L s sz n] },
+               { source: '#define luaL_loadfile(L,f) luaL_loadfilex(L,f,NULL)',
+                 name: 'luaL_loadfile',
+                 input: %w[L f] },
+               { source: '#define luaL_opt(L,f,n,d) (lua_isnoneornil(L,(n)) ? (d) : f(L,(n)))',
+                 name: 'luaL_opt',
+                 input: %w[L f n d] },
+               { source: '#define luaL_optint(L,n,d) ((int)luaL_optinteger(L, (n), (d)))',
+                 name: 'luaL_optint',
+                 input: %w[L n d] },
+               { source: '#define luaL_optlong(L,n,d) ((long)luaL_optinteger(L, (n), (d)))',
+                 name: 'luaL_optlong',
+                 input: %w[L n d] },
+               { source: '#define luaL_optstring(L,n,d) (luaL_optlstring(L, (n), (d), NULL))',
+                 name: 'luaL_optstring',
+                 input: %w[L n d] },
+               { source: '#define luaL_prepbuffer(B) luaL_prepbuffsize(B, LUAL_BUFFERSIZE)',
+                 name: 'luaL_prepbuffer',
+                 input: ['B'] },
+               { source: '#define luaL_pushfail(L) lua_pushnil(L)',
+                 name: 'luaL_pushfail',
+                 input: ['L'] },
+               { source: '#define luaL_typename(L,i) lua_typename(L, lua_type(L,(i)))',
+                 name: 'luaL_typename',
+                 input: %w[L i] },
+               { source: '#define luaM_error(L) luaD_throw(L, LUA_ERRMEM)',
+                 name: 'luaM_error',
+                 input: ['L'] },
+               { source: '#define luaM_free(L, b) luaM_free_(L, (b), sizeof(*(b)))',
+                 name: 'luaM_free',
+                 input: %w[L b] },
+               { source: '#define luaM_freearray(L, b, n) luaM_free_(L, (b), (n)*sizeof(*(b)))',
+                 name: 'luaM_freearray',
+                 input: %w[L b n] },
+               { source: '#define luaM_freemem(L, b, s) luaM_free_(L, (b), (s))',
+                 name: 'luaM_freemem',
+                 input: %w[L b s] },
+               { source: '#define luaM_new(L,t) cast(t*, luaM_malloc_(L, sizeof(t), 0))',
+                 name: 'luaM_new',
+                 input: %w[L t] },
+               { source: '#define luaM_newobject(L,tag,s) luaM_malloc_(L, (s), tag)',
+                 name: 'luaM_newobject',
+                 input: %w[L tag s] },
+               { source: '#define luaM_newvector(L,n,t) cast(t*, luaM_malloc_(L, (n)*sizeof(t), 0))',
+                 name: 'luaM_newvector',
+                 input: %w[L n t] },
+               { source: '#define luaS_newliteral(L, s) (luaS_newlstr(L, "" s, \\ (sizeof(s)/sizeof(char))-1))',
+                 name: 'luaS_newliteral',
+                 input: %w[L s] },
+               { source: '#define luaV_rawequalobj(t1,t2) luaV_equalobj(NULL,t1,t2)',
+                 name: 'luaV_rawequalobj',
+                 input: %w[t1 t2] },
+               { source: '#define luaZ_buffremove(buff,i) ((buff)->n -= (i))',
+                 name: 'luaZ_buffremove',
+                 input: %w[buff i] },
+               { source: '#define luaZ_freebuffer(L, buff) luaZ_resizebuffer(L, buff, 0)',
+                 name: 'luaZ_freebuffer',
+                 input: %w[L buff] },
+               { source: '#define luaZ_initbuffer(L, buff) ((buff)->buffer = NULL, (buff)->buffsize = 0)',
+                 name: 'luaZ_initbuffer',
+                 input: %w[L buff] },
+               { source: '#define lua_assert(c) assert(c)',
+                 name: 'lua_assert',
+                 input: ['c'] },
+               { source: '#define lua_call(L,n,r) lua_callk(L, (n), (r), 0, NULL)',
+                 name: 'lua_call',
+                 input: %w[L n r] },
+               { source: '#define lua_equal(L,idx1,idx2) lua_compare(L,(idx1),(idx2),LUA_OPEQ)',
+                 name: 'lua_equal',
+                 input: %w[L idx1 idx2] },
+               { source: '#define lua_getextraspace(L) ((void *)((char *)(L) - LUA_EXTRASPACE))',
+                 name: 'lua_getextraspaceL',
+                 input: ['void'] },
+               { source: '#define lua_getlocaledecpoint() (localeconv()->decimal_point[0])',
+                 name: 'lua_getlocaledecpoint',
+                 input: [] },
+               { source: '#define lua_getuservalue(L,idx) lua_getiuservalue(L,idx,1)',
+                 name: 'lua_getuservalue',
+                 input: %w[L idx] },
+               { source: '#define lua_insert(L,idx) lua_rotate(L, (idx), 1)',
+                 name: 'lua_insert',
+                 input: %w[L idx] },
+               { source: '#define lua_isboolean(L,n) (lua_type(L, (n)) == LUA_TBOOLEAN)',
+                 name: 'lua_isboolean',
+                 input: %w[L n] },
+               { source: '#define lua_isfunction(L,n) (lua_type(L, (n)) == LUA_TFUNCTION)',
+                 name: 'lua_isfunction',
+                 input: %w[L n] },
+               { source: '#define lua_islightuserdata(L,n) (lua_type(L, (n)) == LUA_TLIGHTUSERDATA)',
+                 name: 'lua_islightuserdata',
+                 input: %w[L n] },
+               { source: '#define lua_isnil(L,n) (lua_type(L, (n)) == LUA_TNIL)',
+                 name: 'lua_isnil',
+                 input: %w[L n] },
+               { source: '#define lua_isnone(L,n) (lua_type(L, (n)) == LUA_TNONE)',
+                 name: 'lua_isnone',
+                 input: %w[L n] },
+               { source: '#define lua_isnoneornil(L, n) (lua_type(L, (n)) <= 0)',
+                 name: 'lua_isnoneornil',
+                 input: %w[L n] },
+               { source: '#define lua_istable(L,n) (lua_type(L, (n)) == LUA_TTABLE)',
+                 name: 'lua_istable',
+                 input: %w[L n] },
+               { source: '#define lua_isthread(L,n) (lua_type(L, (n)) == LUA_TTHREAD)',
+                 name: 'lua_isthread',
+                 input: %w[L n] },
+               { source: '#define lua_lessthan(L,idx1,idx2) lua_compare(L,(idx1),(idx2),LUA_OPLT)',
+                 name: 'lua_lessthan',
+                 input: %w[L idx1 idx2] },
+               { source: '#define lua_newtable(L) lua_createtable(L, 0, 0)',
+                 name: 'lua_newtable',
+                 input: ['L'] },
+               { source: '#define lua_newuserdata(L,s) lua_newuserdatauv(L,s,1)',
+                 name: 'lua_newuserdata',
+                 input: %w[L s] },
+               { source: '#define lua_objlen(L,i) lua_rawlen(L, (i))',
+                 name: 'lua_objlen',
+                 input: %w[L i] },
+               { source: '#define lua_pcall(L,n,r,f) lua_pcallk(L, (n), (r), (f), 0, NULL)',
+                 name: 'lua_pcall',
+                 input: %w[L n r f] },
+               { source: '#define lua_pointer2str(buff,sz,p) l_sprintf(buff,sz,"%p",p)',
+                 name: 'lua_pointer2str',
+                 input: %w[buff sz p] },
+               { source: '#define lua_pop(L,n) lua_settop(L, -(n)-1)',
+                 name: 'lua_pop',
+                 input: %w[L n] },
+               { source: '#define lua_pushcfunction(L,f) lua_pushcclosure(L, (f), 0)',
+                 name: 'lua_pushcfunction',
+                 input: %w[L f] },
+               { source: '#define lua_pushliteral(L, s) lua_pushstring(L, "" s)',
+                 name: 'lua_pushliteral',
+                 input: %w[L s] },
+               { source: '#define lua_pushunsigned(L,n) lua_pushinteger(L, (lua_Integer)(n))',
+                 name: 'lua_pushunsigned',
+                 input: %w[L n] },
+               { source: '#define lua_register(L,n,f) (lua_pushcfunction(L, (f)), lua_setglobal(L, (n)))',
+                 name: 'lua_register',
+                 input: %w[L n f] },
+               { source: '#define lua_remove(L,idx) (lua_rotate(L, (idx), -1), lua_pop(L, 1))',
+                 name: 'lua_remove',
+                 input: %w[L idx] },
+               { source: '#define lua_replace(L,idx) (lua_copy(L, -1, (idx)), lua_pop(L, 1))',
+                 name: 'lua_replace',
+                 input: %w[L idx] },
+               { source: '#define lua_setuservalue(L,idx) lua_setiuservalue(L,idx,1)',
+                 name: 'lua_setuservalue',
+                 input: %w[L idx] },
+               { source: '#define lua_str2number(s,p) strtold((s), (p))',
+                 name: 'lua_str2number',
+                 input: %w[s p] },
+               { source: '#define lua_strlen(L,i) lua_rawlen(L, (i))',
+                 name: 'lua_strlen',
+                 input: %w[L i] },
+               { source: '#define lua_strx2number(s,p) lua_str2number(s,p)',
+                 name: 'lua_strx2number',
+                 input: %w[s p] },
+               { source: '#define lua_tointeger(L,i) lua_tointegerx(L,(i),NULL)',
+                 name: 'lua_tointeger',
+                 input: %w[L i] },
+               { source: '#define lua_tonumber(L,i) lua_tonumberx(L,(i),NULL)',
+                 name: 'lua_tonumber',
+                 input: %w[L i] },
+               { source: '#define lua_tostring(L,i) lua_tolstring(L, (i), NULL)',
+                 name: 'lua_tostring',
+                 input: %w[L i] },
+               { source: '#define lua_tounsigned(L,i) lua_tounsignedx(L,(i),NULL)',
+                 name: 'lua_tounsigned',
+                 input: %w[L i] },
+               { source: '#define lua_tounsignedx(L,i,is) ((lua_Unsigned)lua_tointegerx(L,i,is))',
+                 name: 'lua_tounsignedx',
+                 input: %w[L i is] },
+               { source: '#define lua_writeline() (lua_writestring("\\n", 1), fflush(stdout))',
+                 name: 'lua_writeline',
+                 input: [] },
+               { source: '#define lua_writestring(s,l) fwrite((s), sizeof(char), (l), stdout)',
+                 name: 'lua_writestring',
+                 input: %w[s l] },
+               { source: '#define lua_yield(L,n) lua_yieldk(L, (n), 0, NULL)',
+                 name: 'lua_yield',
+                 input: %w[L n] },
+               { source: '#define luai_apicheck(l,e) assert(e)',
+                 name: 'luai_apicheck',
+                 input: %w[l e] },
+               { source: '#define luai_numadd(L,a,b) ((a)+(b))',
+                 name: 'luai_numadd',
+                 input: %w[L a b] },
+               { source: '#define luai_numdiv(L,a,b) ((a)/(b))',
+                 name: 'luai_numdiv',
+                 input: %w[L a b] },
+               { source: '#define luai_numeq(a,b) ((a)==(b))',
+                 name: 'luai_numeq',
+                 input: %w[a b] },
+               { source: '#define luai_numge(a,b) ((a)>=(b))',
+                 name: 'luai_numge',
+                 input: %w[a b] },
+               { source: '#define luai_numgt(a,b) ((a)>(b))',
+                 name: 'luai_numgt',
+                 input: %w[a b] },
+               { source: '#define luai_numidiv(L,a,b) ((void)L, l_floor(luai_numdiv(L,a,b)))',
+                 name: 'luai_numidiv',
+                 input: %w[L a b] },
+               { source: '#define luai_numle(a,b) ((a)<=(b))',
+                 name: 'luai_numle',
+                 input: %w[a b] },
+               { source: '#define luai_numlt(a,b) ((a)<(b))',
+                 name: 'luai_numlt',
+                 input: %w[a b] },
+               { source: '#define luai_nummul(L,a,b) ((a)*(b))',
+                 name: 'luai_nummul',
+                 input: %w[L a b] },
+               { source: '#define luai_numsub(L,a,b) ((a)-(b))',
+                 name: 'luai_numsub',
+                 input: %w[L a b] },
+               { source: '#define luai_numunm(L,a) (-(a))',
+                 name: 'luai_numunm',
+                 input: %w[L a] },
+               { source: '#define luai_userstatefree(L,L1) ((void)L)',
+                 name: 'luai_userstatefree',
+                 input: %w[L L1] },
+               { source: '#define luai_userstateresume(L,n) ((void)L)',
+                 name: 'luai_userstateresume',
+                 input: %w[L n] },
+               { source: '#define luai_userstatethread(L,L1) ((void)L)',
+                 name: 'luai_userstatethread',
+                 input: %w[L L1] },
+               { source: '#define luai_userstateyield(L,n) ((void)L)',
+                 name: 'luai_userstateyield',
+                 input: %w[L n] }]
+    }
+  end
+end

data/logic/spec.rb

@@ -0,0 +1,13 @@
+module Logic
+  Spec = {
+    name: 'sweet-moon',
+    command: 'sweet-moon',
+    version: '0.0.1',
+    author: 'gbaptista',
+    summary: 'Lua / Fennel from Ruby and vice versa.',
+    description: 'A resilient solution that makes working with Lua / Fennel from ' \
+                 'Ruby and vice versa a delightful experience.',
+    github: 'https://github.com/gbaptista/sweet-moon',
+    license: 'MIT'
+  }
+end

data/logic/tables.rb

@@ -0,0 +1,32 @@
+module Logic
+  Tables = {
+    to_hash_or_array: ->(tuples) {
+      indexes = tuples.map { |kv| kv[0] }
+
+      is_array = true
+
+      previous = 0.0
+
+      indexes.each do |index|
+        is_array = false unless index.is_a? Numeric
+        is_array = false if index != previous + 1
+
+        break unless is_array
+
+        previous += 1
+      end
+
+      # TODO: How to handle empty?
+      return tuples.map { |kv| kv[1] } if indexes.size.positive? && is_array
+
+      result = {}
+
+      tuples.each do |key_value|
+        key, value = key_value
+        result[key] = value
+      end
+
+      result
+    }
+  }
+end

data/ports/in/dsl/sweet-moon/errors.rb

@@ -0,0 +1,3 @@
+require_relative '../../../../dsl/errors'
+
+include SweetMoon::Errors

data/ports/in/dsl/sweet-moon.rb

@@ -0,0 +1 @@
+require_relative '../../../dsl/sweet_moon'