Add vendor:lua/5.1

examples/all/all_vendor.odin

@@ -26,6 +26,7 @@ import NS         "vendor:darwin/Foundation"
 import MTL        "vendor:darwin/Metal"
 import CA         "vendor:darwin/QuartzCore"
 
+// NOTE(bill): only one can be checked at a time
 import lua_5_4    "vendor:lua/5.4"
 
 _ :: botan

vendor/lua/5.1/include/lauxlib.h

@@ -0,0 +1,174 @@
+/*
+** $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"
+
+
+#if defined(LUA_COMPAT_GETN)
+LUALIB_API int (luaL_getn) (lua_State *L, int t);
+LUALIB_API void (luaL_setn) (lua_State *L, int t, int n);
+#else
+#define luaL_getn(L,i)          ((int)lua_objlen(L, i))
+#define luaL_setn(L,i,j)        ((void)0)  /* no op! */
+#endif
+
+#if defined(LUA_COMPAT_OPENLIB)
+#define luaI_openlib	luaL_openlib
+#endif
+
+
+/* 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 (luaI_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[]);
+
+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);
+
+
+
+
+/*
+** ===============================================================
+** 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)))
+
+/*
+** {======================================================
+** 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);
+
+
+/* }====================================================== */
+
+
+/* compatibility with ref system */
+
+/* pre-defined references */
+#define LUA_NOREF       (-2)
+#define LUA_REFNIL      (-1)
+
+#define lua_ref(L,lock) ((lock) ? luaL_ref(L, LUA_REGISTRYINDEX) : \
+      (lua_pushstring(L, "unlocked references are obsolete"), lua_error(L), 0))
+
+#define lua_unref(L,ref)        luaL_unref(L, LUA_REGISTRYINDEX, (ref))
+
+#define lua_getref(L,ref)       lua_rawgeti(L, LUA_REGISTRYINDEX, (ref))
+
+
+#define luaL_reg	luaL_Reg
+
+#endif
+
+

vendor/lua/5.1/include/lua.h

@@ -0,0 +1,388 @@
+/*
+** $Id: lua.h,v 1.218.1.7 2012/01/13 20:36:20 roberto Exp $
+** Lua - An Extensible Extension Language
+** Lua.org, PUC-Rio, Brazil (http://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.5"
+#define LUA_VERSION_NUM	501
+#define LUA_COPYRIGHT	"Copyright (C) 1994-2012 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; 0 is OK */
+#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
+
+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);
+
+
+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-2012 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

vendor/lua/5.1/include/lua.hpp

@@ -0,0 +1,9 @@
+// lua.hpp
+// Lua header files for C++
+// <<extern "C">> not supplied automatically because Lua also compiles as C++
+
+extern "C" {
+#include "lua.h"
+#include "lualib.h"
+#include "lauxlib.h"
+}

vendor/lua/5.1/include/luaconf.h

