remove unused field from remotery bindings

TODO

@@ -12,7 +12,6 @@
 	
 *** UP NEXT (NO PARTICULAR ORDER) ***
 	003 [floats] 16-bit fixed point floats, 128-bit floats
-	004 [thirdparty/luajit] create bindings
 	005 [thirdparty/sokol] create bindings module (should use [math] types)
 	006 [thirdparty/sdl3] create bindings module (should use [math] types)
 	007 [bytes] create byte utilities module (should include Buffer type)
@@ -73,3 +72,4 @@
 	010 [x] make base jai files standalone (ie. [array], [memory], etc... big maybe)
 	042 [x] use absolute imports internally (ie. #import "jc/math"), update symlink/install process in README
 	000 [math] add easing procedures 
+	004 [thirdparty/luajit] create bindings

thirdparty/luajit/examples/000-it-works.jai

@@ -0,0 +1,15 @@
+main :: () {
+   L := lua.L_newstate();
+   defer lua.close(L);
+
+   lua.L_openlibs(L);
+
+   lua.L_loadstring(L, #string END
+      print("it works")
+   END);
+
+   basic.assert(lua.pcall(L, 0, lua.LUA_MULTRET, 0) == 0);
+}
+
+lua   :: #import,file "../module.jai";
+basic :: #import "Basic";

thirdparty/luajit/generate.jai

@@ -0,0 +1,44 @@
+#scope_file;
+
+#run {
+   set_build_options_dc(.{ do_output = false });
+
+   #if OS == {
+      case .WINDOWS;
+         lib_ext  :: "dll";
+         out_base :: "win";
+      case .MACOS;
+         lib_ext  :: "dylib";
+         out_base :: "mac";
+      case .LINUX;
+         lib_ext  :: "so";
+         out_base :: "linux";
+   }
+
+   print("generating bindings\n");
+
+   opts: Generate_Bindings_Options;
+   opts.add_generator_command         = false;
+   opts.generate_library_declarations = false;
+
+   array_add(*opts.strip_prefixes, "LUA_", "lua_", "lua");
+   array_add(*opts.extra_clang_arguments, "-x", "c");
+   array_add(*opts.libpaths, out_base);
+   array_add(*opts.libnames, tprint("luajit-5.1.%", lib_ext));
+   array_add(*opts.source_files,
+      "./lib/lua.h",
+      "./lib/luaconf.h",
+      "./lib/luajit.h",
+      "./lib/lualib.h",
+      "./lib/lauxlib.h",
+   );
+
+   assert(generate_bindings(opts, "luajit.jai"));
+}
+
+#import "File";
+#import "Basic";
+#import "String";
+#import "Compiler";
+#import "BuildCpp";
+#import "Bindings_Generator";

thirdparty/luajit/lib/lauxlib.h

@@ -0,0 +1,161 @@
+/*
+** $Id: lauxlib.h,v 1.88.1.1 2007/12/27 13:02:25 roberto Exp $
+** Auxiliary functions for building Lua libraries
+** See Copyright Notice in lua.h
+*/
+
+
+#ifndef lauxlib_h
+#define lauxlib_h
+
+
+#include <stddef.h>
+#include <stdio.h>
+
+#include "lua.h"
+
+
+/* extra error code for `luaL_load' */
+#define LUA_ERRFILE     (LUA_ERRERR+1)
+
+typedef struct luaL_Reg {
+  const char *name;
+  lua_CFunction func;
+} luaL_Reg;
+
+LUALIB_API void (luaL_openlib) (lua_State *L, const char *libname,
+                                const luaL_Reg *l, int nup);
+LUALIB_API void (luaL_register) (lua_State *L, const char *libname,
+                                const luaL_Reg *l);
+LUALIB_API int (luaL_getmetafield) (lua_State *L, int obj, const char *e);
+LUALIB_API int (luaL_callmeta) (lua_State *L, int obj, const char *e);
+LUALIB_API int (luaL_typerror) (lua_State *L, int narg, const char *tname);
+LUALIB_API int (luaL_argerror) (lua_State *L, int numarg, const char *extramsg);
+LUALIB_API const char *(luaL_checklstring) (lua_State *L, int numArg,
+                                                          size_t *l);
+LUALIB_API const char *(luaL_optlstring) (lua_State *L, int numArg,
+                                          const char *def, size_t *l);
+LUALIB_API lua_Number (luaL_checknumber) (lua_State *L, int numArg);
+LUALIB_API lua_Number (luaL_optnumber) (lua_State *L, int nArg, lua_Number def);
+
+LUALIB_API lua_Integer (luaL_checkinteger) (lua_State *L, int numArg);
+LUALIB_API lua_Integer (luaL_optinteger) (lua_State *L, int nArg,
+                                          lua_Integer def);
+
+LUALIB_API void (luaL_checkstack) (lua_State *L, int sz, const char *msg);
+LUALIB_API void (luaL_checktype) (lua_State *L, int narg, int t);
+LUALIB_API void (luaL_checkany) (lua_State *L, int narg);
+
+LUALIB_API int   (luaL_newmetatable) (lua_State *L, const char *tname);
+LUALIB_API void *(luaL_checkudata) (lua_State *L, int ud, const char *tname);
+
+LUALIB_API void (luaL_where) (lua_State *L, int lvl);
+LUALIB_API int (luaL_error) (lua_State *L, const char *fmt, ...);
+
+LUALIB_API int (luaL_checkoption) (lua_State *L, int narg, const char *def,
+                                   const char *const lst[]);
+
+/* pre-defined references */
+#define LUA_NOREF       (-2)
+#define LUA_REFNIL      (-1)
+
+LUALIB_API int (luaL_ref) (lua_State *L, int t);
+LUALIB_API void (luaL_unref) (lua_State *L, int t, int ref);
+
+LUALIB_API int (luaL_loadfile) (lua_State *L, const char *filename);
+LUALIB_API int (luaL_loadbuffer) (lua_State *L, const char *buff, size_t sz,
+                                  const char *name);
+LUALIB_API int (luaL_loadstring) (lua_State *L, const char *s);
+
+LUALIB_API lua_State *(luaL_newstate) (void);
+
+
+LUALIB_API const char *(luaL_gsub) (lua_State *L, const char *s, const char *p,
+                                                  const char *r);
+
+LUALIB_API const char *(luaL_findtable) (lua_State *L, int idx,
+                                         const char *fname, int szhint);
+
+/* From Lua 5.2. */
+LUALIB_API int luaL_fileresult(lua_State *L, int stat, const char *fname);
+LUALIB_API int luaL_execresult(lua_State *L, int stat);
+LUALIB_API int (luaL_loadfilex) (lua_State *L, const char *filename,
+				 const char *mode);
+LUALIB_API int (luaL_loadbufferx) (lua_State *L, const char *buff, size_t sz,
+				   const char *name, const char *mode);
+LUALIB_API void luaL_traceback (lua_State *L, lua_State *L1, const char *msg,
+				int level);
+LUALIB_API void (luaL_setfuncs) (lua_State *L, const luaL_Reg *l, int nup);
+LUALIB_API void (luaL_pushmodule) (lua_State *L, const char *modname,
+				   int sizehint);
+LUALIB_API void *(luaL_testudata) (lua_State *L, int ud, const char *tname);
+LUALIB_API void (luaL_setmetatable) (lua_State *L, const char *tname);
+
+
+/*
+** ===============================================================
+** some useful macros
+** ===============================================================
+*/
+
+#define luaL_argcheck(L, cond,numarg,extramsg)	\
+		((void)((cond) || luaL_argerror(L, (numarg), (extramsg))))
+#define luaL_checkstring(L,n)	(luaL_checklstring(L, (n), NULL))
+#define luaL_optstring(L,n,d)	(luaL_optlstring(L, (n), (d), NULL))
+#define luaL_checkint(L,n)	((int)luaL_checkinteger(L, (n)))
+#define luaL_optint(L,n,d)	((int)luaL_optinteger(L, (n), (d)))
+#define luaL_checklong(L,n)	((long)luaL_checkinteger(L, (n)))
+#define luaL_optlong(L,n,d)	((long)luaL_optinteger(L, (n), (d)))
+
+#define luaL_typename(L,i)	lua_typename(L, lua_type(L,(i)))
+
+#define luaL_dofile(L, fn) \
+	(luaL_loadfile(L, fn) || lua_pcall(L, 0, LUA_MULTRET, 0))
+
+#define luaL_dostring(L, s) \
+	(luaL_loadstring(L, s) || lua_pcall(L, 0, LUA_MULTRET, 0))
+
+#define luaL_getmetatable(L,n)	(lua_getfield(L, LUA_REGISTRYINDEX, (n)))
+
+#define luaL_opt(L,f,n,d)	(lua_isnoneornil(L,(n)) ? (d) : f(L,(n)))
+
+/* From Lua 5.2. */
+#define luaL_newlibtable(L, l) \
+	lua_createtable(L, 0, sizeof(l)/sizeof((l)[0]) - 1)
+#define luaL_newlib(L, l)	(luaL_newlibtable(L, l), luaL_setfuncs(L, l, 0))
+
+/*
+** {======================================================
+** Generic Buffer manipulation
+** =======================================================
+*/
+
+
+
+typedef struct luaL_Buffer {
+  char *p;			/* current position in buffer */
+  int lvl;  /* number of strings in the stack (level) */
+  lua_State *L;
+  char buffer[LUAL_BUFFERSIZE];
+} luaL_Buffer;
+
+#define luaL_addchar(B,c) \
+  ((void)((B)->p < ((B)->buffer+LUAL_BUFFERSIZE) || luaL_prepbuffer(B)), \
+   (*(B)->p++ = (char)(c)))
+
+/* compatibility only */
+#define luaL_putchar(B,c)	luaL_addchar(B,c)
+
+#define luaL_addsize(B,n)	((B)->p += (n))
+
+LUALIB_API void (luaL_buffinit) (lua_State *L, luaL_Buffer *B);
+LUALIB_API char *(luaL_prepbuffer) (luaL_Buffer *B);
+LUALIB_API void (luaL_addlstring) (luaL_Buffer *B, const char *s, size_t l);
+LUALIB_API void (luaL_addstring) (luaL_Buffer *B, const char *s);
+LUALIB_API void (luaL_addvalue) (luaL_Buffer *B);
+LUALIB_API void (luaL_pushresult) (luaL_Buffer *B);
+
+
+/* }====================================================== */
+
+#endif

