diff --git a/resources/include/lite_xl_plugin_api.h b/resources/include/lite_xl_plugin_api.h new file mode 100644 index 00000000..2947039e --- /dev/null +++ b/resources/include/lite_xl_plugin_api.h @@ -0,0 +1,2563 @@ +/** + * lite_xl_plugin_api.h + * API for writing C extension modules loaded by Lite XL. + * This file is licensed under MIT. + * + * The Lite XL plugin API is quite simple. + * You would write a lua C extension and replace any references to lua.h, lauxlib.h + * and lualib.h with lite_xl_plugin_api.h. + * In your main file (where your entrypoint resides), define LITE_XL_PLUGIN_ENTRYPOINT. + * If you have multiple entrypoints, define LITE_XL_PLUGIN_ENTRYPOINT in one of them. + * + * After that, you need to create a Lite XL entrypoint, which is formatted as + * luaopen_lite_xl_xxxxx instead of luaopen_xxxxx. + * This entrypoint accepts a lua_State and an extra parameter of type void *. + * In this entrypoint, call lite_xl_plugin_init() with the extra parameter. + * If you have multiple entrypoints, you must call lite_xl_plugin_init() in + * each of them. + * This function is not thread safe, so don't try to do anything stupid. + * + * An example: + * + * #define LITE_XL_PLUGIN_ENTRYPOINT + * #include "lite_xl_plugin_api.h" + * int luaopen_lite_xl_xxxxx(lua_State* L, void* XL) { + * lite_xl_plugin_init(XL); + * ... + * return 1; + * } + * + * You can compile the library just like any Lua library without linking to Lua. + * An example command would be: gcc -shared -o xxxxx.so xxxxx.c + * You must not link to ANY lua library to avoid symbol collision. + * + * This file contains stock configuration for a typical installation of Lua 5.4. + * DO NOT MODIFY ANYTHING. MODIFYING STUFFS IN HERE WILL BREAK + * COMPATIBILITY WITH LITE XL AND CAUSE UNDEBUGGABLE BUGS. +**/ +#ifndef LITE_XL_PLUGIN_API +#define LITE_XL_PLUGIN_API + +#include +#include + +#ifdef __GNUC__ +#define UNUSED __attribute__((__unused__)) +#else +#define UNUSED +#endif + +/* FOR_EACH macro */ +#define CONCAT(arg1, arg2) CONCAT1(arg1, arg2) +#define CONCAT1(arg1, arg2) CONCAT2(arg1, arg2) +#define CONCAT2(arg1, arg2) arg1##arg2 +#define FE_1(what, x) what x +#define FE_2(what, x, ...) what x,FE_1(what, __VA_ARGS__) +#define FE_3(what, x, ...) what x,FE_2(what, __VA_ARGS__) +#define FE_4(what, x, ...) what x,FE_3(what, __VA_ARGS__) +#define FE_5(what, x, ...) what x,FE_4(what, __VA_ARGS__) +#define FE_6(what, x, ...) what x,FE_5(what, __VA_ARGS__) +#define FE_7(what, x, ...) what x,FE_6(what, __VA_ARGS__) +#define FE_8(what, x, ...) what x,FE_7(what, __VA_ARGS__) +#define FOR_EACH_NARG(...) FOR_EACH_NARG_(__VA_ARGS__, FOR_EACH_RSEQ_N()) +#define FOR_EACH_NARG_(...) FOR_EACH_ARG_N(__VA_ARGS__) +#define FOR_EACH_ARG_N(_1, _2, _3, _4, _5, _6, _7, _8, N, ...) N +#define FOR_EACH_RSEQ_N() 8, 7, 6, 5, 4, 3, 2, 1, 0 +#define FOR_EACH_(N, what, ...) CONCAT(FE_, N)(what, __VA_ARGS__) +#define FOR_EACH(what, ...) FOR_EACH_(FOR_EACH_NARG(__VA_ARGS__), what, __VA_ARGS__) + +#define SYMBOL_WRAP_DECL(ret, name, ...) \ + ret name(__VA_ARGS__) + +#define SYMBOL_WRAP_CALL(name, ...) \ + __##name(__VA_ARGS__) + +#define SYMBOL_WRAP_CALL_FB(name, ...) \ + return __lite_xl_fallback_##name(__VA_ARGS__) + +#ifdef LITE_XL_PLUGIN_ENTRYPOINT + #define SYMBOL_DECLARE(ret, name, ...) \ + static ret (*__##name) (__VA_ARGS__); \ + SYMBOL_WRAP_DECL(ret, name, __VA_ARGS__); \ + static ret __lite_xl_fallback_##name(FOR_EACH(UNUSED, __VA_ARGS__)) { \ + fputs("warning: " #name " is a stub", stderr); \ + exit(1); \ + } + #define SYMBOL_DECLARE_VARARG(ret, name, ...) \ + static ret (*__##name) (__VA_ARGS__, ...); \ + SYMBOL_WRAP_DECL(ret, name, __VA_ARGS__, ...); \ + static ret __lite_xl_fallback_##name(FOR_EACH(UNUSED, __VA_ARGS__), ...) { \ + fputs("warning: " #name " is a stub", stderr); \ + exit(1); \ + } +#else + #define SYMBOL_DECLARE(ret, name, ...) \ + SYMBOL_WRAP_DECL(ret, name, __VA_ARGS__); + #define SYMBOL_DECLARE_VARARG(ret, name, ...) \ + SYMBOL_WRAP_DECL(ret, name, __VA_ARGS__, ...); +#endif + + + + + +/* +** $Id: luaconf.h $ +** Configuration file for Lua +** See Copyright Notice in lua.h +*/ + + +#ifndef luaconf_h +#define luaconf_h + +#include +#include + + +/* +** =================================================================== +** General Configuration File for Lua +** +** Some definitions here can be changed externally, through the compiler +** (e.g., with '-D' options): They are commented out or protected +** by '#if !defined' guards. However, several other definitions +** should be changed directly here, either because they affect the +** Lua ABI (by making the changes here, you ensure that all software +** connected to Lua, such as C libraries, will be compiled with the same +** configuration); or because they are seldom changed. +** +** Search for "@@" to find all configurable definitions. +** =================================================================== +*/ + + +/* +** {==================================================================== +** System Configuration: macros to adapt (if needed) Lua to some +** particular platform, for instance restricting it to C89. +** ===================================================================== +*/ + +/* +@@ LUA_USE_C89 controls the use of non-ISO-C89 features. +** Define it if you want Lua to avoid the use of a few C99 features +** or Windows-specific features on Windows. +*/ +/* #define LUA_USE_C89 */ + + +/* +** By default, Lua on Windows use (some) specific Windows features +*/ +#if !defined(LUA_USE_C89) && defined(_WIN32) && !defined(_WIN32_WCE) +#define LUA_USE_WINDOWS /* enable goodies for regular Windows */ +#endif + + +#if defined(LUA_USE_WINDOWS) +#define LUA_DL_DLL /* enable support for DLL */ +#define LUA_USE_C89 /* broadly, Windows is C89 */ +#endif + + +#if defined(LUA_USE_LINUX) +#define LUA_USE_POSIX +#define LUA_USE_DLOPEN /* needs an extra library: -ldl */ +#endif + + +#if defined(LUA_USE_MACOSX) +#define LUA_USE_POSIX +#define LUA_USE_DLOPEN /* MacOS does not need -ldl */ +#endif + + +/* +@@ LUAI_IS32INT is true iff 'int' has (at least) 32 bits. +*/ +#define LUAI_IS32INT ((UINT_MAX >> 30) >= 3) + +/* }================================================================== */ + + + +/* +** {================================================================== +** Configuration for Number types. These options should not be +** set externally, because any other code connected to Lua must +** use the same configuration. +** =================================================================== +*/ + +/* +@@ LUA_INT_TYPE defines the type for Lua integers. +@@ LUA_FLOAT_TYPE defines the type for Lua floats. +** Lua should work fine with any mix of these options supported +** by your C compiler. The usual configurations are 64-bit integers +** and 'double' (the default), 32-bit integers and 'float' (for +** restricted platforms), and 'long'/'double' (for C compilers not +** compliant with C99, which may not have support for 'long long'). +*/ + +/* predefined options for LUA_INT_TYPE */ +#define LUA_INT_INT 1 +#define LUA_INT_LONG 2 +#define LUA_INT_LONGLONG 3 + +/* predefined options for LUA_FLOAT_TYPE */ +#define LUA_FLOAT_FLOAT 1 +#define LUA_FLOAT_DOUBLE 2 +#define LUA_FLOAT_LONGDOUBLE 3 + + +/* Default configuration ('long long' and 'double', for 64-bit Lua) */ +#define LUA_INT_DEFAULT LUA_INT_LONGLONG +#define LUA_FLOAT_DEFAULT LUA_FLOAT_DOUBLE + + +/* +@@ LUA_32BITS enables Lua with 32-bit integers and 32-bit floats. +*/ +#define LUA_32BITS 0 + + +/* +@@ LUA_C89_NUMBERS ensures that Lua uses the largest types available for +** C89 ('long' and 'double'); Windows always has '__int64', so it does +** not need to use this case. +*/ +#if defined(LUA_USE_C89) && !defined(LUA_USE_WINDOWS) +#define LUA_C89_NUMBERS 1 +#else +#define LUA_C89_NUMBERS 0 +#endif + + +#if LUA_32BITS /* { */ +/* +** 32-bit integers and 'float' +*/ +#if LUAI_IS32INT /* use 'int' if big enough */ +#define LUA_INT_TYPE LUA_INT_INT +#else /* otherwise use 'long' */ +#define LUA_INT_TYPE LUA_INT_LONG +#endif +#define LUA_FLOAT_TYPE LUA_FLOAT_FLOAT + +#elif LUA_C89_NUMBERS /* }{ */ +/* +** largest types available for C89 ('long' and 'double') +*/ +#define LUA_INT_TYPE LUA_INT_LONG +#define LUA_FLOAT_TYPE LUA_FLOAT_DOUBLE + +#else /* }{ */ +/* use defaults */ + +#define LUA_INT_TYPE LUA_INT_DEFAULT +#define LUA_FLOAT_TYPE LUA_FLOAT_DEFAULT + +#endif /* } */ + + +/* }================================================================== */ + + + +/* +** {================================================================== +** Configuration for Paths. +** =================================================================== +*/ + +/* +** LUA_PATH_SEP is the character that separates templates in a path. +** LUA_PATH_MARK is the string that marks the substitution points in a +** template. +** LUA_EXEC_DIR in a Windows path is replaced by the executable's +** directory. +*/ +#define LUA_PATH_SEP ";" +#define LUA_PATH_MARK "?" +#define LUA_EXEC_DIR "!" + + +/* +@@ 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. +*/ + +#define LUA_VDIR LUA_VERSION_MAJOR "." LUA_VERSION_MINOR +#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_SHRDIR "!\\..\\share\\lua\\" LUA_VDIR "\\" + +#if !defined(LUA_PATH_DEFAULT) +#define LUA_PATH_DEFAULT \ + LUA_LDIR"?.lua;" LUA_LDIR"?\\init.lua;" \ + LUA_CDIR"?.lua;" LUA_CDIR"?\\init.lua;" \ + LUA_SHRDIR"?.lua;" LUA_SHRDIR"?\\init.lua;" \ + ".\\?.lua;" ".\\?\\init.lua" +#endif + +#if !defined(LUA_CPATH_DEFAULT) +#define LUA_CPATH_DEFAULT \ + LUA_CDIR"?.dll;" \ + LUA_CDIR"..\\lib\\lua\\" LUA_VDIR "\\?.dll;" \ + LUA_CDIR"loadall.dll;" ".\\?.dll" +#endif + +#else /* }{ */ + +#define LUA_ROOT "/usr/local/" +#define LUA_LDIR LUA_ROOT "share/lua/" LUA_VDIR "/" +#define LUA_CDIR LUA_ROOT "lib/lua/" LUA_VDIR "/" + +#if !defined(LUA_PATH_DEFAULT) +#define LUA_PATH_DEFAULT \ + LUA_LDIR"?.lua;" LUA_LDIR"?/init.lua;" \ + LUA_CDIR"?.lua;" LUA_CDIR"?/init.lua;" \ + "./?.lua;" "./?/init.lua" +#endif + +#if !defined(LUA_CPATH_DEFAULT) +#define LUA_CPATH_DEFAULT \ + LUA_CDIR"?.so;" LUA_CDIR"loadall.so;" "./?.so" +#endif + +#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(LUA_DIRSEP) + +#if defined(_WIN32) +#define LUA_DIRSEP "\\" +#else +#define LUA_DIRSEP "/" +#endif + +#endif + +/* }================================================================== */ + + +/* +** {================================================================== +** Marks for exported symbols in the C code +** =================================================================== +*/ + +/* +@@ LUA_API is a mark for all core API functions. +@@ LUALIB_API is a mark for all auxiliary library functions. +@@ LUAMOD_API is a mark for all standard library opening 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 +#define LUAMOD_API LUA_API + + +/* +@@ LUAI_FUNC is a mark for all extern functions that are not to be +** exported to outside modules. +@@ LUAI_DDEF and LUAI_DDEC are marks for all extern (const) variables, +** none of which to be exported to outside modules (LUAI_DDEF for +** definitions and LUAI_DDEC for declarations). +** 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. Not all elf targets support +** this attribute. Unfortunately, gcc does not offer a way to check +** whether the target offers that support, and those without support +** give a warning about it. To avoid these warnings, change to the +** default definition. +*/ +#if defined(__GNUC__) && ((__GNUC__*100 + __GNUC_MINOR__) >= 302) && \ + defined(__ELF__) /* { */ +#define LUAI_FUNC __attribute__((visibility("internal"))) extern +#else /* }{ */ +#define LUAI_FUNC extern +#endif /* } */ + +#define LUAI_DDEC(dec) LUAI_FUNC dec +#define LUAI_DDEF /* empty */ + +/* }================================================================== */ + + +/* +** {================================================================== +** Compatibility with previous versions +** =================================================================== +*/ + +/* +@@ LUA_COMPAT_5_3 controls other macros for compatibility with Lua 5.3. +** You can define it to get all options, or change specific options +** to fit your specific needs. +*/ +#if defined(LUA_COMPAT_5_3) /* { */ + +/* +@@ LUA_COMPAT_MATHLIB controls the presence of several deprecated +** functions in the mathematical library. +** (These functions were already officially removed in 5.3; +** nevertheless they are still available here.) +*/ +#define LUA_COMPAT_MATHLIB + +/* +@@ LUA_COMPAT_APIINTCASTS controls the presence of macros for +** manipulating other integer types (lua_pushunsigned, lua_tounsigned, +** luaL_checkint, luaL_checklong, etc.) +** (These macros were also officially removed in 5.3, but they are still +** available here.) +*/ +#define LUA_COMPAT_APIINTCASTS + + +/* +@@ LUA_COMPAT_LT_LE controls the emulation of the '__le' metamethod +** using '__lt'. +*/ +#define LUA_COMPAT_LT_LE + + +/* +@@ The following macros supply trivial compatibility for some +** changes in the API. The macros themselves document how to +** change your code to avoid using them. +** (Once more, these macros were officially removed in 5.3, but they are +** still available here.) +*/ +#define lua_strlen(L,i) lua_rawlen(L, (i)) + +#define lua_objlen(L,i) lua_rawlen(L, (i)) + +#define lua_equal(L,idx1,idx2) lua_compare(L,(idx1),(idx2),LUA_OPEQ) +#define lua_lessthan(L,idx1,idx2) lua_compare(L,(idx1),(idx2),LUA_OPLT) + +#endif /* } */ + +/* }================================================================== */ + + + +/* +** {================================================================== +** Configuration for Numbers (low-level part). +** Change these definitions if no predefined LUA_FLOAT_* / LUA_INT_* +** satisfy your needs. +** =================================================================== +*/ + +/* +@@ LUAI_UACNUMBER is the result of a 'default argument promotion' +@@ over a floating number. +@@ l_floatatt(x) corrects float attribute 'x' to the proper float type +** by prefixing it with one of FLT/DBL/LDBL. +@@ LUA_NUMBER_FRMLEN is the length modifier for writing floats. +@@ LUA_NUMBER_FMT is the format for writing floats. +@@ lua_number2str converts a float to a string. +@@ l_mathop allows the addition of an 'l' or 'f' to all math operations. +@@ l_floor takes the floor of a float. +@@ lua_str2number converts a decimal numeral to a number. +*/ + + +/* The following definitions are good for most cases here */ + +#define l_floor(x) (l_mathop(floor)(x)) + +#define lua_number2str(s,sz,n) \ + l_sprintf((s), sz, LUA_NUMBER_FMT, (LUAI_UACNUMBER)(n)) + +/* +@@ lua_numbertointeger converts a float number with an integral value +** to an integer, or returns 0 if float is not within the range of +** a lua_Integer. (The range comparisons are tricky because of +** rounding. The tests here assume a two-complement representation, +** where MININTEGER always has an exact representation as a float; +** MAXINTEGER may not have one, and therefore its conversion to float +** may have an ill-defined value.) +*/ +#define lua_numbertointeger(n,p) \ + ((n) >= (LUA_NUMBER)(LUA_MININTEGER) && \ + (n) < -(LUA_NUMBER)(LUA_MININTEGER) && \ + (*(p) = (LUA_INTEGER)(n), 1)) + + +/* now the variable definitions */ + +#if LUA_FLOAT_TYPE == LUA_FLOAT_FLOAT /* { single float */ + +#define LUA_NUMBER float + +#define l_floatatt(n) (FLT_##n) + +#define LUAI_UACNUMBER double + +#define LUA_NUMBER_FRMLEN "" +#define LUA_NUMBER_FMT "%.7g" + +#define l_mathop(op) op##f + +#define lua_str2number(s,p) strtof((s), (p)) + + +#elif LUA_FLOAT_TYPE == LUA_FLOAT_LONGDOUBLE /* }{ long double */ + +#define LUA_NUMBER long double + +#define l_floatatt(n) (LDBL_##n) + +#define LUAI_UACNUMBER long double + +#define LUA_NUMBER_FRMLEN "L" +#define LUA_NUMBER_FMT "%.19Lg" + +#define l_mathop(op) op##l + +#define lua_str2number(s,p) strtold((s), (p)) + +#elif LUA_FLOAT_TYPE == LUA_FLOAT_DOUBLE /* }{ double */ + +#define LUA_NUMBER double + +#define l_floatatt(n) (DBL_##n) + +#define LUAI_UACNUMBER double + +#define LUA_NUMBER_FRMLEN "" +#define LUA_NUMBER_FMT "%.14g" + +#define l_mathop(op) op + +#define lua_str2number(s,p) strtod((s), (p)) + +#else /* }{ */ + +#error "numeric float type not defined" + +#endif /* } */ + + + +/* +@@ LUA_UNSIGNED is the unsigned version of LUA_INTEGER. +@@ LUAI_UACINT is the result of a 'default argument promotion' +@@ over a LUA_INTEGER. +@@ LUA_INTEGER_FRMLEN is the length modifier for reading/writing integers. +@@ LUA_INTEGER_FMT is the format for writing integers. +@@ LUA_MAXINTEGER is the maximum value for a LUA_INTEGER. +@@ LUA_MININTEGER is the minimum value for a LUA_INTEGER. +@@ LUA_MAXUNSIGNED is the maximum value for a LUA_UNSIGNED. +@@ lua_integer2str converts an integer to a string. +*/ + + +/* The following definitions are good for most cases here */ + +#define LUA_INTEGER_FMT "%" LUA_INTEGER_FRMLEN "d" + +#define LUAI_UACINT LUA_INTEGER + +#define lua_integer2str(s,sz,n) \ + l_sprintf((s), sz, LUA_INTEGER_FMT, (LUAI_UACINT)(n)) + +/* +** use LUAI_UACINT here to avoid problems with promotions (which +** can turn a comparison between unsigneds into a signed comparison) +*/ +#define LUA_UNSIGNED unsigned LUAI_UACINT + + +/* now the variable definitions */ + +#if LUA_INT_TYPE == LUA_INT_INT /* { int */ + +#define LUA_INTEGER int +#define LUA_INTEGER_FRMLEN "" + +#define LUA_MAXINTEGER INT_MAX +#define LUA_MININTEGER INT_MIN + +#define LUA_MAXUNSIGNED UINT_MAX + +#elif LUA_INT_TYPE == LUA_INT_LONG /* }{ long */ + +#define LUA_INTEGER long +#define LUA_INTEGER_FRMLEN "l" + +#define LUA_MAXINTEGER LONG_MAX +#define LUA_MININTEGER LONG_MIN + +#define LUA_MAXUNSIGNED ULONG_MAX + +#elif LUA_INT_TYPE == LUA_INT_LONGLONG /* }{ long long */ + +/* use presence of macro LLONG_MAX as proxy for C99 compliance */ +#if defined(LLONG_MAX) /* { */ +/* use ISO C99 stuff */ + +#define LUA_INTEGER long long +#define LUA_INTEGER_FRMLEN "ll" + +#define LUA_MAXINTEGER LLONG_MAX +#define LUA_MININTEGER LLONG_MIN + +#define LUA_MAXUNSIGNED ULLONG_MAX + +#elif defined(LUA_USE_WINDOWS) /* }{ */ +/* in Windows, can use specific Windows types */ + +#define LUA_INTEGER __int64 +#define LUA_INTEGER_FRMLEN "I64" + +#define LUA_MAXINTEGER _I64_MAX +#define LUA_MININTEGER _I64_MIN + +#define LUA_MAXUNSIGNED _UI64_MAX + +#else /* }{ */ + +#error "Compiler does not support 'long long'. Use option '-DLUA_32BITS' \ + or '-DLUA_C89_NUMBERS' (see file 'luaconf.h' for details)" + +#endif /* } */ + +#else /* }{ */ + +#error "numeric integer type not defined" + +#endif /* } */ + +/* }================================================================== */ + + +/* +** {================================================================== +** Dependencies with C99 and other C details +** =================================================================== +*/ + +/* +@@ l_sprintf is equivalent to 'snprintf' or 'sprintf' in C89. +** (All uses in Lua have only one format item.) +*/ +#if !defined(LUA_USE_C89) +#define l_sprintf(s,sz,f,i) snprintf(s,sz,f,i) +#else +#define l_sprintf(s,sz,f,i) ((void)(sz), sprintf(s,f,i)) +#endif + + +/* +@@ lua_strx2number converts a hexadecimal numeral to a number. +** In C99, 'strtod' does that conversion. Otherwise, you can +** leave 'lua_strx2number' undefined and Lua will provide its own +** implementation. +*/ +#if !defined(LUA_USE_C89) +#define lua_strx2number(s,p) lua_str2number(s,p) +#endif + + +/* +@@ lua_pointer2str converts a pointer to a readable string in a +** non-specified way. +*/ +#define lua_pointer2str(buff,sz,p) l_sprintf(buff,sz,"%p",p) + + +/* +@@ lua_number2strx converts a float to a hexadecimal numeral. +** In C99, 'sprintf' (with format specifiers '%a'/'%A') does that. +** Otherwise, you can leave 'lua_number2strx' undefined and Lua will +** provide its own implementation. +*/ +#if !defined(LUA_USE_C89) +#define lua_number2strx(L,b,sz,f,n) \ + ((void)L, l_sprintf(b,sz,f,(LUAI_UACNUMBER)(n))) +#endif + + +/* +** 'strtof' and 'opf' variants for math functions are not valid in +** C89. Otherwise, the macro 'HUGE_VALF' is a good proxy for testing the +** availability of these variants. ('math.h' is already included in +** all files that use these macros.) +*/ +#if defined(LUA_USE_C89) || (defined(HUGE_VAL) && !defined(HUGE_VALF)) +#undef l_mathop /* variants not available */ +#undef lua_str2number +#define l_mathop(op) (lua_Number)op /* no variant */ +#define lua_str2number(s,p) ((lua_Number)strtod((s), (p))) +#endif + + +/* +@@ LUA_KCONTEXT is the type of the context ('ctx') for continuation +** functions. It must be a numerical type; Lua will use 'intptr_t' if +** available, otherwise it will use 'ptrdiff_t' (the nearest thing to +** 'intptr_t' in C89) +*/ +#define LUA_KCONTEXT ptrdiff_t + +#if !defined(LUA_USE_C89) && defined(__STDC_VERSION__) && \ + __STDC_VERSION__ >= 199901L +#include +#if defined(INTPTR_MAX) /* even in C99 this type is optional */ +#undef LUA_KCONTEXT +#define LUA_KCONTEXT intptr_t +#endif +#endif + + +/* +@@ lua_getlocaledecpoint gets the locale "radix character" (decimal point). +** Change that if you do not want to use C locales. (Code using this +** macro must include the header 'locale.h'.) +*/ +#if !defined(lua_getlocaledecpoint) +#define lua_getlocaledecpoint() (localeconv()->decimal_point[0]) +#endif + + +/* +** macros to improve jump prediction, used mostly for error handling +** and debug facilities. (Some macros in the Lua API use these macros. +** Define LUA_NOBUILTIN if you do not want '__builtin_expect' in your +** code.) +*/ +#if !defined(luai_likely) + +#if defined(__GNUC__) && !defined(LUA_NOBUILTIN) +#define luai_likely(x) (__builtin_expect(((x) != 0), 1)) +#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) +#else +#define luai_likely(x) (x) +#define luai_unlikely(x) (x) +#endif + +#endif + + +#if defined(LUA_CORE) || defined(LUA_LIB) +/* shorter names for Lua's own use */ +#define l_likely(x) luai_likely(x) +#define l_unlikely(x) luai_unlikely(x) +#endif + + + +/* }================================================================== */ + + +/* +** {================================================================== +** Language Variations +** ===================================================================== +*/ + +/* +@@ LUA_NOCVTN2S/LUA_NOCVTS2N control how Lua performs some +** coercions. Define LUA_NOCVTN2S to turn off automatic coercion from +** numbers to strings. Define LUA_NOCVTS2N to turn off automatic +** coercion from strings to numbers. +*/ +/* #define LUA_NOCVTN2S */ +/* #define LUA_NOCVTS2N */ + + +/* +@@ LUA_USE_APICHECK turns on several consistency checks on the C API. +** Define it as a help when debugging C code. +*/ +#if defined(LUA_USE_APICHECK) +#include +#define luai_apicheck(l,e) assert(e) +#endif + +/* }================================================================== */ + + +/* +** {================================================================== +** Macros that affect the API and must be stable (that is, must be the +** same when you compile Lua and when you compile code that links to +** Lua). +** ===================================================================== +*/ + +/* +@@ 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.) +*/ +#if LUAI_IS32INT +#define LUAI_MAXSTACK 1000000 +#else +#define LUAI_MAXSTACK 15000 +#endif + + +/* +@@ 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. +*/ +#define LUA_EXTRASPACE (sizeof(void *)) + + +/* +@@ 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 + + +/* +@@ LUAL_BUFFERSIZE is the buffer size used by the lauxlib buffer system. +*/ +#define LUAL_BUFFERSIZE ((int)(16 * sizeof(void*) * sizeof(lua_Number))) + + +/* +@@ LUAI_MAXALIGN defines fields that, when used in a union, ensure +** maximum alignment for the other items in that union. +*/ +#define LUAI_MAXALIGN lua_Number n; double u; void *s; lua_Integer i; long l + +/* }================================================================== */ + +#endif + + + + + +/* +** $Id: lua.h $ +** Lua - A Scripting 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 +#include + + +#define LUA_VERSION_MAJOR "5" +#define LUA_VERSION_MINOR "4" +#define LUA_VERSION_RELEASE "4" + +#define LUA_VERSION_NUM 504 +#define LUA_VERSION_RELEASE_NUM (LUA_VERSION_NUM * 100 + 4) + +#define LUA_VERSION "Lua " LUA_VERSION_MAJOR "." LUA_VERSION_MINOR +#define LUA_RELEASE LUA_VERSION "." LUA_VERSION_RELEASE +#define LUA_COPYRIGHT LUA_RELEASE " Copyright (C) 1994-2022 Lua.org, PUC-Rio" +#define LUA_AUTHORS "R. Ierusalimschy, L. H. de Figueiredo, W. Celes" + + +/* mark for precompiled code ('Lua') */ +#define LUA_SIGNATURE "\x1bLua" + +/* option for multiple returns in 'lua_pcall' and 'lua_call' */ +#define LUA_MULTRET (-1) + + +/* +** Pseudo-indices +** (-LUAI_MAXSTACK is the minimum valid index; we keep some free empty +** space after that to help overflow detection) +*/ +#define LUA_REGISTRYINDEX (-LUAI_MAXSTACK - 1000) +#define lua_upvalueindex(i) (LUA_REGISTRYINDEX - (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; + + +/* +** 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 + +#define LUA_NUMTYPES 9 + + + +/* minimum Lua stack available to a C function */ +#define LUA_MINSTACK 20 + + +/* predefined values in the registry */ +#define LUA_RIDX_MAINTHREAD 1 +#define LUA_RIDX_GLOBALS 2 +#define LUA_RIDX_LAST LUA_RIDX_GLOBALS + + +/* type of numbers in Lua */ +typedef LUA_NUMBER lua_Number; + + +/* type for integer functions */ +typedef LUA_INTEGER lua_Integer; + +/* unsigned integer type */ +typedef LUA_UNSIGNED lua_Unsigned; + +/* type for continuation-function contexts */ +typedef LUA_KCONTEXT lua_KContext; + + +/* +** Type for C functions registered with Lua +*/ +typedef int (*lua_CFunction) (lua_State *L); + +/* +** Type for continuation functions +*/ +typedef int (*lua_KFunction) (lua_State *L, int status, lua_KContext ctx); + + +/* +** Type for 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); + + +/* +** Type for memory-allocation functions +*/ +typedef void * (*lua_Alloc) (void *ud, void *ptr, size_t osize, size_t nsize); + + +/* +** Type for warning functions +*/ +typedef void (*lua_WarnFunction) (void *ud, const char *msg, int tocont); + + + + +/* +** generic extra include file +*/ +#if defined(LUA_USER_H) +#include LUA_USER_H +#endif + + +/* +** RCS ident string +*/ +extern const char lua_ident[]; + + +/* +** state manipulation +*/ +SYMBOL_DECLARE(lua_State *, lua_newstate, lua_Alloc f, void *ud) +SYMBOL_DECLARE(void, lua_close, lua_State *L) +SYMBOL_DECLARE(lua_State *, lua_newthread, lua_State *L) +SYMBOL_DECLARE(int, lua_resetthread, lua_State *L) + +SYMBOL_DECLARE(lua_CFunction, lua_atpanic, lua_State *L, lua_CFunction panicf) + + +SYMBOL_DECLARE(lua_Number, lua_version, lua_State *L) + + +/* +** basic stack manipulation +*/ +SYMBOL_DECLARE(int , lua_absindex, lua_State *L, int idx) +SYMBOL_DECLARE(int , lua_gettop, lua_State *L) +SYMBOL_DECLARE(void, lua_settop, lua_State *L, int idx) +SYMBOL_DECLARE(void, lua_pushvalue, lua_State *L, int idx) +SYMBOL_DECLARE(void, lua_rotate, lua_State *L, int idx, int n) +SYMBOL_DECLARE(void, lua_copy, lua_State *L, int fromidx, int toidx) +SYMBOL_DECLARE(int , lua_checkstack, lua_State *L, int n) + +SYMBOL_DECLARE(void, lua_xmove, lua_State *from, lua_State *to, int n) + + +/* +** access functions (stack -> C) +*/ + +SYMBOL_DECLARE(int , lua_isnumber, lua_State *L, int idx) +SYMBOL_DECLARE(int , lua_isstring, lua_State *L, int idx) +SYMBOL_DECLARE(int , lua_iscfunction, lua_State *L, int idx) +SYMBOL_DECLARE(int , lua_isinteger, lua_State *L, int idx) +SYMBOL_DECLARE(int , lua_isuserdata, lua_State *L, int idx) +SYMBOL_DECLARE(int , lua_type, lua_State *L, int idx) +SYMBOL_DECLARE(const char *, lua_typename, lua_State *L, int tp) + +SYMBOL_DECLARE(lua_Number , lua_tonumberx, lua_State *L, int idx, int *isnum) +SYMBOL_DECLARE(lua_Integer , lua_tointegerx, lua_State *L, int idx, int *isnum) +SYMBOL_DECLARE(int , lua_toboolean, lua_State *L, int idx) +SYMBOL_DECLARE(const char *, lua_tolstring, lua_State *L, int idx, size_t *len) +SYMBOL_DECLARE(lua_Unsigned , lua_rawlen, lua_State *L, int idx) +SYMBOL_DECLARE(lua_CFunction , lua_tocfunction, lua_State *L, int idx) +SYMBOL_DECLARE(void *, lua_touserdata, lua_State *L, int idx) +SYMBOL_DECLARE(lua_State *, lua_tothread, lua_State *L, int idx) +SYMBOL_DECLARE(const void *, lua_topointer, lua_State *L, int idx) + + +/* +** Comparison and arithmetic functions +*/ + +#define LUA_OPADD 0 /* ORDER TM, ORDER OP */ +#define LUA_OPSUB 1 +#define LUA_OPMUL 2 +#define LUA_OPMOD 3 +#define LUA_OPPOW 4 +#define LUA_OPDIV 5 +#define LUA_OPIDIV 6 +#define LUA_OPBAND 7 +#define LUA_OPBOR 8 +#define LUA_OPBXOR 9 +#define LUA_OPSHL 10 +#define LUA_OPSHR 11 +#define LUA_OPUNM 12 +#define LUA_OPBNOT 13 + +SYMBOL_DECLARE(void , lua_arith, lua_State *L, int op) + +#define LUA_OPEQ 0 +#define LUA_OPLT 1 +#define LUA_OPLE 2 + +SYMBOL_DECLARE(int , lua_rawequal, lua_State *L, int idx1, int idx2) +SYMBOL_DECLARE(int , lua_compare, lua_State *L, int idx1, int idx2, int op) + + +/* +** push functions (C -> stack) +*/ +SYMBOL_DECLARE(void , lua_pushnil, lua_State *L) +SYMBOL_DECLARE(void , lua_pushnumber, lua_State *L, lua_Number n) +SYMBOL_DECLARE(void , lua_pushinteger, lua_State *L, lua_Integer n) +SYMBOL_DECLARE(const char *, lua_pushlstring, lua_State *L, const char *s, size_t len) +SYMBOL_DECLARE(const char *, lua_pushstring, lua_State *L, const char *s) +SYMBOL_DECLARE(const char *, lua_pushvfstring, lua_State *L, const char *fmt, + va_list argp) +SYMBOL_DECLARE_VARARG(const char *, lua_pushfstring, lua_State *L, const char *fmt) +SYMBOL_DECLARE(void , lua_pushcclosure, lua_State *L, lua_CFunction fn, int n) +SYMBOL_DECLARE(void , lua_pushboolean, lua_State *L, int b) +SYMBOL_DECLARE(void , lua_pushlightuserdata, lua_State *L, void *p) +SYMBOL_DECLARE(int , lua_pushthread, lua_State *L) + + +/* +** get functions (Lua -> stack) +*/ +SYMBOL_DECLARE(int , lua_getglobal, lua_State *L, const char *name) +SYMBOL_DECLARE(int , lua_gettable, lua_State *L, int idx) +SYMBOL_DECLARE(int , lua_getfield, lua_State *L, int idx, const char *k) +SYMBOL_DECLARE(int , lua_geti, lua_State *L, int idx, lua_Integer n) +SYMBOL_DECLARE(int , lua_rawget, lua_State *L, int idx) +SYMBOL_DECLARE(int , lua_rawgeti, lua_State *L, int idx, lua_Integer n) +SYMBOL_DECLARE(int , lua_rawgetp, lua_State *L, int idx, const void *p) + +SYMBOL_DECLARE(void , lua_createtable, lua_State *L, int narr, int nrec) +SYMBOL_DECLARE(void *, lua_newuserdatauv, lua_State *L, size_t sz, int nuvalue) +SYMBOL_DECLARE(int , lua_getmetatable, lua_State *L, int objindex) +SYMBOL_DECLARE(int , lua_getiuservalue, lua_State *L, int idx, int n) + + +/* +** set functions (stack -> Lua) +*/ +SYMBOL_DECLARE(void , lua_setglobal, lua_State *L, const char *name) +SYMBOL_DECLARE(void , lua_settable, lua_State *L, int idx) +SYMBOL_DECLARE(void , lua_setfield, lua_State *L, int idx, const char *k) +SYMBOL_DECLARE(void , lua_seti, lua_State *L, int idx, lua_Integer n) +SYMBOL_DECLARE(void , lua_rawset, lua_State *L, int idx) +SYMBOL_DECLARE(void , lua_rawseti, lua_State *L, int idx, lua_Integer n) +SYMBOL_DECLARE(void , lua_rawsetp, lua_State *L, int idx, const void *p) +SYMBOL_DECLARE(int , lua_setmetatable, lua_State *L, int objindex) +SYMBOL_DECLARE(int , lua_setiuservalue, lua_State *L, int idx, int n) + + +/* +** 'load' and 'call' functions (load and run Lua code) +*/ +SYMBOL_DECLARE(void, lua_callk, lua_State *L, int nargs, int nresults, + lua_KContext ctx, lua_KFunction k) +#define lua_call(L,n,r) lua_callk(L, (n), (r), 0, NULL) + +SYMBOL_DECLARE(int, lua_pcallk, lua_State *L, int nargs, int nresults, int errfunc, + lua_KContext ctx, lua_KFunction k) +#define lua_pcall(L,n,r,f) lua_pcallk(L, (n), (r), (f), 0, NULL) + +SYMBOL_DECLARE(int, lua_load, lua_State *L, lua_Reader reader, void *dt, + const char *chunkname, const char *mode) + +SYMBOL_DECLARE(int, lua_dump, lua_State *L, lua_Writer writer, void *data, int strip) + + +/* +** coroutine functions +*/ +SYMBOL_DECLARE(int, lua_yieldk, lua_State *L, int nresults, lua_KContext ctx, + lua_KFunction k) +SYMBOL_DECLARE(int, lua_resume, lua_State *L, lua_State *from, int narg, + int *nres) +SYMBOL_DECLARE(int, lua_status, lua_State *L) +SYMBOL_DECLARE(int, lua_isyieldable, lua_State *L) + +#define lua_yield(L,n) lua_yieldk(L, (n), 0, NULL) + + +/* +** Warning-related functions +*/ +SYMBOL_DECLARE(void, lua_setwarnf, lua_State *L, lua_WarnFunction f, void *ud) +SYMBOL_DECLARE(void, lua_warning, lua_State *L, const char *msg, int tocont) + + +/* +** 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 +#define LUA_GCGEN 10 +#define LUA_GCINC 11 + +SYMBOL_DECLARE_VARARG(int, lua_gc, lua_State *L, int what) + + +/* +** miscellaneous functions +*/ + +SYMBOL_DECLARE(int , lua_error, lua_State *L) + +SYMBOL_DECLARE(int , lua_next, lua_State *L, int idx) + +SYMBOL_DECLARE(void, lua_concat, lua_State *L, int n) +SYMBOL_DECLARE(void, lua_len, lua_State *L, int idx) + +SYMBOL_DECLARE(size_t, lua_stringtonumber, lua_State *L, const char *s) + +SYMBOL_DECLARE(lua_Alloc, lua_getallocf, lua_State *L, void **ud) +SYMBOL_DECLARE(void , lua_setallocf, lua_State *L, lua_Alloc f, void *ud) + +SYMBOL_DECLARE(void, lua_toclose, lua_State *L, int idx) +SYMBOL_DECLARE(void, lua_closeslot, lua_State *L, int idx) + + +/* +** {============================================================== +** some useful macros +** =============================================================== +*/ + +#define lua_getextraspace(L) ((void *)((char *)(L) - LUA_EXTRASPACE)) + +#define lua_tonumber(L,i) lua_tonumberx(L,(i),NULL) +#define lua_tointeger(L,i) lua_tointegerx(L,(i),NULL) + +#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_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_pushstring(L, "" s) + +#define lua_pushglobaltable(L) \ + ((void)lua_rawgeti(L, LUA_REGISTRYINDEX, LUA_RIDX_GLOBALS)) + +#define lua_tostring(L,i) lua_tolstring(L, (i), NULL) + + +#define lua_insert(L,idx) lua_rotate(L, (idx), 1) + +#define lua_remove(L,idx) (lua_rotate(L, (idx), -1), lua_pop(L, 1)) + +#define lua_replace(L,idx) (lua_copy(L, -1, (idx)), lua_pop(L, 1)) + +/* }============================================================== */ + + +/* +** {============================================================== +** compatibility macros +** =============================================================== +*/ +#if defined(LUA_COMPAT_APIINTCASTS) + +#define lua_pushunsigned(L,n) lua_pushinteger(L, (lua_Integer)(n)) +#define lua_tounsignedx(L,i,is) ((lua_Unsigned)lua_tointegerx(L,i,is)) +#define lua_tounsigned(L,i) lua_tounsignedx(L,(i),NULL) + +#endif + +#define lua_newuserdata(L,s) lua_newuserdatauv(L,s,1) +#define lua_getuservalue(L,idx) lua_getiuservalue(L,idx,1) +#define lua_setuservalue(L,idx) lua_setiuservalue(L,idx,1) + +#define LUA_NUMTAGS LUA_NUMTYPES + +/* }============================================================== */ + +/* +** {====================================================================== +** Debug API +** ======================================================================= +*/ + + +/* +** Event codes +*/ +#define LUA_HOOKCALL 0 +#define LUA_HOOKRET 1 +#define LUA_HOOKLINE 2 +#define LUA_HOOKCOUNT 3 +#define LUA_HOOKTAILCALL 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 debugger in specific events */ +typedef void (*lua_Hook) (lua_State *L, lua_Debug *ar); + + +SYMBOL_DECLARE(int, lua_getstack, lua_State *L, int level, lua_Debug *ar) +SYMBOL_DECLARE(int, lua_getinfo, lua_State *L, const char *what, lua_Debug *ar) +SYMBOL_DECLARE(const char *, lua_getlocal, lua_State *L, const lua_Debug *ar, int n) +SYMBOL_DECLARE(const char *, lua_setlocal, lua_State *L, const lua_Debug *ar, int n) +SYMBOL_DECLARE(const char *, lua_getupvalue, lua_State *L, int funcindex, int n) +SYMBOL_DECLARE(const char *, lua_setupvalue, lua_State *L, int funcindex, int n) + +SYMBOL_DECLARE(void *, lua_upvalueid, lua_State *L, int fidx, int n) +SYMBOL_DECLARE(void, lua_upvaluejoin, lua_State *L, int fidx1, int n1, + int fidx2, int n2) + +SYMBOL_DECLARE(void, lua_sethook, lua_State *L, lua_Hook func, int mask, int count) +SYMBOL_DECLARE(lua_Hook, lua_gethook, lua_State *L) +SYMBOL_DECLARE(int, lua_gethookmask, lua_State *L) +SYMBOL_DECLARE(int, lua_gethookcount, lua_State *L) + +SYMBOL_DECLARE(int, lua_setcstacklimit, lua_State *L, unsigned int limit) + +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) */ + size_t srclen; /* (S) */ + int currentline; /* (l) */ + int linedefined; /* (S) */ + int lastlinedefined; /* (S) */ + unsigned char nups; /* (u) number of upvalues */ + unsigned char nparams;/* (u) number of parameters */ + char isvararg; /* (u) */ + char istailcall; /* (t) */ + unsigned short ftransfer; /* (r) index of first value transferred */ + unsigned short ntransfer; /* (r) number of transferred values */ + char short_src[LUA_IDSIZE]; /* (S) */ + /* private part */ + struct CallInfo *i_ci; /* active function */ +}; + +/* }====================================================================== */ + + +#endif + + + + + +/* +** $Id: lauxlib.h $ +** Auxiliary functions for building Lua libraries +** See Copyright Notice in lua.h +*/ + + +#ifndef lauxlib_h +#define lauxlib_h + + +#include +#include + + +/* global table */ +#define LUA_GNAME "_G" + + +typedef struct luaL_Buffer luaL_Buffer; + + +/* extra error code for 'luaL_loadfilex' */ +#define LUA_ERRFILE (LUA_ERRERR+1) + + +/* key, in the registry, for table of loaded modules */ +#define LUA_LOADED_TABLE "_LOADED" + + +/* key, in the registry, for table of preloaded loaders */ +#define LUA_PRELOAD_TABLE "_PRELOAD" + + +typedef struct luaL_Reg { + const char *name; + lua_CFunction func; +} luaL_Reg; + + +#define LUAL_NUMSIZES (sizeof(lua_Integer)*16 + sizeof(lua_Number)) + +SYMBOL_DECLARE(void, luaL_checkversion_, lua_State *L, lua_Number ver, size_t sz) +#define luaL_checkversion(L) \ + luaL_checkversion_(L, LUA_VERSION_NUM, LUAL_NUMSIZES) + +SYMBOL_DECLARE(int, luaL_getmetafield, lua_State *L, int obj, const char *e) +SYMBOL_DECLARE(int, luaL_callmeta, lua_State *L, int obj, const char *e) +SYMBOL_DECLARE(const char *, luaL_tolstring, lua_State *L, int idx, size_t *len) +SYMBOL_DECLARE(int, luaL_argerror, lua_State *L, int arg, const char *extramsg) +SYMBOL_DECLARE(int, luaL_typeerror, lua_State *L, int arg, const char *tname) +SYMBOL_DECLARE(const char *, luaL_checklstring, lua_State *L, int arg, + size_t *l) +SYMBOL_DECLARE(const char *, luaL_optlstring, lua_State *L, int arg, + const char *def, size_t *l) +SYMBOL_DECLARE(lua_Number, luaL_checknumber, lua_State *L, int arg) +SYMBOL_DECLARE(lua_Number, luaL_optnumber, lua_State *L, int arg, lua_Number def) + +SYMBOL_DECLARE(lua_Integer, luaL_checkinteger, lua_State *L, int arg) +SYMBOL_DECLARE(lua_Integer, luaL_optinteger, lua_State *L, int arg, + lua_Integer def) + +SYMBOL_DECLARE(void, luaL_checkstack, lua_State *L, int sz, const char *msg) +SYMBOL_DECLARE(void, luaL_checktype, lua_State *L, int arg, int t) +SYMBOL_DECLARE(void, luaL_checkany, lua_State *L, int arg) + +SYMBOL_DECLARE(int , luaL_newmetatable, lua_State *L, const char *tname) +SYMBOL_DECLARE(void , luaL_setmetatable, lua_State *L, const char *tname) +SYMBOL_DECLARE(void *, luaL_testudata, lua_State *L, int ud, const char *tname) +SYMBOL_DECLARE(void *, luaL_checkudata, lua_State *L, int ud, const char *tname) + +SYMBOL_DECLARE(void, luaL_where, lua_State *L, int lvl) +SYMBOL_DECLARE_VARARG(int, luaL_error, lua_State *L, const char *fmt) + +SYMBOL_DECLARE(int, luaL_checkoption, lua_State *L, int arg, const char *def, + const char *const lst[]) + +SYMBOL_DECLARE(int, luaL_fileresult, lua_State *L, int stat, const char *fname) +SYMBOL_DECLARE(int, luaL_execresult, lua_State *L, int stat) + + +/* predefined references */ +#define LUA_NOREF (-2) +#define LUA_REFNIL (-1) + +SYMBOL_DECLARE(int, luaL_ref, lua_State *L, int t) +SYMBOL_DECLARE(void, luaL_unref, lua_State *L, int t, int ref) + +SYMBOL_DECLARE(int, luaL_loadfilex, lua_State *L, const char *filename, + const char *mode) + +#define luaL_loadfile(L,f) luaL_loadfilex(L,f,NULL) + +SYMBOL_DECLARE(int, luaL_loadbufferx, lua_State *L, const char *buff, size_t sz, + const char *name, const char *mode) +SYMBOL_DECLARE(int, luaL_loadstring, lua_State *L, const char *s) + +SYMBOL_DECLARE(lua_State *, luaL_newstate, void) + +SYMBOL_DECLARE(lua_Integer, luaL_len, lua_State *L, int idx) + +SYMBOL_DECLARE(void, luaL_addgsub, luaL_Buffer *b, const char *s, + const char *p, const char *r) +SYMBOL_DECLARE(const char *, luaL_gsub, lua_State *L, const char *s, + const char *p, const char *r) + +SYMBOL_DECLARE(void, luaL_setfuncs, lua_State *L, const luaL_Reg *l, int nup) + +SYMBOL_DECLARE(int, luaL_getsubtable, lua_State *L, int idx, const char *fname) + +SYMBOL_DECLARE(void, luaL_traceback, lua_State *L, lua_State *L1, + const char *msg, int level) + +SYMBOL_DECLARE(void, luaL_requiref, lua_State *L, const char *modname, + lua_CFunction openf, int glb) + +/* +** =============================================================== +** some useful macros +** =============================================================== +*/ + + +#define luaL_newlibtable(L,l) \ + lua_createtable(L, 0, sizeof(l)/sizeof((l)[0]) - 1) + +#define luaL_newlib(L,l) \ + (luaL_checkversion(L), luaL_newlibtable(L,l), luaL_setfuncs(L,l,0)) + +#define luaL_argcheck(L, cond,arg,extramsg) \ + ((void)(luai_likely(cond) || luaL_argerror(L, (arg), (extramsg)))) + +#define luaL_argexpected(L,cond,arg,tname) \ + ((void)(luai_likely(cond) || luaL_typeerror(L, (arg), (tname)))) + +#define luaL_checkstring(L,n) (luaL_checklstring(L, (n), NULL)) +#define luaL_optstring(L,n,d) (luaL_optlstring(L, (n), (d), NULL)) + +#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))) + +#define luaL_loadbuffer(L,s,sz,n) luaL_loadbufferx(L,s,sz,n,NULL) + + +/* +** Perform arithmetic operations on lua_Integer values with wrap-around +** semantics, as the Lua core does. +*/ +#define luaL_intop(op,v1,v2) \ + ((lua_Integer)((lua_Unsigned)(v1) op (lua_Unsigned)(v2))) + + +/* push the value used to represent failure/error */ +#define luaL_pushfail(L) lua_pushnil(L) + + +/* +** Internal assertions for in-house debugging +*/ +#if !defined(lua_assert) + +#if defined LUAI_ASSERT + #include + #define lua_assert(c) assert(c) +#else + #define lua_assert(c) ((void)0) +#endif + +#endif + + + +/* +** {====================================================== +** Generic Buffer manipulation +** ======================================================= +*/ + +struct luaL_Buffer { + char *b; /* buffer address */ + size_t size; /* buffer size */ + size_t n; /* number of characters in buffer */ + lua_State *L; + union { + LUAI_MAXALIGN; /* ensure maximum alignment for buffer */ + char b[LUAL_BUFFERSIZE]; /* initial buffer */ + } init; +}; + + +#define luaL_bufflen(bf) ((bf)->n) +#define luaL_buffaddr(bf) ((bf)->b) + + +#define luaL_addchar(B,c) \ + ((void)((B)->n < (B)->size || luaL_prepbuffsize((B), 1)), \ + ((B)->b[(B)->n++] = (c))) + +#define luaL_addsize(B,s) ((B)->n += (s)) + +#define luaL_buffsub(B,s) ((B)->n -= (s)) + +SYMBOL_DECLARE(void, luaL_buffinit, lua_State *L, luaL_Buffer *B) +SYMBOL_DECLARE(char *, luaL_prepbuffsize, luaL_Buffer *B, size_t sz) +SYMBOL_DECLARE(void, luaL_addlstring, luaL_Buffer *B, const char *s, size_t l) +SYMBOL_DECLARE(void, luaL_addstring, luaL_Buffer *B, const char *s) +SYMBOL_DECLARE(void, luaL_addvalue, luaL_Buffer *B) +SYMBOL_DECLARE(void, luaL_pushresult, luaL_Buffer *B) +SYMBOL_DECLARE(void, luaL_pushresultsize, luaL_Buffer *B, size_t sz) +SYMBOL_DECLARE(char *, luaL_buffinitsize, lua_State *L, luaL_Buffer *B, size_t sz) + +#define luaL_prepbuffer(B) luaL_prepbuffsize(B, LUAL_BUFFERSIZE) + +/* }====================================================== */ + + + +/* +** {====================================================== +** File handles for IO library +** ======================================================= +*/ + +/* +** A file handle is a userdata with metatable 'LUA_FILEHANDLE' and +** initial structure 'luaL_Stream' (it may contain other fields +** after that initial structure). +*/ + +#define LUA_FILEHANDLE "FILE*" + + +typedef struct luaL_Stream { + FILE *f; /* stream (NULL for incompletely created streams) */ + lua_CFunction closef; /* to close stream (NULL for closed streams) */ +} luaL_Stream; + +/* }====================================================== */ + +/* +** {================================================================== +** "Abstraction Layer" for basic report of messages and errors +** =================================================================== +*/ + +/* print a string */ +#if !defined(lua_writestring) +#define lua_writestring(s,l) fwrite((s), sizeof(char), (l), stdout) +#endif + +/* print a newline and flush the output */ +#if !defined(lua_writeline) +#define lua_writeline() (lua_writestring("\n", 1), fflush(stdout)) +#endif + +/* print an error message */ +#if !defined(lua_writestringerror) +#define lua_writestringerror(s,p) \ + (fprintf(stderr, (s), (p)), fflush(stderr)) +#endif + +/* }================================================================== */ + + +/* +** {============================================================ +** Compatibility with deprecated conversions +** ============================================================= +*/ +#if defined(LUA_COMPAT_APIINTCASTS) + +#define luaL_checkunsigned(L,a) ((lua_Unsigned)luaL_checkinteger(L,a)) +#define luaL_optunsigned(L,a,d) \ + ((lua_Unsigned)luaL_optinteger(L,a,(lua_Integer)(d))) + +#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))) + +#endif +/* }============================================================ */ + + + +#endif + + + + + +/* +** $Id: lualib.h $ +** Lua standard libraries +** See Copyright Notice in lua.h +*/ + + +#ifndef lualib_h +#define lualib_h + + +/* version suffix for environment variable names */ +#define LUA_VERSUFFIX "_" LUA_VERSION_MAJOR "_" LUA_VERSION_MINOR + + +SYMBOL_DECLARE(int, luaopen_base, lua_State *L) + +#define LUA_COLIBNAME "coroutine" +SYMBOL_DECLARE(int, luaopen_coroutine, lua_State *L) + +#define LUA_TABLIBNAME "table" +SYMBOL_DECLARE(int, luaopen_table, lua_State *L) + +#define LUA_IOLIBNAME "io" +SYMBOL_DECLARE(int, luaopen_io, lua_State *L) + +#define LUA_OSLIBNAME "os" +SYMBOL_DECLARE(int, luaopen_os, lua_State *L) + +#define LUA_STRLIBNAME "string" +SYMBOL_DECLARE(int, luaopen_string, lua_State *L) + +#define LUA_UTF8LIBNAME "utf8" +SYMBOL_DECLARE(int, luaopen_utf8, lua_State *L) + +#define LUA_MATHLIBNAME "math" +SYMBOL_DECLARE(int, luaopen_math, lua_State *L) + +#define LUA_DBLIBNAME "debug" +SYMBOL_DECLARE(int, luaopen_debug, lua_State *L) + +#define LUA_LOADLIBNAME "package" +SYMBOL_DECLARE(int, luaopen_package, lua_State *L) + + +/* open all previous libraries */ +SYMBOL_DECLARE(void, luaL_openlibs, lua_State *L) + + +#endif + + + + + +#ifdef LITE_XL_PLUGIN_ENTRYPOINT + +SYMBOL_WRAP_DECL(lua_State *, lua_newstate, lua_Alloc f, void *ud) { + return SYMBOL_WRAP_CALL(lua_newstate, f, ud); +} +SYMBOL_WRAP_DECL(void, lua_close, lua_State *L) { + SYMBOL_WRAP_CALL(lua_close, L); +} +SYMBOL_WRAP_DECL(lua_State *, lua_newthread, lua_State *L) { + return SYMBOL_WRAP_CALL(lua_newthread, L); +} +SYMBOL_WRAP_DECL(int, lua_resetthread, lua_State *L) { + return SYMBOL_WRAP_CALL(lua_resetthread, L); +} + +SYMBOL_WRAP_DECL(lua_CFunction, lua_atpanic, lua_State *L, lua_CFunction panicf) { + return SYMBOL_WRAP_CALL(lua_atpanic, L, panicf); +} + + +SYMBOL_WRAP_DECL(lua_Number, lua_version, lua_State *L) { + return SYMBOL_WRAP_CALL(lua_version, L); +} + + + + + +SYMBOL_WRAP_DECL(int, lua_absindex, lua_State *L, int idx) { + return SYMBOL_WRAP_CALL(lua_absindex, L, idx); +} +SYMBOL_WRAP_DECL(int, lua_gettop, lua_State *L) { + return SYMBOL_WRAP_CALL(lua_gettop, L); +} +SYMBOL_WRAP_DECL(void, lua_settop, lua_State *L, int idx) { + SYMBOL_WRAP_CALL(lua_settop, L, idx); +} +SYMBOL_WRAP_DECL(void, lua_pushvalue, lua_State *L, int idx) { + SYMBOL_WRAP_CALL(lua_pushvalue, L, idx); +} +SYMBOL_WRAP_DECL(void, lua_rotate, lua_State *L, int idx, int n) { + SYMBOL_WRAP_CALL(lua_rotate, L, idx, n); +} +SYMBOL_WRAP_DECL(void, lua_copy, lua_State *L, int fromidx, int toidx) { + SYMBOL_WRAP_CALL(lua_copy, L, fromidx, toidx); +} +SYMBOL_WRAP_DECL(int, lua_checkstack, lua_State *L, int sz) { + return SYMBOL_WRAP_CALL(lua_checkstack, L, sz); +} +SYMBOL_WRAP_DECL(void, lua_xmove, lua_State *from, lua_State *to, int n) { + SYMBOL_WRAP_CALL(lua_xmove, from, to, n); +} + + + + + + +SYMBOL_WRAP_DECL(int, lua_isnumber, lua_State *L, int idx) { + return SYMBOL_WRAP_CALL(lua_isnumber, L, idx); +} +SYMBOL_WRAP_DECL(int, lua_isstring, lua_State *L, int idx) { + return SYMBOL_WRAP_CALL(lua_isstring, L, idx); +} +SYMBOL_WRAP_DECL(int, lua_iscfunction, lua_State *L, int idx) { + return SYMBOL_WRAP_CALL(lua_iscfunction, L, idx); +} +SYMBOL_WRAP_DECL(int, lua_isinteger, lua_State *L, int idx) { + return SYMBOL_WRAP_CALL(lua_isinteger, L, idx); +} +SYMBOL_WRAP_DECL(int, lua_isuserdata, lua_State *L, int idx) { + return SYMBOL_WRAP_CALL(lua_isuserdata, L, idx); +} +SYMBOL_WRAP_DECL(int, lua_type, lua_State *L, int idx) { + return SYMBOL_WRAP_CALL(lua_type, L, idx); +} +SYMBOL_WRAP_DECL(const char *, lua_typename, lua_State *L, int tp) { + return SYMBOL_WRAP_CALL(lua_typename, L, tp); +} + +SYMBOL_WRAP_DECL(lua_Number, lua_tonumberx, lua_State *L, int idx, int *isnum) { + return SYMBOL_WRAP_CALL(lua_tonumberx, L, idx, isnum); +} +SYMBOL_WRAP_DECL(lua_Integer, lua_tointegerx, lua_State *L, int idx, int *isnum) { + return SYMBOL_WRAP_CALL(lua_tointegerx, L, idx, isnum); +} +SYMBOL_WRAP_DECL(int, lua_toboolean, lua_State *L, int idx) { + return SYMBOL_WRAP_CALL(lua_toboolean, L, idx); +} +SYMBOL_WRAP_DECL(const char *, lua_tolstring, lua_State *L, int idx, size_t *len) { + return SYMBOL_WRAP_CALL(lua_tolstring, L, idx, len); +} +SYMBOL_WRAP_DECL(lua_Unsigned, lua_rawlen, lua_State *L, int idx) { + return SYMBOL_WRAP_CALL(lua_rawlen, L, idx); +} +SYMBOL_WRAP_DECL(lua_CFunction, lua_tocfunction, lua_State *L, int idx) { + return SYMBOL_WRAP_CALL(lua_tocfunction, L, idx); +} +SYMBOL_WRAP_DECL(void *, lua_touserdata, lua_State *L, int idx) { + return SYMBOL_WRAP_CALL(lua_touserdata, L, idx); +} +SYMBOL_WRAP_DECL(lua_State *, lua_tothread, lua_State *L, int idx) { + return SYMBOL_WRAP_CALL(lua_tothread, L, idx); +} +SYMBOL_WRAP_DECL(const void *, lua_topointer, lua_State *L, int idx) { + return SYMBOL_WRAP_CALL(lua_topointer, L, idx); +} + + + + + + +SYMBOL_WRAP_DECL(void, lua_arith, lua_State *L, int op) { + SYMBOL_WRAP_CALL(lua_arith, L, op); +} + +SYMBOL_WRAP_DECL(int, lua_rawequal, lua_State *L, int idx1, int idx2) { + return SYMBOL_WRAP_CALL(lua_rawequal, L, idx1, idx2); +} +SYMBOL_WRAP_DECL(int, lua_compare, lua_State *L, int idx1, int idx2, int op) { + return SYMBOL_WRAP_CALL(lua_compare, L, idx1, idx2, op); +} + +SYMBOL_WRAP_DECL(void, lua_pushnil, lua_State *L) { + SYMBOL_WRAP_CALL(lua_pushnil, L); +} +SYMBOL_WRAP_DECL(void, lua_pushnumber, lua_State *L, lua_Number n) { + SYMBOL_WRAP_CALL(lua_pushnumber, L, n); +} +SYMBOL_WRAP_DECL(void, lua_pushinteger, lua_State *L, lua_Integer n) { + SYMBOL_WRAP_CALL(lua_pushinteger, L, n); +} +SYMBOL_WRAP_DECL(const char *, lua_pushlstring, lua_State *L, const char *s, size_t l) { + return SYMBOL_WRAP_CALL(lua_pushlstring, L, s, l); +} +SYMBOL_WRAP_DECL(const char *, lua_pushstring, lua_State *L, const char *s) { + return SYMBOL_WRAP_CALL(lua_pushstring, L, s); +} +SYMBOL_WRAP_DECL(const char *, lua_pushvfstring, lua_State *L, const char *fmt, va_list argp) { + return SYMBOL_WRAP_CALL(lua_pushvfstring, L, fmt, argp); +} +SYMBOL_WRAP_DECL(const char *, lua_pushfstring, lua_State *L, const char *fmt, ...) { + const char *res; + va_list argp; + va_start(argp, fmt); + res = lua_pushvfstring(L, fmt, argp); + va_end(argp); + return res; +} +SYMBOL_WRAP_DECL(void, lua_pushcclosure, lua_State *L, lua_CFunction fn, int n) { + SYMBOL_WRAP_CALL(lua_pushcclosure, L, fn, n); +} +SYMBOL_WRAP_DECL(void, lua_pushboolean, lua_State *L, int b) { + SYMBOL_WRAP_CALL(lua_pushboolean, L, b); +} +SYMBOL_WRAP_DECL(void, lua_pushlightuserdata, lua_State *L, void *p) { + SYMBOL_WRAP_CALL(lua_pushlightuserdata, L, p); +} +SYMBOL_WRAP_DECL(int, lua_pushthread, lua_State *L) { + return SYMBOL_WRAP_CALL(lua_pushthread, L); +} + + + + + +SYMBOL_WRAP_DECL(int, lua_getglobal, lua_State *L, const char *var) { + return SYMBOL_WRAP_CALL(lua_getglobal, L, var); +} +SYMBOL_WRAP_DECL(int, lua_gettable, lua_State *L, int idx) { + return SYMBOL_WRAP_CALL(lua_gettable, L, idx); +} +SYMBOL_WRAP_DECL(int, lua_getfield, lua_State *L, int idx, const char *k) { + return SYMBOL_WRAP_CALL(lua_getfield, L, idx, k); +} +SYMBOL_WRAP_DECL(int , lua_geti, lua_State *L, int idx, lua_Integer n) { + return SYMBOL_WRAP_CALL(lua_geti, L, idx, n); +} +SYMBOL_WRAP_DECL(int, lua_rawget, lua_State *L, int idx) { + return SYMBOL_WRAP_CALL(lua_rawget, L, idx); +} +SYMBOL_WRAP_DECL(int, lua_rawgeti, lua_State *L, int idx, lua_Integer n) { + return SYMBOL_WRAP_CALL(lua_rawgeti, L, idx, n); +} +SYMBOL_WRAP_DECL(int, lua_rawgetp, lua_State *L, int idx, const void *p) { + return SYMBOL_WRAP_CALL(lua_rawgetp, L, idx, p); +} +SYMBOL_WRAP_DECL(void, lua_createtable, lua_State *L, int narr, int nrec) { + SYMBOL_WRAP_CALL(lua_createtable, L, narr, nrec); +} +SYMBOL_WRAP_DECL(void *, lua_newuserdatauv, lua_State *L, size_t sz, int nuvalue) { + return SYMBOL_WRAP_CALL(lua_newuserdatauv, L, sz, nuvalue); +} +SYMBOL_WRAP_DECL(int, lua_getmetatable, lua_State *L, int objindex) { + return SYMBOL_WRAP_CALL(lua_getmetatable, L, objindex); +} +SYMBOL_WRAP_DECL(int, lua_getiuservalue, lua_State *L, int idx, int n) { + return SYMBOL_WRAP_CALL(lua_getiuservalue, L, idx, n); +} + +SYMBOL_WRAP_DECL(void, lua_setglobal, lua_State *L, const char *var) { + SYMBOL_WRAP_CALL(lua_setglobal, L, var); +} +SYMBOL_WRAP_DECL(void, lua_settable, lua_State *L, int idx) { + SYMBOL_WRAP_CALL(lua_settable, L, idx); +} +SYMBOL_WRAP_DECL(void, lua_setfield, lua_State *L, int idx, const char *k) { + SYMBOL_WRAP_CALL(lua_setfield, L, idx, k); +} +SYMBOL_WRAP_DECL(void, lua_seti, lua_State *L, int idx, lua_Integer n) { + SYMBOL_WRAP_CALL(lua_seti, L, idx, n); +} +SYMBOL_WRAP_DECL(void, lua_rawset, lua_State *L, int idx) { + SYMBOL_WRAP_CALL(lua_rawset, L, idx); +} +SYMBOL_WRAP_DECL(void, lua_rawseti, lua_State *L, int idx, lua_Integer n) { + SYMBOL_WRAP_CALL(lua_rawseti, L, idx, n); +} +SYMBOL_WRAP_DECL(void, lua_rawsetp, lua_State *L, int idx, const void *p) { + SYMBOL_WRAP_CALL(lua_rawsetp, L, idx, p); +} +SYMBOL_WRAP_DECL(int, lua_setmetatable, lua_State *L, int objindex) { + return SYMBOL_WRAP_CALL(lua_setmetatable, L, objindex); +} +SYMBOL_WRAP_DECL(int, lua_setiuservalue, lua_State *L, int idx, int n) { + return SYMBOL_WRAP_CALL(lua_setiuservalue, L, idx, n); +} + + + + + +SYMBOL_WRAP_DECL(void, lua_callk, lua_State *L, int nargs, int nresults, lua_KContext ctx, lua_KFunction k) { + SYMBOL_WRAP_CALL(lua_callk, L, nargs, nresults, ctx, k); +} +SYMBOL_WRAP_DECL(int, lua_pcallk, lua_State *L, int nargs, int nresults, int errfunc, lua_KContext ctx, lua_KFunction k) { + return SYMBOL_WRAP_CALL(lua_pcallk, L, nargs, nresults, errfunc, ctx, k); +} +SYMBOL_WRAP_DECL(int, lua_load, lua_State *L, lua_Reader reader, void *dt, const char *chunkname, const char *mode) { + return SYMBOL_WRAP_CALL(lua_load, L, reader, dt, chunkname, mode); +} +SYMBOL_WRAP_DECL(int, lua_dump, lua_State *L, lua_Writer writer, void *data, int strip) { + return SYMBOL_WRAP_CALL(lua_dump, L, writer, data, strip); +} + + + + + +SYMBOL_WRAP_DECL(int, lua_yieldk, lua_State *L, int nresults, lua_KContext ctx, lua_KFunction k) { + return SYMBOL_WRAP_CALL(lua_yieldk, L, nresults, ctx, k); +} +SYMBOL_WRAP_DECL(int, lua_resume, lua_State *L, lua_State *from, int narg, int *nres) { + return SYMBOL_WRAP_CALL(lua_resume, L, from, narg, nres); +} +SYMBOL_WRAP_DECL(int, lua_status, lua_State *L) { + return SYMBOL_WRAP_CALL(lua_status, L); +} +SYMBOL_WRAP_DECL(int, lua_isyieldable, lua_State *L) { + return SYMBOL_WRAP_CALL(lua_isyieldable, L); +} + + + + + +SYMBOL_WRAP_DECL(void, lua_setwarnf, lua_State *L, lua_WarnFunction f, void *ud) { + SYMBOL_WRAP_CALL(lua_setwarnf, L, f, ud); +} +SYMBOL_WRAP_DECL(void, lua_warning, lua_State *L, const char *msg, int tocont) { + SYMBOL_WRAP_CALL(lua_warning, L, msg, tocont); +} + + + + + + +SYMBOL_WRAP_DECL(int, lua_gc, lua_State *L, int what, ...) { + /* there are no straightforward ways of passing data. */ + int r; + va_list ap; + va_start(ap, what); + if (what == LUA_GCSTEP) { + int stepsize = va_arg(ap, int); + r = __lua_gc(L, what, stepsize); + } else if (what == LUA_GCINC) { + int pause = va_arg(ap, int); + int stepmul = va_arg(ap, int); + int stepsize = va_arg(ap, int); + r = __lua_gc(L, what, pause, stepmul, stepsize); + } else if (what == LUA_GCGEN) { + int minormul = va_arg(ap, int); + int majormul = va_arg(ap, int); + r = __lua_gc(L, what, minormul, majormul); + } else { + r = __lua_gc(L, what); + } + return r; +} + + + + + + +SYMBOL_WRAP_DECL(int, lua_error, lua_State *L) { + return SYMBOL_WRAP_CALL(lua_error, L); +} + +SYMBOL_WRAP_DECL(int, lua_next, lua_State *L, int idx) { + return SYMBOL_WRAP_CALL(lua_next, L, idx); +} + +SYMBOL_WRAP_DECL(void, lua_concat, lua_State *L, int n) { + SYMBOL_WRAP_CALL(lua_concat, L, n); +} +SYMBOL_WRAP_DECL(void, lua_len, lua_State *L, int idx) { + SYMBOL_WRAP_CALL(lua_len, L, idx); +} + +SYMBOL_WRAP_DECL(size_t, lua_stringtonumber, lua_State *L, const char *s) { + return SYMBOL_WRAP_CALL(lua_stringtonumber, L, s); +} + +SYMBOL_WRAP_DECL(lua_Alloc, lua_getallocf, lua_State *L, void **ud) { + return SYMBOL_WRAP_CALL(lua_getallocf, L, ud); +} +SYMBOL_WRAP_DECL(void, lua_setallocf, lua_State *L, lua_Alloc f, void *ud) { + SYMBOL_WRAP_CALL(lua_setallocf, L, f, ud); +} + +SYMBOL_WRAP_DECL(void, lua_toclose, lua_State *L, int idx) { + SYMBOL_WRAP_CALL(lua_toclose, L, idx); +} +SYMBOL_WRAP_DECL(void, lua_closeslot, lua_State *L, int idx) { + SYMBOL_WRAP_CALL(lua_closeslot, L, idx); +} + + + + + + +SYMBOL_WRAP_DECL(int, lua_getstack, lua_State *L, int level, lua_Debug *ar) { + return SYMBOL_WRAP_CALL(lua_getstack, L, level, ar); +} +SYMBOL_WRAP_DECL(int, lua_getinfo, lua_State *L, const char *what, lua_Debug *ar) { + return SYMBOL_WRAP_CALL(lua_getinfo, L, what, ar); +} +SYMBOL_WRAP_DECL(const char *, lua_getlocal, lua_State *L, const lua_Debug *ar, int n) { + return SYMBOL_WRAP_CALL(lua_getlocal, L, ar, n); +} +SYMBOL_WRAP_DECL(const char *, lua_setlocal, lua_State *L, const lua_Debug *ar, int n) { + return SYMBOL_WRAP_CALL(lua_setlocal, L, ar, n); +} +SYMBOL_WRAP_DECL(const char *, lua_getupvalue, lua_State *L, int funcindex, int n) { + return SYMBOL_WRAP_CALL(lua_getupvalue, L, funcindex, n); +} +SYMBOL_WRAP_DECL(const char *, lua_setupvalue, lua_State *L, int funcindex, int n) { + return SYMBOL_WRAP_CALL(lua_setupvalue, L, funcindex, n); +} + +SYMBOL_WRAP_DECL(void *, lua_upvalueid, lua_State *L, int fidx, int n) { + return SYMBOL_WRAP_CALL(lua_upvalueid, L, fidx, n); +} +SYMBOL_WRAP_DECL(void, lua_upvaluejoin, lua_State *L, int fidx1, int n1, int fidx2, int n2) { + SYMBOL_WRAP_CALL(lua_upvaluejoin, L, fidx1, n1, fidx2, n2); +} + +SYMBOL_WRAP_DECL(void, lua_sethook, lua_State *L, lua_Hook func, int mask, int count) { + SYMBOL_WRAP_CALL(lua_sethook, L, func, mask, count); +} +SYMBOL_WRAP_DECL(lua_Hook, lua_gethook, lua_State *L) { + return SYMBOL_WRAP_CALL(lua_gethook, L); +} +SYMBOL_WRAP_DECL(int, lua_gethookmask, lua_State *L) { + return SYMBOL_WRAP_CALL(lua_gethookmask, L); +} +SYMBOL_WRAP_DECL(int, lua_gethookcount, lua_State *L) { + return SYMBOL_WRAP_CALL(lua_gethookcount, L); +} + +SYMBOL_WRAP_DECL(int, lua_setcstacklimit, lua_State *L, unsigned int limit) { + return SYMBOL_WRAP_CALL(lua_setcstacklimit, L, limit); +} + + + + + + +SYMBOL_WRAP_DECL(void, luaL_checkversion_, lua_State *L, lua_Number ver, size_t sz) { + SYMBOL_WRAP_CALL(luaL_checkversion_, L, ver, sz); +} +SYMBOL_WRAP_DECL(int, luaL_getmetafield, lua_State *L, int obj, const char *e) { + return SYMBOL_WRAP_CALL(luaL_getmetafield, L, obj, e); +} +SYMBOL_WRAP_DECL(int, luaL_callmeta, lua_State *L, int obj, const char *e) { + return SYMBOL_WRAP_CALL(luaL_callmeta, L, obj, e); +} +SYMBOL_WRAP_DECL(const char *, luaL_tolstring, lua_State *L, int idx, size_t *len) { + return SYMBOL_WRAP_CALL(luaL_tolstring, L, idx, len); +} +SYMBOL_WRAP_DECL(int, luaL_argerror, lua_State *L, int numarg, const char *extramsg) { + return SYMBOL_WRAP_CALL(luaL_argerror, L, numarg, extramsg); +} +SYMBOL_WRAP_DECL(int, luaL_typeerror, lua_State *L, int arg, const char *tname) { + return SYMBOL_WRAP_CALL(luaL_typeerror, L, arg, tname); +} +SYMBOL_WRAP_DECL(const char *, luaL_checklstring, lua_State *L, int numArg, size_t *l) { + return SYMBOL_WRAP_CALL(luaL_checklstring, L, numArg, l); +} +SYMBOL_WRAP_DECL(const char *, luaL_optlstring, lua_State *L, int numArg, const char *def, size_t *l) { + return SYMBOL_WRAP_CALL(luaL_optlstring, L, numArg, def, l); +} +SYMBOL_WRAP_DECL(lua_Number, luaL_checknumber, lua_State *L, int numArg) { + return SYMBOL_WRAP_CALL(luaL_checknumber, L, numArg); +} +SYMBOL_WRAP_DECL(lua_Number, luaL_optnumber, lua_State *L, int nArg, lua_Number def) { + return SYMBOL_WRAP_CALL(luaL_optnumber, L, nArg, def); +} + +SYMBOL_WRAP_DECL(lua_Integer, luaL_checkinteger, lua_State *L, int numArg) { + return SYMBOL_WRAP_CALL(luaL_checkinteger, L, numArg); +} +SYMBOL_WRAP_DECL(lua_Integer, luaL_optinteger, lua_State *L, int nArg, lua_Integer def) { + return SYMBOL_WRAP_CALL(luaL_optinteger, L, nArg, def); +} + +SYMBOL_WRAP_DECL(void, luaL_checkstack, lua_State *L, int sz, const char *msg) { + SYMBOL_WRAP_CALL(luaL_checkstack, L, sz, msg); +} +SYMBOL_WRAP_DECL(void, luaL_checktype, lua_State *L, int narg, int t) { + SYMBOL_WRAP_CALL(luaL_checktype, L, narg, t); +} +SYMBOL_WRAP_DECL(void, luaL_checkany, lua_State *L, int narg) { + SYMBOL_WRAP_CALL(luaL_checkany, L, narg); +} +SYMBOL_WRAP_DECL(int, luaL_newmetatable, lua_State *L, const char *tname) { + return SYMBOL_WRAP_CALL(luaL_newmetatable, L, tname); +} +SYMBOL_WRAP_DECL(void, luaL_setmetatable, lua_State *L, const char *tname) { + SYMBOL_WRAP_CALL(luaL_setmetatable, L, tname); +} +SYMBOL_WRAP_DECL(void *, luaL_testudata, lua_State *L, int ud, const char *tname) { + return SYMBOL_WRAP_CALL(luaL_testudata, L, ud, tname); +} +SYMBOL_WRAP_DECL(void *, luaL_checkudata, lua_State *L, int ud, const char *tname) { + return SYMBOL_WRAP_CALL(luaL_checkudata, L, ud, tname); +} + +SYMBOL_WRAP_DECL(void, luaL_where, lua_State *L, int lvl) { + SYMBOL_WRAP_CALL(luaL_where, L, lvl); +} +SYMBOL_WRAP_DECL(int, luaL_error, lua_State *L, const char *fmt, ...) { + va_list argp; + va_start(argp, fmt); + luaL_where(L, 1); + lua_pushvfstring(L, fmt, argp); + va_end(argp); + lua_concat(L, 2); + return lua_error(L); +} + +SYMBOL_WRAP_DECL(int, luaL_checkoption, lua_State *L, int narg, const char *def, const char *const lst[]) { + return SYMBOL_WRAP_CALL(luaL_checkoption, L, narg, def, lst); +} + +SYMBOL_WRAP_DECL(int, luaL_fileresult, lua_State *L, int stat, const char *fname) { + return SYMBOL_WRAP_CALL(luaL_fileresult, L, stat, fname); +} +SYMBOL_WRAP_DECL(int, luaL_execresult, lua_State *L, int stat) { + return SYMBOL_WRAP_CALL(luaL_execresult, L, stat); +} + + + + + + +SYMBOL_WRAP_DECL(int, luaL_ref, lua_State *L, int t) { + return SYMBOL_WRAP_CALL(luaL_ref, L, t); +} +SYMBOL_WRAP_DECL(void, luaL_unref, lua_State *L, int t, int ref) { + SYMBOL_WRAP_CALL(luaL_unref, L, t, ref); +} + +SYMBOL_WRAP_DECL(int, luaL_loadfilex, lua_State *L, const char *filename, const char *mode) { + return SYMBOL_WRAP_CALL(luaL_loadfilex, L, filename, mode); +} + +SYMBOL_WRAP_DECL(int, luaL_loadbufferx, lua_State *L, const char *buff, size_t sz, const char *name, const char *mode) { + return SYMBOL_WRAP_CALL(luaL_loadbufferx, L, buff, sz, name, mode); +} + +SYMBOL_WRAP_DECL(int, luaL_loadstring, lua_State *L, const char *s) { + return SYMBOL_WRAP_CALL(luaL_loadstring, L, s); +} + +SYMBOL_WRAP_DECL(lua_State *, luaL_newstate, void) { + return __luaL_newstate(); +} +SYMBOL_WRAP_DECL(lua_Integer, luaL_len, lua_State *L, int idx) { + return SYMBOL_WRAP_CALL(luaL_len, L, idx); +} + +SYMBOL_WRAP_DECL(void, luaL_addgsub, luaL_Buffer *b, const char *s, + const char *p, const char *r) { + SYMBOL_WRAP_CALL(luaL_addgsub, b, s, p, r); +} +SYMBOL_WRAP_DECL(const char *, luaL_gsub, lua_State *L, const char *s, const char *p, const char *r) { + return SYMBOL_WRAP_CALL(luaL_gsub, L, s, p, r); +} + +SYMBOL_WRAP_DECL(void, luaL_setfuncs, lua_State *L, const luaL_Reg *l, int nup) { + SYMBOL_WRAP_CALL(luaL_setfuncs, L, l, nup); +} + +SYMBOL_WRAP_DECL(int, luaL_getsubtable, lua_State *L, int idx, const char *fname) { + return SYMBOL_WRAP_CALL(luaL_getsubtable, L, idx, fname); +} + +SYMBOL_WRAP_DECL(void, luaL_traceback, lua_State *L, lua_State *L1, const char *msg, int level) { + SYMBOL_WRAP_CALL(luaL_traceback, L, L1, msg, level); +} + +SYMBOL_WRAP_DECL(void, luaL_requiref, lua_State *L, const char *modname, lua_CFunction openf, int glb) { + SYMBOL_WRAP_CALL(luaL_requiref, L, modname, openf, glb); +} + + + + + + +SYMBOL_WRAP_DECL(void, luaL_buffinit, lua_State *L, luaL_Buffer *B) { + SYMBOL_WRAP_CALL(luaL_buffinit, L, B); +} +SYMBOL_WRAP_DECL(char *, luaL_prepbuffsize, luaL_Buffer *B, size_t sz) { + return SYMBOL_WRAP_CALL(luaL_prepbuffsize, B, sz); +} +SYMBOL_WRAP_DECL(void, luaL_addlstring, luaL_Buffer *B, const char *s, size_t l) { + SYMBOL_WRAP_CALL(luaL_addlstring, B, s, l); +} +SYMBOL_WRAP_DECL(void, luaL_addstring, luaL_Buffer *B, const char *s) { + SYMBOL_WRAP_CALL(luaL_addstring, B, s); +} +SYMBOL_WRAP_DECL(void, luaL_addvalue, luaL_Buffer *B) { + SYMBOL_WRAP_CALL(luaL_addvalue, B); +} +SYMBOL_WRAP_DECL(void, luaL_pushresult, luaL_Buffer *B) { + SYMBOL_WRAP_CALL(luaL_pushresult, B); +} +SYMBOL_WRAP_DECL(void, luaL_pushresultsize, luaL_Buffer *B, size_t sz) { + SYMBOL_WRAP_CALL(luaL_pushresultsize, B, sz); +} +SYMBOL_WRAP_DECL(char *, luaL_buffinitsize, lua_State *L, luaL_Buffer *B, size_t sz) { + return SYMBOL_WRAP_CALL(luaL_buffinitsize, L, B, sz); +} + +SYMBOL_WRAP_DECL(int, luaopen_base, lua_State *L) { + return SYMBOL_WRAP_CALL(luaopen_base, L); +} + +SYMBOL_WRAP_DECL(int, luaopen_coroutine, lua_State *L) { + return SYMBOL_WRAP_CALL(luaopen_coroutine, L); +} + +SYMBOL_WRAP_DECL(int, luaopen_table, lua_State *L) { + return SYMBOL_WRAP_CALL(luaopen_table, L); +} + +SYMBOL_WRAP_DECL(int, luaopen_io, lua_State *L) { + return SYMBOL_WRAP_CALL(luaopen_io, L); +} + +SYMBOL_WRAP_DECL(int, luaopen_os, lua_State *L) { + return SYMBOL_WRAP_CALL(luaopen_os, L); +} + +SYMBOL_WRAP_DECL(int, luaopen_string, lua_State *L) { + return SYMBOL_WRAP_CALL(luaopen_string, L); +} + +SYMBOL_WRAP_DECL(int, luaopen_utf8, lua_State *L) { + return SYMBOL_WRAP_CALL(luaopen_utf8, L); +} + +SYMBOL_WRAP_DECL(int, luaopen_math, lua_State *L) { + return SYMBOL_WRAP_CALL(luaopen_math, L); +} + +SYMBOL_WRAP_DECL(int, luaopen_debug, lua_State *L) { + return SYMBOL_WRAP_CALL(luaopen_debug, L); +} + +SYMBOL_WRAP_DECL(int, luaopen_package, lua_State *L) { + return SYMBOL_WRAP_CALL(luaopen_package, L); +} + +SYMBOL_WRAP_DECL(void, luaL_openlibs, lua_State *L) { + SYMBOL_WRAP_CALL(luaL_openlibs, L); +} + + + + + + +#define IMPORT_SYMBOL(name, ret, ...) \ + __##name = (\ + (*(void **) (&__##name) = symbol(#name)), \ + __##name == NULL ? ((ret (*) (__VA_ARGS__)) &__lite_xl_fallback_##name) : __##name\ + ) + +void lite_xl_plugin_init(void *XL) { + void* (*symbol)(const char *); + *(void **) (&symbol) = XL; + IMPORT_SYMBOL(lua_newstate, lua_State *, lua_Alloc f, void *ud); + IMPORT_SYMBOL(lua_close, void, lua_State *L); + IMPORT_SYMBOL(lua_newthread, lua_State *, lua_State *L); + IMPORT_SYMBOL(lua_resetthread, int, lua_State *L); + IMPORT_SYMBOL(lua_atpanic, lua_CFunction, lua_State *L, lua_CFunction panicf); + IMPORT_SYMBOL(lua_version, lua_Number, lua_State *L); + IMPORT_SYMBOL(lua_absindex, int, lua_State *L, int idx); + IMPORT_SYMBOL(lua_gettop, int, lua_State *L); + IMPORT_SYMBOL(lua_settop, void, lua_State *L, int idx); + IMPORT_SYMBOL(lua_pushvalue, void, lua_State *L, int idx); + IMPORT_SYMBOL(lua_rotate, void, lua_State *L, int idx, int n); + IMPORT_SYMBOL(lua_copy, void, lua_State *L, int fromidx, int toidx); + IMPORT_SYMBOL(lua_checkstack, int, lua_State *L, int sz); + IMPORT_SYMBOL(lua_xmove, void, lua_State *from, lua_State *to, int n); + IMPORT_SYMBOL(lua_isnumber, int, lua_State *L, int idx); + IMPORT_SYMBOL(lua_isstring, int, lua_State *L, int idx); + IMPORT_SYMBOL(lua_iscfunction, int, lua_State *L, int idx); + IMPORT_SYMBOL(lua_isinteger, int, lua_State *L, int idx); + IMPORT_SYMBOL(lua_isuserdata, int, lua_State *L, int idx); + IMPORT_SYMBOL(lua_type, int, lua_State *L, int idx); + IMPORT_SYMBOL(lua_typename, const char *, lua_State *L, int tp); + IMPORT_SYMBOL(lua_tonumberx, lua_Number, lua_State *L, int idx, int *isnum); + IMPORT_SYMBOL(lua_tointegerx, lua_Integer, lua_State *L, int idx, int *isnum); + IMPORT_SYMBOL(lua_toboolean, int, lua_State *L, int idx); + IMPORT_SYMBOL(lua_tolstring, const char *, lua_State *L, int idx, size_t *len); + IMPORT_SYMBOL(lua_rawlen, lua_Unsigned, lua_State *L, int idx); + IMPORT_SYMBOL(lua_tocfunction, lua_CFunction, lua_State *L, int idx); + IMPORT_SYMBOL(lua_touserdata, void *, lua_State *L, int idx); + IMPORT_SYMBOL(lua_tothread, lua_State *, lua_State *L, int idx); + IMPORT_SYMBOL(lua_topointer, const void *, lua_State *L, int idx); + IMPORT_SYMBOL(lua_arith, void, lua_State *L, int op); + IMPORT_SYMBOL(lua_rawequal, int, lua_State *L, int idx1, int idx2); + IMPORT_SYMBOL(lua_compare, int, lua_State *L, int idx1, int idx2, int op); + IMPORT_SYMBOL(lua_pushnil, void, lua_State *L); + IMPORT_SYMBOL(lua_pushnumber, void, lua_State *L, lua_Number n); + IMPORT_SYMBOL(lua_pushinteger, void, lua_State *L, lua_Integer n); + IMPORT_SYMBOL(lua_pushlstring, const char *, lua_State *L, const char *s, size_t l); + IMPORT_SYMBOL(lua_pushstring, const char *, lua_State *L, const char *s); + IMPORT_SYMBOL(lua_pushvfstring, const char *, lua_State *L, const char *fmt, va_list argp); + IMPORT_SYMBOL(lua_pushfstring, const char *, lua_State *L, const char *fmt, ...); + IMPORT_SYMBOL(lua_pushcclosure, void, lua_State *L, lua_CFunction fn, int n); + IMPORT_SYMBOL(lua_pushboolean, void, lua_State *L, int b); + IMPORT_SYMBOL(lua_pushlightuserdata, void, lua_State *L, void *p); + IMPORT_SYMBOL(lua_pushthread, int, lua_State *L); + IMPORT_SYMBOL(lua_getglobal, int, lua_State *L, const char *var); + IMPORT_SYMBOL(lua_gettable, int, lua_State *L, int idx); + IMPORT_SYMBOL(lua_getfield, int, lua_State *L, int idx, const char *k); + IMPORT_SYMBOL(lua_geti, int, lua_State *L, int idx, lua_Integer n); + IMPORT_SYMBOL(lua_rawget, int, lua_State *L, int idx); + IMPORT_SYMBOL(lua_rawgeti, int, lua_State *L, int idx, lua_Integer n); + IMPORT_SYMBOL(lua_rawgetp, int, lua_State *L, int idx, const void *p); + IMPORT_SYMBOL(lua_createtable, void, lua_State *L, int narr, int nrec); + IMPORT_SYMBOL(lua_newuserdatauv, void *, lua_State *L, size_t sz, int nuvalue); + IMPORT_SYMBOL(lua_getmetatable, int, lua_State *L, int objindex); + IMPORT_SYMBOL(lua_getiuservalue, int, lua_State *L, int idx, int n); + IMPORT_SYMBOL(lua_setglobal, void, lua_State *L, const char *var); + IMPORT_SYMBOL(lua_settable, void, lua_State *L, int idx); + IMPORT_SYMBOL(lua_setfield, void, lua_State *L, int idx, const char *k); + IMPORT_SYMBOL(lua_seti, void, lua_State *L, int idx, lua_Integer n); + IMPORT_SYMBOL(lua_rawset, void, lua_State *L, int idx); + IMPORT_SYMBOL(lua_rawseti, void, lua_State *L, int idx, lua_Integer n); + IMPORT_SYMBOL(lua_rawsetp, void, lua_State *L, int idx, const void *p); + IMPORT_SYMBOL(lua_setmetatable, int, lua_State *L, int objindex); + IMPORT_SYMBOL(lua_setiuservalue, int, lua_State *L, int idx, int n); + IMPORT_SYMBOL(lua_callk, void, lua_State *L, int nargs, int nresults, lua_KContext ctx, lua_KFunction k); + IMPORT_SYMBOL(lua_pcallk, int, lua_State *L, int nargs, int nresults, int errfunc, lua_KContext ctx, lua_KFunction k); + IMPORT_SYMBOL(lua_load, int, lua_State *L, lua_Reader reader, void *dt, const char *chunkname, const char *mode); + IMPORT_SYMBOL(lua_dump, int, lua_State *L, lua_Writer writer, void *data, int strip); + IMPORT_SYMBOL(lua_yieldk, int, lua_State *L, int nresults, lua_KContext ctx, lua_KFunction k); + IMPORT_SYMBOL(lua_resume, int, lua_State *L, lua_State *from, int narg, int *nres); + IMPORT_SYMBOL(lua_status, int, lua_State *L); + IMPORT_SYMBOL(lua_isyieldable, int, lua_State *L); + IMPORT_SYMBOL(lua_setwarnf, void, lua_State *L, lua_WarnFunction f, void *ud); + IMPORT_SYMBOL(lua_warning, void, lua_State *L, const char *msg, int tocont); + IMPORT_SYMBOL(lua_gc, int, lua_State *L, int what, ...); + IMPORT_SYMBOL(lua_error, int, lua_State *L); + IMPORT_SYMBOL(lua_next, int, lua_State *L, int idx); + IMPORT_SYMBOL(lua_concat, void, lua_State *L, int n); + IMPORT_SYMBOL(lua_len, void, lua_State *L, int idx); + IMPORT_SYMBOL(lua_stringtonumber, size_t, lua_State *L, const char *s); + IMPORT_SYMBOL(lua_getallocf, lua_Alloc, lua_State *L, void **ud); + IMPORT_SYMBOL(lua_setallocf, void, lua_State *L, lua_Alloc f, void *ud); + IMPORT_SYMBOL(lua_toclose, void, lua_State *L, int idx); + IMPORT_SYMBOL(lua_closeslot, void, lua_State *L, int idx); + IMPORT_SYMBOL(lua_getstack, int, lua_State *L, int level, lua_Debug *ar); + IMPORT_SYMBOL(lua_getinfo, int, lua_State *L, const char *what, lua_Debug *ar); + IMPORT_SYMBOL(lua_getlocal, const char *, lua_State *L, const lua_Debug *ar, int n); + IMPORT_SYMBOL(lua_setlocal, const char *, lua_State *L, const lua_Debug *ar, int n); + IMPORT_SYMBOL(lua_getupvalue, const char *, lua_State *L, int funcindex, int n); + IMPORT_SYMBOL(lua_setupvalue, const char *, lua_State *L, int funcindex, int n); + IMPORT_SYMBOL(lua_upvalueid, void *, lua_State *L, int fidx, int n); + IMPORT_SYMBOL(lua_upvaluejoin, void, lua_State *L, int fidx1, int n1, int fidx2, int n2); + IMPORT_SYMBOL(lua_sethook, void, lua_State *L, lua_Hook func, int mask, int count); + IMPORT_SYMBOL(lua_gethook, lua_Hook, lua_State *L); + IMPORT_SYMBOL(lua_gethookmask, int, lua_State *L); + IMPORT_SYMBOL(lua_gethookcount, int, lua_State *L); + IMPORT_SYMBOL(lua_setcstacklimit, int, lua_State *L, unsigned int limit); + IMPORT_SYMBOL(luaL_checkversion_, void, lua_State *L, lua_Number ver, size_t sz); + IMPORT_SYMBOL(luaL_getmetafield, int, lua_State *L, int obj, const char *e); + IMPORT_SYMBOL(luaL_callmeta, int, lua_State *L, int obj, const char *e); + IMPORT_SYMBOL(luaL_tolstring, const char *, lua_State *L, int idx, size_t *len); + IMPORT_SYMBOL(luaL_argerror, int, lua_State *L, int numarg, const char *extramsg); + IMPORT_SYMBOL(luaL_typeerror, int, lua_State *L, int arg, const char *tname); + IMPORT_SYMBOL(luaL_checklstring, const char *, lua_State *L, int numArg, size_t *l); + IMPORT_SYMBOL(luaL_optlstring, const char *, lua_State *L, int numArg, const char *def, size_t *l); + IMPORT_SYMBOL(luaL_checknumber, lua_Number, lua_State *L, int numArg); + IMPORT_SYMBOL(luaL_optnumber, lua_Number, lua_State *L, int nArg, lua_Number def); + IMPORT_SYMBOL(luaL_checkinteger, lua_Integer, lua_State *L, int numArg); + IMPORT_SYMBOL(luaL_optinteger, lua_Integer, lua_State *L, int nArg, lua_Integer def); + IMPORT_SYMBOL(luaL_checkstack, void, lua_State *L, int sz, const char *msg); + IMPORT_SYMBOL(luaL_checktype, void, lua_State *L, int narg, int t); + IMPORT_SYMBOL(luaL_checkany, void, lua_State *L, int narg); + IMPORT_SYMBOL(luaL_newmetatable, int, lua_State *L, const char *tname); + IMPORT_SYMBOL(luaL_setmetatable, void, lua_State *L, const char *tname); + IMPORT_SYMBOL(luaL_testudata, void *, lua_State *L, int ud, const char *tname); + IMPORT_SYMBOL(luaL_checkudata, void *, lua_State *L, int ud, const char *tname); + IMPORT_SYMBOL(luaL_where, void, lua_State *L, int lvl); + IMPORT_SYMBOL(luaL_error, int, lua_State *L, const char *fmt, ...); + IMPORT_SYMBOL(luaL_checkoption, int, lua_State *L, int narg, const char *def, const char *const lst[]); + IMPORT_SYMBOL(luaL_fileresult, int, lua_State *L, int stat, const char *fname); + IMPORT_SYMBOL(luaL_execresult, int, lua_State *L, int stat); + IMPORT_SYMBOL(luaL_ref, int, lua_State *L, int t); + IMPORT_SYMBOL(luaL_unref, void, lua_State *L, int t, int ref); + IMPORT_SYMBOL(luaL_loadfilex, int, lua_State *L, const char *filename, const char *mode); + IMPORT_SYMBOL(luaL_loadbufferx, int, lua_State *L, const char *buff, size_t sz, const char *name, const char *mode); + IMPORT_SYMBOL(luaL_loadstring, int, lua_State *L, const char *s); + IMPORT_SYMBOL(luaL_newstate, lua_State *, void); + IMPORT_SYMBOL(luaL_len, lua_Integer, lua_State *L, int idx); + IMPORT_SYMBOL(luaL_addgsub, void, luaL_Buffer *b, const char *s, const char *p, const char *r); + IMPORT_SYMBOL(luaL_gsub, const char *, lua_State *L, const char *s, const char *p, const char *r); + IMPORT_SYMBOL(luaL_setfuncs, void, lua_State *L, const luaL_Reg *l, int nup); + IMPORT_SYMBOL(luaL_getsubtable, int, lua_State *L, int idx, const char *fname); + IMPORT_SYMBOL(luaL_traceback, void, lua_State *L, lua_State *L1, const char *msg, int level); + IMPORT_SYMBOL(luaL_requiref, void, lua_State *L, const char *modname, lua_CFunction openf, int glb); + IMPORT_SYMBOL(luaL_buffinit, void, lua_State *L, luaL_Buffer *B); + IMPORT_SYMBOL(luaL_prepbuffsize, char *, luaL_Buffer *B, size_t sz); + IMPORT_SYMBOL(luaL_addlstring, void, luaL_Buffer *B, const char *s, size_t l); + IMPORT_SYMBOL(luaL_addstring, void, luaL_Buffer *B, const char *s); + IMPORT_SYMBOL(luaL_addvalue, void, luaL_Buffer *B); + IMPORT_SYMBOL(luaL_pushresult, void, luaL_Buffer *B); + IMPORT_SYMBOL(luaL_pushresultsize, void, luaL_Buffer *B, size_t sz); + IMPORT_SYMBOL(luaL_buffinitsize, char *, lua_State *L, luaL_Buffer *B, size_t sz); + IMPORT_SYMBOL(luaopen_base, int, lua_State *L); + IMPORT_SYMBOL(luaopen_coroutine, int, lua_State *L); + IMPORT_SYMBOL(luaopen_table, int, lua_State *L); + IMPORT_SYMBOL(luaopen_io, int, lua_State *L); + IMPORT_SYMBOL(luaopen_os, int, lua_State *L); + IMPORT_SYMBOL(luaopen_string, int, lua_State *L); + IMPORT_SYMBOL(luaopen_utf8, int, lua_State *L); + IMPORT_SYMBOL(luaopen_math, int, lua_State *L); + IMPORT_SYMBOL(luaopen_debug, int, lua_State *L); + IMPORT_SYMBOL(luaopen_package, int, lua_State *L); + IMPORT_SYMBOL(luaL_openlibs, void, lua_State* L); +} + +#undef IMPORT_SYMBOL +#undef IMPORT_SYMBOL_OPT + +#else /* LITE_XL_PLUGIN_ENTRYPOINT */ + +void lite_xl_plugin_init(void *XL); + +#endif /* LITE_XL_PLUGIN_ENTRYPOINT */ + +#undef LITE_XL_API +#undef SYMBOL_WRAP_DECL +#undef SYMBOL_WRAP_CALL +#undef SYMBOL_WRAP_CALL_FB +#undef SYMBOL_DECLARE +#undef SYMBOL_DECLARE_VARARG +#undef UNUSED +#undef CONCAT +#undef CONCAT1 +#undef CONCAT2 +#undef FE_1 +#undef FE_2 +#undef FE_3 +#undef FE_4 +#undef FE_5 +#undef FE_6 +#undef FE_7 +#undef FE_8 +#undef FOR_EACH_NARG +#undef FOR_EACH_NARG_ +#undef FOR_EACH_ARG_N +#undef FOR_EACH_RSEQ_N +#undef FOR_EACH_ +#undef FOR_EACH + +#endif /* LITE_XL_PLUGIN_API */ + +/****************************************************************************** +* Copyright (C) 1994-2023 Lua.org, PUC-Rio; Lite XL contributors. +* +* 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. +******************************************************************************/ \ No newline at end of file diff --git a/resources/lite_xl_plugin_api.h b/resources/lite_xl_plugin_api.h deleted file mode 100644 index 8bf74054..00000000 --- a/resources/lite_xl_plugin_api.h +++ /dev/null @@ -1,1124 +0,0 @@ -#ifndef LITE_XL_PLUGIN_API -#define LITE_XL_PLUGIN_API -/** -The lite_xl plugin API is quite simple. Any shared library can be a plugin file, so long -as it has an entrypoint that looks like the following, where xxxxx is the plugin name: - -#define LITE_XL_PLUGIN_ENTRYPOINT -#include "lite_xl_plugin_api.h" -int luaopen_lite_xl_xxxxx(lua_State* L, void* XL) { - lite_xl_plugin_init(XL); - ... - return 1; -} - -NOTE: `#define LITE_XL_PLUGIN_ENTRYPOINT` needs to be defined only on the -source file where the lite_xl_plugin_init() initialization function is called. - -In linux, to compile this file, you'd do: 'gcc -o xxxxx.so -shared xxxxx.c'. Simple! -Due to the way the API is structured, you *should not* link or include lua libraries. -This file was automatically generated. DO NOT MODIFY DIRECTLY. - -UNLESS you're us, and you had to modify this file manually to get it ready for 2.1. - -Go figure. - -**/ - - -#include -#include // for BUFSIZ? this is kinda weird -#include - -#define SYMBOL_WRAP_DECL(ret, name, ...) \ - ret name(__VA_ARGS__) - -#define SYMBOL_WRAP_CALL(name, ...) \ - return __##name(__VA_ARGS__) - -#define SYMBOL_WRAP_CALL_FB(name, ...) \ - return __lite_xl_fallback_##name(__VA_ARGS__) - -#ifdef LITE_XL_PLUGIN_ENTRYPOINT - #define SYMBOL_DECLARE(ret, name, ...) \ - static ret (*__##name) (__VA_ARGS__); \ - SYMBOL_WRAP_DECL(ret, name, __VA_ARGS__); \ - static ret __lite_xl_fallback_##name(__VA_ARGS__) { \ - fputs("warning: " #name " is a stub", stderr); \ - exit(1); \ - } -#else - #define SYMBOL_DECLARE(ret, name, ...) \ - SYMBOL_WRAP_DECL(ret, name, __VA_ARGS__); -#endif - -/** luaconf.h **/ - -#ifndef lconfig_h -#define lconfig_h -#include -#include -#if !defined(LUA_ANSI) && defined(__STRICT_ANSI__) -#define LUA_ANSI -#endif -#if !defined(LUA_ANSI) && defined(_WIN32) && !defined(_WIN32_WCE) -#define LUA_WIN -#endif -#if defined(LUA_WIN) -#define LUA_DL_DLL -#define LUA_USE_AFORMAT -#endif -#if defined(LUA_USE_LINUX) -#define LUA_USE_POSIX -#define LUA_USE_DLOPEN -#define LUA_USE_READLINE -#define LUA_USE_STRTODHEX -#define LUA_USE_AFORMAT -#define LUA_USE_LONGLONG -#endif -#if defined(LUA_USE_MACOSX) -#define LUA_USE_POSIX -#define LUA_USE_DLOPEN -#define LUA_USE_READLINE -#define LUA_USE_STRTODHEX -#define LUA_USE_AFORMAT -#define LUA_USE_LONGLONG -#endif -#if defined(LUA_USE_POSIX) -#define LUA_USE_MKSTEMP -#define LUA_USE_ISATTY -#define LUA_USE_POPEN -#define LUA_USE_ULONGJMP -#define LUA_USE_GMTIME_R -#endif -#if defined(_WIN32) -#define LUA_LDIR "!\\lua\\" -#define LUA_CDIR "!\\" -#define LUA_PATH_DEFAULT LUA_LDIR"?.lua;" LUA_LDIR"?\\init.lua;" LUA_CDIR"?.lua;" LUA_CDIR"?\\init.lua;" ".\\?.lua" -#define LUA_CPATH_DEFAULT LUA_CDIR"?.dll;" LUA_CDIR"loadall.dll;" ".\\?.dll" -#else -#define LUA_VDIR LUA_VERSION_MAJOR "." LUA_VERSION_MINOR "/" -#define LUA_ROOT "/usr/local/" -#define LUA_LDIR LUA_ROOT "share/lua/" LUA_VDIR -#define LUA_CDIR LUA_ROOT "lib/lua/" LUA_VDIR -#define LUA_PATH_DEFAULT LUA_LDIR"?.lua;" LUA_LDIR"?/init.lua;" LUA_CDIR"?.lua;" LUA_CDIR"?/init.lua;" "./?.lua" -#define LUA_CPATH_DEFAULT LUA_CDIR"?.so;" LUA_CDIR"loadall.so;" "./?.so" -#endif -#if defined(_WIN32) -#define LUA_DIRSEP "\\" -#else -#define LUA_DIRSEP "/" -#endif -#define LUA_ENV "_ENV" -#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 -#define LUAMOD_API LUALIB_API -#if defined(__GNUC__) && ((__GNUC__*100 + __GNUC_MINOR__) >= 302) && defined(__ELF__) -#define LUAI_FUNC __attribute__((visibility("hidden"))) extern -#define LUAI_DDEC LUAI_FUNC -#define LUAI_DDEF -#else -#define LUAI_FUNC extern -#define LUAI_DDEC extern -#define LUAI_DDEF -#endif -#define LUA_QL(x) "'" x "'" -#define LUA_QS LUA_QL("%s") -#define LUA_IDSIZE 60 -#if defined(LUA_LIB) || defined(lua_c) -#include -#define luai_writestring(s,l) fwrite((s), sizeof(char), (l), stdout) -#define luai_writeline() (luai_writestring("\n", 1), fflush(stdout)) -#endif -#define luai_writestringerror(s,p) (fprintf(stderr, (s), (p)), fflush(stderr)) -#define LUAI_MAXSHORTLEN 40 -#if defined(LUA_COMPAT_ALL) -#define LUA_COMPAT_UNPACK -#define LUA_COMPAT_LOADERS -#define lua_cpcall(L,f,u) (lua_pushcfunction(L, (f)), lua_pushlightuserdata(L,(u)), lua_pcall(L,1,0,0)) -#define LUA_COMPAT_LOG10 -#define LUA_COMPAT_LOADSTRING -#define LUA_COMPAT_MAXN -#define lua_strlen(L,i) lua_rawlen(L, (i)) -#define lua_objlen(L,i) lua_rawlen(L, (i)) -#define lua_equal(L,idx1,idx2) lua_compare(L,(idx1),(idx2),LUA_OPEQ) -#define lua_lessthan(L,idx1,idx2) lua_compare(L,(idx1),(idx2),LUA_OPLT) -#define LUA_COMPAT_MODULE -#endif -#if INT_MAX-20 < 32760 -#define LUAI_BITSINT 16 -#elif INT_MAX > 2147483640L -#define LUAI_BITSINT 32 -#else -#error "you must define LUA_BITSINT with number of bits in an integer" -#endif -#if LUAI_BITSINT >= 32 -#define LUA_INT32 int -#define LUAI_UMEM size_t -#define LUAI_MEM ptrdiff_t -#else -#define LUA_INT32 long -#define LUAI_UMEM unsigned long -#define LUAI_MEM long -#endif -#if LUAI_BITSINT >= 32 -#define LUAI_MAXSTACK 1000000 -#else -#define LUAI_MAXSTACK 15000 -#endif -#define LUAI_FIRSTPSEUDOIDX (-LUAI_MAXSTACK - 1000) -#define LUAL_BUFFERSIZE BUFSIZ -#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 l_mathop(x) (x) -#define lua_str2number(s,p) strtod((s), (p)) -#if defined(LUA_USE_STRTODHEX) -#define lua_strx2number(s,p) strtod((s), (p)) -#endif -#if defined(lobject_c) || defined(lvm_c) -#include -#define luai_nummod(L,a,b) ((a) - l_mathop(floor)((a)/(b))*(b)) -#define luai_numpow(L,a,b) (l_mathop(pow)(a,b)) -#endif -#if defined(LUA_CORE) -#define luai_numadd(L,a,b) ((a)+(b)) -#define luai_numsub(L,a,b) ((a)-(b)) -#define luai_nummul(L,a,b) ((a)*(b)) -#define luai_numdiv(L,a,b) ((a)/(b)) -#define luai_numunm(L,a) (-(a)) -#define luai_numeq(a,b) ((a)==(b)) -#define luai_numlt(L,a,b) ((a)<(b)) -#define luai_numle(L,a,b) ((a)<=(b)) -#define luai_numisnan(L,a) (!luai_numeq((a), (a))) -#endif -#define LUA_INTEGER ptrdiff_t -#define LUA_KCONTEXT ptrdiff_t -#define LUA_UNSIGNED unsigned LUA_INT32 -#if defined(LUA_NUMBER_DOUBLE) && !defined(LUA_ANSI) -#if defined(LUA_WIN) && defined(_MSC_VER) && defined(_M_IX86) -#define LUA_MSASMTRICK -#define LUA_IEEEENDIAN 0 -#define LUA_NANTRICK -#elif defined(__i386__) || defined(__i386) || defined(__X86__) -#define LUA_IEEE754TRICK -#define LUA_IEEELL -#define LUA_IEEEENDIAN 0 -#define LUA_NANTRICK -#elif defined(__x86_64) -#define LUA_IEEE754TRICK -#define LUA_IEEEENDIAN 0 -#elif defined(__POWERPC__) || defined(__ppc__) -#define LUA_IEEE754TRICK -#define LUA_IEEEENDIAN 1 -#else -#define LUA_IEEE754TRICK -#endif -#endif -#endif - -/** lua.h **/ - -typedef struct lua_State lua_State; -typedef int (*lua_CFunction) (lua_State *L); -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); -typedef void * (*lua_Alloc) (void *ud, void *ptr, size_t osize, size_t nsize); -typedef LUA_KCONTEXT lua_KContext; -typedef LUA_NUMBER lua_Number; -typedef LUA_INTEGER lua_Integer; -typedef LUA_UNSIGNED lua_Unsigned; -typedef struct lua_Debug lua_Debug; -typedef int (*lua_KFunction) (lua_State *L, int status, lua_KContext ctx); -typedef void (*lua_Hook) (lua_State *L, lua_Debug *ar); -struct lua_Debug { - int event; - const char *name; - const char *namewhat; - const char *what; - const char *source; - int currentline; - int linedefined; - int lastlinedefined; - unsigned char nups; - unsigned char nparams; - char isvararg; - char istailcall; - char short_src[LUA_IDSIZE]; - struct CallInfo *i_ci; -}; - -SYMBOL_DECLARE(lua_State *, lua_newstate, lua_Alloc f, void *ud) -SYMBOL_DECLARE(void, lua_close, lua_State *L) -SYMBOL_DECLARE(lua_State *, lua_newthread, lua_State *L) -SYMBOL_DECLARE(lua_CFunction, lua_atpanic, lua_State *L, lua_CFunction panicf) -SYMBOL_DECLARE(const lua_Number *, lua_version, lua_State *L) -SYMBOL_DECLARE(int, lua_absindex, lua_State *L, int idx) -SYMBOL_DECLARE(int, lua_gettop, lua_State *L) -SYMBOL_DECLARE(void, lua_settop, lua_State *L, int idx) -SYMBOL_DECLARE(void, lua_pushvalue, lua_State *L, int idx) -SYMBOL_DECLARE(void, lua_copy, lua_State *L, int fromidx, int toidx) -SYMBOL_DECLARE(int, lua_checkstack, lua_State *L, int sz) -SYMBOL_DECLARE(void, lua_xmove, lua_State *from, lua_State *to, int n) -SYMBOL_DECLARE(int, lua_isnumber, lua_State *L, int idx) -SYMBOL_DECLARE(int, lua_isstring, lua_State *L, int idx) -SYMBOL_DECLARE(int, lua_iscfunction, lua_State *L, int idx) -SYMBOL_DECLARE(int, lua_isuserdata, lua_State *L, int idx) -SYMBOL_DECLARE(int, lua_type, lua_State *L, int idx) -SYMBOL_DECLARE(const char *, lua_typename, lua_State *L, int tp) -SYMBOL_DECLARE(lua_Number, lua_tonumberx, lua_State *L, int idx, int *isnum) -SYMBOL_DECLARE(lua_Integer, lua_tointegerx, lua_State *L, int idx, int *isnum) -SYMBOL_DECLARE(lua_Unsigned, lua_tounsignedx, lua_State *L, int idx, int *isnum) -SYMBOL_DECLARE(int, lua_toboolean, lua_State *L, int idx) -SYMBOL_DECLARE(const char *, lua_tolstring, lua_State *L, int idx, size_t *len) -SYMBOL_DECLARE(size_t, lua_rawlen, lua_State *L, int idx) -SYMBOL_DECLARE(lua_CFunction, lua_tocfunction, lua_State *L, int idx) -SYMBOL_DECLARE(void *, lua_touserdata, lua_State *L, int idx) -SYMBOL_DECLARE(lua_State *, lua_tothread, lua_State *L, int idx) -SYMBOL_DECLARE(const void *, lua_topointer, lua_State *L, int idx) -SYMBOL_DECLARE(void, lua_arith, lua_State *L, int op) -SYMBOL_DECLARE(int, lua_rawequal, lua_State *L, int idx1, int idx2) -SYMBOL_DECLARE(int, lua_compare, lua_State *L, int idx1, int idx2, int op) -SYMBOL_DECLARE(void, lua_pushnil, lua_State *L) -SYMBOL_DECLARE(void, lua_pushnumber, lua_State *L, lua_Number n) -SYMBOL_DECLARE(void, lua_pushinteger, lua_State *L, lua_Integer n) -SYMBOL_DECLARE(void, lua_pushunsigned, lua_State *L, lua_Unsigned n) -SYMBOL_DECLARE(const char *, lua_pushlstring, lua_State *L, const char *s, size_t l) -SYMBOL_DECLARE(const char *, lua_pushstring, lua_State *L, const char *s) -SYMBOL_DECLARE(const char *, lua_pushvfstring, lua_State *L, const char *fmt, va_list argp) -SYMBOL_DECLARE(const char *, lua_pushfstring, lua_State *L, const char *fmt, ...) -SYMBOL_DECLARE(void, lua_pushcclosure, lua_State *L, lua_CFunction fn, int n) -SYMBOL_DECLARE(void, lua_pushboolean, lua_State *L, int b) -SYMBOL_DECLARE(void, lua_pushlightuserdata, lua_State *L, void *p) -SYMBOL_DECLARE(int, lua_pushthread, lua_State *L) -SYMBOL_DECLARE(void, lua_getglobal, lua_State *L, const char *var) -SYMBOL_DECLARE(void, lua_gettable, lua_State *L, int idx) -SYMBOL_DECLARE(void, lua_getfield, lua_State *L, int idx, const char *k) -SYMBOL_DECLARE(void, lua_rawget, lua_State *L, int idx) -SYMBOL_DECLARE(void, lua_rawgeti, lua_State *L, int idx, int n) -SYMBOL_DECLARE(void, lua_rawgetp, lua_State *L, int idx, const void *p) -SYMBOL_DECLARE(void, lua_createtable, lua_State *L, int narr, int nrec) -SYMBOL_DECLARE(void *, lua_newuserdata, lua_State *L, size_t sz) -SYMBOL_DECLARE(void *, lua_newuserdatauv, lua_State *L, size_t sz, int nuvalue) -SYMBOL_DECLARE(int, lua_getmetatable, lua_State *L, int objindex) -SYMBOL_DECLARE(void, lua_getuservalue, lua_State *L, int idx) -SYMBOL_DECLARE(void, lua_getiuservalue, lua_State *L, int idx, int n) -SYMBOL_DECLARE(void, lua_setglobal, lua_State *L, const char *var) -SYMBOL_DECLARE(void, lua_settable, lua_State *L, int idx) -SYMBOL_DECLARE(void, lua_setfield, lua_State *L, int idx, const char *k) -SYMBOL_DECLARE(void, lua_rawset, lua_State *L, int idx) -SYMBOL_DECLARE(void, lua_rawseti, lua_State *L, int idx, int n) -SYMBOL_DECLARE(void, lua_rawsetp, lua_State *L, int idx, const void *p) -SYMBOL_DECLARE(int, lua_setmetatable, lua_State *L, int objindex) -SYMBOL_DECLARE(void, lua_setuservalue, lua_State *L, int idx) -SYMBOL_DECLARE(void, lua_setiuservalue, lua_State *L, int idx, int n) -SYMBOL_DECLARE(void, lua_callk, lua_State *L, int nargs, int nresults, lua_KContext ctx, lua_KFunction k) -SYMBOL_DECLARE(int, lua_getctx, lua_State *L, int *ctx) -SYMBOL_DECLARE(int, lua_pcallk, lua_State *L, int nargs, int nresults, int errfunc, lua_KContext ctx, lua_KFunction k) -SYMBOL_DECLARE(int, lua_load, lua_State *L, lua_Reader reader, void *dt, const char *chunkname, const char *mode) -SYMBOL_DECLARE(int, lua_dump, lua_State *L, lua_Writer writer, void *data, int strip) -SYMBOL_DECLARE(int, lua_yieldk, lua_State *L, int nresults, lua_KContext ctx, lua_KFunction k) -SYMBOL_DECLARE(int, lua_resume, lua_State *L, lua_State *from, int narg) -SYMBOL_DECLARE(int, lua_status, lua_State *L) -SYMBOL_DECLARE(int, lua_gc, lua_State *L, int what, int data) -SYMBOL_DECLARE(int, lua_error, lua_State *L) -SYMBOL_DECLARE(int, lua_next, lua_State *L, int idx) -SYMBOL_DECLARE(void, lua_concat, lua_State *L, int n) -SYMBOL_DECLARE(void, lua_len, lua_State *L, int idx) -SYMBOL_DECLARE(lua_Alloc, lua_getallocf, lua_State *L, void **ud) -SYMBOL_DECLARE(void, lua_setallocf, lua_State *L, lua_Alloc f, void *ud) -SYMBOL_DECLARE(int, lua_getstack, lua_State *L, int level, lua_Debug *ar) -SYMBOL_DECLARE(int, lua_getinfo, lua_State *L, const char *what, lua_Debug *ar) -SYMBOL_DECLARE(const char *, lua_getlocal, lua_State *L, const lua_Debug *ar, int n) -SYMBOL_DECLARE(const char *, lua_setlocal, lua_State *L, const lua_Debug *ar, int n) -SYMBOL_DECLARE(const char *, lua_getupvalue, lua_State *L, int funcindex, int n) -SYMBOL_DECLARE(const char *, lua_setupvalue, lua_State *L, int funcindex, int n) -SYMBOL_DECLARE(void *, lua_upvalueid, lua_State *L, int fidx, int n) -SYMBOL_DECLARE(void, lua_upvaluejoin, lua_State *L, int fidx1, int n1, int fidx2, int n2) -SYMBOL_DECLARE(int, lua_sethook, lua_State *L, lua_Hook func, int mask, int count) -SYMBOL_DECLARE(lua_Hook, lua_gethook, lua_State *L) -SYMBOL_DECLARE(int, lua_gethookmask, lua_State *L) -SYMBOL_DECLARE(int, lua_gethookcount, lua_State *L) - -#define lua_h -#define LUA_VERSION_MAJOR "5" -#define LUA_VERSION_MINOR "4" -#define LUA_VERSION_NUM 504 -#define LUA_VERSION_RELEASE "4" -#define LUA_VERSION "Lua " LUA_VERSION_MAJOR "." LUA_VERSION_MINOR -#define LUA_RELEASE LUA_VERSION "." LUA_VERSION_RELEASE -#define LUA_COPYRIGHT LUA_RELEASE " Copyright (C) 1994-2015 Lua.org, PUC-Rio" -#define LUA_AUTHORS "R. Ierusalimschy, L. H. de Figueiredo, W. Celes" -#define LUA_SIGNATURE "\033Lua" -#define LUA_MULTRET (-1) -#define LUA_REGISTRYINDEX LUAI_FIRSTPSEUDOIDX -#define lua_upvalueindex(i) (LUA_REGISTRYINDEX - (i)) -#define LUA_OK 0 -#define LUA_YIELD 1 -#define LUA_ERRRUN 2 -#define LUA_ERRSYNTAX 3 -#define LUA_ERRMEM 4 -#define LUA_ERRGCMM 5 -#define LUA_ERRERR 6 -#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 -#define LUA_NUMTAGS 9 -#define LUA_MINSTACK 20 -#define LUA_RIDX_MAINTHREAD 1 -#define LUA_RIDX_GLOBALS 2 -#define LUA_RIDX_LAST LUA_RIDX_GLOBALS -#define LUA_OPADD 0 -#define LUA_OPSUB 1 -#define LUA_OPMUL 2 -#define LUA_OPDIV 3 -#define LUA_OPMOD 4 -#define LUA_OPPOW 5 -#define LUA_OPUNM 6 -#define LUA_OPEQ 0 -#define LUA_OPLT 1 -#define LUA_OPLE 2 -#define lua_call(L,n,r) lua_callk(L, (n), (r), 0, NULL) -#define lua_pcall(L,n,r,f) lua_pcallk(L, (n), (r), (f), 0, NULL) -#define lua_yield(L,n) lua_yieldk(L, (n), 0, NULL) -#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_GCSETMAJORINC 8 -#define LUA_GCISRUNNING 9 -#define LUA_GCGEN 10 -#define LUA_GCINC 11 -#define lua_tonumber(L,i) lua_tonumberx(L,i,NULL) -#define lua_tointeger(L,i) lua_tointegerx(L,i,NULL) -#define lua_tounsigned(L,i) lua_tounsignedx(L,i,NULL) -#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_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_pushglobaltable(L) lua_rawgeti(L, LUA_REGISTRYINDEX, LUA_RIDX_GLOBALS) -#define lua_tostring(L,i) lua_tolstring(L, (i), NULL) -#define lua_insert(L,idx) lua_rotate(L, (idx), 1) -#define lua_replace(L,idx) (lua_copy(L, -1, (idx)), lua_pop(L, 1)) -#define lua_remove(L,idx) (lua_rotate(L, (idx), -1), lua_pop(L, 1)) -#define LUA_HOOKCALL 0 -#define LUA_HOOKRET 1 -#define LUA_HOOKLINE 2 -#define LUA_HOOKCOUNT 3 -#define LUA_HOOKTAILCALL 4 -#define LUA_MASKCALL (1 << LUA_HOOKCALL) -#define LUA_MASKRET (1 << LUA_HOOKRET) -#define LUA_MASKLINE (1 << LUA_HOOKLINE) -#define LUA_MASKCOUNT (1 << LUA_HOOKCOUNT) - -/** lauxlib.h **/ - -typedef struct luaL_Reg { - const char *name; - lua_CFunction func; -} luaL_Reg; -typedef struct luaL_Buffer { - char *b; - size_t size; - size_t n; - lua_State *L; - char initb[LUAL_BUFFERSIZE]; -} luaL_Buffer; -typedef struct luaL_Stream { - FILE *f; - lua_CFunction closef; -} luaL_Stream; - -SYMBOL_DECLARE(void, luaL_checkversion_, lua_State *L, lua_Number ver) -SYMBOL_DECLARE(int, luaL_getmetafield, lua_State *L, int obj, const char *e) -SYMBOL_DECLARE(int, luaL_callmeta, lua_State *L, int obj, const char *e) -SYMBOL_DECLARE(const char *, luaL_tolstring, lua_State *L, int idx, size_t *len) -SYMBOL_DECLARE(int, luaL_argerror, lua_State *L, int numarg, const char *extramsg) -SYMBOL_DECLARE(const char *, luaL_checklstring, lua_State *L, int numArg, size_t *l) -SYMBOL_DECLARE(const char *, luaL_optlstring, lua_State *L, int numArg, const char *def, size_t *l) -SYMBOL_DECLARE(lua_Number, luaL_checknumber, lua_State *L, int numArg) -SYMBOL_DECLARE(lua_Number, luaL_optnumber, lua_State *L, int nArg, lua_Number def) -SYMBOL_DECLARE(lua_Integer, luaL_checkinteger, lua_State *L, int numArg) -SYMBOL_DECLARE(lua_Integer, luaL_optinteger, lua_State *L, int nArg, lua_Integer def) -SYMBOL_DECLARE(lua_Unsigned, luaL_checkunsigned, lua_State *L, int numArg) -SYMBOL_DECLARE(lua_Unsigned, luaL_optunsigned, lua_State *L, int numArg, lua_Unsigned def) -SYMBOL_DECLARE(void, luaL_checkstack, lua_State *L, int sz, const char *msg) -SYMBOL_DECLARE(void, luaL_checktype, lua_State *L, int narg, int t) -SYMBOL_DECLARE(void, luaL_checkany, lua_State *L, int narg) -SYMBOL_DECLARE(int, luaL_newmetatable, lua_State *L, const char *tname) -SYMBOL_DECLARE(void, luaL_setmetatable, lua_State *L, const char *tname) -SYMBOL_DECLARE(void *, luaL_testudata, lua_State *L, int ud, const char *tname) -SYMBOL_DECLARE(void *, luaL_checkudata, lua_State *L, int ud, const char *tname) -SYMBOL_DECLARE(void, luaL_where, lua_State *L, int lvl) -SYMBOL_DECLARE(int, luaL_error, lua_State *L, const char *fmt, ...) -SYMBOL_DECLARE(int, luaL_checkoption, lua_State *L, int narg, const char *def, const char *const lst[]) -SYMBOL_DECLARE(int, luaL_fileresult, lua_State *L, int stat, const char *fname) -SYMBOL_DECLARE(int, luaL_execresult, lua_State *L, int stat) -SYMBOL_DECLARE(int, luaL_ref, lua_State *L, int t) -SYMBOL_DECLARE(void, luaL_unref, lua_State *L, int t, int ref) -SYMBOL_DECLARE(int, luaL_loadfilex, lua_State *L, const char *filename, const char *mode) -SYMBOL_DECLARE(int, luaL_loadbufferx, lua_State *L, const char *buff, size_t sz, const char *name, const char *mode) -SYMBOL_DECLARE(int, luaL_loadstring, lua_State *L, const char *s) -SYMBOL_DECLARE(lua_State *, luaL_newstate, void) -SYMBOL_DECLARE(int, luaL_len, lua_State *L, int idx) -SYMBOL_DECLARE(const char *, luaL_gsub, lua_State *L, const char *s, const char *p, const char *r) -SYMBOL_DECLARE(void, luaL_setfuncs, lua_State *L, const luaL_Reg *l, int nup) -SYMBOL_DECLARE(int, luaL_getsubtable, lua_State *L, int idx, const char *fname) -SYMBOL_DECLARE(void, luaL_traceback, lua_State *L, lua_State *L1, const char *msg, int level) -SYMBOL_DECLARE(void, luaL_requiref, lua_State *L, const char *modname, lua_CFunction openf, int glb) -SYMBOL_DECLARE(void, luaL_buffinit, lua_State *L, luaL_Buffer *B) -SYMBOL_DECLARE(char *, luaL_prepbuffsize, luaL_Buffer *B, size_t sz) -SYMBOL_DECLARE(void, luaL_addlstring, luaL_Buffer *B, const char *s, size_t l) -SYMBOL_DECLARE(void, luaL_addstring, luaL_Buffer *B, const char *s) -SYMBOL_DECLARE(void, luaL_addvalue, luaL_Buffer *B) -SYMBOL_DECLARE(void, luaL_pushresult, luaL_Buffer *B) -SYMBOL_DECLARE(void, luaL_pushresultsize, luaL_Buffer *B, size_t sz) -SYMBOL_DECLARE(char *, luaL_buffinitsize, lua_State *L, luaL_Buffer *B, size_t sz) -SYMBOL_DECLARE(void, luaL_openlibs, lua_State *L) - -#define lauxlib_h -#define LUA_ERRFILE (LUA_ERRERR+1) -#define luaL_checkversion(L) luaL_checkversion_(L, LUA_VERSION_NUM) -#define LUA_NOREF (-2) -#define LUA_REFNIL (-1) -#define luaL_loadfile(L,f) luaL_loadfilex(L,f,NULL) -#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)) -#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))) -#define luaL_loadbuffer(L,s,sz,n) luaL_loadbufferx(L,s,sz,n,NULL) -#define luaL_addchar(B,c) ((void)((B)->n < (B)->size || luaL_prepbuffsize((B), 1)), ((B)->b[(B)->n++] = (c))) -#define luaL_addsize(B,s) ((B)->n += (s)) -#define luaL_prepbuffer(B) luaL_prepbuffsize(B, LUAL_BUFFERSIZE) -#define LUA_FILEHANDLE "FILE*" - -#ifdef LITE_XL_PLUGIN_ENTRYPOINT - -SYMBOL_WRAP_DECL(lua_State *, lua_newstate, lua_Alloc f, void *ud){ - SYMBOL_WRAP_CALL(lua_newstate, f, ud); -} -SYMBOL_WRAP_DECL(void, lua_close, lua_State *L){ - SYMBOL_WRAP_CALL(lua_close, L); -} -SYMBOL_WRAP_DECL(lua_State *, lua_newthread, lua_State *L){ - SYMBOL_WRAP_CALL(lua_newthread, L); -} -SYMBOL_WRAP_DECL(lua_CFunction, lua_atpanic, lua_State *L, lua_CFunction panicf){ - SYMBOL_WRAP_CALL(lua_atpanic, L, panicf); -} -SYMBOL_WRAP_DECL(const lua_Number *, lua_version, lua_State *L){ - SYMBOL_WRAP_CALL(lua_version, L); -} -SYMBOL_WRAP_DECL(int, lua_absindex, lua_State *L, int idx){ - SYMBOL_WRAP_CALL(lua_absindex, L, idx); -} -SYMBOL_WRAP_DECL(int, lua_gettop, lua_State *L){ - SYMBOL_WRAP_CALL(lua_gettop, L); -} -SYMBOL_WRAP_DECL(void, lua_settop, lua_State *L, int idx){ - SYMBOL_WRAP_CALL(lua_settop, L, idx); -} -SYMBOL_WRAP_DECL(void, lua_pushvalue, lua_State *L, int idx){ - SYMBOL_WRAP_CALL(lua_pushvalue, L, idx); -} -SYMBOL_WRAP_DECL(void, lua_copy, lua_State *L, int fromidx, int toidx){ - SYMBOL_WRAP_CALL(lua_copy, L, fromidx, toidx); -} -SYMBOL_WRAP_DECL(int, lua_checkstack, lua_State *L, int sz){ - SYMBOL_WRAP_CALL(lua_checkstack, L, sz); -} -SYMBOL_WRAP_DECL(void, lua_xmove, lua_State *from, lua_State *to, int n){ - SYMBOL_WRAP_CALL(lua_xmove, from, to, n); -} -SYMBOL_WRAP_DECL(int, lua_isnumber, lua_State *L, int idx){ - SYMBOL_WRAP_CALL(lua_isnumber, L, idx); -} -SYMBOL_WRAP_DECL(int, lua_isstring, lua_State *L, int idx){ - SYMBOL_WRAP_CALL(lua_isstring, L, idx); -} -SYMBOL_WRAP_DECL(int, lua_iscfunction, lua_State *L, int idx){ - SYMBOL_WRAP_CALL(lua_iscfunction, L, idx); -} -SYMBOL_WRAP_DECL(int, lua_isuserdata, lua_State *L, int idx){ - SYMBOL_WRAP_CALL(lua_isuserdata, L, idx); -} -SYMBOL_WRAP_DECL(int, lua_type, lua_State *L, int idx){ - SYMBOL_WRAP_CALL(lua_type, L, idx); -} -SYMBOL_WRAP_DECL(const char *, lua_typename, lua_State *L, int tp){ - SYMBOL_WRAP_CALL(lua_typename, L, tp); -} -SYMBOL_WRAP_DECL(lua_Number, lua_tonumberx, lua_State *L, int idx, int *isnum){ - SYMBOL_WRAP_CALL(lua_tonumberx, L, idx, isnum); -} -SYMBOL_WRAP_DECL(lua_Integer, lua_tointegerx, lua_State *L, int idx, int *isnum){ - SYMBOL_WRAP_CALL(lua_tointegerx, L, idx, isnum); -} -SYMBOL_WRAP_DECL(lua_Unsigned, lua_tounsignedx, lua_State *L, int idx, int *isnum){ - SYMBOL_WRAP_CALL(lua_tounsignedx, L, idx, isnum); -} -SYMBOL_WRAP_DECL(int, lua_toboolean, lua_State *L, int idx){ - SYMBOL_WRAP_CALL(lua_toboolean, L, idx); -} -SYMBOL_WRAP_DECL(const char *, lua_tolstring, lua_State *L, int idx, size_t *len){ - SYMBOL_WRAP_CALL(lua_tolstring, L, idx, len); -} -SYMBOL_WRAP_DECL(size_t, lua_rawlen, lua_State *L, int idx){ - SYMBOL_WRAP_CALL(lua_rawlen, L, idx); -} -SYMBOL_WRAP_DECL(lua_CFunction, lua_tocfunction, lua_State *L, int idx){ - SYMBOL_WRAP_CALL(lua_tocfunction, L, idx); -} -SYMBOL_WRAP_DECL(void *, lua_touserdata, lua_State *L, int idx){ - SYMBOL_WRAP_CALL(lua_touserdata, L, idx); -} -SYMBOL_WRAP_DECL(lua_State *, lua_tothread, lua_State *L, int idx){ - SYMBOL_WRAP_CALL(lua_tothread, L, idx); -} -SYMBOL_WRAP_DECL(const void *, lua_topointer, lua_State *L, int idx){ - SYMBOL_WRAP_CALL(lua_topointer, L, idx); -} -SYMBOL_WRAP_DECL(void, lua_arith, lua_State *L, int op){ - SYMBOL_WRAP_CALL(lua_arith, L, op); -} -SYMBOL_WRAP_DECL(int, lua_rawequal, lua_State *L, int idx1, int idx2){ - SYMBOL_WRAP_CALL(lua_rawequal, L, idx1, idx2); -} -SYMBOL_WRAP_DECL(int, lua_compare, lua_State *L, int idx1, int idx2, int op){ - SYMBOL_WRAP_CALL(lua_compare, L, idx1, idx2, op); -} -SYMBOL_WRAP_DECL(void, lua_pushnil, lua_State *L){ - SYMBOL_WRAP_CALL(lua_pushnil, L); -} -SYMBOL_WRAP_DECL(void, lua_pushnumber, lua_State *L, lua_Number n){ - SYMBOL_WRAP_CALL(lua_pushnumber, L, n); -} -SYMBOL_WRAP_DECL(void, lua_pushinteger, lua_State *L, lua_Integer n){ - SYMBOL_WRAP_CALL(lua_pushinteger, L, n); -} -SYMBOL_WRAP_DECL(void, lua_pushunsigned, lua_State *L, lua_Unsigned n){ - SYMBOL_WRAP_CALL(lua_pushunsigned, L, n); -} -SYMBOL_WRAP_DECL(const char *, lua_pushlstring, lua_State *L, const char *s, size_t l){ - SYMBOL_WRAP_CALL(lua_pushlstring, L, s, l); -} -SYMBOL_WRAP_DECL(const char *, lua_pushstring, lua_State *L, const char *s){ - SYMBOL_WRAP_CALL(lua_pushstring, L, s); -} -SYMBOL_WRAP_DECL(const char *, lua_pushvfstring, lua_State *L, const char *fmt, va_list argp){ - SYMBOL_WRAP_CALL(lua_pushvfstring, L, fmt, argp); -} -SYMBOL_WRAP_DECL(const char *, lua_pushfstring, lua_State *L, const char *fmt, ...){ - SYMBOL_WRAP_CALL(lua_pushfstring, L, fmt); -} -SYMBOL_WRAP_DECL(void, lua_pushcclosure, lua_State *L, lua_CFunction fn, int n){ - SYMBOL_WRAP_CALL(lua_pushcclosure, L, fn, n); -} -SYMBOL_WRAP_DECL(void, lua_pushboolean, lua_State *L, int b){ - SYMBOL_WRAP_CALL(lua_pushboolean, L, b); -} -SYMBOL_WRAP_DECL(void, lua_pushlightuserdata, lua_State *L, void *p){ - SYMBOL_WRAP_CALL(lua_pushlightuserdata, L, p); -} -SYMBOL_WRAP_DECL(int, lua_pushthread, lua_State *L){ - SYMBOL_WRAP_CALL(lua_pushthread, L); -} -SYMBOL_WRAP_DECL(void, lua_getglobal, lua_State *L, const char *var){ - SYMBOL_WRAP_CALL(lua_getglobal, L, var); -} -SYMBOL_WRAP_DECL(void, lua_gettable, lua_State *L, int idx){ - SYMBOL_WRAP_CALL(lua_gettable, L, idx); -} -SYMBOL_WRAP_DECL(void, lua_getfield, lua_State *L, int idx, const char *k){ - SYMBOL_WRAP_CALL(lua_getfield, L, idx, k); -} -SYMBOL_WRAP_DECL(void, lua_rawget, lua_State *L, int idx){ - SYMBOL_WRAP_CALL(lua_rawget, L, idx); -} -SYMBOL_WRAP_DECL(void, lua_rawgeti, lua_State *L, int idx, int n){ - SYMBOL_WRAP_CALL(lua_rawgeti, L, idx, n); -} -SYMBOL_WRAP_DECL(void, lua_rawgetp, lua_State *L, int idx, const void *p){ - SYMBOL_WRAP_CALL(lua_rawgetp, L, idx, p); -} -SYMBOL_WRAP_DECL(void, lua_createtable, lua_State *L, int narr, int nrec){ - SYMBOL_WRAP_CALL(lua_createtable, L, narr, nrec); -} -SYMBOL_WRAP_DECL(void *, lua_newuserdata, lua_State *L, size_t sz){ - if (__lua_newuserdatauv != NULL) { - return lua_newuserdatauv(L, sz, 1); - } else if (__lua_newuserdata != NULL) { - SYMBOL_WRAP_CALL(lua_newuserdata, L, sz); - } - SYMBOL_WRAP_CALL_FB(lua_newuserdata, L, sz); -} -SYMBOL_WRAP_DECL(void *, lua_newuserdatauv, lua_State *L, size_t sz, int nuvalue){ - SYMBOL_WRAP_CALL(lua_newuserdatauv, L, sz, nuvalue); -} -SYMBOL_WRAP_DECL(int, lua_getmetatable, lua_State *L, int objindex){ - SYMBOL_WRAP_CALL(lua_getmetatable, L, objindex); -} -SYMBOL_WRAP_DECL(void, lua_getuservalue, lua_State *L, int idx){ - if (__lua_getiuservalue != NULL) { - return lua_getiuservalue(L, idx, 1); - } else if (__lua_getuservalue != NULL) { - SYMBOL_WRAP_CALL(lua_getuservalue, L, idx); - } - SYMBOL_WRAP_CALL_FB(lua_getuservalue, L, idx); -} -SYMBOL_WRAP_DECL(void, lua_getiuservalue, lua_State *L, int idx, int n){ - SYMBOL_WRAP_CALL(lua_getiuservalue, L, idx, n); -} -SYMBOL_WRAP_DECL(void, lua_setglobal, lua_State *L, const char *var){ - SYMBOL_WRAP_CALL(lua_setglobal, L, var); -} -SYMBOL_WRAP_DECL(void, lua_settable, lua_State *L, int idx){ - SYMBOL_WRAP_CALL(lua_settable, L, idx); -} -SYMBOL_WRAP_DECL(void, lua_setfield, lua_State *L, int idx, const char *k){ - SYMBOL_WRAP_CALL(lua_setfield, L, idx, k); -} -SYMBOL_WRAP_DECL(void, lua_rawset, lua_State *L, int idx){ - SYMBOL_WRAP_CALL(lua_rawset, L, idx); -} -SYMBOL_WRAP_DECL(void, lua_rawseti, lua_State *L, int idx, int n){ - SYMBOL_WRAP_CALL(lua_rawseti, L, idx, n); -} -SYMBOL_WRAP_DECL(void, lua_rawsetp, lua_State *L, int idx, const void *p){ - SYMBOL_WRAP_CALL(lua_rawsetp, L, idx, p); -} -SYMBOL_WRAP_DECL(int, lua_setmetatable, lua_State *L, int objindex){ - SYMBOL_WRAP_CALL(lua_setmetatable, L, objindex); -} -SYMBOL_WRAP_DECL(void, lua_setuservalue, lua_State *L, int idx){ - if (__lua_setiuservalue != NULL) { - return lua_setiuservalue(L, idx, 1); - } else if (__lua_setuservalue != NULL) { - SYMBOL_WRAP_CALL(lua_setuservalue, L, idx); - } - SYMBOL_WRAP_CALL_FB(lua_setuservalue, L, idx); -} -SYMBOL_WRAP_DECL(void, lua_setiuservalue, lua_State *L, int idx, int n){ - SYMBOL_WRAP_CALL(lua_setiuservalue, L, idx, n); -} -SYMBOL_WRAP_DECL(void, lua_callk, lua_State *L, int nargs, int nresults, lua_KContext ctx, lua_KFunction k){ - SYMBOL_WRAP_CALL(lua_callk, L, nargs, nresults, ctx, k); -} -SYMBOL_WRAP_DECL(int, lua_getctx, lua_State *L, int *ctx){ - SYMBOL_WRAP_CALL(lua_getctx, L, ctx); -} -SYMBOL_WRAP_DECL(int, lua_pcallk, lua_State *L, int nargs, int nresults, int errfunc, lua_KContext ctx, lua_KFunction k){ - SYMBOL_WRAP_CALL(lua_pcallk, L, nargs, nresults, errfunc, ctx, k); -} -SYMBOL_WRAP_DECL(int, lua_load, lua_State *L, lua_Reader reader, void *dt, const char *chunkname, const char *mode){ - SYMBOL_WRAP_CALL(lua_load, L, reader, dt, chunkname, mode); -} -SYMBOL_WRAP_DECL(int, lua_dump, lua_State *L, lua_Writer writer, void *data, int strip){ - SYMBOL_WRAP_CALL(lua_dump, L, writer, data, strip); -} -SYMBOL_WRAP_DECL(int, lua_yieldk, lua_State *L, int nresults, lua_KContext ctx, lua_KFunction k){ - SYMBOL_WRAP_CALL(lua_yieldk, L, nresults, ctx, k); -} -SYMBOL_WRAP_DECL(int, lua_resume, lua_State *L, lua_State *from, int narg){ - SYMBOL_WRAP_CALL(lua_resume, L, from, narg); -} -SYMBOL_WRAP_DECL(int, lua_status, lua_State *L){ - SYMBOL_WRAP_CALL(lua_status, L); -} -SYMBOL_WRAP_DECL(int, lua_gc, lua_State *L, int what, int data){ - SYMBOL_WRAP_CALL(lua_gc, L, what, data); -} -SYMBOL_WRAP_DECL(int, lua_error, lua_State *L){ - SYMBOL_WRAP_CALL(lua_error, L); -} -SYMBOL_WRAP_DECL(int, lua_next, lua_State *L, int idx){ - SYMBOL_WRAP_CALL(lua_next, L, idx); -} -SYMBOL_WRAP_DECL(void, lua_concat, lua_State *L, int n){ - SYMBOL_WRAP_CALL(lua_concat, L, n); -} -SYMBOL_WRAP_DECL(void, lua_len, lua_State *L, int idx){ - SYMBOL_WRAP_CALL(lua_len, L, idx); -} -SYMBOL_WRAP_DECL(lua_Alloc, lua_getallocf, lua_State *L, void **ud){ - SYMBOL_WRAP_CALL(lua_getallocf, L, ud); -} -SYMBOL_WRAP_DECL(void, lua_setallocf, lua_State *L, lua_Alloc f, void *ud){ - SYMBOL_WRAP_CALL(lua_setallocf, L, f, ud); -} -SYMBOL_WRAP_DECL(int, lua_getstack, lua_State *L, int level, lua_Debug *ar){ - SYMBOL_WRAP_CALL(lua_getstack, L, level, ar); -} -SYMBOL_WRAP_DECL(int, lua_getinfo, lua_State *L, const char *what, lua_Debug *ar){ - SYMBOL_WRAP_CALL(lua_getinfo, L, what, ar); -} -SYMBOL_WRAP_DECL(const char *, lua_getlocal, lua_State *L, const lua_Debug *ar, int n){ - SYMBOL_WRAP_CALL(lua_getlocal, L, ar, n); -} -SYMBOL_WRAP_DECL(const char *, lua_setlocal, lua_State *L, const lua_Debug *ar, int n){ - SYMBOL_WRAP_CALL(lua_setlocal, L, ar, n); -} -SYMBOL_WRAP_DECL(const char *, lua_getupvalue, lua_State *L, int funcindex, int n){ - SYMBOL_WRAP_CALL(lua_getupvalue, L, funcindex, n); -} -SYMBOL_WRAP_DECL(const char *, lua_setupvalue, lua_State *L, int funcindex, int n){ - SYMBOL_WRAP_CALL(lua_setupvalue, L, funcindex, n); -} -SYMBOL_WRAP_DECL(void *, lua_upvalueid, lua_State *L, int fidx, int n){ - SYMBOL_WRAP_CALL(lua_upvalueid, L, fidx, n); -} -SYMBOL_WRAP_DECL(void, lua_upvaluejoin, lua_State *L, int fidx1, int n1, int fidx2, int n2){ - SYMBOL_WRAP_CALL(lua_upvaluejoin, L, fidx1, n1, fidx2, n2); -} -SYMBOL_WRAP_DECL(int, lua_sethook, lua_State *L, lua_Hook func, int mask, int count){ - SYMBOL_WRAP_CALL(lua_sethook, L, func, mask, count); -} -SYMBOL_WRAP_DECL(lua_Hook, lua_gethook, lua_State *L){ - SYMBOL_WRAP_CALL(lua_gethook, L); -} -SYMBOL_WRAP_DECL(int, lua_gethookmask, lua_State *L){ - SYMBOL_WRAP_CALL(lua_gethookmask, L); -} -SYMBOL_WRAP_DECL(int, lua_gethookcount, lua_State *L){ - SYMBOL_WRAP_CALL(lua_gethookcount, L); -} -SYMBOL_WRAP_DECL(void, luaL_checkversion_, lua_State *L, lua_Number ver){ - SYMBOL_WRAP_CALL(luaL_checkversion_, L, ver); -} -SYMBOL_WRAP_DECL(int, luaL_getmetafield, lua_State *L, int obj, const char *e){ - SYMBOL_WRAP_CALL(luaL_getmetafield, L, obj, e); -} -SYMBOL_WRAP_DECL(int, luaL_callmeta, lua_State *L, int obj, const char *e){ - SYMBOL_WRAP_CALL(luaL_callmeta, L, obj, e); -} -SYMBOL_WRAP_DECL(const char *, luaL_tolstring, lua_State *L, int idx, size_t *len){ - SYMBOL_WRAP_CALL(luaL_tolstring, L, idx, len); -} -SYMBOL_WRAP_DECL(int, luaL_argerror, lua_State *L, int numarg, const char *extramsg){ - SYMBOL_WRAP_CALL(luaL_argerror, L, numarg, extramsg); -} -SYMBOL_WRAP_DECL(const char *, luaL_checklstring, lua_State *L, int numArg, size_t *l){ - SYMBOL_WRAP_CALL(luaL_checklstring, L, numArg, l); -} -SYMBOL_WRAP_DECL(const char *, luaL_optlstring, lua_State *L, int numArg, const char *def, size_t *l){ - SYMBOL_WRAP_CALL(luaL_optlstring, L, numArg, def, l); -} -SYMBOL_WRAP_DECL(lua_Number, luaL_checknumber, lua_State *L, int numArg){ - SYMBOL_WRAP_CALL(luaL_checknumber, L, numArg); -} -SYMBOL_WRAP_DECL(lua_Number, luaL_optnumber, lua_State *L, int nArg, lua_Number def){ - SYMBOL_WRAP_CALL(luaL_optnumber, L, nArg, def); -} -SYMBOL_WRAP_DECL(lua_Integer, luaL_checkinteger, lua_State *L, int numArg){ - SYMBOL_WRAP_CALL(luaL_checkinteger, L, numArg); -} -SYMBOL_WRAP_DECL(lua_Integer, luaL_optinteger, lua_State *L, int nArg, lua_Integer def){ - SYMBOL_WRAP_CALL(luaL_optinteger, L, nArg, def); -} -SYMBOL_WRAP_DECL(lua_Unsigned, luaL_checkunsigned, lua_State *L, int numArg){ - SYMBOL_WRAP_CALL(luaL_checkunsigned, L, numArg); -} -SYMBOL_WRAP_DECL(lua_Unsigned, luaL_optunsigned, lua_State *L, int numArg, lua_Unsigned def){ - SYMBOL_WRAP_CALL(luaL_optunsigned, L, numArg, def); -} -SYMBOL_WRAP_DECL(void, luaL_checkstack, lua_State *L, int sz, const char *msg){ - SYMBOL_WRAP_CALL(luaL_checkstack, L, sz, msg); -} -SYMBOL_WRAP_DECL(void, luaL_checktype, lua_State *L, int narg, int t){ - SYMBOL_WRAP_CALL(luaL_checktype, L, narg, t); -} -SYMBOL_WRAP_DECL(void, luaL_checkany, lua_State *L, int narg){ - SYMBOL_WRAP_CALL(luaL_checkany, L, narg); -} -SYMBOL_WRAP_DECL(int, luaL_newmetatable, lua_State *L, const char *tname){ - SYMBOL_WRAP_CALL(luaL_newmetatable, L, tname); -} -SYMBOL_WRAP_DECL(void, luaL_setmetatable, lua_State *L, const char *tname){ - SYMBOL_WRAP_CALL(luaL_setmetatable, L, tname); -} -SYMBOL_WRAP_DECL(void *, luaL_testudata, lua_State *L, int ud, const char *tname){ - SYMBOL_WRAP_CALL(luaL_testudata, L, ud, tname); -} -SYMBOL_WRAP_DECL(void *, luaL_checkudata, lua_State *L, int ud, const char *tname){ - SYMBOL_WRAP_CALL(luaL_checkudata, L, ud, tname); -} -SYMBOL_WRAP_DECL(void, luaL_where, lua_State *L, int lvl){ - SYMBOL_WRAP_CALL(luaL_where, L, lvl); -} -SYMBOL_WRAP_DECL(int, luaL_error, lua_State *L, const char *fmt, ...){ - va_list argp; - va_start(argp, fmt); - luaL_where(L, 1); - lua_pushvfstring(L, fmt, argp); - va_end(argp); - lua_concat(L, 2); - return lua_error(L); -} -SYMBOL_WRAP_DECL(int, luaL_checkoption, lua_State *L, int narg, const char *def, const char *const lst[]){ - SYMBOL_WRAP_CALL(luaL_checkoption, L, narg, def, lst); -} -SYMBOL_WRAP_DECL(int, luaL_fileresult, lua_State *L, int stat, const char *fname){ - SYMBOL_WRAP_CALL(luaL_fileresult, L, stat, fname); -} -SYMBOL_WRAP_DECL(int, luaL_execresult, lua_State *L, int stat){ - SYMBOL_WRAP_CALL(luaL_execresult, L, stat); -} -SYMBOL_WRAP_DECL(int, luaL_ref, lua_State *L, int t){ - SYMBOL_WRAP_CALL(luaL_ref, L, t); -} -SYMBOL_WRAP_DECL(void, luaL_unref, lua_State *L, int t, int ref){ - SYMBOL_WRAP_CALL(luaL_unref, L, t, ref); -} -SYMBOL_WRAP_DECL(int, luaL_loadfilex, lua_State *L, const char *filename, const char *mode){ - SYMBOL_WRAP_CALL(luaL_loadfilex, L, filename, mode); -} -SYMBOL_WRAP_DECL(int, luaL_loadbufferx, lua_State *L, const char *buff, size_t sz, const char *name, const char *mode){ - SYMBOL_WRAP_CALL(luaL_loadbufferx, L, buff, sz, name, mode); -} -SYMBOL_WRAP_DECL(int, luaL_loadstring, lua_State *L, const char *s){ - SYMBOL_WRAP_CALL(luaL_loadstring, L, s); -} -SYMBOL_WRAP_DECL(lua_State *, luaL_newstate, void){ - return __luaL_newstate(); -} -SYMBOL_WRAP_DECL(int, luaL_len, lua_State *L, int idx){ - SYMBOL_WRAP_CALL(luaL_len, L, idx); -} -SYMBOL_WRAP_DECL(const char *, luaL_gsub, lua_State *L, const char *s, const char *p, const char *r){ - SYMBOL_WRAP_CALL(luaL_gsub, L, s, p, r); -} -SYMBOL_WRAP_DECL(void, luaL_setfuncs, lua_State *L, const luaL_Reg *l, int nup){ - SYMBOL_WRAP_CALL(luaL_setfuncs, L, l, nup); -} -SYMBOL_WRAP_DECL(int, luaL_getsubtable, lua_State *L, int idx, const char *fname){ - SYMBOL_WRAP_CALL(luaL_getsubtable, L, idx, fname); -} -SYMBOL_WRAP_DECL(void, luaL_traceback, lua_State *L, lua_State *L1, const char *msg, int level){ - SYMBOL_WRAP_CALL(luaL_traceback, L, L1, msg, level); -} -SYMBOL_WRAP_DECL(void, luaL_requiref, lua_State *L, const char *modname, lua_CFunction openf, int glb){ - SYMBOL_WRAP_CALL(luaL_requiref, L, modname, openf, glb); -} -SYMBOL_WRAP_DECL(void, luaL_buffinit, lua_State *L, luaL_Buffer *B){ - SYMBOL_WRAP_CALL(luaL_buffinit, L, B); -} -SYMBOL_WRAP_DECL(char *, luaL_prepbuffsize, luaL_Buffer *B, size_t sz){ - SYMBOL_WRAP_CALL(luaL_prepbuffsize, B, sz); -} -SYMBOL_WRAP_DECL(void, luaL_addlstring, luaL_Buffer *B, const char *s, size_t l){ - SYMBOL_WRAP_CALL(luaL_addlstring, B, s, l); -} -SYMBOL_WRAP_DECL(void, luaL_addstring, luaL_Buffer *B, const char *s){ - SYMBOL_WRAP_CALL(luaL_addstring, B, s); -} -SYMBOL_WRAP_DECL(void, luaL_addvalue, luaL_Buffer *B){ - SYMBOL_WRAP_CALL(luaL_addvalue, B); -} -SYMBOL_WRAP_DECL(void, luaL_pushresult, luaL_Buffer *B){ - SYMBOL_WRAP_CALL(luaL_pushresult, B); -} -SYMBOL_WRAP_DECL(void, luaL_pushresultsize, luaL_Buffer *B, size_t sz){ - SYMBOL_WRAP_CALL(luaL_pushresultsize, B, sz); -} -SYMBOL_WRAP_DECL(char *, luaL_buffinitsize, lua_State *L, luaL_Buffer *B, size_t sz){ - SYMBOL_WRAP_CALL(luaL_buffinitsize, L, B, sz); -} -SYMBOL_WRAP_DECL(void, luaL_openlibs, lua_State *L){ - SYMBOL_WRAP_CALL(luaL_openlibs, L); -} - -#define IMPORT_SYMBOL(name, ret, ...) \ - __##name = (\ - __##name = (ret (*) (__VA_ARGS__)) symbol(#name), \ - __##name == NULL ? &__lite_xl_fallback_##name : __##name\ - ) - -#define IMPORT_SYMBOL_OPT(name, ret, ...) \ - __##name = symbol(#name) - -static void lite_xl_plugin_init(void *XL) { - void* (*symbol)(const char *) = (void* (*) (const char *)) XL; - IMPORT_SYMBOL(lua_newstate, lua_State *, lua_Alloc f, void *ud); - IMPORT_SYMBOL(lua_close, void , lua_State *L); - IMPORT_SYMBOL(lua_newthread, lua_State *, lua_State *L); - IMPORT_SYMBOL(lua_atpanic, lua_CFunction , lua_State *L, lua_CFunction panicf); - IMPORT_SYMBOL(lua_version, const lua_Number *, lua_State *L); - IMPORT_SYMBOL(lua_absindex, int , lua_State *L, int idx); - IMPORT_SYMBOL(lua_gettop, int , lua_State *L); - IMPORT_SYMBOL(lua_settop, void , lua_State *L, int idx); - IMPORT_SYMBOL(lua_pushvalue, void , lua_State *L, int idx); - IMPORT_SYMBOL(lua_copy, void , lua_State *L, int fromidx, int toidx); - IMPORT_SYMBOL(lua_checkstack, int , lua_State *L, int sz); - IMPORT_SYMBOL(lua_xmove, void , lua_State *from, lua_State *to, int n); - IMPORT_SYMBOL(lua_isnumber, int , lua_State *L, int idx); - IMPORT_SYMBOL(lua_isstring, int , lua_State *L, int idx); - IMPORT_SYMBOL(lua_iscfunction, int , lua_State *L, int idx); - IMPORT_SYMBOL(lua_isuserdata, int , lua_State *L, int idx); - IMPORT_SYMBOL(lua_type, int , lua_State *L, int idx); - IMPORT_SYMBOL(lua_typename, const char *, lua_State *L, int tp); - IMPORT_SYMBOL(lua_tonumberx, lua_Number , lua_State *L, int idx, int *isnum); - IMPORT_SYMBOL(lua_tointegerx, lua_Integer , lua_State *L, int idx, int *isnum); - IMPORT_SYMBOL(lua_tounsignedx, lua_Unsigned , lua_State *L, int idx, int *isnum); - IMPORT_SYMBOL(lua_toboolean, int , lua_State *L, int idx); - IMPORT_SYMBOL(lua_tolstring, const char *, lua_State *L, int idx, size_t *len); - IMPORT_SYMBOL(lua_rawlen, size_t , lua_State *L, int idx); - IMPORT_SYMBOL(lua_tocfunction, lua_CFunction , lua_State *L, int idx); - IMPORT_SYMBOL(lua_touserdata, void *, lua_State *L, int idx); - IMPORT_SYMBOL(lua_tothread, lua_State *, lua_State *L, int idx); - IMPORT_SYMBOL(lua_topointer, const void *, lua_State *L, int idx); - IMPORT_SYMBOL(lua_arith, void , lua_State *L, int op); - IMPORT_SYMBOL(lua_rawequal, int , lua_State *L, int idx1, int idx2); - IMPORT_SYMBOL(lua_compare, int , lua_State *L, int idx1, int idx2, int op); - IMPORT_SYMBOL(lua_pushnil, void , lua_State *L); - IMPORT_SYMBOL(lua_pushnumber, void , lua_State *L, lua_Number n); - IMPORT_SYMBOL(lua_pushinteger, void , lua_State *L, lua_Integer n); - IMPORT_SYMBOL(lua_pushunsigned, void , lua_State *L, lua_Unsigned n); - IMPORT_SYMBOL(lua_pushlstring, const char *, lua_State *L, const char *s, size_t l); - IMPORT_SYMBOL(lua_pushstring, const char *, lua_State *L, const char *s); - IMPORT_SYMBOL(lua_pushvfstring, const char *, lua_State *L, const char *fmt, va_list argp); - IMPORT_SYMBOL(lua_pushfstring, const char *, lua_State *L, const char *fmt, ...); - IMPORT_SYMBOL(lua_pushcclosure, void , lua_State *L, lua_CFunction fn, int n); - IMPORT_SYMBOL(lua_pushboolean, void , lua_State *L, int b); - IMPORT_SYMBOL(lua_pushlightuserdata, void , lua_State *L, void *p); - IMPORT_SYMBOL(lua_pushthread, int , lua_State *L); - IMPORT_SYMBOL(lua_getglobal, void , lua_State *L, const char *var); - IMPORT_SYMBOL(lua_gettable, void , lua_State *L, int idx); - IMPORT_SYMBOL(lua_getfield, void , lua_State *L, int idx, const char *k); - IMPORT_SYMBOL(lua_rawget, void , lua_State *L, int idx); - IMPORT_SYMBOL(lua_rawgeti, void , lua_State *L, int idx, int n); - IMPORT_SYMBOL(lua_rawgetp, void , lua_State *L, int idx, const void *p); - IMPORT_SYMBOL(lua_createtable, void , lua_State *L, int narr, int nrec); - IMPORT_SYMBOL_OPT(lua_newuserdata, void *, lua_State *L, size_t sz); - IMPORT_SYMBOL(lua_newuserdatauv, void *, lua_State *L, size_t sz, int nuvalue); - IMPORT_SYMBOL(lua_getmetatable, int , lua_State *L, int objindex); - IMPORT_SYMBOL_OPT(lua_getuservalue, void , lua_State *L, int idx); - IMPORT_SYMBOL(lua_getiuservalue, void , lua_State *L, int idx, int n); - IMPORT_SYMBOL(lua_setglobal, void , lua_State *L, const char *var); - IMPORT_SYMBOL(lua_settable, void , lua_State *L, int idx); - IMPORT_SYMBOL(lua_setfield, void , lua_State *L, int idx, const char *k); - IMPORT_SYMBOL(lua_rawset, void , lua_State *L, int idx); - IMPORT_SYMBOL(lua_rawseti, void , lua_State *L, int idx, int n); - IMPORT_SYMBOL(lua_rawsetp, void , lua_State *L, int idx, const void *p); - IMPORT_SYMBOL(lua_setmetatable, int , lua_State *L, int objindex); - IMPORT_SYMBOL_OPT(lua_setuservalue, void , lua_State *L, int idx); - IMPORT_SYMBOL(lua_setiuservalue, void , lua_State *L, int idx, int n); - IMPORT_SYMBOL(lua_callk, void , lua_State *L, int nargs, int nresults, lua_KContext ctx, lua_KFunction k); - IMPORT_SYMBOL(lua_getctx, int , lua_State *L, int *ctx); - IMPORT_SYMBOL(lua_pcallk, int , lua_State *L, int nargs, int nresults, int errfunc, lua_KContext ctx, lua_KFunction k); - IMPORT_SYMBOL(lua_load, int , lua_State *L, lua_Reader reader, void *dt, const char *chunkname, const char *mode); - IMPORT_SYMBOL(lua_dump, int , lua_State *L, lua_Writer writer, void *data, int strip); - IMPORT_SYMBOL(lua_yieldk, int , lua_State *L, int nresults, lua_KContext ctx, lua_KFunction k); - IMPORT_SYMBOL(lua_resume, int , lua_State *L, lua_State *from, int narg); - IMPORT_SYMBOL(lua_status, int , lua_State *L); - IMPORT_SYMBOL(lua_gc, int , lua_State *L, int what, int data); - IMPORT_SYMBOL(lua_error, int , lua_State *L); - IMPORT_SYMBOL(lua_next, int , lua_State *L, int idx); - IMPORT_SYMBOL(lua_concat, void , lua_State *L, int n); - IMPORT_SYMBOL(lua_len, void , lua_State *L, int idx); - IMPORT_SYMBOL(lua_getallocf, lua_Alloc , lua_State *L, void **ud); - IMPORT_SYMBOL(lua_setallocf, void , lua_State *L, lua_Alloc f, void *ud); - IMPORT_SYMBOL(lua_getstack, int , lua_State *L, int level, lua_Debug *ar); - IMPORT_SYMBOL(lua_getinfo, int , lua_State *L, const char *what, lua_Debug *ar); - IMPORT_SYMBOL(lua_getlocal, const char *, lua_State *L, const lua_Debug *ar, int n); - IMPORT_SYMBOL(lua_setlocal, const char *, lua_State *L, const lua_Debug *ar, int n); - IMPORT_SYMBOL(lua_getupvalue, const char *, lua_State *L, int funcindex, int n); - IMPORT_SYMBOL(lua_setupvalue, const char *, lua_State *L, int funcindex, int n); - IMPORT_SYMBOL(lua_upvalueid, void *, lua_State *L, int fidx, int n); - IMPORT_SYMBOL(lua_upvaluejoin, void , lua_State *L, int fidx1, int n1, int fidx2, int n2); - IMPORT_SYMBOL(lua_sethook, int , lua_State *L, lua_Hook func, int mask, int count); - IMPORT_SYMBOL(lua_gethook, lua_Hook , lua_State *L); - IMPORT_SYMBOL(lua_gethookmask, int , lua_State *L); - IMPORT_SYMBOL(lua_gethookcount, int , lua_State *L); - IMPORT_SYMBOL(luaL_checkversion_, void , lua_State *L, lua_Number ver); - IMPORT_SYMBOL(luaL_getmetafield, int , lua_State *L, int obj, const char *e); - IMPORT_SYMBOL(luaL_callmeta, int , lua_State *L, int obj, const char *e); - IMPORT_SYMBOL(luaL_tolstring, const char *, lua_State *L, int idx, size_t *len); - IMPORT_SYMBOL(luaL_argerror, int , lua_State *L, int numarg, const char *extramsg); - IMPORT_SYMBOL(luaL_checklstring, const char *, lua_State *L, int numArg, size_t *l); - IMPORT_SYMBOL(luaL_optlstring, const char *, lua_State *L, int numArg, const char *def, size_t *l); - IMPORT_SYMBOL(luaL_checknumber, lua_Number , lua_State *L, int numArg); - IMPORT_SYMBOL(luaL_optnumber, lua_Number , lua_State *L, int nArg, lua_Number def); - IMPORT_SYMBOL(luaL_checkinteger, lua_Integer , lua_State *L, int numArg); - IMPORT_SYMBOL(luaL_optinteger, lua_Integer , lua_State *L, int nArg, lua_Integer def); - IMPORT_SYMBOL(luaL_checkunsigned, lua_Unsigned , lua_State *L, int numArg); - IMPORT_SYMBOL(luaL_optunsigned, lua_Unsigned , lua_State *L, int numArg, lua_Unsigned def); - IMPORT_SYMBOL(luaL_checkstack, void , lua_State *L, int sz, const char *msg); - IMPORT_SYMBOL(luaL_checktype, void , lua_State *L, int narg, int t); - IMPORT_SYMBOL(luaL_checkany, void , lua_State *L, int narg); - IMPORT_SYMBOL(luaL_newmetatable, int , lua_State *L, const char *tname); - IMPORT_SYMBOL(luaL_setmetatable, void , lua_State *L, const char *tname); - IMPORT_SYMBOL(luaL_testudata, void *, lua_State *L, int ud, const char *tname); - IMPORT_SYMBOL(luaL_checkudata, void *, lua_State *L, int ud, const char *tname); - IMPORT_SYMBOL(luaL_where, void , lua_State *L, int lvl); - IMPORT_SYMBOL(luaL_error, int , lua_State *L, const char *fmt, ...); - IMPORT_SYMBOL(luaL_checkoption, int , lua_State *L, int narg, const char *def, const char *const lst[]); - IMPORT_SYMBOL(luaL_fileresult, int , lua_State *L, int stat, const char *fname); - IMPORT_SYMBOL(luaL_execresult, int , lua_State *L, int stat); - IMPORT_SYMBOL(luaL_ref, int , lua_State *L, int t); - IMPORT_SYMBOL(luaL_unref, void , lua_State *L, int t, int ref); - IMPORT_SYMBOL(luaL_loadfilex, int , lua_State *L, const char *filename, const char *mode); - IMPORT_SYMBOL(luaL_loadbufferx, int , lua_State *L, const char *buff, size_t sz, const char *name, const char *mode); - IMPORT_SYMBOL(luaL_loadstring, int , lua_State *L, const char *s); - IMPORT_SYMBOL(luaL_newstate, lua_State *, void); - IMPORT_SYMBOL(luaL_len, int , lua_State *L, int idx); - IMPORT_SYMBOL(luaL_gsub, const char *, lua_State *L, const char *s, const char *p, const char *r); - IMPORT_SYMBOL(luaL_setfuncs, void , lua_State *L, const luaL_Reg *l, int nup); - IMPORT_SYMBOL(luaL_getsubtable, int , lua_State *L, int idx, const char *fname); - IMPORT_SYMBOL(luaL_traceback, void , lua_State *L, lua_State *L1, const char *msg, int level); - IMPORT_SYMBOL(luaL_requiref, void , lua_State *L, const char *modname, lua_CFunction openf, int glb); - IMPORT_SYMBOL(luaL_buffinit, void , lua_State *L, luaL_Buffer *B); - IMPORT_SYMBOL(luaL_prepbuffsize, char *, luaL_Buffer *B, size_t sz); - IMPORT_SYMBOL(luaL_addlstring, void , luaL_Buffer *B, const char *s, size_t l); - IMPORT_SYMBOL(luaL_addstring, void , luaL_Buffer *B, const char *s); - IMPORT_SYMBOL(luaL_addvalue, void , luaL_Buffer *B); - IMPORT_SYMBOL(luaL_pushresult, void , luaL_Buffer *B); - IMPORT_SYMBOL(luaL_pushresultsize, void , luaL_Buffer *B, size_t sz); - IMPORT_SYMBOL(luaL_buffinitsize, char *, lua_State *L, luaL_Buffer *B, size_t sz); - IMPORT_SYMBOL(luaL_openlibs, void, lua_State* L); -} - -#endif /* LITE_XL_PLUGIN_ENTRYPOINT */ - -#endif /* LITE_XL_PLUGIN_API */