@@ -0,0 +1,766 @@
+/*
+** $Id: luaconf.h,v 1.82.1.7 2008/02/11 16:25:08 roberto Exp $
+** Configuration file for Lua
+** See Copyright Notice in lua.h
+*/
+
+
+#ifndef lconfig_h
+#define lconfig_h
+
+#include <limits.h>
+#include <stddef.h>
+
+
+/*
+** ==================================================================
+** Search for "@@" to find all configurable definitions.
+** ===================================================================
+*/
+
+
+/*
+@@ LUA_ANSI controls the use of non-ansi features.
+** CHANGE it (define it) if you want Lua to avoid the use of any
+** non-ansi feature or library.
+*/
+#if defined(__STRICT_ANSI__)
+#define LUA_ANSI
+#endif
+
+
+#if !defined(LUA_ANSI) && defined(_WIN32)
+#define LUA_WIN
+#endif
+
+#if defined(LUA_USE_LINUX)
+#define LUA_USE_POSIX
+#define LUA_USE_DLOPEN		/* needs an extra library: -ldl */
+#define LUA_USE_READLINE	/* needs some extra libraries */
+#endif
+
+#if defined(LUA_USE_MACOSX)
+#define LUA_USE_POSIX
+#define LUA_DL_DYLD		/* does not need extra library */
+#endif
+
+
+
+/*
+@@ LUA_USE_POSIX includes all functionallity listed as X/Open System
+@* Interfaces Extension (XSI).
+** CHANGE it (define it) if your system is XSI compatible.
+*/
+#if defined(LUA_USE_POSIX)
+#define LUA_USE_MKSTEMP
+#define LUA_USE_ISATTY
+#define LUA_USE_POPEN
+#define LUA_USE_ULONGJMP
+#endif
+
+
+/*
+@@ LUA_PATH and LUA_CPATH are the names of the environment variables that
+@* Lua check to set its paths.
+@@ LUA_INIT is the name of the environment variable that Lua
+@* checks for initialization code.
+** CHANGE them if you want different names.
+*/
+#define LUA_PATH        "LUA_PATH"
+#define LUA_CPATH       "LUA_CPATH"
+#define LUA_INIT	"LUA_INIT"
+
+
+/*
+@@ LUA_PATH_DEFAULT is the default path that Lua uses to look for
+@* Lua libraries.
+@@ LUA_CPATH_DEFAULT is the default path that Lua uses to look for
+@* C libraries.
+** CHANGE them if your machine has a non-conventional directory
+** hierarchy or if you want to install your libraries in
+** non-conventional directories.
+*/
+#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;" \
+		             LUA_CDIR"?.lua;"  LUA_CDIR"?\\init.lua"
+#define LUA_CPATH_DEFAULT \
+		".\\?.dll;"  LUA_CDIR"?.dll;" LUA_CDIR"loadall.dll;" \
+		LUA_CDIR"clibs\\?.dll;" LUA_CDIR"clibs\\loadall.dll;" \
+		".\\?51.dll;"  LUA_CDIR"?51.dll;" LUA_CDIR"clibs\\?51.dll" 
+
+#else
+#define LUA_ROOT	"/usr/local/"
+#define LUA_LDIR	LUA_ROOT "share/lua/5.1/"
+#define LUA_CDIR	LUA_ROOT "lib/lua/5.1/"
+#define LUA_PATH_DEFAULT  \
+		"./?.lua;"  LUA_LDIR"?.lua;"  LUA_LDIR"?/init.lua;" \
+		            LUA_CDIR"?.lua;"  LUA_CDIR"?/init.lua"
+#define LUA_CPATH_DEFAULT \
+		"./?.so;"  LUA_CDIR"?.so;" LUA_CDIR"loadall.so;" \
+		"./lib?51.so;" LUA_CDIR"lib?51.so"
+#endif
+
+
+/*
+@@ LUA_DIRSEP is the directory separator (for submodules).
+** CHANGE it if your machine does not use "/" as the directory separator
+** and is not Windows. (On Windows Lua automatically uses "\".)
+*/
+#if defined(_WIN32)
+#define LUA_DIRSEP	"\\"
+#else
+#define LUA_DIRSEP	"/"
+#endif
+
+
+/*
+@@ LUA_PATHSEP is the character that separates templates in a path.
+@@ LUA_PATH_MARK is the string that marks the substitution points in a
+@* template.
+@@ LUA_EXECDIR in a Windows path is replaced by the executable's
+@* directory.
+@@ LUA_IGMARK is a mark to ignore all before it when bulding the
+@* luaopen_ function name.
+** CHANGE them if for some reason your system cannot use those
+** characters. (E.g., if one of those characters is a common character
+** in file/directory names.) Probably you do not need to change them.
+*/
+#define LUA_PATHSEP	";"
+#define LUA_PATH_MARK	"?"
+#define LUA_EXECDIR	"!"
+#define LUA_IGMARK	"-"
+
+
+/*
+@@ LUA_INTEGER is the integral type used by lua_pushinteger/lua_tointeger.
+** CHANGE that if ptrdiff_t is not adequate on your machine. (On most
+** machines, ptrdiff_t gives a good choice between int or long.)
+*/
+#define LUA_INTEGER	ptrdiff_t
+
+
+/*
+@@ LUA_API is a mark for all core API functions.
+@@ LUALIB_API is a mark for all standard library functions.
+** CHANGE them if you need to define those functions in some special way.
+** For instance, if you want to create one Windows DLL with the core and
+** the libraries, you may want to use the following definition (define
+** LUA_BUILD_AS_DLL to get it).
+*/
+#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
+
+/* more often than not the libs go together with the core */
+#define LUALIB_API	LUA_API
+
+
+/*
+@@ LUAI_FUNC is a mark for all extern functions that are not to be
+@* exported to outside modules.
+@@ LUAI_DATA is a mark for all extern (const) variables that are not to
+@* be exported to outside modules.
+** CHANGE them if you need to mark them in some special way. Elf/gcc
+** (versions 3.2 and later) mark them as "hidden" to optimize access
+** when Lua is compiled as a shared library.
+*/
+#if defined(luaall_c)
+#define LUAI_FUNC	static
+#define LUAI_DATA	/* empty */
+
+#elif defined(__GNUC__) && ((__GNUC__*100 + __GNUC_MINOR__) >= 302) && \
+      defined(__ELF__)
+#define LUAI_FUNC	__attribute__((visibility("hidden"))) extern
+#define LUAI_DATA	LUAI_FUNC
+
+#else
+#define LUAI_FUNC	extern
+#define LUAI_DATA	extern
+#endif
+
+
+
+/*
+@@ LUA_QL describes how error messages quote program elements.
+** CHANGE it if you want a different appearance.
+*/
+#define LUA_QL(x)	"'" x "'"
+#define LUA_QS		LUA_QL("%s")
+
+
+/*
+@@ LUA_IDSIZE gives the maximum size for the description of the source
+@* of a function in debug information.
+** CHANGE it if you want a different size.
+*/
+#define LUA_IDSIZE	60
+
+
+/*
+** {==================================================================
+** Stand-alone configuration
+** ===================================================================
+*/
+
+#if defined(lua_c) || defined(luaall_c)
+
+/*
+@@ lua_stdin_is_tty detects whether the standard input is a 'tty' (that
+@* is, whether we're running lua interactively).
+** CHANGE it if you have a better definition for non-POSIX/non-Windows
+** systems.
+*/
+#if defined(LUA_USE_ISATTY)
+#include <unistd.h>
+#define lua_stdin_is_tty()	isatty(0)
+#elif defined(LUA_WIN)
+#include <io.h>
+#include <stdio.h>
+#define lua_stdin_is_tty()	_isatty(_fileno(stdin))
+#else
+#define lua_stdin_is_tty()	1  /* assume stdin is a tty */
+#endif
+
+
+/*
+@@ LUA_PROMPT is the default prompt used by stand-alone Lua.
+@@ LUA_PROMPT2 is the default continuation prompt used by stand-alone Lua.
+** CHANGE them if you want different prompts. (You can also change the
+** prompts dynamically, assigning to globals _PROMPT/_PROMPT2.)
+*/
+#define LUA_PROMPT		"> "
+#define LUA_PROMPT2		">> "
+
+
+/*
+@@ LUA_PROGNAME is the default name for the stand-alone Lua program.
+** CHANGE it if your stand-alone interpreter has a different name and
+** your system is not able to detect that name automatically.
+*/
+#define LUA_PROGNAME		"lua"
+
+
+/*
+@@ LUA_MAXINPUT is the maximum length for an input line in the
+@* stand-alone interpreter.
+** CHANGE it if you need longer lines.
+*/
+#define LUA_MAXINPUT	512
+
+
+/*
+@@ lua_readline defines how to show a prompt and then read a line from
+@* the standard input.
+@@ lua_saveline defines how to "save" a read line in a "history".
+@@ lua_freeline defines how to free a line read by lua_readline.
+** CHANGE them if you want to improve this functionality (e.g., by using
+** GNU readline and history facilities).
+*/
+#if defined(LUA_USE_READLINE)
+#include <stdio.h>
+#include <readline/readline.h>
+#include <readline/history.h>
+#define lua_readline(L,b,p)	((void)L, ((b)=readline(p)) != NULL)
+#define lua_saveline(L,idx) \
+	if (lua_strlen(L,idx) > 0)  /* non-empty line? */ \
+	  add_history(lua_tostring(L, idx));  /* add it to history */
+#define lua_freeline(L,b)	((void)L, free(b))
+#else
+#define lua_readline(L,b,p)	\
+	((void)L, fputs(p, stdout), fflush(stdout),  /* show prompt */ \
+	fgets(b, LUA_MAXINPUT, stdin) != NULL)  /* get line */
+#define lua_saveline(L,idx)	{ (void)L; (void)idx; }
+#define lua_freeline(L,b)	{ (void)L; (void)b; }
+#endif
+
+#endif
+
+/* }================================================================== */
+
+
+/*
+@@ LUAI_GCPAUSE defines the default pause between garbage-collector cycles
+@* as a percentage.
+** CHANGE it if you want the GC to run faster or slower (higher values
+** mean larger pauses which mean slower collection.) You can also change
+** this value dynamically.
+*/
+#define LUAI_GCPAUSE	200  /* 200% (wait memory to double before next GC) */
+
+
+/*
+@@ LUAI_GCMUL defines the default speed of garbage collection relative to
+@* memory allocation as a percentage.
+** CHANGE it if you want to change the granularity of the garbage
+** collection. (Higher values mean coarser collections. 0 represents
+** infinity, where each step performs a full collection.) You can also
+** change this value dynamically.
+*/
+#define LUAI_GCMUL	200 /* GC runs 'twice the speed' of memory allocation */
+
+
+
+/*
+@@ LUA_COMPAT_GETN controls compatibility with old getn behavior.
+** CHANGE it (define it) if you want exact compatibility with the
+** behavior of setn/getn in Lua 5.0.
+*/
+#undef LUA_COMPAT_GETN
+
+/*
+@@ LUA_COMPAT_LOADLIB controls compatibility about global loadlib.
+** CHANGE it to undefined as soon as you do not need a global 'loadlib'
+** function (the function is still available as 'package.loadlib').
+*/
+#undef LUA_COMPAT_LOADLIB
+
+/*
+@@ LUA_COMPAT_VARARG controls compatibility with old vararg feature.
+** CHANGE it to undefined as soon as your programs use only '...' to
+** access vararg parameters (instead of the old 'arg' table).
+*/
+#define LUA_COMPAT_VARARG
+
+/*
+@@ LUA_COMPAT_MOD controls compatibility with old math.mod function.
+** CHANGE it to undefined as soon as your programs use 'math.fmod' or
+** the new '%' operator instead of 'math.mod'.
+*/
+#define LUA_COMPAT_MOD
+
+/*
+@@ LUA_COMPAT_LSTR controls compatibility with old long string nesting
+@* facility.
+** CHANGE it to 2 if you want the old behaviour, or undefine it to turn
+** off the advisory error when nesting [[...]].
+*/
+#define LUA_COMPAT_LSTR		1
+
+/*
+@@ LUA_COMPAT_GFIND controls compatibility with old 'string.gfind' name.
+** CHANGE it to undefined as soon as you rename 'string.gfind' to
+** 'string.gmatch'.
+*/
+#define LUA_COMPAT_GFIND
+
+/*
+@@ LUA_COMPAT_OPENLIB controls compatibility with old 'luaL_openlib'
+@* behavior.
+** CHANGE it to undefined as soon as you replace to 'luaL_register'
+** your uses of 'luaL_openlib'
+*/
+#define LUA_COMPAT_OPENLIB
+
+
+
+/*
+@@ luai_apicheck is the assert macro used by the Lua-C API.
+** CHANGE luai_apicheck if you want Lua to perform some checks in the
+** parameters it gets from API calls. This may slow down the interpreter
+** a bit, but may be quite useful when debugging C code that interfaces
+** with Lua. A useful redefinition is to use assert.h.
+*/
+#if defined(LUA_USE_APICHECK)
+#include <assert.h>
+#define luai_apicheck(L,o)	{ (void)L; assert(o); }
+#else
+#define luai_apicheck(L,o)	{ (void)L; }
+#endif
+
+
+/*
+@@ LUAI_BITSINT defines the number of bits in an int.
+** CHANGE here if Lua cannot automatically detect the number of bits of
+** your machine. Probably you do not need to change this.
+*/
+/* avoid overflows in comparison */
+#if INT_MAX-20 < 32760
+#define LUAI_BITSINT	16
+#elif INT_MAX > 2147483640L
+/* int has at least 32 bits */
+#define LUAI_BITSINT	32
+#else
+#error "you must define LUA_BITSINT with number of bits in an integer"
+#endif
+
+
+/*
+@@ LUAI_UINT32 is an unsigned integer with at least 32 bits.
+@@ LUAI_INT32 is an signed integer with at least 32 bits.
+@@ LUAI_UMEM is an unsigned integer big enough to count the total
+@* memory used by Lua.
+@@ LUAI_MEM is a signed integer big enough to count the total memory
+@* used by Lua.
+** CHANGE here if for some weird reason the default definitions are not
+** good enough for your machine. (The definitions in the 'else'
+** part always works, but may waste space on machines with 64-bit
+** longs.) Probably you do not need to change this.
+*/
+#if LUAI_BITSINT >= 32
+#define LUAI_UINT32	unsigned int
+#define LUAI_INT32	int
+#define LUAI_MAXINT32	INT_MAX
+#define LUAI_UMEM	size_t
+#define LUAI_MEM	ptrdiff_t
+#else
+/* 16-bit ints */
+#define LUAI_UINT32	unsigned long
+#define LUAI_INT32	long
+#define LUAI_MAXINT32	LONG_MAX
+#define LUAI_UMEM	unsigned long
+#define LUAI_MEM	long
+#endif
+
+
+/*
+@@ LUAI_MAXCALLS limits the number of nested calls.
+** CHANGE it if you need really deep recursive calls. This limit is
+** arbitrary; its only purpose is to stop infinite recursion before
+** exhausting memory.
+*/
+#define LUAI_MAXCALLS	20000
+
+
+/*
+@@ LUAI_MAXCSTACK limits the number of Lua stack slots that a C function
+@* can use.
+** CHANGE it if you need lots of (Lua) stack space for your C
+** functions. This limit is arbitrary; its only purpose is to stop C
+** functions to consume unlimited stack space. (must be smaller than
+** -LUA_REGISTRYINDEX)
+*/
+#define LUAI_MAXCSTACK	8000
+
+
+
+/*
+** {==================================================================
+** CHANGE (to smaller values) the following definitions if your system
+** has a small C stack. (Or you may want to change them to larger
+** values if your system has a large C stack and these limits are
+** too rigid for you.) Some of these constants control the size of
+** stack-allocated arrays used by the compiler or the interpreter, while
+** others limit the maximum number of recursive calls that the compiler
+** or the interpreter can perform. Values too large may cause a C stack
+** overflow for some forms of deep constructs.
+** ===================================================================
+*/
+
+
+/*
+@@ LUAI_MAXCCALLS is the maximum depth for nested C calls (short) and
+@* syntactical nested non-terminals in a program.
+*/
+#define LUAI_MAXCCALLS		200
+
+
+/*
+@@ LUAI_MAXVARS is the maximum number of local variables per function
+@* (must be smaller than 250).
+*/
+#define LUAI_MAXVARS		200
+
+
+/*
+@@ LUAI_MAXUPVALUES is the maximum number of upvalues per function
+@* (must be smaller than 250).
+*/
+#define LUAI_MAXUPVALUES	60
+
+
+/*
+@@ LUAL_BUFFERSIZE is the buffer size used by the lauxlib buffer system.
+*/
+#define LUAL_BUFFERSIZE		BUFSIZ
+
+/* }================================================================== */
+
+
+
+
+/*
+** {==================================================================
+@@ LUA_NUMBER is the type of numbers in Lua.
+** CHANGE the following definitions only if you want to build Lua
+** with a number type different from double. You may also need to
+** change lua_number2int & lua_number2integer.
+** ===================================================================
+*/
+
+#define LUA_NUMBER_DOUBLE
+#define LUA_NUMBER	double
+
+/*
+@@ LUAI_UACNUMBER is the result of an 'usual argument conversion'
+@* over a number.
+*/
+#define LUAI_UACNUMBER	double
+
+
+/*
+@@ LUA_NUMBER_SCAN is the format for reading numbers.
+@@ LUA_NUMBER_FMT is the format for writing numbers.
+@@ lua_number2str converts a number to a string.
+@@ LUAI_MAXNUMBER2STR is maximum size of previous conversion.
+@@ lua_str2number converts a string to a number.
+*/
+#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 /* 16 digits, sign, point, and \0 */
+#define lua_str2number(s,p)	strtod((s), (p))
+
+
+/*
+@@ The luai_num* macros define the primitive operations over numbers.
+*/
+#if defined(LUA_CORE)
+#include <math.h>
+#define luai_numadd(a,b)	((a)+(b))
+#define luai_numsub(a,b)	((a)-(b))
+#define luai_nummul(a,b)	((a)*(b))
+#define luai_numdiv(a,b)	((a)/(b))
+#define luai_nummod(a,b)	((a) - floor((a)/(b))*(b))
+#define luai_numpow(a,b)	(pow(a,b))
+#define luai_numunm(a)		(-(a))
+#define luai_numeq(a,b)		((a)==(b))
+#define luai_numlt(a,b)		((a)<(b))
+#define luai_numle(a,b)		((a)<=(b))
+#define luai_numisnan(a)	(!luai_numeq((a), (a)))
+#endif
+
+
+/*
+@@ lua_number2int is a macro to convert lua_Number to int.
+@@ lua_number2integer is a macro to convert lua_Number to lua_Integer.
+** CHANGE them if you know a faster way to convert a lua_Number to
+** int (with any rounding method and without throwing errors) in your
+** system. In Pentium machines, a naive typecast from double to int
+** in C is extremely slow, so any alternative is worth trying.
+*/
+
+/* On a Pentium, resort to a trick */
+#if defined(LUA_NUMBER_DOUBLE) && !defined(LUA_ANSI) && !defined(__SSE2__) && \
+    (defined(__i386) || defined (_M_IX86) || defined(__i386__))
+
+/* On a Microsoft compiler, use assembler */
+#if defined(_MSC_VER)
+
+#define lua_number2int(i,d)   __asm fld d   __asm fistp i
+#define lua_number2integer(i,n)		lua_number2int(i, n)
+
+/* the next trick should work on any Pentium, but sometimes clashes
+   with a DirectX idiosyncrasy */
+#else
+
+union luai_Cast { double l_d; long l_l; };
+#define lua_number2int(i,d) \
+  { volatile union luai_Cast u; u.l_d = (d) + 6755399441055744.0; (i) = u.l_l; }
+#define lua_number2integer(i,n)		lua_number2int(i, n)
+
+#endif
+
+
+/* this option always works, but may be slow */
+#else
+#define lua_number2int(i,d)	((i)=(int)(d))
+#define lua_number2integer(i,d)	((i)=(lua_Integer)(d))
+
+#endif
+
+/* }================================================================== */
+
+
+/*
+@@ LUAI_USER_ALIGNMENT_T is a type that requires maximum alignment.
+** CHANGE it if your system requires alignments larger than double. (For
+** instance, if your system supports long doubles and they must be
+** aligned in 16-byte boundaries, then you should add long double in the
+** union.) Probably you do not need to change this.
+*/
+#define LUAI_USER_ALIGNMENT_T	union { double u; void *s; long l; }
+
+
+/*
+@@ LUAI_THROW/LUAI_TRY define how Lua does exception handling.
+** CHANGE them if you prefer to use longjmp/setjmp even with C++
+** or if want/don't to use _longjmp/_setjmp instead of regular
+** longjmp/setjmp. By default, Lua handles errors with exceptions when
+** compiling as C++ code, with _longjmp/_setjmp when asked to use them,
+** and with longjmp/setjmp otherwise.
+*/
+#if defined(__cplusplus)
+/* C++ exceptions */
+#define LUAI_THROW(L,c)	throw(c)
+#define LUAI_TRY(L,c,a)	try { a } catch(...) \
+	{ if ((c)->status == 0) (c)->status = -1; }
+#define luai_jmpbuf	int  /* dummy variable */
+
+#elif defined(LUA_USE_ULONGJMP)
+/* in Unix, try _longjmp/_setjmp (more efficient) */
+#define LUAI_THROW(L,c)	_longjmp((c)->b, 1)
+#define LUAI_TRY(L,c,a)	if (_setjmp((c)->b) == 0) { a }
+#define luai_jmpbuf	jmp_buf
+
+#else
+/* default handling with long jumps */
+#define LUAI_THROW(L,c)	longjmp((c)->b, 1)
+#define LUAI_TRY(L,c,a)	if (setjmp((c)->b) == 0) { a }
+#define luai_jmpbuf	jmp_buf
+
+#endif
+
+
+/*
+@@ LUA_MAXCAPTURES is the maximum number of captures that a pattern
+@* can do during pattern-matching.
+** CHANGE it if you need more captures. This limit is arbitrary.
+*/
+#define LUA_MAXCAPTURES		32
+
+
+/*
+@@ lua_tmpnam is the function that the OS library uses to create a
+@* temporary name.
+@@ LUA_TMPNAMBUFSIZE is the maximum size of a name created by lua_tmpnam.
+** CHANGE them if you have an alternative to tmpnam (which is considered
+** insecure) or if you want the original tmpnam anyway.  By default, Lua
+** uses tmpnam except when POSIX is available, where it uses mkstemp.
+*/
+#if defined(loslib_c) || defined(luaall_c)
+
+#if defined(LUA_USE_MKSTEMP)
+#include <unistd.h>
+#define LUA_TMPNAMBUFSIZE	32
+#define lua_tmpnam(b,e)	{ \
+	strcpy(b, "/tmp/lua_XXXXXX"); \
+	e = mkstemp(b); \
+	if (e != -1) close(e); \
+	e = (e == -1); }
+
+#else
+#define LUA_TMPNAMBUFSIZE	L_tmpnam
+#define lua_tmpnam(b,e)		{ e = (tmpnam(b) == NULL); }
+#endif
+
+#endif
+
+
+/*
+@@ lua_popen spawns a new process connected to the current one through
+@* the file streams.
+** CHANGE it if you have a way to implement it in your system.
+*/
+#if defined(LUA_USE_POPEN)
+
+#define lua_popen(L,c,m)	((void)L, fflush(NULL), popen(c,m))
+#define lua_pclose(L,file)	((void)L, (pclose(file) != -1))
+
+#elif defined(LUA_WIN)
+
+#define lua_popen(L,c,m)	((void)L, _popen(c,m))
+#define lua_pclose(L,file)	((void)L, (_pclose(file) != -1))
+
+#else
+
+#define lua_popen(L,c,m)	((void)((void)c, m),  \
+		luaL_error(L, LUA_QL("popen") " not supported"), (FILE*)0)
+#define lua_pclose(L,file)		((void)((void)L, file), 0)
+
+#endif
+
+/*
+@@ LUA_DL_* define which dynamic-library system Lua should use.
+** CHANGE here if Lua has problems choosing the appropriate
+** dynamic-library system for your platform (either Windows' DLL, Mac's
+** dyld, or Unix's dlopen). If your system is some kind of Unix, there
+** is a good chance that it has dlopen, so LUA_DL_DLOPEN will work for
+** it.  To use dlopen you also need to adapt the src/Makefile (probably
+** adding -ldl to the linker options), so Lua does not select it
+** automatically.  (When you change the makefile to add -ldl, you must
+** also add -DLUA_USE_DLOPEN.)
+** If you do not want any kind of dynamic library, undefine all these
+** options.
+** By default, _WIN32 gets LUA_DL_DLL and MAC OS X gets LUA_DL_DYLD.
+*/
+#if defined(LUA_USE_DLOPEN)
+#define LUA_DL_DLOPEN
+#endif
+
+#if defined(LUA_WIN)
+#define LUA_DL_DLL
+#endif
+
+
+/*
+@@ LUAI_EXTRASPACE allows you to add user-specific data in a lua_State
+@* (the data goes just *before* the lua_State pointer).
+** CHANGE (define) this if you really need that. This value must be
+** a multiple of the maximum alignment required for your machine.
+*/
+#define LUAI_EXTRASPACE		0
+
+
+/*
+@@ luai_userstate* allow user-specific actions on threads.
+** CHANGE them if you defined LUAI_EXTRASPACE and need to do something
+** extra when a thread is created/deleted/resumed/yielded.
+*/
+#define luai_userstateopen(L)		((void)L)
+#define luai_userstateclose(L)		((void)L)
+#define luai_userstatethread(L,L1)	((void)L)
+#define luai_userstatefree(L)		((void)L)
+#define luai_userstateresume(L,n)	((void)L)
+#define luai_userstateyield(L,n)	((void)L)
+
+
+/*
+@@ LUA_INTFRMLEN is the length modifier for integer conversions
+@* in 'string.format'.
+@@ LUA_INTFRM_T is the integer type correspoding to the previous length
+@* modifier.
+** CHANGE them if your system supports long long or does not support long.
+*/
+
+#if defined(LUA_USELONGLONG)
+
+#define LUA_INTFRMLEN		"ll"
+#define LUA_INTFRM_T		long long
+
+#else
+
+#define LUA_INTFRMLEN		"l"
+#define LUA_INTFRM_T		long
+
+#endif
+
+
+
+/* =================================================================== */
+
+/*
+** Local configuration. You can use this space to add your redefinitions
+** without modifying the main part of the file.
+*/
+
+
+
+#endif
+