thirdparty/luajit/lib/lua.h

@@ -0,0 +1,402 @@
+/*
+** $Id: lua.h,v 1.218.1.5 2008/08/06 13:30:12 roberto Exp $
+** Lua - An Extensible Extension Language
+** Lua.org, PUC-Rio, Brazil (https://www.lua.org)
+** See Copyright Notice at the end of this file
+*/
+
+
+#ifndef lua_h
+#define lua_h
+
+#include <stdarg.h>
+#include <stddef.h>
+
+
+#include "luaconf.h"
+
+
+#define LUA_VERSION	"Lua 5.1"
+#define LUA_RELEASE	"Lua 5.1.4"
+#define LUA_VERSION_NUM	501
+#define LUA_COPYRIGHT	"Copyright (C) 1994-2008 Lua.org, PUC-Rio"
+#define LUA_AUTHORS	"R. Ierusalimschy, L. H. de Figueiredo & W. Celes"
+
+
+/* mark for precompiled code (`<esc>Lua') */
+#define	LUA_SIGNATURE	"\033Lua"
+
+/* option for multiple returns in `lua_pcall' and `lua_call' */
+#define LUA_MULTRET	(-1)
+
+
+/*
+** pseudo-indices
+*/
+#define LUA_REGISTRYINDEX	(-10000)
+#define LUA_ENVIRONINDEX	(-10001)
+#define LUA_GLOBALSINDEX	(-10002)
+#define lua_upvalueindex(i)	(LUA_GLOBALSINDEX-(i))
+
+
+/* thread status */
+#define LUA_OK		0
+#define LUA_YIELD	1
+#define LUA_ERRRUN	2
+#define LUA_ERRSYNTAX	3
+#define LUA_ERRMEM	4
+#define LUA_ERRERR	5
+
+
+typedef struct lua_State lua_State;
+
+typedef int (*lua_CFunction) (lua_State *L);
+
+
+/*
+** functions that read/write blocks when loading/dumping Lua chunks
+*/
+typedef const char * (*lua_Reader) (lua_State *L, void *ud, size_t *sz);
+
+typedef int (*lua_Writer) (lua_State *L, const void* p, size_t sz, void* ud);
+
+
+/*
+** prototype for memory-allocation functions
+*/
+typedef void * (*lua_Alloc) (void *ud, void *ptr, size_t osize, size_t nsize);
+
+
+/*
+** basic types
+*/
+#define LUA_TNONE		(-1)
+
+#define LUA_TNIL		0
+#define LUA_TBOOLEAN		1
+#define LUA_TLIGHTUSERDATA	2
+#define LUA_TNUMBER		3
+#define LUA_TSTRING		4
+#define LUA_TTABLE		5
+#define LUA_TFUNCTION		6
+#define LUA_TUSERDATA		7
+#define LUA_TTHREAD		8
+
+
+
+/* minimum Lua stack available to a C function */
+#define LUA_MINSTACK	20
+
+
+/*
+** generic extra include file
+*/
+#if defined(LUA_USER_H)
+#include LUA_USER_H
+#endif
+
+
+/* type of numbers in Lua */
+typedef LUA_NUMBER lua_Number;
+
+
+/* type for integer functions */
+typedef LUA_INTEGER lua_Integer;
+
+
+
+/*
+** state manipulation
+*/
+LUA_API lua_State *(lua_newstate) (lua_Alloc f, void *ud);
+LUA_API void       (lua_close) (lua_State *L);
+LUA_API lua_State *(lua_newthread) (lua_State *L);
+
+LUA_API lua_CFunction (lua_atpanic) (lua_State *L, lua_CFunction panicf);
+
+
+/*
+** basic stack manipulation
+*/
+LUA_API int   (lua_gettop) (lua_State *L);
+LUA_API void  (lua_settop) (lua_State *L, int idx);
+LUA_API void  (lua_pushvalue) (lua_State *L, int idx);
+LUA_API void  (lua_remove) (lua_State *L, int idx);
+LUA_API void  (lua_insert) (lua_State *L, int idx);
+LUA_API void  (lua_replace) (lua_State *L, int idx);
+LUA_API int   (lua_checkstack) (lua_State *L, int sz);
+
+LUA_API void  (lua_xmove) (lua_State *from, lua_State *to, int n);
+
+
+/*
+** access functions (stack -> C)
+*/
+
+LUA_API int             (lua_isnumber) (lua_State *L, int idx);
+LUA_API int             (lua_isstring) (lua_State *L, int idx);
+LUA_API int             (lua_iscfunction) (lua_State *L, int idx);
+LUA_API int             (lua_isuserdata) (lua_State *L, int idx);
+LUA_API int             (lua_type) (lua_State *L, int idx);
+LUA_API const char     *(lua_typename) (lua_State *L, int tp);
+
+LUA_API int            (lua_equal) (lua_State *L, int idx1, int idx2);
+LUA_API int            (lua_rawequal) (lua_State *L, int idx1, int idx2);
+LUA_API int            (lua_lessthan) (lua_State *L, int idx1, int idx2);
+
+LUA_API lua_Number      (lua_tonumber) (lua_State *L, int idx);
+LUA_API lua_Integer     (lua_tointeger) (lua_State *L, int idx);
+LUA_API int             (lua_toboolean) (lua_State *L, int idx);
+LUA_API const char     *(lua_tolstring) (lua_State *L, int idx, size_t *len);
+LUA_API size_t          (lua_objlen) (lua_State *L, int idx);
+LUA_API lua_CFunction   (lua_tocfunction) (lua_State *L, int idx);
+LUA_API void	       *(lua_touserdata) (lua_State *L, int idx);
+LUA_API lua_State      *(lua_tothread) (lua_State *L, int idx);
+LUA_API const void     *(lua_topointer) (lua_State *L, int idx);
+
+
+/*
+** push functions (C -> stack)
+*/
+LUA_API void  (lua_pushnil) (lua_State *L);
+LUA_API void  (lua_pushnumber) (lua_State *L, lua_Number n);
+LUA_API void  (lua_pushinteger) (lua_State *L, lua_Integer n);
+LUA_API void  (lua_pushlstring) (lua_State *L, const char *s, size_t l);
+LUA_API void  (lua_pushstring) (lua_State *L, const char *s);
+LUA_API const char *(lua_pushvfstring) (lua_State *L, const char *fmt,
+                                                      va_list argp);
+LUA_API const char *(lua_pushfstring) (lua_State *L, const char *fmt, ...);
+LUA_API void  (lua_pushcclosure) (lua_State *L, lua_CFunction fn, int n);
+LUA_API void  (lua_pushboolean) (lua_State *L, int b);
+LUA_API void  (lua_pushlightuserdata) (lua_State *L, void *p);
+LUA_API int   (lua_pushthread) (lua_State *L);
+
+
+/*
+** get functions (Lua -> stack)
+*/
+LUA_API void  (lua_gettable) (lua_State *L, int idx);
+LUA_API void  (lua_getfield) (lua_State *L, int idx, const char *k);
+LUA_API void  (lua_rawget) (lua_State *L, int idx);
+LUA_API void  (lua_rawgeti) (lua_State *L, int idx, int n);
+LUA_API void  (lua_createtable) (lua_State *L, int narr, int nrec);
+LUA_API void *(lua_newuserdata) (lua_State *L, size_t sz);
+LUA_API int   (lua_getmetatable) (lua_State *L, int objindex);
+LUA_API void  (lua_getfenv) (lua_State *L, int idx);
+
+
+/*
+** set functions (stack -> Lua)
+*/
+LUA_API void  (lua_settable) (lua_State *L, int idx);
+LUA_API void  (lua_setfield) (lua_State *L, int idx, const char *k);
+LUA_API void  (lua_rawset) (lua_State *L, int idx);
+LUA_API void  (lua_rawseti) (lua_State *L, int idx, int n);
+LUA_API int   (lua_setmetatable) (lua_State *L, int objindex);
+LUA_API int   (lua_setfenv) (lua_State *L, int idx);
+
+
+/*
+** `load' and `call' functions (load and run Lua code)
+*/
+LUA_API void  (lua_call) (lua_State *L, int nargs, int nresults);
+LUA_API int   (lua_pcall) (lua_State *L, int nargs, int nresults, int errfunc);
+LUA_API int   (lua_cpcall) (lua_State *L, lua_CFunction func, void *ud);
+LUA_API int   (lua_load) (lua_State *L, lua_Reader reader, void *dt,
+                                        const char *chunkname);
+
+LUA_API int (lua_dump) (lua_State *L, lua_Writer writer, void *data);
+
+
+/*
+** coroutine functions
+*/
+LUA_API int  (lua_yield) (lua_State *L, int nresults);
+LUA_API int  (lua_resume) (lua_State *L, int narg);
+LUA_API int  (lua_status) (lua_State *L);
+
+/*
+** garbage-collection function and options
+*/
+
+#define LUA_GCSTOP		0
+#define LUA_GCRESTART		1
+#define LUA_GCCOLLECT		2
+#define LUA_GCCOUNT		3
+#define LUA_GCCOUNTB		4
+#define LUA_GCSTEP		5
+#define LUA_GCSETPAUSE		6
+#define LUA_GCSETSTEPMUL	7
+#define LUA_GCISRUNNING		9
+
+LUA_API int (lua_gc) (lua_State *L, int what, int data);
+
+
+/*
+** miscellaneous functions
+*/
+
+LUA_API int   (lua_error) (lua_State *L);
+
+LUA_API int   (lua_next) (lua_State *L, int idx);
+
+LUA_API void  (lua_concat) (lua_State *L, int n);
+
+LUA_API lua_Alloc (lua_getallocf) (lua_State *L, void **ud);
+LUA_API void lua_setallocf (lua_State *L, lua_Alloc f, void *ud);
+
+
+
+/*
+** ===============================================================
+** some useful macros
+** ===============================================================
+*/
+
+#define lua_pop(L,n)		lua_settop(L, -(n)-1)
+
+#define lua_newtable(L)		lua_createtable(L, 0, 0)
+
+#define lua_register(L,n,f) (lua_pushcfunction(L, (f)), lua_setglobal(L, (n)))
+
+#define lua_pushcfunction(L,f)	lua_pushcclosure(L, (f), 0)
+
+#define lua_strlen(L,i)		lua_objlen(L, (i))
+
+#define lua_isfunction(L,n)	(lua_type(L, (n)) == LUA_TFUNCTION)
+#define lua_istable(L,n)	(lua_type(L, (n)) == LUA_TTABLE)
+#define lua_islightuserdata(L,n)	(lua_type(L, (n)) == LUA_TLIGHTUSERDATA)
+#define lua_isnil(L,n)		(lua_type(L, (n)) == LUA_TNIL)
+#define lua_isboolean(L,n)	(lua_type(L, (n)) == LUA_TBOOLEAN)
+#define lua_isthread(L,n)	(lua_type(L, (n)) == LUA_TTHREAD)
+#define lua_isnone(L,n)		(lua_type(L, (n)) == LUA_TNONE)
+#define lua_isnoneornil(L, n)	(lua_type(L, (n)) <= 0)
+
+#define lua_pushliteral(L, s)	\
+	lua_pushlstring(L, "" s, (sizeof(s)/sizeof(char))-1)
+
+#define lua_setglobal(L,s)	lua_setfield(L, LUA_GLOBALSINDEX, (s))
+#define lua_getglobal(L,s)	lua_getfield(L, LUA_GLOBALSINDEX, (s))
+
+#define lua_tostring(L,i)	lua_tolstring(L, (i), NULL)
+
+
+
+/*
+** compatibility macros and functions
+*/
+
+#define lua_open()	luaL_newstate()
+
+#define lua_getregistry(L)	lua_pushvalue(L, LUA_REGISTRYINDEX)
+
+#define lua_getgccount(L)	lua_gc(L, LUA_GCCOUNT, 0)
+
+#define lua_Chunkreader		lua_Reader
+#define lua_Chunkwriter		lua_Writer
+
+
+/* hack */
+LUA_API void lua_setlevel	(lua_State *from, lua_State *to);
+
+
+/*
+** {======================================================================
+** Debug API
+** =======================================================================
+*/
+
+
+/*
+** Event codes
+*/
+#define LUA_HOOKCALL	0
+#define LUA_HOOKRET	1
+#define LUA_HOOKLINE	2
+#define LUA_HOOKCOUNT	3
+#define LUA_HOOKTAILRET 4
+
+
+/*
+** Event masks
+*/
+#define LUA_MASKCALL	(1 << LUA_HOOKCALL)
+#define LUA_MASKRET	(1 << LUA_HOOKRET)
+#define LUA_MASKLINE	(1 << LUA_HOOKLINE)
+#define LUA_MASKCOUNT	(1 << LUA_HOOKCOUNT)
+
+typedef struct lua_Debug lua_Debug;  /* activation record */
+
+
+/* Functions to be called by the debuger in specific events */
+typedef void (*lua_Hook) (lua_State *L, lua_Debug *ar);
+
+
+LUA_API int lua_getstack (lua_State *L, int level, lua_Debug *ar);
+LUA_API int lua_getinfo (lua_State *L, const char *what, lua_Debug *ar);
+LUA_API const char *lua_getlocal (lua_State *L, const lua_Debug *ar, int n);
+LUA_API const char *lua_setlocal (lua_State *L, const lua_Debug *ar, int n);
+LUA_API const char *lua_getupvalue (lua_State *L, int funcindex, int n);
+LUA_API const char *lua_setupvalue (lua_State *L, int funcindex, int n);
+LUA_API int lua_sethook (lua_State *L, lua_Hook func, int mask, int count);
+LUA_API lua_Hook lua_gethook (lua_State *L);
+LUA_API int lua_gethookmask (lua_State *L);
+LUA_API int lua_gethookcount (lua_State *L);
+
+/* From Lua 5.2. */
+LUA_API void *lua_upvalueid (lua_State *L, int idx, int n);
+LUA_API void lua_upvaluejoin (lua_State *L, int idx1, int n1, int idx2, int n2);
+LUA_API int lua_loadx (lua_State *L, lua_Reader reader, void *dt,
+		       const char *chunkname, const char *mode);
+LUA_API const lua_Number *lua_version (lua_State *L);
+LUA_API void lua_copy (lua_State *L, int fromidx, int toidx);
+LUA_API lua_Number lua_tonumberx (lua_State *L, int idx, int *isnum);
+LUA_API lua_Integer lua_tointegerx (lua_State *L, int idx, int *isnum);
+
+/* From Lua 5.3. */
+LUA_API int lua_isyieldable (lua_State *L);
+
+
+struct lua_Debug {
+  int event;
+  const char *name;	/* (n) */
+  const char *namewhat;	/* (n) `global', `local', `field', `method' */
+  const char *what;	/* (S) `Lua', `C', `main', `tail' */
+  const char *source;	/* (S) */
+  int currentline;	/* (l) */
+  int nups;		/* (u) number of upvalues */
+  int linedefined;	/* (S) */
+  int lastlinedefined;	/* (S) */
+  char short_src[LUA_IDSIZE]; /* (S) */
+  /* private part */
+  int i_ci;  /* active function */
+};
+
+/* }====================================================================== */
+
+
+/******************************************************************************
+* Copyright (C) 1994-2008 Lua.org, PUC-Rio.  All rights reserved.
+*
+* Permission is hereby granted, free of charge, to any person obtaining
+* a copy of this software and associated documentation files (the
+* "Software"), to deal in the Software without restriction, including
+* without limitation the rights to use, copy, modify, merge, publish,
+* distribute, sublicense, and/or sell copies of the Software, and to
+* permit persons to whom the Software is furnished to do so, subject to
+* the following conditions:
+*
+* The above copyright notice and this permission notice shall be
+* included in all copies or substantial portions of the Software.
+*
+* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+******************************************************************************/
+
+
+#endif

