/** * 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.6. * DO NOT MODIFY ANYTHING. MODIFYING STUFFS IN HERE WILL BREAK * COMPATIBILITY WITH LITE XL AND CAUSE UNDEBUGGABLE BUGS. * * For reference, here are a list of permalinks to previous version of this file that targets an older version of Lua. * If you don't need functionalities offered by the new version, use the OLDEST FILE for backwards compatibility. * * - Lua 5.4.4: https://github.com/lite-xl/lite-xl/blob/397973067f14420b26e3b20a238a50016c0b75e2/resources/include/lite_xl_plugin_api.h **/ #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_closethread, lua_State *L, lua_State *from) 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_closethread, lua_State *L, lua_State *from) { return SYMBOL_WRAP_CALL(lua_closethread, L, from); } 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_closethread, int, lua_State *L, lua_State *from); 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. ******************************************************************************/