vendor/lua/5.1/include/lualib.h

@@ -0,0 +1,53 @@
+/*
+** $Id: lualib.h,v 1.36.1.1 2007/12/27 13:02:25 roberto Exp $
+** Lua standard libraries
+** See Copyright Notice in lua.h
+*/
+
+
+#ifndef lualib_h
+#define lualib_h
+
+#include "lua.h"
+
+
+/* Key to file-handle type */
+#define LUA_FILEHANDLE		"FILE*"
+
+
+#define LUA_COLIBNAME	"coroutine"
+LUALIB_API int (luaopen_base) (lua_State *L);
+
+#define LUA_TABLIBNAME	"table"
+LUALIB_API int (luaopen_table) (lua_State *L);
+
+#define LUA_IOLIBNAME	"io"
+LUALIB_API int (luaopen_io) (lua_State *L);
+
+#define LUA_OSLIBNAME	"os"
+LUALIB_API int (luaopen_os) (lua_State *L);
+
+#define LUA_STRLIBNAME	"string"
+LUALIB_API int (luaopen_string) (lua_State *L);
+
+#define LUA_MATHLIBNAME	"math"
+LUALIB_API int (luaopen_math) (lua_State *L);
+
+#define LUA_DBLIBNAME	"debug"
+LUALIB_API int (luaopen_debug) (lua_State *L);
+
+#define LUA_LOADLIBNAME	"package"
+LUALIB_API int (luaopen_package) (lua_State *L);
+
+
+/* open all previous libraries */
+LUALIB_API void (luaL_openlibs) (lua_State *L); 
+
+
+
+#ifndef lua_assert
+#define lua_assert(x)	((void)0)
+#endif
+
+
+#endif