thirdparty/luajit/lib/luaconf.h

@@ -0,0 +1,154 @@
+/*
+** Configuration header.
+** Copyright (C) 2005-2025 Mike Pall. See Copyright Notice in luajit.h
+*/
+
+#ifndef luaconf_h
+#define luaconf_h
+
+#ifndef WINVER
+#define WINVER 0x0501
+#endif
+#include <stddef.h>
+
+/* Default path for loading Lua and C modules with require(). */
+#if defined(_WIN32)
+/*
+** In Windows, any exclamation mark ('!') in the path is replaced by the
+** path of the directory of the executable file of the current process.
+*/
+#define LUA_LDIR	"!\\lua\\"
+#define LUA_CDIR	"!\\"
+#define LUA_PATH_DEFAULT \
+  ".\\?.lua;" LUA_LDIR"?.lua;" LUA_LDIR"?\\init.lua;"
+#define LUA_CPATH_DEFAULT \
+  ".\\?.dll;" LUA_CDIR"?.dll;" LUA_CDIR"loadall.dll"
+#else
+/*
+** Note to distribution maintainers: do NOT patch the following lines!
+** Please read ../doc/install.html#distro and pass PREFIX=/usr instead.
+*/
+#ifndef LUA_MULTILIB
+#define LUA_MULTILIB	"lib"
+#endif
+#ifndef LUA_LMULTILIB
+#define LUA_LMULTILIB	"lib"
+#endif
+#define LUA_LROOT	"/usr/local"
+#define LUA_LUADIR	"/lua/5.1/"
+
+#ifdef LUA_ROOT
+#define LUA_JROOT	LUA_ROOT
+#define LUA_RLDIR	LUA_ROOT "/share" LUA_LUADIR
+#define LUA_RCDIR	LUA_ROOT "/" LUA_MULTILIB LUA_LUADIR
+#define LUA_RLPATH	";" LUA_RLDIR "?.lua;" LUA_RLDIR "?/init.lua"
+#define LUA_RCPATH	";" LUA_RCDIR "?.so"
+#else
+#define LUA_JROOT	LUA_LROOT
+#define LUA_RLPATH
+#define LUA_RCPATH
+#endif
+
+#ifndef LUA_LJDIR
+#define LUA_LJDIR	LUA_JROOT "/share/luajit-2.1"
+#endif
+
+#define LUA_JPATH	";" LUA_LJDIR "/?.lua"
+#define LUA_LLDIR	LUA_LROOT "/share" LUA_LUADIR
+#define LUA_LCDIR	LUA_LROOT "/" LUA_LMULTILIB LUA_LUADIR
+#define LUA_LLPATH	";" LUA_LLDIR "?.lua;" LUA_LLDIR "?/init.lua"
+#define LUA_LCPATH1	";" LUA_LCDIR "?.so"
+#define LUA_LCPATH2	";" LUA_LCDIR "loadall.so"
+
+#define LUA_PATH_DEFAULT	"./?.lua" LUA_JPATH LUA_LLPATH LUA_RLPATH
+#define LUA_CPATH_DEFAULT	"./?.so" LUA_LCPATH1 LUA_RCPATH LUA_LCPATH2
+#endif
+
+/* Environment variable names for path overrides and initialization code. */
+#define LUA_PATH	"LUA_PATH"
+#define LUA_CPATH	"LUA_CPATH"
+#define LUA_INIT	"LUA_INIT"
+
+/* Special file system characters. */
+#if defined(_WIN32)
+#define LUA_DIRSEP	"\\"
+#else
+#define LUA_DIRSEP	"/"
+#endif
+#define LUA_PATHSEP	";"
+#define LUA_PATH_MARK	"?"
+#define LUA_EXECDIR	"!"
+#define LUA_IGMARK	"-"
+#define LUA_PATH_CONFIG \
+  LUA_DIRSEP "\n" LUA_PATHSEP "\n" LUA_PATH_MARK "\n" \
+  LUA_EXECDIR "\n" LUA_IGMARK "\n"
+
+/* Quoting in error messages. */
+#define LUA_QL(x)	"'" x "'"
+#define LUA_QS		LUA_QL("%s")
+
+/* Various tunables. */
+#define LUAI_MAXSTACK	65500	/* Max. # of stack slots for a thread (<64K). */
+#define LUAI_MAXCSTACK	8000	/* Max. # of stack slots for a C func (<10K). */
+#define LUAI_GCPAUSE	200	/* Pause GC until memory is at 200%. */
+#define LUAI_GCMUL	200	/* Run GC at 200% of allocation speed. */
+#define LUA_MAXCAPTURES	32	/* Max. pattern captures. */
+
+/* Configuration for the frontend (the luajit executable). */
+#if defined(luajit_c)
+#define LUA_PROGNAME	"luajit"  /* Fallback frontend name. */
+#define LUA_PROMPT	"> "	/* Interactive prompt. */
+#define LUA_PROMPT2	">> "	/* Continuation prompt. */
+#define LUA_MAXINPUT	512	/* Max. input line length. */
+#endif
+
+/* Note: changing the following defines breaks the Lua 5.1 ABI. */
+#define LUA_INTEGER	ptrdiff_t
+#define LUA_IDSIZE	60	/* Size of lua_Debug.short_src. */
+/*
+** Size of lauxlib and io.* on-stack buffers. Weird workaround to avoid using
+** unreasonable amounts of stack space, but still retain ABI compatibility.
+** Blame Lua for depending on BUFSIZ in the ABI, blame **** for wrecking it.
+*/
+#define LUAL_BUFFERSIZE	(BUFSIZ > 16384 ? 8192 : BUFSIZ)
+
+/* The following defines are here only for compatibility with luaconf.h
+** from the standard Lua distribution. They must not be changed for LuaJIT.
+*/
+#define LUA_NUMBER_DOUBLE
+#define LUA_NUMBER		double
+#define LUAI_UACNUMBER		double
+#define LUA_NUMBER_SCAN		"%lf"
+#define LUA_NUMBER_FMT		"%.14g"
+#define lua_number2str(s, n)	sprintf((s), LUA_NUMBER_FMT, (n))
+#define LUAI_MAXNUMBER2STR	32
+#define LUA_INTFRMLEN		"l"
+#define LUA_INTFRM_T		long
+
+/* Linkage of public API functions. */
+#if defined(LUA_BUILD_AS_DLL)
+#if defined(LUA_CORE) || defined(LUA_LIB)
+#define LUA_API		__declspec(dllexport)
+#else
+#define LUA_API		__declspec(dllimport)
+#endif
+#else
+#define LUA_API		extern
+#endif
+
+#define LUALIB_API	LUA_API
+
+/* Compatibility support for assertions. */
+#if defined(LUA_USE_ASSERT) || defined(LUA_USE_APICHECK)
+#include <assert.h>
+#endif
+#ifdef LUA_USE_ASSERT
+#define lua_assert(x)		assert(x)
+#endif
+#ifdef LUA_USE_APICHECK
+#define luai_apicheck(L, o)	{ (void)L; assert(o); }
+#else
+#define luai_apicheck(L, o)	{ (void)L; }
+#endif
+
+#endif

