sweet-moon 0.0.1

data/logic/signatures/signatures_514.rb

@@ -0,0 +1,460 @@
+module Logic
+  module V514
+    Signatures = {
+      functions: [{ source: 'LUALIB_API char *(luaL_prepbuffer) (luaL_Buffer *B);',
+                    ffi: [:luaL_prepbuffer, [:pointer], :pointer] },
+                  { source: 'LUALIB_API const char *(luaL_checklstring) (lua_State *L, int numArg, size_t *l);',
+                    ffi: [:luaL_checklstring, %i[pointer int pointer], :pointer] },
+                  { source: 'LUALIB_API const char *(luaL_findtable) (lua_State *L, int idx, const char *fname, int szhint);',
+                    ffi: [:luaL_findtable, %i[pointer int pointer int], :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 numArg, const char *def, size_t *l);',
+                    ffi: [:luaL_optlstring, %i[pointer int pointer pointer], :pointer] },
+                  { source: 'LUALIB_API int (luaL_argerror) (lua_State *L, int numarg, 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 narg, 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_getmetafield) (lua_State *L, int obj, const char *e);',
+                    ffi: [:luaL_getmetafield, %i[pointer int pointer], :int] },
+                  { source: 'LUALIB_API int (luaL_loadbuffer) (lua_State *L, const char *buff, size_t sz, const char *name);',
+                    ffi: [:luaL_loadbuffer, %i[pointer pointer ulong pointer], :int] },
+                  { source: 'LUALIB_API int (luaL_loadfile) (lua_State *L, const char *filename);',
+                    ffi: [:luaL_loadfile, %i[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_typerror) (lua_State *L, int narg, const char *tname);',
+                    ffi: [:luaL_typerror, %i[pointer int pointer], :int] },
+                  { source: 'LUALIB_API int (luaopen_base) (lua_State *L);',
+                    ffi: [:luaopen_base, [:pointer], :int] },
+                  { source: 'LUALIB_API int (luaopen_debug) (lua_State *L);',
+                    ffi: [:luaopen_debug, [:pointer], :int] },
+                  { source: 'LUALIB_API int (luaopen_io) (lua_State *L);',
+                    ffi: [:luaopen_io, [:pointer], :int] },
+                  { source: 'LUALIB_API int (luaopen_math) (lua_State *L);',
+                    ffi: [:luaopen_math, [:pointer], :int] },
+                  { source: 'LUALIB_API int (luaopen_os) (lua_State *L);',
+                    ffi: [:luaopen_os, [:pointer], :int] },
+                  { source: 'LUALIB_API int (luaopen_package) (lua_State *L);',
+                    ffi: [:luaopen_package, [:pointer], :int] },
+                  { source: 'LUALIB_API int (luaopen_string) (lua_State *L);',
+                    ffi: [:luaopen_string, [:pointer], :int] },
+                  { source: 'LUALIB_API int (luaopen_table) (lua_State *L);',
+                    ffi: [:luaopen_table, [:pointer], :int] },
+                  { source: 'LUALIB_API lua_Integer (luaL_checkinteger) (lua_State *L, int numArg);',
+                    ffi: [:luaL_checkinteger, %i[pointer int], :int] },
+                  { source: 'LUALIB_API lua_Integer (luaL_optinteger) (lua_State *L, int nArg, lua_Integer def);',
+                    ffi: [:luaL_optinteger, %i[pointer int int], :int] },
+                  { source: 'LUALIB_API lua_Number (luaL_checknumber) (lua_State *L, int numArg);',
+                    ffi: [:luaL_checknumber, %i[pointer int], :double] },
+                  { source: 'LUALIB_API lua_Number (luaL_optnumber) (lua_State *L, int nArg, 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 narg);',
+                    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 narg, int t);',
+                    ffi: [:luaL_checktype, %i[pointer int int], :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_register) (lua_State *L, const char *libname, const luaL_Reg *l);',
+                    ffi: [:luaL_register, %i[pointer pointer pointer], :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: '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_pushvfstring) (lua_State *L, const char *fmt, va_list argp);',
+                    ffi: [:lua_pushvfstring, %i[pointer pointer varargs], :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 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_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 void *(lua_topointer) (lua_State *L, int idx);',
+                    ffi: [:lua_topointer, %i[pointer int], :pointer] },
+                  { source: 'LUA_API int (lua_checkstack) (lua_State *L, int sz);',
+                    ffi: [:lua_checkstack, %i[pointer int], :int] },
+                  { source: 'LUA_API int (lua_cpcall) (lua_State *L, lua_CFunction func, void *ud);',
+                    ffi: [:lua_cpcall, %i[pointer int pointer], :int] },
+                  { source: 'LUA_API int (lua_dump) (lua_State *L, lua_Writer writer, void *data);',
+                    ffi: [:lua_dump, %i[pointer int pointer], :int] },
+                  { source: 'LUA_API int (lua_equal) (lua_State *L, int idx1, int idx2);',
+                    ffi: [:lua_equal, %i[pointer int 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, int data);',
+                    ffi: [:lua_gc, %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_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_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_lessthan) (lua_State *L, int idx1, int idx2);',
+                    ffi: [:lua_lessthan, %i[pointer int int], :int] },
+                  { source: 'LUA_API int (lua_load) (lua_State *L, lua_Reader reader, void *dt, const char *chunkname);',
+                    ffi: [:lua_load, %i[pointer char 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_pcall) (lua_State *L, int nargs, int nresults, int errfunc);',
+                    ffi: [:lua_pcall, %i[pointer 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_resume) (lua_State *L, int narg);',
+                    ffi: [:lua_resume, %i[pointer int], :int] },
+                  { source: 'LUA_API int (lua_setfenv) (lua_State *L, int idx);',
+                    ffi: [:lua_setfenv, %i[pointer 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_yield) (lua_State *L, int nresults);',
+                    ffi: [:lua_yield, %i[pointer int], :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_getinfo (lua_State *L, const char *what, lua_Debug *ar);',
+                    ffi: [:lua_getinfo, %i[pointer pointer pointer], :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_sethook (lua_State *L, lua_Hook func, int mask, int count);',
+                    ffi: [:lua_sethook, %i[pointer void 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_tointeger) (lua_State *L, int idx);',
+                    ffi: [:lua_tointeger, %i[pointer int], :int] },
+                  { source: 'LUA_API lua_Number (lua_tonumber) (lua_State *L, int idx);',
+                    ffi: [:lua_tonumber, %i[pointer int], :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 size_t (lua_objlen) (lua_State *L, int idx);',
+                    ffi: [:lua_objlen, %i[pointer int], :ulong] },
+                  { source: 'LUA_API void (lua_call) (lua_State *L, int nargs, int nresults);',
+                    ffi: [:lua_call, %i[pointer 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_createtable) (lua_State *L, int narr, int nrec);',
+                    ffi: [:lua_createtable, %i[pointer int int], :void] },
+                  { source: 'LUA_API void (lua_getfenv) (lua_State *L, int idx);',
+                    ffi: [:lua_getfenv, %i[pointer int], :void] },
+                  { source: 'LUA_API void (lua_getfield) (lua_State *L, int idx, const char *k);',
+                    ffi: [:lua_getfield, %i[pointer int pointer], :void] },
+                  { source: 'LUA_API void (lua_gettable) (lua_State *L, int idx);',
+                    ffi: [:lua_gettable, %i[pointer int], :void] },
+                  { source: 'LUA_API void (lua_insert) (lua_State *L, int idx);',
+                    ffi: [:lua_insert, %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_pushlstring) (lua_State *L, const char *s, size_t l);',
+                    ffi: [:lua_pushlstring, %i[pointer pointer ulong], :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_pushstring) (lua_State *L, const char *s);',
+                    ffi: [:lua_pushstring, %i[pointer pointer], :void] },
+                  { source: 'LUA_API void (lua_pushvalue) (lua_State *L, int idx);',
+                    ffi: [:lua_pushvalue, %i[pointer int], :void] },
+                  { source: 'LUA_API void (lua_rawget) (lua_State *L, int idx);',
+                    ffi: [:lua_rawget, %i[pointer int], :void] },
+                  { source: 'LUA_API void (lua_rawgeti) (lua_State *L, int idx, int n);',
+                    ffi: [:lua_rawgeti, %i[pointer int 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, int n);',
+                    ffi: [:lua_rawseti, %i[pointer int int], :void] },
+                  { source: 'LUA_API void (lua_remove) (lua_State *L, int idx);',
+                    ffi: [:lua_remove, %i[pointer int], :void] },
+                  { source: 'LUA_API void (lua_replace) (lua_State *L, int idx);',
+                    ffi: [:lua_replace, %i[pointer int], :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_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_xmove) (lua_State *from, lua_State *to, int n);',
+                    ffi: [:lua_xmove, %i[pointer pointer int], :void] },
+                  { source: 'LUA_API void *(lua_newuserdata) (lua_State *L, size_t sz);',
+                    ffi: [:lua_newuserdata, %i[pointer ulong], :pointer] },
+                  { source: 'LUA_API void *(lua_touserdata) (lua_State *L, int idx);',
+                    ffi: [:lua_touserdata, %i[pointer int], :pointer] },
+                  { 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_setlevel (lua_State *from, lua_State *to);',
+                    ffi: [:lua_setlevel, %i[pointer pointer], :void] }],
+      macros: [{ source: '#define LUAI_THROW(L,c) throw(c)',
+                 name: 'LUAI_THROW',
+                 input: %w[L c] },
+               { source: '#define luaC_white(g) cast(lu_byte, (g)->currentwhite & WHITEBITS)',
+                 name: 'luaC_white',
+                 input: ['g'] },
+               { source: '#define luaK_codeAsBx(fs,o,A,sBx) luaK_codeABx(fs,o,A,(sBx)+MAXARG_sBx)',
+                 name: 'luaK_codeAsBx',
+                 input: %w[fs o A sBx] },
+               { source: '#define luaK_setmultret(fs,e) luaK_setreturns(fs, e, LUA_MULTRET)',
+                 name: 'luaK_setmultret',
+                 input: %w[fs e] },
+               { source: '#define luaL_addsize(B,n) ((B)->p += (n))',
+                 name: 'luaL_addsize',
+                 input: %w[B n] },
+               { 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_getmetatable(L,n) (lua_getfield(L, LUA_REGISTRYINDEX, (n)))',
+                 name: 'luaL_getmetatable',
+                 input: %w[L n] },
+               { source: '#define luaL_getn(L,i) ((int)lua_objlen(L, i))',
+                 name: 'luaL_getn',
+                 input: %w[L i] },
+               { 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_putchar(B,c) luaL_addchar(B,c)',
+                 name: 'luaL_putchar',
+                 input: %w[B c] },
+               { source: '#define luaL_setn(L,i,j) ((void)0)',
+                 name: 'luaL_setn',
+                 input: %w[L i j] },
+               { source: '#define luaL_typename(L,i) lua_typename(L, lua_type(L,(i)))',
+                 name: 'luaL_typename',
+                 input: %w[L i] },
+               { source: '#define luaM_free(L, b) luaM_realloc_(L, (b), sizeof(*(b)), 0)',
+                 name: 'luaM_free',
+                 input: %w[L b] },
+               { source: '#define luaM_freearray(L, b, n, t) luaM_reallocv(L, (b), n, 0, sizeof(t))',
+                 name: 'luaM_freearray',
+                 input: %w[L b n t] },
+               { source: '#define luaM_freemem(L, b, s) luaM_realloc_(L, (b), (s), 0)',
+                 name: 'luaM_freemem',
+                 input: %w[L b s] },
+               { source: '#define luaM_malloc(L,t) luaM_realloc_(L, NULL, 0, (t))',
+                 name: 'luaM_malloc',
+                 input: %w[L t] },
+               { source: '#define luaM_new(L,t) cast(t *, luaM_malloc(L, sizeof(t)))',
+                 name: 'luaM_new',
+                 input: %w[L t] },
+               { source: '#define luaS_fix(s) l_setbit((s)->tsv.marked, FIXEDBIT)',
+                 name: 'luaS_fix',
+                 input: ['s'] },
+               { source: '#define luaS_new(L, s) (luaS_newlstr(L, s, strlen(s)))',
+                 name: 'luaS_new',
+                 input: %w[L s] },
+               { source: '#define luaS_newliteral(L, s) (luaS_newlstr(L, "" s, \\ (sizeof(s)/sizeof(char))-1))',
+                 name: 'luaS_newliteral',
+                 input: %w[L s] },
+               { 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_freeline(L,b) ((void)L, free(b))',
+                 name: 'lua_freeline',
+                 input: %w[L b] },
+               { source: '#define lua_getgccount(L) lua_gc(L, LUA_GCCOUNT, 0)',
+                 name: 'lua_getgccount',
+                 input: ['L'] },
+               { source: '#define lua_getglobal(L,s) lua_getfield(L, LUA_GLOBALSINDEX, (s))',
+                 name: 'lua_getglobal',
+                 input: %w[L s] },
+               { source: '#define lua_getref(L,ref) lua_rawgeti(L, LUA_REGISTRYINDEX, (ref))',
+                 name: 'lua_getref',
+                 input: %w[L ref] },
+               { source: '#define lua_getregistry(L) lua_pushvalue(L, LUA_REGISTRYINDEX)',
+                 name: 'lua_getregistry',
+                 input: ['L'] },
+               { 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_newtable(L) lua_createtable(L, 0, 0)',
+                 name: 'lua_newtable',
+                 input: ['L'] },
+               { source: '#define lua_number2int(i,d) ((i)=(int)(d))',
+                 name: 'lua_number2int',
+                 input: %w[i d] },
+               { source: '#define lua_number2integer(i,n) lua_number2int(i, n)',
+                 name: 'lua_number2integer',
+                 input: %w[i n] },
+               { source: '#define lua_number2str(s,n) sprintf((s), LUA_NUMBER_FMT, (n))',
+                 name: 'lua_number2str',
+                 input: %w[s n] },
+               { source: '#define lua_open() luaL_newstate()',
+                 name: 'lua_open',
+                 input: [] },
+               { source: '#define lua_pclose(L,file) ((void)L, (pclose(file) != -1))',
+                 name: 'lua_pclose',
+                 input: %w[L file] },
+               { source: '#define lua_pop(L,n) lua_settop(L, -(n)-1)',
+                 name: 'lua_pop',
+                 input: %w[L n] },
+               { source: '#define lua_popen(L,c,m) ((void)L, fflush(NULL), popen(c,m))',
+                 name: 'lua_popen',
+                 input: %w[L c m] },
+               { source: '#define lua_pushcfunction(L,f) lua_pushcclosure(L, (f), 0)',
+                 name: 'lua_pushcfunction',
+                 input: %w[L f] },
+               { source: '#define lua_readline(L,b,p) ((void)L, ((b)=readline(p)) != NULL)',
+                 name: 'lua_readline',
+                 input: %w[L b p] },
+               { source: '#define lua_ref(L,lock) ((lock) ? luaL_ref(L, LUA_REGISTRYINDEX) : \\ (lua_pushstring(L, "unlocked references are obsolete"), lua_error(L), 0))',
+                 name: 'lua_ref',
+                 input: %w[L lock] },
+               { 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_setglobal(L,s) lua_setfield(L, LUA_GLOBALSINDEX, (s))',
+                 name: 'lua_setglobal',
+                 input: %w[L s] },
+               { source: '#define lua_stdin_is_tty() isatty(0)',
+                 name: 'lua_stdin_is_tty',
+                 input: [] },
+               { source: '#define lua_str2number(s,p) strtod((s), (p))',
+                 name: 'lua_str2number',
+                 input: %w[s p] },
+               { source: '#define lua_strlen(L,i) lua_objlen(L, (i))',
+                 name: 'lua_strlen',
+                 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_unref(L,ref) luaL_unref(L, LUA_REGISTRYINDEX, (ref))',
+                 name: 'lua_unref',
+                 input: %w[L ref] },
+               { source: '#define luai_numadd(a,b) ((a)+(b))',
+                 name: 'luai_numadd',
+                 input: %w[a b] },
+               { source: '#define luai_numdiv(a,b) ((a)/(b))',
+                 name: 'luai_numdiv',
+                 input: %w[a b] },
+               { source: '#define luai_numeq(a,b) ((a)==(b))',
+                 name: 'luai_numeq',
+                 input: %w[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_nummod(a,b) ((a) - floor((a)/(b))*(b))',
+                 name: 'luai_nummod',
+                 input: %w[a b] },
+               { source: '#define luai_nummul(a,b) ((a)*(b))',
+                 name: 'luai_nummul',
+                 input: %w[a b] },
+               { source: '#define luai_numpow(a,b) (pow(a,b))',
+                 name: 'luai_numpow',
+                 input: %w[a b] },
+               { source: '#define luai_numsub(a,b) ((a)-(b))',
+                 name: 'luai_numsub',
+                 input: %w[a b] },
+               { 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