vendor/lua/5.1/lua.odin

@@ -0,0 +1,659 @@
+package lua_5_1
+
+import "core:intrinsics"
+import "core:builtin"
+
+import c "core:c/libc"
+
+#assert(size_of(c.int) == size_of(b32))
+
+when ODIN_OS == .Windows {
+	foreign import lib "windows/lua5.1.dll.lib"
+} else when ODIN_OS == .Linux {
+	foreign import lib "linux/liblua5.1.a"
+} else {
+	#panic(`Unsupported platform of "vendor:lua/5.1"`)
+}
+
+VERSION	        :: "Lua 5.1"
+RELEASE	        :: "Lua 5.1.5"
+VERSION_NUM	:: 501
+COPYRIGHT	:: "Copyright (C) 1994-2012 Lua.org, PUC-Rio"
+AUTHORS         :: "R. Ierusalimschy, L. H. de Figueiredo & W. Celes"
+
+/* mark for precompiled code ('<esc>Lua') */
+SIGNATURE :: "\x1bLua"
+
+/* option for multiple returns in 'lua_pcall' and 'lua_call' */
+MULTRET :: -1
+
+REGISTRYINDEX :: -10000
+ENVIRONINDEX  :: -10001
+GLOBALSINDEX  :: -10002
+
+/*
+@@ LUAI_MAXSTACK limits the size of the Lua stack.
+** CHANGE it if you need a different limit. This limit is arbitrary;
+** its only purpose is to stop Lua from consuming unlimited stack
+** space (and to reserve some numbers for pseudo-indices).
+** (It must fit into max(size_t)/32.)
+*/
+MAXSTACK :: 1000000 when size_of(rawptr) == 4 else 15000
+
+
+/*
+@@ LUA_EXTRASPACE defines the size of a raw memory area associated with
+** a Lua state with very fast access.
+** CHANGE it if you need a different size.
+*/
+EXTRASPACE :: size_of(rawptr)
+
+
+
+/*
+@@ LUA_IDSIZE gives the maximum size for the description of the source
+@@ of a function in debug information.
+** CHANGE it if you want a different size.
+*/
+IDSIZE :: 60
+
+
+/*
+@@ LUAL_BUFFERSIZE is the buffer size used by the lauxlib buffer system.
+*/
+L_BUFFERSIZE :: c.int(16 * size_of(rawptr) * size_of(Number))
+
+
+MAXALIGNVAL :: max(align_of(Number), align_of(f64), align_of(rawptr), align_of(Integer), align_of(c.long))
+
+
+Status :: enum c.int {
+	OK        = 0,
+	YIELD     = 1,
+	ERRRUN    = 2,
+	ERRSYNTAX = 3,
+	ERRMEM    = 4,
+	ERRERR    = 5,
+	ERRFILE   = 6,
+}
+
+/* thread status */
+OK        :: Status.OK
+YIELD     :: Status.YIELD
+ERRRUN    :: Status.ERRRUN
+ERRSYNTAX :: Status.ERRSYNTAX
+ERRMEM    :: Status.ERRMEM
+ERRERR    :: Status.ERRERR
+ERRFILE   :: Status.ERRFILE
+
+/*
+** basic types
+*/
+
+
+Type :: enum c.int {
+	NONE          = -1,
+
+	NIL           = 0,
+	BOOLEAN       = 1,
+	LIGHTUSERDATA = 2,
+	NUMBER        = 3,
+	STRING        = 4,
+	TABLE         = 5,
+	FUNCTION      = 6,
+	USERDATA      = 7,
+	THREAD        = 8,
+}
+
+TNONE          :: Type.NONE
+TNIL           :: Type.NIL
+TBOOLEAN       :: Type.BOOLEAN
+TLIGHTUSERDATA :: Type.LIGHTUSERDATA
+TNUMBER        :: Type.NUMBER
+TSTRING        :: Type.STRING
+TTABLE         :: Type.TABLE
+TFUNCTION      :: Type.FUNCTION
+TUSERDATA      :: Type.USERDATA
+TTHREAD        :: Type.THREAD
+NUMTYPES :: 9
+
+
+CompareOp :: enum c.int {
+	EQ = 0,
+	LT = 1,
+	LE = 2,
+}
+
+OPEQ :: CompareOp.EQ
+OPLT :: CompareOp.LT
+OPLE :: CompareOp.LE
+
+
+/* minimum Lua stack available to a C function */
+MINSTACK :: 20
+
+
+/* type of numbers in Lua */
+Number :: distinct (f32 when size_of(uintptr) == 4 else f64)
+
+
+/* type for integer functions */
+Integer :: distinct (i32 when size_of(uintptr) == 4 else i64)
+
+
+/*
+** Type for C functions registered with Lua
+*/
+CFunction :: #type proc "c" (L: ^State) -> c.int
+
+
+
+/*
+** Type for functions that read/write blocks when loading/dumping Lua chunks
+*/
+Reader :: #type proc "c" (L: ^State, ud: rawptr, sz: ^c.size_t) -> cstring
+Writer :: #type proc "c" (L: ^State, p: rawptr, sz: ^c.size_t, ud: rawptr) -> c.int
+
+
+/*
+** Type for memory-allocation functions
+*/
+Alloc :: #type proc "c" (ud: rawptr, ptr: rawptr, osize, nsize: c.size_t) -> rawptr
+
+
+GCWhat :: enum c.int {
+	STOP        = 0,
+	RESTART     = 1,
+	COLLECT     = 2,
+	COUNT       = 3,
+	COUNTB      = 4,
+	STEP        = 5,
+	SETPAUSE    = 6,
+	SETSTEPMUL  = 7,
+}
+GCSTOP        :: GCWhat.STOP
+GCRESTART     :: GCWhat.RESTART
+GCCOLLECT     :: GCWhat.COLLECT
+GCCOUNT       :: GCWhat.COUNT
+GCCOUNTB      :: GCWhat.COUNTB
+GCSTEP        :: GCWhat.STEP
+GCSETPAUSE    :: GCWhat.SETPAUSE
+GCSETSTEPMUL  :: GCWhat.SETSTEPMUL
+
+
+/*
+** Event codes
+*/
+
+HookEvent :: enum c.int {
+	CALL     = 0,
+	RET      = 1,
+	LINE     = 2,
+	COUNT    = 3,
+	TAILRET  = 4,
+}
+HOOKCALL    :: HookEvent.CALL
+HOOKRET     :: HookEvent.RET
+HOOKLINE    :: HookEvent.LINE
+HOOKCOUNT   :: HookEvent.COUNT
+HOOKTAILRET :: HookEvent.TAILRET
+
+
+/*
+** Event masks
+*/
+HookMask :: distinct bit_set[HookEvent; c.int]
+MASKCALL  :: HookMask{.CALL}
+MASKRET   :: HookMask{.RET}
+MASKLINE  :: HookMask{.LINE}
+MASKCOUNT :: HookMask{.COUNT}
+
+/* activation record */
+Debug :: struct {
+	event:           HookEvent,
+	name:            cstring,              /* (n) */
+	namewhat:        cstring,              /* (n) 'global', 'local', 'field', 'method' */
+	what:            cstring,              /* (S) 'Lua', 'C', 'main', 'tail' */
+	source:          cstring,              /* (S) */
+	currentline:     c.int,                /* (l) */
+	nups:            c.int,                /* (u) number of upvalues */
+	linedefined:     c.int,                /* (S) */
+	lastlinedefined: c.int,                /* (S) */
+	short_src:       [IDSIZE]u8 `fmt:"s"`, /* (S) */
+	/* private part */
+	i_ci:            c.int,                /* active function */
+}
+
+
+/* Functions to be called by the debugger in specific events */
+Hook :: #type proc "c" (L: ^State, ar: ^Debug)
+
+
+State :: struct {} // opaque data type
+
+
+@(link_prefix="lua_")
+@(default_calling_convention="c")
+foreign lib {
+	/*
+	** RCS ident string
+	*/
+
+	ident: [^]u8 // TODO(bill): is this correct?
+
+
+	/*
+	** state manipulation
+	*/
+
+	newstate  :: proc(f: Alloc, ud: rawptr) -> ^State ---
+	close     :: proc(L: ^State) ---
+	newthread :: proc(L: ^State) -> ^State ---
+
+	atpanic :: proc(L: ^State, panicf: CFunction) -> CFunction ---
+
+
+	/*
+	** basic stack manipulation
+	*/
+
+	gettop     :: proc (L: ^State) -> c.int ---
+	settop     :: proc (L: ^State, idx: c.int) ---
+	pushvalue  :: proc (L: ^State, idx: c.int) ---
+	remove     :: proc (L: ^State, idx: c.int) ---
+	insert     :: proc (L: ^State, idx: c.int) ---
+	replace    :: proc (L: ^State, idx: c.int) ---
+	checkstack :: proc (L: ^State, sz: c.int) -> c.int ---
+
+	xmove :: proc(from, to: ^State, n: c.int) ---
+
+
+	/*
+	** access functions (stack -> C)
+	*/
+
+	isnumber    :: proc(L: ^State, idx: c.int) -> b32 ---
+	isstring    :: proc(L: ^State, idx: c.int) -> b32 ---
+	iscfunction :: proc(L: ^State, idx: c.int) -> b32 ---
+	isinteger   :: proc(L: ^State, idx: c.int) -> b32 ---
+	isuserdata  :: proc(L: ^State, idx: c.int) -> b32 ---
+	type        :: proc(L: ^State, idx: c.int) -> Type ---
+	typename    :: proc(L: ^State, tp: Type) -> cstring ---
+
+	equal    :: proc(L: ^State, idx1, idx2: c.int) -> b32 ---
+	rawequal :: proc(L: ^State, idx1, idx2: c.int) -> b32 ---
+	lessthan :: proc(L: ^State, idx1, idx2: c.int) -> b32 ---
+
+	toboolean   :: proc(L: ^State, idx: c.int) -> b32 ---
+	tolstring   :: proc(L: ^State, idx: c.int, len: ^c.size_t) -> cstring ---
+	objlen      :: proc(L: ^State, idx: c.int) -> c.size_t ---
+	tocfunction :: proc(L: ^State, idx: c.int) -> CFunction ---
+	touserdata  :: proc(L: ^State, idx: c.int) -> rawptr ---
+	tothread    :: proc(L: ^State, idx: c.int) -> ^State ---
+	topointer   :: proc(L: ^State, idx: c.int) -> rawptr ---
+
+	/*
+	** push functions (C -> stack)
+	*/
+
+	pushnil      :: proc(L: ^State) ---
+	pushnumber   :: proc(L: ^State, n: Number) ---
+	pushinteger  :: proc(L: ^State, n: Integer) ---
+	pushlstring  :: proc(L: ^State, s: cstring, l: c.size_t) ---
+	pushstring   :: proc(L: ^State, s: cstring) ---
+	pushvfstring :: proc(L: ^State, fmt: cstring, argp: c.va_list) -> cstring ---
+	pushfstring       :: proc(L: ^State, fmt: cstring, #c_vararg args: ..any) -> cstring ---
+	pushcclosure      :: proc(L: ^State, fn: CFunction, n: c.int) ---
+	pushboolean       :: proc(L: ^State, b: b32) ---
+	pushlightuserdata :: proc(L: ^State, p: rawptr) ---
+	pushthread        :: proc(L: ^State) -> Status ---
+
+	/*
+	** get functions (Lua -> stack)
+	*/
+
+	gettable  :: proc(L: ^State, idx: c.int) ---
+	getfield  :: proc(L: ^State, idx: c.int, k: cstring) ---
+	geti      :: proc(L: ^State, idx: c.int, n: Integer) ---
+	rawget    :: proc(L: ^State, idx: c.int) ---
+	rawgeti   :: proc(L: ^State, idx: c.int, n: Integer) ---
+	rawgetp   :: proc(L: ^State, idx: c.int, p: rawptr) ---
+
+	createtable  :: proc(L: ^State, narr, nrec: c.int) ---
+	newuserdata  :: proc(L: ^State, sz: c.size_t) -> rawptr ---
+	getmetatable :: proc(L: ^State, objindex: c.int) -> c.int ---
+	getfenv      :: proc(L: ^State, idx: c.int) ---
+
+
+	/*
+	** set functions (stack -> Lua)
+	*/
+
+	settable     :: proc(L: ^State, idx: c.int) ---
+	setfield     :: proc(L: ^State, idx: c.int, k: cstring) ---
+	rawset       :: proc(L: ^State, idx: c.int) ---
+	rawseti      :: proc(L: ^State, idx: c.int, n: c.int) ---
+	rawsetp      :: proc(L: ^State, idx: c.int, p: rawptr) ---
+	setmetatable :: proc(L: ^State, objindex: c.int) -> c.int ---
+	setfenv      :: proc(L: ^State, idx: c.int) -> c.int ---
+
+
+	/*
+	** 'load' and 'call' functions (load and run Lua code)
+	*/
+
+	call :: proc(L: ^State, nargs, nresults: c.int) ---
+
+	getctx :: proc(L: ^State, ctx: ^c.int) -> c.int ---
+
+	pcall :: proc(L: ^State, nargs, nresults: c.int, errfunc: c.int) -> c.int ---
+	cpcall :: proc(L: ^State, func: CFunction, ud: rawptr) -> c.int ---
+
+	load :: proc(L: ^State, reader: Reader, dt: rawptr,
+	             chunkname: cstring) -> Status ---
+
+	dump :: proc(L: ^State, writer: Writer, data: rawptr) -> Status ---
+
+
+	/*
+	** coroutine functions
+	*/
+
+	yield       :: proc(L: ^State, nresults: c.int) -> Status ---
+	resume      :: proc(L: ^State, narg: c.int) -> Status ---
+	status      :: proc(L: ^State) -> Status ---
+
+
+	/*
+	** garbage-collection function and options
+	*/
+
+
+
+	gc :: proc(L: ^State, what: GCWhat, data: c.int) -> c.int ---
+
+
+	/*
+	** miscellaneous functions
+	*/
+
+	error :: proc(L: ^State) -> Status ---
+
+	next :: proc(L: ^State, idx: c.int) -> c.int ---
+
+	concat :: proc(L: ^State, n: c.int) ---
+	len    :: proc(L: ^State, idx: c.int) ---
+
+	getallocf :: proc(L: State, ud: ^rawptr) -> Alloc ---
+	setallocf :: proc(L: ^State, f: Alloc, ud: rawptr) ---
+
+	/*
+	** {======================================================================
+	** Debug API
+	** =======================================================================
+	*/
+
+	getstack   :: proc(L: ^State, level: c.int, ar: ^Debug) -> c.int ---
+	getinfo    :: proc(L: ^State, what: cstring, ar: ^Debug) -> c.int ---
+	getlocal   :: proc(L: ^State, ar: ^Debug, n: c.int) -> cstring ---
+	setlocal   :: proc(L: ^State, ar: ^Debug, n: c.int) -> cstring ---
+	getupvalue :: proc(L: ^State, funcindex: c.int, n: c.int) -> cstring ---
+	setupvalue :: proc(L: ^State, funcindex: c.int, n: c.int) -> cstring ---
+
+	sethook :: proc(L: ^State, func: Hook, mask: HookMask, count: c.int) -> c.int ---
+	gethook :: proc(L: ^State) -> Hook ---
+	gethookmask  :: proc(L: ^State) -> HookMask ---
+	gethookcount :: proc(L: ^State) -> c.int ---
+
+	/* }============================================================== */
+}
+
+
+
+COLIBNAME   :: "coroutine"
+TABLIBNAME  :: "table"
+IOLIBNAME   :: "io"
+OSLIBNAME   :: "os"
+STRLIBNAME  :: "string"
+UTF8LIBNAME :: "utf8"
+MATHLIBNAME :: "math"
+DBLIBNAME   :: "debug"
+LOADLIBNAME :: "package"
+
+@(link_prefix="lua")
+@(default_calling_convention="c")
+foreign lib {
+	open_base      :: proc(L: ^State) -> c.int ---
+	open_table     :: proc(L: ^State) -> c.int ---
+	open_io        :: proc(L: ^State) -> c.int ---
+	open_os        :: proc(L: ^State) -> c.int ---
+	open_string    :: proc(L: ^State) -> c.int ---
+	open_utf8      :: proc(L: ^State) -> c.int ---
+	open_math      :: proc(L: ^State) -> c.int ---
+	open_debug     :: proc(L: ^State) -> c.int ---
+	open_package   :: proc(L: ^State) -> c.int ---
+
+	/* open all previous libraries */
+
+	L_openlibs :: proc(L: ^State) ---
+}
+
+
+
+GNAME :: "_G"
+
+L_Reg :: struct {
+	name: cstring,
+  	func: CFunction,
+}
+
+/* predefined references */
+NOREF  :: -2
+REFNIL :: -1
+
+@(link_prefix="lua")
+@(default_calling_convention="c")
+foreign lib {
+	L_openlib      :: proc(L: ^State, libname: cstring, l: [^]L_Reg, nup: c.int) ---
+	L_register     :: proc(L: ^State, libname: cstring, l: ^L_Reg) ---
+	L_getmetafield :: proc(L: ^State, obj: c.int, e: cstring) -> c.int ---
+	L_callmeta     :: proc(L: ^State, obj: c.int, e: cstring) -> c.int ---
+	L_typeerror    :: proc(L: ^State, narg: c.int, tname: cstring) -> c.int ---
+	L_argerror     :: proc(L: ^State, numarg: c.int, extramsg: cstring) -> c.int ---
+	@(link_name="luaL_checklstring")
+	L_checkstring  :: proc(L: ^State, numArg: c.int, l: ^c.size_t = nil) -> cstring ---
+	@(link_name="luaL_optlstring")
+	L_optstring    :: proc(L: ^State, numArg: c.int, def: cstring, l: ^c.size_t = nil) -> cstring ---
+	L_checknumber  :: proc(L: ^State, numArg: c.int) -> Number ---
+	L_optnumber    :: proc(L: ^State, nArg: c.int, def: Number) -> Number ---
+
+	L_checkinteger  :: proc(L: ^State, numArg: c.int) -> Integer ---
+	L_optinteger    :: proc(L: ^State, nArg: c.int, def: Integer) -> Integer ---
+
+
+	L_checkstack :: proc(L: ^State, sz: c.int, msg: cstring) ---
+	L_checktype  :: proc(L: ^State, narg: c.int, t: c.int) ---
+	L_checkany   :: proc(L: ^State, narg: c.int) ---
+
+	L_newmetatable :: proc(L: ^State, tname: cstring) -> c.int ---
+	L_checkudata   :: proc(L: ^State, ud: c.int, tname: cstring) -> rawptr ---
+
+	L_where :: proc(L: ^State, lvl: c.int) ---
+	L_error :: proc(L: ^State, fmt: cstring, #c_vararg args: ..any) -> Status ---
+
+	L_checkoption :: proc(L: ^State, narg: c.int, def: cstring, lst: [^]cstring) -> c.int ---
+
+
+	L_ref   :: proc(L: ^State, t: c.int) -> c.int ---
+	L_unref :: proc(L: ^State, t: c.int, ref: c.int) ---
+
+	L_loadfile :: proc (L: ^State, filename: cstring) -> Status ---
+
+	L_loadbuffer :: proc(L: ^State, buff: [^]byte, sz: c.size_t, name: cstring) -> Status ---
+	L_loadstring  :: proc(L: ^State, s: cstring) -> Status ---
+
+	L_newstate :: proc() -> ^State ---
+
+	L_gsub :: proc(L: ^State, s, p, r: cstring) -> cstring ---
+
+	L_findtable :: proc(L: ^State, idx: c.int, fname: cstring, szhint: c.int) -> cstring ---
+}
+/*
+** {======================================================
+** Generic Buffer manipulation
+** =======================================================
+*/
+
+
+L_Buffer :: struct {
+	p:    [^]byte,  /* buffer address */
+	lvl:  c.int,    /* number of strings in the stack (level) */
+	L:    ^State,
+	buffer: [L_BUFFERSIZE]byte,  /* initial buffer */
+}
+
+L_addchar :: #force_inline proc "c" (B: ^L_Buffer, c: byte) {
+	end := ([^]byte)(&B.buffer)[L_BUFFERSIZE:]
+	if B.p < end {
+		L_prepbuffer(B)
+	}
+	B.p[0] = c
+	B.p = B.p[1:]
+}
+L_putchar :: L_addchar
+
+L_addsize :: #force_inline proc "c" (B: ^L_Buffer, s: c.size_t) -> [^]byte {
+	B.p = B.p[s:]
+	return B.p
+}
+
+
+@(link_prefix="lua")
+@(default_calling_convention="c")
+foreign lib {
+	L_buffinit       :: proc(L: ^State, B: ^L_Buffer) ---
+	L_prepbuffer     :: proc(B: ^L_Buffer) -> [^]byte ---
+	L_addlstring     :: proc(B: ^L_Buffer, s: cstring, l: c.size_t) ---
+	L_addstring      :: proc(B: ^L_Buffer, s: cstring) ---
+	L_addvalue       :: proc(B: ^L_Buffer) ---
+	L_pushresult     :: proc(B: ^L_Buffer) ---
+	L_pushresultsize :: proc(B: ^L_Buffer, sz: c.size_t) ---
+	L_buffinitsize   :: proc(L: ^State, B: ^L_Buffer, sz: c.size_t) -> [^]byte ---
+}
+
+@(link_prefix="lua_")
+@(default_calling_convention="c")
+foreign lib {
+	/* hack */
+	setlevel :: proc(from, to: ^State) ---
+}
+
+
+/* }====================================================== */
+
+
+
+
+/*
+** {==============================================================
+** some useful macros
+** ===============================================================
+*/
+
+pop :: #force_inline proc "c" (L: ^State, n: c.int) {
+	settop(L, -n-1)
+}
+newtable :: #force_inline proc "c" (L: ^State) {
+	createtable(L, 0, 0)
+}
+register :: #force_inline proc "c" (L: ^State, n: cstring, f: CFunction) {
+	pushcfunction(L, f)
+	setglobal(L, n)
+}
+
+pushcfunction :: #force_inline proc "c" (L: ^State, f: CFunction) {
+	pushcclosure(L, f, 0)
+}
+
+strlen :: #force_inline proc "c" (L: ^State, i: c.int) -> c.size_t {
+	return objlen(L, i)
+}
+
+
+isfunction      :: #force_inline proc "c" (L: ^State, n: c.int) -> bool { return type(L, n) == .FUNCTION      }
+istable         :: #force_inline proc "c" (L: ^State, n: c.int) -> bool { return type(L, n) == .TABLE         }
+islightuserdata :: #force_inline proc "c" (L: ^State, n: c.int) -> bool { return type(L, n) == .LIGHTUSERDATA }
+isnil           :: #force_inline proc "c" (L: ^State, n: c.int) -> bool { return type(L, n) == .NIL           }
+isboolean       :: #force_inline proc "c" (L: ^State, n: c.int) -> bool { return type(L, n) == .BOOLEAN       }
+isthread        :: #force_inline proc "c" (L: ^State, n: c.int) -> bool { return type(L, n) == .THREAD        }
+isnone          :: #force_inline proc "c" (L: ^State, n: c.int) -> bool { return type(L, n) == .NONE          }
+isnoneornil     :: #force_inline proc "c" (L: ^State, n: c.int) -> bool { return type(L, n) <= .NIL           }
+
+
+pushliteral :: pushstring
+setglobal :: #force_inline proc "c" (L: ^State, s: cstring) {
+	setfield(L, GLOBALSINDEX, s)
+}
+getglobal :: #force_inline proc "c" (L: ^State, s: cstring) {
+	getfield(L, GLOBALSINDEX, s)
+}
+tostring :: #force_inline proc "c" (L: ^State, i: c.int) -> cstring {
+	return tolstring(L, i, nil)
+}
+
+open :: newstate
+getregistry :: #force_inline proc "c" (L: ^State) {
+	pushvalue(L, REGISTRYINDEX)
+}
+
+getgccount :: #force_inline proc "c" (L: ^State) -> c.int {
+	return gc(L, .COUNT, 0)
+}
+
+Chunkreader :: Reader
+Chunkwriter :: Writer
+
+
+L_argcheck :: #force_inline proc "c" (L: ^State, cond: bool, numarg: c.int, extramsg: cstring) {
+	if cond {
+		L_argerror(L, numarg, extramsg)
+	}
+}
+
+L_typename :: #force_inline proc "c" (L: ^State, i: c.int) -> cstring {
+	return typename(L, type(L, i))
+}
+L_dofile :: #force_inline proc "c" (L: ^State, s: cstring) -> c.int {
+	err := L_loadfile(L, s)
+	return pcall(L, 0, MULTRET, 0) if err == nil else c.int(err)
+}
+L_dostring :: #force_inline proc "c" (L: ^State, s: cstring) -> c.int {
+	err := L_loadstring(L, s)
+	return pcall(L, 0, MULTRET, 0) if err == nil else c.int(err)
+}
+L_getmetatable :: #force_inline proc "c" (L: ^State, n: cstring) {
+	getfield(L, REGISTRYINDEX, n)
+}
+L_opt :: #force_inline proc "c" (L: ^State, f: $F, n: c.int, d: $T) -> T where intrinsics.type_is_proc(F) {
+	return d if isnoneornil(L, n) else f(L, n)
+}
+
+
+
+ref :: #force_inline proc "c" (L: ^State, lock: bool) -> c.int {
+	if lock {
+		return L_ref(L, REGISTRYINDEX)
+	}
+	pushstring(L, "unlocked references are obsolete")
+	error(L)
+	return 0
+}
+unref :: #force_inline proc "c" (L: ^State, ref: c.int) {
+	L_unref(L,REGISTRYINDEX, ref)
+}
+getref :: #force_inline proc "c" (L: ^State, ref: Integer) {
+	rawgeti(L, REGISTRYINDEX, ref)
+}
+
+
+/* }============================================================== */

vendor/lua/5.2/lua.odin

@@ -407,14 +407,14 @@ foreign lib {
 	*/
 
 	@(link_name="lua_callk")
-	call :: proc(L: ^State, nargs, nresults: c.int,
+	call :: proc(L: ^State, nargs, nresults: c.int, ctx: c.int = 0,
 	             k: CFunction = nil) ---
 
 	getctx :: proc(L: ^State, ctx: ^c.int) -> c.int ---
 
 	@(link_name="lua_pcallk")
 	pcall :: proc(L: ^State, nargs, nresults: c.int, errfunc: c.int,
-	              k: CFunction = nil) -> c.int ---
+	              ctx: c.int = 0, k: CFunction = nil) -> c.int ---
 
 	load :: proc(L: ^State, reader: Reader, dt: rawptr,
 	             chunkname, mode: cstring) -> Status ---