thirdparty/luajit/lib/luajit.h

@@ -0,0 +1,79 @@
+/*
+** LuaJIT -- a Just-In-Time Compiler for Lua. https://luajit.org/
+**
+** Copyright (C) 2005-2025 Mike Pall. All rights reserved.
+**
+** Permission is hereby granted, free of charge, to any person obtaining
+** a copy of this software and associated documentation files (the
+** "Software"), to deal in the Software without restriction, including
+** without limitation the rights to use, copy, modify, merge, publish,
+** distribute, sublicense, and/or sell copies of the Software, and to
+** permit persons to whom the Software is furnished to do so, subject to
+** the following conditions:
+**
+** The above copyright notice and this permission notice shall be
+** included in all copies or substantial portions of the Software.
+**
+** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+** SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**
+** [ MIT license: https://www.opensource.org/licenses/mit-license.php ]
+*/
+
+#ifndef _LUAJIT_H
+#define _LUAJIT_H
+
+#include "lua.h"
+
+#define LUAJIT_VERSION		"LuaJIT 2.1.1744318430"
+#define LUAJIT_VERSION_NUM	20199  /* Deprecated. */
+#define LUAJIT_VERSION_SYM	luaJIT_version_2_1_1744318430
+#define LUAJIT_COPYRIGHT	"Copyright (C) 2005-2025 Mike Pall"
+#define LUAJIT_URL		"https://luajit.org/"
+
+/* Modes for luaJIT_setmode. */
+#define LUAJIT_MODE_MASK	0x00ff
+
+enum {
+  LUAJIT_MODE_ENGINE,		/* Set mode for whole JIT engine. */
+  LUAJIT_MODE_DEBUG,		/* Set debug mode (idx = level). */
+
+  LUAJIT_MODE_FUNC,		/* Change mode for a function. */
+  LUAJIT_MODE_ALLFUNC,		/* Recurse into subroutine protos. */
+  LUAJIT_MODE_ALLSUBFUNC,	/* Change only the subroutines. */
+
+  LUAJIT_MODE_TRACE,		/* Flush a compiled trace. */
+
+  LUAJIT_MODE_WRAPCFUNC = 0x10,	/* Set wrapper mode for C function calls. */
+
+  LUAJIT_MODE_MAX
+};
+
+/* Flags or'ed in to the mode. */
+#define LUAJIT_MODE_OFF		0x0000	/* Turn feature off. */
+#define LUAJIT_MODE_ON		0x0100	/* Turn feature on. */
+#define LUAJIT_MODE_FLUSH	0x0200	/* Flush JIT-compiled code. */
+
+/* LuaJIT public C API. */
+
+/* Control the JIT engine. */
+LUA_API int luaJIT_setmode(lua_State *L, int idx, int mode);
+
+/* Low-overhead profiling API. */
+typedef void (*luaJIT_profile_callback)(void *data, lua_State *L,
+					int samples, int vmstate);
+LUA_API void luaJIT_profile_start(lua_State *L, const char *mode,
+				  luaJIT_profile_callback cb, void *data);
+LUA_API void luaJIT_profile_stop(lua_State *L);
+LUA_API const char *luaJIT_profile_dumpstack(lua_State *L, const char *fmt,
+					     int depth, size_t *len);
+
+/* Enforce (dynamic) linker error for version mismatches. Call from main. */
+LUA_API void LUAJIT_VERSION_SYM(void);
+
+#endif

thirdparty/luajit/lib/lualib.h

@@ -0,0 +1,44 @@
+/*
+** Standard library header.
+** Copyright (C) 2005-2025 Mike Pall. See Copyright Notice in luajit.h
+*/
+
+#ifndef _LUALIB_H
+#define _LUALIB_H
+
+#include "lua.h"
+
+#define LUA_FILEHANDLE	"FILE*"
+
+#define LUA_COLIBNAME	"coroutine"
+#define LUA_MATHLIBNAME	"math"
+#define LUA_STRLIBNAME	"string"
+#define LUA_TABLIBNAME	"table"
+#define LUA_IOLIBNAME	"io"
+#define LUA_OSLIBNAME	"os"
+#define LUA_LOADLIBNAME	"package"
+#define LUA_DBLIBNAME	"debug"
+#define LUA_BITLIBNAME	"bit"
+#define LUA_JITLIBNAME	"jit"
+#define LUA_FFILIBNAME	"ffi"
+
+LUALIB_API int luaopen_base(lua_State *L);
+LUALIB_API int luaopen_math(lua_State *L);
+LUALIB_API int luaopen_string(lua_State *L);
+LUALIB_API int luaopen_table(lua_State *L);
+LUALIB_API int luaopen_io(lua_State *L);
+LUALIB_API int luaopen_os(lua_State *L);
+LUALIB_API int luaopen_package(lua_State *L);
+LUALIB_API int luaopen_debug(lua_State *L);
+LUALIB_API int luaopen_bit(lua_State *L);
+LUALIB_API int luaopen_jit(lua_State *L);
+LUALIB_API int luaopen_ffi(lua_State *L);
+LUALIB_API int luaopen_string_buffer(lua_State *L);
+
+LUALIB_API void luaL_openlibs(lua_State *L);
+
+#ifndef lua_assert
+#define lua_assert(x)	((void)0)
+#endif
+
+#endif

thirdparty/luajit/luajit.jai

@@ -0,0 +1,551 @@
+//
+// This file was autogenerated.
+//
+
+
+
+WINVER :: 0x0501;
+
+LUA_MULTILIB :: "lib";
+
+LUA_LMULTILIB :: "lib";
+
+LUA_LROOT :: "/usr/local";
+LUA_LUADIR :: "/lua/5.1/";
+
+LUA_JROOT :: LUA_LROOT;
+
+LUA_PATH :: "LUA_PATH";
+LUA_CPATH :: "LUA_CPATH";
+LUA_INIT :: "LUA_INIT";
+
+LUA_DIRSEP :: "/";
+
+LUA_PATHSEP :: ";";
+LUA_PATH_MARK :: "?";
+LUA_EXECDIR :: "!";
+LUA_IGMARK :: "-";
+
+LUAI_MAXSTACK :: 65500;
+LUAI_MAXCSTACK :: 8000;
+LUAI_GCPAUSE :: 200;
+LUAI_GCMUL :: 200;
+LUA_MAXCAPTURES :: 32;
+
+LUA_IDSIZE :: 60;
+
+LUA_NUMBER_SCAN :: "%lf";
+LUA_NUMBER_FMT :: "%.14g";
+
+LUAI_MAXNUMBER2STR :: 32;
+LUA_INTFRMLEN :: "l";
+
+LUA_VERSION :: "Lua 5.1";
+LUA_RELEASE :: "Lua 5.1.4";
+LUA_VERSION_NUM :: 501;
+LUA_COPYRIGHT :: "Copyright (C) 1994-2008 Lua.org, PUC-Rio";
+LUA_AUTHORS :: "R. Ierusalimschy, L. H. de Figueiredo & W. Celes";
+
+LUA_SIGNATURE :: "\033Lua";
+
+LUA_MULTRET :: -1;
+
+LUA_REGISTRYINDEX :: -10000;
+LUA_ENVIRONINDEX :: -10001;
+LUA_GLOBALSINDEX :: -10002;
+
+LUA_OK :: 0;
+LUA_YIELD :: 1;
+LUA_ERRRUN :: 2;
+LUA_ERRSYNTAX :: 3;
+LUA_ERRMEM :: 4;
+LUA_ERRERR :: 5;
+
+LUA_TNONE :: -1;
+
+LUA_TNIL :: 0;
+LUA_TBOOLEAN :: 1;
+LUA_TLIGHTUSERDATA :: 2;
+LUA_TNUMBER :: 3;
+LUA_TSTRING :: 4;
+LUA_TTABLE :: 5;
+LUA_TFUNCTION :: 6;
+LUA_TUSERDATA :: 7;
+LUA_TTHREAD :: 8;
+
+LUA_MINSTACK :: 20;
+
+LUA_GCSTOP :: 0;
+LUA_GCRESTART :: 1;
+LUA_GCCOLLECT :: 2;
+LUA_GCCOUNT :: 3;
+LUA_GCCOUNTB :: 4;
+LUA_GCSTEP :: 5;
+LUA_GCSETPAUSE :: 6;
+LUA_GCSETSTEPMUL :: 7;
+LUA_GCISRUNNING :: 9;
+
+lua_Chunkreader :: Reader;
+lua_Chunkwriter :: Writer;
+
+LUA_HOOKCALL :: 0;
+LUA_HOOKRET :: 1;
+LUA_HOOKLINE :: 2;
+LUA_HOOKCOUNT :: 3;
+LUA_HOOKTAILRET :: 4;
+
+LUA_MASKCALL :: 1 << LUA_HOOKCALL;
+LUA_MASKRET :: 1 << LUA_HOOKRET;
+LUA_MASKLINE :: 1 << LUA_HOOKLINE;
+LUA_MASKCOUNT :: 1 << LUA_HOOKCOUNT;
+
+LUAJIT_VERSION :: "LuaJIT 2.1.1744318430";
+LUAJIT_VERSION_NUM :: 20199;
+LUAJIT_VERSION_SYM :: JIT_version_2_1_1744318430;
+LUAJIT_COPYRIGHT :: "Copyright (C) 2005-2025 Mike Pall";
+LUAJIT_URL :: "https://luajit.org/";
+
+LUAJIT_MODE_MASK :: 0x00ff;
+
+LUAJIT_MODE_OFF :: 0x0000;
+LUAJIT_MODE_ON :: 0x0100;
+LUAJIT_MODE_FLUSH :: 0x0200;
+
+LUA_FILEHANDLE :: "FILE*";
+
+LUA_COLIBNAME :: "coroutine";
+LUA_MATHLIBNAME :: "math";
+LUA_STRLIBNAME :: "string";
+LUA_TABLIBNAME :: "table";
+LUA_IOLIBNAME :: "io";
+LUA_OSLIBNAME :: "os";
+LUA_LOADLIBNAME :: "package";
+LUA_DBLIBNAME :: "debug";
+LUA_BITLIBNAME :: "bit";
+LUA_JITLIBNAME :: "jit";
+LUA_FFILIBNAME :: "ffi";
+
+LUA_ERRFILE :: LUA_ERRERR+1;
+
+LUA_NOREF :: -2;
+LUA_REFNIL :: -1;
+
+State :: struct {}
+
+CFunction :: #type (L: *State) -> s32 #c_call;
+
+/*
+** functions that read/write blocks when loading/dumping Lua chunks
+*/
+Reader :: #type (L: *State, ud: *void, sz: *u64) -> *u8 #c_call;
+
+Writer :: #type (L: *State, p: *void, sz: u64, ud: *void) -> s32 #c_call;
+
+/*
+** prototype for memory-allocation functions
+*/
+Alloc :: #type (ud: *void, ptr: *void, osize: u64, nsize: u64) -> *void #c_call;
+
+/* type of numbers in Lua */
+Number :: float64;
+
+/* type for integer functions */
+Integer :: ptrdiff_t;
+
+/*
+** state manipulation
+*/
+newstate :: (f: Alloc, ud: *void) -> *State #foreign luajit_5_1 "lua_newstate";
+close :: (L: *State) -> void #foreign luajit_5_1 "lua_close";
+newthread :: (L: *State) -> *State #foreign luajit_5_1 "lua_newthread";
+
+atpanic :: (L: *State, panicf: CFunction) -> CFunction #foreign luajit_5_1 "lua_atpanic";
+
+/*
+** basic stack manipulation
+*/
+gettop :: (L: *State) -> s32 #foreign luajit_5_1 "lua_gettop";
+settop :: (L: *State, idx: s32) -> void #foreign luajit_5_1 "lua_settop";
+pushvalue :: (L: *State, idx: s32) -> void #foreign luajit_5_1 "lua_pushvalue";
+_remove :: (L: *State, idx: s32) -> void #foreign luajit_5_1 "lua_remove";
+insert :: (L: *State, idx: s32) -> void #foreign luajit_5_1 "lua_insert";
+replace :: (L: *State, idx: s32) -> void #foreign luajit_5_1 "lua_replace";
+checkstack :: (L: *State, sz: s32) -> s32 #foreign luajit_5_1 "lua_checkstack";
+
+xmove :: (from: *State, to: *State, n: s32) -> void #foreign luajit_5_1 "lua_xmove";
+
+/*
+** access functions (stack -> C)
+*/
+isnumber :: (L: *State, idx: s32) -> s32 #foreign luajit_5_1 "lua_isnumber";
+isstring :: (L: *State, idx: s32) -> s32 #foreign luajit_5_1 "lua_isstring";
+iscfunction :: (L: *State, idx: s32) -> s32 #foreign luajit_5_1 "lua_iscfunction";
+isuserdata :: (L: *State, idx: s32) -> s32 #foreign luajit_5_1 "lua_isuserdata";
+type :: (L: *State, idx: s32) -> s32 #foreign luajit_5_1 "lua_type";
+typename :: (L: *State, tp: s32) -> *u8 #foreign luajit_5_1 "lua_typename";
+
+equal :: (L: *State, idx1: s32, idx2: s32) -> s32 #foreign luajit_5_1 "lua_equal";
+rawequal :: (L: *State, idx1: s32, idx2: s32) -> s32 #foreign luajit_5_1 "lua_rawequal";
+lessthan :: (L: *State, idx1: s32, idx2: s32) -> s32 #foreign luajit_5_1 "lua_lessthan";
+
+tonumber :: (L: *State, idx: s32) -> Number #foreign luajit_5_1 "lua_tonumber";
+tointeger :: (L: *State, idx: s32) -> Integer #foreign luajit_5_1 "lua_tointeger";
+toboolean :: (L: *State, idx: s32) -> s32 #foreign luajit_5_1 "lua_toboolean";
+tolstring :: (L: *State, idx: s32, len: *u64) -> *u8 #foreign luajit_5_1 "lua_tolstring";
+objlen :: (L: *State, idx: s32) -> u64 #foreign luajit_5_1 "lua_objlen";
+tocfunction :: (L: *State, idx: s32) -> CFunction #foreign luajit_5_1 "lua_tocfunction";
+touserdata :: (L: *State, idx: s32) -> *void #foreign luajit_5_1 "lua_touserdata";
+tothread :: (L: *State, idx: s32) -> *State #foreign luajit_5_1 "lua_tothread";
+topointer :: (L: *State, idx: s32) -> *void #foreign luajit_5_1 "lua_topointer";
+
+/*
+** push functions (C -> stack)
+*/
+pushnil :: (L: *State) -> void #foreign luajit_5_1 "lua_pushnil";
+pushnumber :: (L: *State, n: Number) -> void #foreign luajit_5_1 "lua_pushnumber";
+pushinteger :: (L: *State, n: Integer) -> void #foreign luajit_5_1 "lua_pushinteger";
+pushlstring :: (L: *State, s: *u8, l: u64) -> void #foreign luajit_5_1 "lua_pushlstring";
+pushstring :: (L: *State, s: *u8) -> void #foreign luajit_5_1 "lua_pushstring";
+
+pushfstring_CFormat :: (L: *State, fmt: *u8, __args: ..Any) -> *u8 #foreign luajit_5_1 "lua_pushfstring";
+pushfstring :: (L: *State, fmt: string, __args: ..Any) -> *u8 {
+    push_allocator(temp);
+    formatted_text_builder: String_Builder;
+    print_to_builder(*formatted_text_builder, fmt, ..__args);
+    append(*formatted_text_builder, "\0");
+    formatted_text := builder_to_string(*formatted_text_builder);
+    return pushfstring_CFormat(L, "%s", formatted_text.data);
+} @PrintLike
+pushcclosure :: (L: *State, fn: CFunction, n: s32) -> void #foreign luajit_5_1 "lua_pushcclosure";
+pushboolean :: (L: *State, b: s32) -> void #foreign luajit_5_1 "lua_pushboolean";
+pushlightuserdata :: (L: *State, p: *void) -> void #foreign luajit_5_1 "lua_pushlightuserdata";
+pushthread :: (L: *State) -> s32 #foreign luajit_5_1 "lua_pushthread";
+
+/*
+** get functions (Lua -> stack)
+*/
+gettable :: (L: *State, idx: s32) -> void #foreign luajit_5_1 "lua_gettable";
+getfield :: (L: *State, idx: s32, k: *u8) -> void #foreign luajit_5_1 "lua_getfield";
+rawget :: (L: *State, idx: s32) -> void #foreign luajit_5_1 "lua_rawget";
+rawgeti :: (L: *State, idx: s32, n: s32) -> void #foreign luajit_5_1 "lua_rawgeti";
+createtable :: (L: *State, narr: s32, nrec: s32) -> void #foreign luajit_5_1 "lua_createtable";
+newuserdata :: (L: *State, sz: u64) -> *void #foreign luajit_5_1 "lua_newuserdata";
+getmetatable :: (L: *State, objindex: s32) -> s32 #foreign luajit_5_1 "lua_getmetatable";
+getfenv :: (L: *State, idx: s32) -> void #foreign luajit_5_1 "lua_getfenv";
+
+/*
+** set functions (stack -> Lua)
+*/
+settable :: (L: *State, idx: s32) -> void #foreign luajit_5_1 "lua_settable";
+setfield :: (L: *State, idx: s32, k: *u8) -> void #foreign luajit_5_1 "lua_setfield";
+rawset :: (L: *State, idx: s32) -> void #foreign luajit_5_1 "lua_rawset";
+rawseti :: (L: *State, idx: s32, n: s32) -> void #foreign luajit_5_1 "lua_rawseti";
+setmetatable :: (L: *State, objindex: s32) -> s32 #foreign luajit_5_1 "lua_setmetatable";
+setfenv :: (L: *State, idx: s32) -> s32 #foreign luajit_5_1 "lua_setfenv";
+
+/*
+** `load' and `call' functions (load and run Lua code)
+*/
+call :: (L: *State, nargs: s32, nresults: s32) -> void #foreign luajit_5_1 "lua_call";
+pcall :: (L: *State, nargs: s32, nresults: s32, errfunc: s32) -> s32 #foreign luajit_5_1 "lua_pcall";
+cpcall :: (L: *State, func: CFunction, ud: *void) -> s32 #foreign luajit_5_1 "lua_cpcall";
+load :: (L: *State, reader: Reader, dt: *void, chunkname: *u8) -> s32 #foreign luajit_5_1 "lua_load";
+
+dump :: (L: *State, writer: Writer, data: *void) -> s32 #foreign luajit_5_1 "lua_dump";
+
+/*
+** coroutine functions
+*/
+yield :: (L: *State, nresults: s32) -> s32 #foreign luajit_5_1 "lua_yield";
+resume :: (L: *State, narg: s32) -> s32 #foreign luajit_5_1 "lua_resume";
+status :: (L: *State) -> s32 #foreign luajit_5_1 "lua_status";
+
+gc :: (L: *State, what: s32, data: s32) -> s32 #foreign luajit_5_1 "lua_gc";
+
+/*
+** miscellaneous functions
+*/
+error :: (L: *State) -> s32 #foreign luajit_5_1 "lua_error";
+
+next :: (L: *State, idx: s32) -> s32 #foreign luajit_5_1 "lua_next";
+
+concat :: (L: *State, n: s32) -> void #foreign luajit_5_1 "lua_concat";
+
+getallocf :: (L: *State, ud: **void) -> Alloc #foreign luajit_5_1 "lua_getallocf";
+setallocf :: (L: *State, f: Alloc, ud: *void) -> void #foreign luajit_5_1 "lua_setallocf";
+
+/* Functions to be called by the debuger in specific events */
+Hook :: #type (L: *State, ar: *Debug) -> void #c_call;
+
+getstack :: (L: *State, level: s32, ar: *Debug) -> s32 #foreign luajit_5_1 "lua_getstack";
+getinfo :: (L: *State, what: *u8, ar: *Debug) -> s32 #foreign luajit_5_1 "lua_getinfo";
+getlocal :: (L: *State, ar: *Debug, n: s32) -> *u8 #foreign luajit_5_1 "lua_getlocal";
+setlocal :: (L: *State, ar: *Debug, n: s32) -> *u8 #foreign luajit_5_1 "lua_setlocal";
+getupvalue :: (L: *State, funcindex: s32, n: s32) -> *u8 #foreign luajit_5_1 "lua_getupvalue";
+setupvalue :: (L: *State, funcindex: s32, n: s32) -> *u8 #foreign luajit_5_1 "lua_setupvalue";
+sethook :: (L: *State, func: Hook, mask: s32, count: s32) -> s32 #foreign luajit_5_1 "lua_sethook";
+gethook :: (L: *State) -> Hook #foreign luajit_5_1 "lua_gethook";
+gethookmask :: (L: *State) -> s32 #foreign luajit_5_1 "lua_gethookmask";
+gethookcount :: (L: *State) -> s32 #foreign luajit_5_1 "lua_gethookcount";
+
+/* From Lua 5.2. */
+upvalueid :: (L: *State, idx: s32, n: s32) -> *void #foreign luajit_5_1 "lua_upvalueid";
+upvaluejoin :: (L: *State, idx1: s32, n1: s32, idx2: s32, n2: s32) -> void #foreign luajit_5_1 "lua_upvaluejoin";
+loadx :: (L: *State, reader: Reader, dt: *void, chunkname: *u8, mode: *u8) -> s32 #foreign luajit_5_1 "lua_loadx";
+
+version :: (L: *State) -> *Number #foreign luajit_5_1 "lua_version";
+copy :: (L: *State, fromidx: s32, toidx: s32) -> void #foreign luajit_5_1 "lua_copy";
+tonumberx :: (L: *State, idx: s32, isnum: *s32) -> Number #foreign luajit_5_1 "lua_tonumberx";
+tointegerx :: (L: *State, idx: s32, isnum: *s32) -> Integer #foreign luajit_5_1 "lua_tointegerx";
+
+/* From Lua 5.3. */
+isyieldable :: (L: *State) -> s32 #foreign luajit_5_1 "lua_isyieldable";
+
+Debug :: struct {
+    event:           s32;
+    name:            *u8; /* (n) */
+    namewhat:        *u8; /* (n) `global', `local', `field', `method' */
+    what:            *u8; /* (S) `Lua', `C', `main', `tail' */
+    source:          *u8; /* (S) */
+    currentline:     s32; /* (l) */
+    nups:            s32; /* (u) number of upvalues */
+    linedefined:     s32; /* (S) */
+    lastlinedefined: s32; /* (S) */
+    short_src:       [60] u8; /* (S) */
+
+    i_ci:            s32; /* active function */
+}
+
+LUAJIT_MODE :: enum u32 {
+    ENGINE     :: 0;
+    DEBUG      :: 1;
+
+    FUNC       :: 2;
+    ALLFUNC    :: 3;
+    ALLSUBFUNC :: 4;
+
+    TRACE      :: 5;
+
+    WRAPCFUNC  :: 16;
+
+    MAX        :: 17;
+
+    LUAJIT_MODE_ENGINE     :: ENGINE;
+    LUAJIT_MODE_DEBUG      :: DEBUG;
+
+    LUAJIT_MODE_FUNC       :: FUNC;
+    LUAJIT_MODE_ALLFUNC    :: ALLFUNC;
+    LUAJIT_MODE_ALLSUBFUNC :: ALLSUBFUNC;
+
+    LUAJIT_MODE_TRACE      :: TRACE;
+
+    LUAJIT_MODE_WRAPCFUNC  :: WRAPCFUNC;
+
+    LUAJIT_MODE_MAX        :: MAX;
+}
+
+/* Control the JIT engine. */
+JIT_setmode :: (L: *State, idx: s32, mode: s32) -> s32 #foreign luajit_5_1 "luaJIT_setmode";
+
+/* Low-overhead profiling API. */
+JIT_profile_callback :: #type (data: *void, L: *State, samples: s32, vmstate: s32) -> void #c_call;
+
+JIT_profile_start :: (L: *State, mode: *u8, cb: JIT_profile_callback, data: *void) -> void #foreign luajit_5_1 "luaJIT_profile_start";
+
+JIT_profile_stop :: (L: *State) -> void #foreign luajit_5_1 "luaJIT_profile_stop";
+JIT_profile_dumpstack :: (L: *State, fmt: *u8, depth: s32, len: *u64) -> *u8 #foreign luajit_5_1 "luaJIT_profile_dumpstack";
+
+/* Enforce (dynamic) linker error for version mismatches. Call from main. */
+JIT_version_2_1_1744318430 :: () -> void #foreign luajit_5_1 "luaJIT_version_2_1_1744318430";
+
+open_base :: (L: *State) -> s32 #foreign luajit_5_1 "luaopen_base";
+open_math :: (L: *State) -> s32 #foreign luajit_5_1 "luaopen_math";
+open_string :: (L: *State) -> s32 #foreign luajit_5_1 "luaopen_string";
+open_table :: (L: *State) -> s32 #foreign luajit_5_1 "luaopen_table";
+open_io :: (L: *State) -> s32 #foreign luajit_5_1 "luaopen_io";
+open_os :: (L: *State) -> s32 #foreign luajit_5_1 "luaopen_os";
+open_package :: (L: *State) -> s32 #foreign luajit_5_1 "luaopen_package";
+open_debug :: (L: *State) -> s32 #foreign luajit_5_1 "luaopen_debug";
+open_bit :: (L: *State) -> s32 #foreign luajit_5_1 "luaopen_bit";
+open_jit :: (L: *State) -> s32 #foreign luajit_5_1 "luaopen_jit";
+open_ffi :: (L: *State) -> s32 #foreign luajit_5_1 "luaopen_ffi";
+open_string_buffer :: (L: *State) -> s32 #foreign luajit_5_1 "luaopen_string_buffer";
+
+L_openlibs :: (L: *State) -> void #foreign luajit_5_1 "luaL_openlibs";
+
+L_Reg :: struct {
+    name: *u8;
+    func: CFunction;
+}
+
+L_openlib :: (L: *State, libname: *u8, l: *L_Reg, nup: s32) -> void #foreign luajit_5_1 "luaL_openlib";
+
+L_register :: (L: *State, libname: *u8, l: *L_Reg) -> void #foreign luajit_5_1 "luaL_register";
+
+L_getmetafield :: (L: *State, obj: s32, e: *u8) -> s32 #foreign luajit_5_1 "luaL_getmetafield";
+L_callmeta :: (L: *State, obj: s32, e: *u8) -> s32 #foreign luajit_5_1 "luaL_callmeta";
+L_typerror :: (L: *State, narg: s32, tname: *u8) -> s32 #foreign luajit_5_1 "luaL_typerror";
+L_argerror :: (L: *State, numarg: s32, extramsg: *u8) -> s32 #foreign luajit_5_1 "luaL_argerror";
+L_checklstring :: (L: *State, numArg: s32, l: *u64) -> *u8 #foreign luajit_5_1 "luaL_checklstring";
+
+L_optlstring :: (L: *State, numArg: s32, def: *u8, l: *u64) -> *u8 #foreign luajit_5_1 "luaL_optlstring";
+
+L_checknumber :: (L: *State, numArg: s32) -> Number #foreign luajit_5_1 "luaL_checknumber";
+L_optnumber :: (L: *State, nArg: s32, def: Number) -> Number #foreign luajit_5_1 "luaL_optnumber";
+
+L_checkinteger :: (L: *State, numArg: s32) -> Integer #foreign luajit_5_1 "luaL_checkinteger";
+L_optinteger :: (L: *State, nArg: s32, def: Integer) -> Integer #foreign luajit_5_1 "luaL_optinteger";
+
+L_checkstack :: (L: *State, sz: s32, msg: *u8) -> void #foreign luajit_5_1 "luaL_checkstack";
+L_checktype :: (L: *State, narg: s32, t: s32) -> void #foreign luajit_5_1 "luaL_checktype";
+L_checkany :: (L: *State, narg: s32) -> void #foreign luajit_5_1 "luaL_checkany";
+
+L_newmetatable :: (L: *State, tname: *u8) -> s32 #foreign luajit_5_1 "luaL_newmetatable";
+L_checkudata :: (L: *State, ud: s32, tname: *u8) -> *void #foreign luajit_5_1 "luaL_checkudata";
+
+L_where :: (L: *State, lvl: s32) -> void #foreign luajit_5_1 "luaL_where";
+L_error_CFormat :: (L: *State, fmt: *u8, __args: ..Any) -> s32 #foreign luajit_5_1 "luaL_error";
+L_error :: (L: *State, fmt: string, __args: ..Any) -> s32 {
+    push_allocator(temp);
+    formatted_text_builder: String_Builder;
+    print_to_builder(*formatted_text_builder, fmt, ..__args);
+    append(*formatted_text_builder, "\0");
+    formatted_text := builder_to_string(*formatted_text_builder);
+    return L_error_CFormat(L, "%s", formatted_text.data);
+} @PrintLike
+
+L_checkoption :: (L: *State, narg: s32, def: *u8, lst: **u8) -> s32 #foreign luajit_5_1 "luaL_checkoption";
+
+L_ref :: (L: *State, t: s32) -> s32 #foreign luajit_5_1 "luaL_ref";
+L_unref :: (L: *State, t: s32, ref: s32) -> void #foreign luajit_5_1 "luaL_unref";
+
+L_loadfile :: (L: *State, filename: *u8) -> s32 #foreign luajit_5_1 "luaL_loadfile";
+L_loadbuffer :: (L: *State, buff: *u8, sz: u64, name: *u8) -> s32 #foreign luajit_5_1 "luaL_loadbuffer";
+
+L_loadstring :: (L: *State, s: *u8) -> s32 #foreign luajit_5_1 "luaL_loadstring";
+
+L_newstate :: () -> *State #foreign luajit_5_1 "luaL_newstate";
+
+L_gsub :: (L: *State, s: *u8, p: *u8, r: *u8) -> *u8 #foreign luajit_5_1 "luaL_gsub";
+
+L_findtable :: (L: *State, idx: s32, fname: *u8, szhint: s32) -> *u8 #foreign luajit_5_1 "luaL_findtable";
+
+/* From Lua 5.2. */
+L_fileresult :: (L: *State, stat: s32, fname: *u8) -> s32 #foreign luajit_5_1 "luaL_fileresult";
+L_execresult :: (L: *State, stat: s32) -> s32 #foreign luajit_5_1 "luaL_execresult";
+L_loadfilex :: (L: *State, filename: *u8, mode: *u8) -> s32 #foreign luajit_5_1 "luaL_loadfilex";
+
+L_loadbufferx :: (L: *State, buff: *u8, sz: u64, name: *u8, mode: *u8) -> s32 #foreign luajit_5_1 "luaL_loadbufferx";
+
+L_traceback :: (L: *State, L1: *State, msg: *u8, level: s32) -> void #foreign luajit_5_1 "luaL_traceback";
+
+L_setfuncs :: (L: *State, l: *L_Reg, nup: s32) -> void #foreign luajit_5_1 "luaL_setfuncs";
+L_pushmodule :: (L: *State, modname: *u8, sizehint: s32) -> void #foreign luajit_5_1 "luaL_pushmodule";
+
+L_testudata :: (L: *State, ud: s32, tname: *u8) -> *void #foreign luajit_5_1 "luaL_testudata";
+L_setmetatable :: (L: *State, tname: *u8) -> void #foreign luajit_5_1 "luaL_setmetatable";
+
+/*
+** {======================================================
+** Generic Buffer manipulation
+** =======================================================
+*/
+L_Buffer :: struct {
+    p:      *u8; /* current position in buffer */
+    lvl:    s32; /* number of strings in the stack (level) */
+    L:      *State;
+    buffer: [1024] u8;
+}
+
+L_buffinit :: (L: *State, B: *L_Buffer) -> void #foreign luajit_5_1 "luaL_buffinit";
+L_prepbuffer :: (B: *L_Buffer) -> *u8 #foreign luajit_5_1 "luaL_prepbuffer";
+L_addlstring :: (B: *L_Buffer, s: *u8, l: u64) -> void #foreign luajit_5_1 "luaL_addlstring";
+L_addstring :: (B: *L_Buffer, s: *u8) -> void #foreign luajit_5_1 "luaL_addstring";
+L_addvalue :: (B: *L_Buffer) -> void #foreign luajit_5_1 "luaL_addvalue";
+L_pushresult :: (B: *L_Buffer) -> void #foreign luajit_5_1 "luaL_pushresult";
+
+#scope_file
+
+#import "Basic"; // For assert, push_context
+
+
+#run {
+    {
+        info := type_info(Debug);
+        for info.members {
+            if it.name == {
+                case "event";
+                    assert(it.offset_in_bytes == 0, "Debug.event has unexpected offset % instead of 0", it.offset_in_bytes);
+                    assert(it.type.runtime_size == 4, "Debug.event has unexpected size % instead of 4", it.type.runtime_size);
+                case "name";
+                    assert(it.offset_in_bytes == 8, "Debug.name has unexpected offset % instead of 8", it.offset_in_bytes);
+                    assert(it.type.runtime_size == 8, "Debug.name has unexpected size % instead of 8", it.type.runtime_size);
+                case "namewhat";
+                    assert(it.offset_in_bytes == 16, "Debug.namewhat has unexpected offset % instead of 16", it.offset_in_bytes);
+                    assert(it.type.runtime_size == 8, "Debug.namewhat has unexpected size % instead of 8", it.type.runtime_size);
+                case "what";
+                    assert(it.offset_in_bytes == 24, "Debug.what has unexpected offset % instead of 24", it.offset_in_bytes);
+                    assert(it.type.runtime_size == 8, "Debug.what has unexpected size % instead of 8", it.type.runtime_size);
+                case "source";
+                    assert(it.offset_in_bytes == 32, "Debug.source has unexpected offset % instead of 32", it.offset_in_bytes);
+                    assert(it.type.runtime_size == 8, "Debug.source has unexpected size % instead of 8", it.type.runtime_size);
+                case "currentline";
+                    assert(it.offset_in_bytes == 40, "Debug.currentline has unexpected offset % instead of 40", it.offset_in_bytes);
+                    assert(it.type.runtime_size == 4, "Debug.currentline has unexpected size % instead of 4", it.type.runtime_size);
+                case "nups";
+                    assert(it.offset_in_bytes == 44, "Debug.nups has unexpected offset % instead of 44", it.offset_in_bytes);
+                    assert(it.type.runtime_size == 4, "Debug.nups has unexpected size % instead of 4", it.type.runtime_size);
+                case "linedefined";
+                    assert(it.offset_in_bytes == 48, "Debug.linedefined has unexpected offset % instead of 48", it.offset_in_bytes);
+                    assert(it.type.runtime_size == 4, "Debug.linedefined has unexpected size % instead of 4", it.type.runtime_size);
+                case "lastlinedefined";
+                    assert(it.offset_in_bytes == 52, "Debug.lastlinedefined has unexpected offset % instead of 52", it.offset_in_bytes);
+                    assert(it.type.runtime_size == 4, "Debug.lastlinedefined has unexpected size % instead of 4", it.type.runtime_size);
+                case "short_src";
+                    assert(it.offset_in_bytes == 56, "Debug.short_src has unexpected offset % instead of 56", it.offset_in_bytes);
+                    assert(it.type.runtime_size == 60, "Debug.short_src has unexpected size % instead of 60", it.type.runtime_size);
+                case "i_ci";
+                    assert(it.offset_in_bytes == 116, "Debug.i_ci has unexpected offset % instead of 116", it.offset_in_bytes);
+                    assert(it.type.runtime_size == 4, "Debug.i_ci has unexpected size % instead of 4", it.type.runtime_size);
+            }
+        }
+        assert(size_of(Debug) == 120, "Debug has size % instead of 120", size_of(Debug));
+    }
+
+    {
+        info := type_info(L_Reg);
+        for info.members {
+            if it.name == {
+                case "name";
+                    assert(it.offset_in_bytes == 0, "L_Reg.name has unexpected offset % instead of 0", it.offset_in_bytes);
+                    assert(it.type.runtime_size == 8, "L_Reg.name has unexpected size % instead of 8", it.type.runtime_size);
+                case "func";
+                    assert(it.offset_in_bytes == 8, "L_Reg.func has unexpected offset % instead of 8", it.offset_in_bytes);
+                    assert(it.type.runtime_size == 8, "L_Reg.func has unexpected size % instead of 8", it.type.runtime_size);
+            }
+        }
+        assert(size_of(L_Reg) == 16, "L_Reg has size % instead of 16", size_of(L_Reg));
+    }
+
+    {
+        info := type_info(L_Buffer);
+        for info.members {
+            if it.name == {
+                case "p";
+                    assert(it.offset_in_bytes == 0, "L_Buffer.p has unexpected offset % instead of 0", it.offset_in_bytes);
+                    assert(it.type.runtime_size == 8, "L_Buffer.p has unexpected size % instead of 8", it.type.runtime_size);
+                case "lvl";
+                    assert(it.offset_in_bytes == 8, "L_Buffer.lvl has unexpected offset % instead of 8", it.offset_in_bytes);
+                    assert(it.type.runtime_size == 4, "L_Buffer.lvl has unexpected size % instead of 4", it.type.runtime_size);
+                case "L";
+                    assert(it.offset_in_bytes == 16, "L_Buffer.L has unexpected offset % instead of 16", it.offset_in_bytes);
+                    assert(it.type.runtime_size == 8, "L_Buffer.L has unexpected size % instead of 8", it.type.runtime_size);
+                case "buffer";
+                    assert(it.offset_in_bytes == 24, "L_Buffer.buffer has unexpected offset % instead of 24", it.offset_in_bytes);
+                    assert(it.type.runtime_size == 1024, "L_Buffer.buffer has unexpected size % instead of 1024", it.type.runtime_size);
+            }
+        }
+        assert(size_of(L_Buffer) == 1048, "L_Buffer has size % instead of 1048", size_of(L_Buffer));
+    }
+}
+

thirdparty/luajit/module.jai

@@ -0,0 +1,28 @@
+#module_parameters(STATIC := true);
+
+#if STATIC {
+   #if OS == {
+      case .WINDOWS;
+         luajit_5_1 :: #library,no_dll,link_always "win/luajit-5.1";
+      case .MACOS;
+         luajit_5_1 :: #library,no_dll,link_always "mac/luajit-5.1";
+      case .LINUX;
+         luajit_5_1 :: #library,no_dll,link_always "linux/luajit-5.1";
+   }
+}
+else {
+   #if OS == {
+      case .WINDOWS;
+         luajit_5_1 :: #library "win/luajit-5.1";
+      case .MACOS;
+         luajit_5_1 :: #library "mac/luajit-5.1";
+      case .LINUX;
+         luajit_5_1 :: #library "linux/luajit-5.1";
+   }
+}
+
+#load "luajit.jai";
+
+#scope_module;
+
+ptrdiff_t :: s64;

thirdparty/remotery/generate.jai

@@ -1,7 +1,5 @@
 #scope_file;
 
-LOWERCASE_FIELD_NAMES :: true;
-
 #run {
    set_build_options_dc(.{ do_output = false });