/*@@ LUAI_BITSINT defines the number of bits in an int.** CHANGE here if Lua cannot automatically detect the number of bits of** your machine. Probably you do not need to change this.*//* avoid overflows in comparison */#if INT_MAX-20 < 32760#define LUAI_BITSINT	16#elif INT_MAX > 2147483640L/* int has at least 32 bits */#define LUAI_BITSINT	32#else#error "you must define LUA_BITSINT with number of bits in an integer"#endif/*@@ LUAI_UINT32 is an unsigned integer with at least 32 bits.@@ LUAI_INT32 is an signed integer with at least 32 bits.@@ LUAI_UMEM is an unsigned integer big enough to count the total@* memory used by Lua.@@ LUAI_MEM is a signed integer big enough to count the total memory@* used by Lua.** CHANGE here if for some weird reason the default definitions are not** good enough for your machine. (The definitions in the 'else'** part always works, but may waste space on machines with 64-bit** longs.) Probably you do not need to change this.*/#if LUAI_BITSINT >= 32#define LUAI_UINT32	unsigned int#define LUAI_INT32	int#define LUAI_MAXINT32	INT_MAX#define LUAI_UMEM	size_t#define LUAI_MEM	ptrdiff_t#else/* 16-bit ints */#define LUAI_UINT32	unsigned long#define LUAI_INT32	long#define LUAI_MAXINT32	LONG_MAX#define LUAI_UMEM	unsigned long#define LUAI_MEM	long#endif/*@@ LUAI_MAXCALLS limits the number of nested calls.** CHANGE it if you need really deep recursive calls. This limit is** arbitrary; its only purpose is to stop infinite recursion before** exhausting memory.*/#define LUAI_MAXCALLS	20000/*@@ LUAI_MAXCSTACK limits the number of Lua stack slots that a C function@* can use.** CHANGE it if you need lots of (Lua) stack space for your C** functions. This limit is arbitrary; its only purpose is to stop C** functions to consume unlimited stack space.*/#define LUAI_MAXCSTACK	2048/*** {==================================================================** CHANGE (to smaller values) the following definitions if your system** has a small C stack. (Or you may want to change them to larger** values if your system has a large C stack and these limits are** too rigid for you.) Some of these constants control the size of** stack-allocated arrays used by the compiler or the interpreter, while** others limit the maximum number of recursive calls that the compiler** or the interpreter can perform. Values too large may cause a C stack** overflow for some forms of deep constructs.** ===================================================================*//*@@ LUAI_MAXCCALLS is the maximum depth for nested C calls (short) and@* syntactical nested non-terminals in a program.*/#define LUAI_MAXCCALLS		200/*@@ LUAI_MAXVARS is the maximum number of local variables per function@* (must be smaller than 250).*/#define LUAI_MAXVARS		200/*@@ LUAI_MAXUPVALUES is the maximum number of upvalues per function@* (must be smaller than 250).*/#define LUAI_MAXUPVALUES	60/*@@ LUAL_BUFFERSIZE is the buffer size used by the lauxlib buffer system.*/#define LUAL_BUFFERSIZE		BUFSIZ/* }================================================================== *//*** {==================================================================@@ LUA_NUMBER is the type of numbers in Lua.** CHANGE the following definitions only if you want to build Lua** with a number type different from double. You may also need to** change lua_number2int & lua_number2integer.** ===================================================================*/#define LUA_NUMBER_DOUBLE#define LUA_NUMBER	double/*@@ LUAI_UACNUMBER is the result of an 'usual argument conversion'@* over a number.*/#define LUAI_UACNUMBER	double/*@@ LUA_NUMBER_SCAN is the format for reading numbers.@@ LUA_NUMBER_FMT is the format for writing numbers.@@ lua_number2str converts a number to a string.@@ LUAI_MAXNUMBER2STR is maximum size of previous conversion.@@ lua_str2number converts a string to a number.*/#define LUA_NUMBER_SCAN		"%lf"#define LUA_NUMBER_FMT		"%.14g"#define lua_number2str(s,n)	sprintf((s), LUA_NUMBER_FMT, (n))#define LUAI_MAXNUMBER2STR	32 /* 16 digits, sign, point, and \0 */#define lua_str2number(s,p)	strtod((s), (p))/*@@ The luai_num* macros define the primitive operations over numbers.*/#if defined(LUA_CORE)#include <math.h>#define luai_numadd(a,b)	((a)+(b))#define luai_numsub(a,b)	((a)-(b))#define luai_nummul(a,b)	((a)*(b))#define luai_numdiv(a,b)	((a)/(b))#define luai_nummod(a,b)	((a) - floor((a)/(b))*(b))#define luai_numpow(a,b)	(pow(a,b))#define luai_numunm(a)		(-(a))#define luai_numeq(a,b)		((a)==(b))#define luai_numlt(a,b)		((a)<(b))#define luai_numle(a,b)		((a)<=(b))#define luai_numisnan(a)	(!luai_numeq((a), (a)))#endif/*@@ lua_number2int is a macro to convert lua_Number to int.@@ lua_number2integer is a macro to convert lua_Number to lua_Integer.** CHANGE them if you know a faster way to convert a lua_Number to** int (with any rounding method and without throwing errors) in your** system. In Pentium machines, a naive typecast from double to int** in C is extremely slow, so any alternative is worth trying.*//* On a Pentium, resort to a trick */#if defined(LUA_NUMBER_DOUBLE) && !defined(LUA_ANSI) && !defined(__SSE2__) && \    (defined(__i386) || defined (_M_IX86) || defined(__i386__))/* On a Microsoft compiler, use assembler */#if defined(_MSC_VER)#define lua_number2int(i,d)   __asm fld d   __asm fistp i#define lua_number2integer(i,n)		lua_number2int(i, n)/* the next trick should work on any Pentium, but sometimes clashes   with a DirectX idiosyncrasy */#elseunion luai_Cast { double l_d; long l_l; };#define lua_number2int(i,d) \  { volatile union luai_Cast u; u.l_d = (d) + 6755399441055744.0; (i) = u.l_l; }#define lua_number2integer(i,n)		lua_number2int(i, n)#endif/* this option always works, but may be slow */#else#define lua_number2int(i,d)	((i)=(int)(d))#define lua_number2integer(i,d)	((i)=(lua_Integer)(d))#endif/* }================================================================== *//*@@ LUAI_USER_ALIGNMENT_T is a type that requires maximum alignment.** CHANGE it if your system requires alignments larger than double. (For** instance, if your system supports long doubles and they must be** aligned in 16-byte boundaries, then you should add long double in the** union.) Probably you do not need to change this.*/#define LUAI_USER_ALIGNMENT_T	union { double u; void *s; long l; }/*@@ LUAI_THROW/LUAI_TRY define how Lua does exception handling.** CHANGE them if you prefer to use longjmp/setjmp even with C++** or if want/don't to use _longjmp/_setjmp instead of regular** longjmp/setjmp. By default, Lua handles errors with exceptions when** compiling as C++ code, with _longjmp/_setjmp when asked to use them,** and with longjmp/setjmp otherwise.*/#if defined(__cplusplus)/* C++ exceptions */#define LUAI_THROW(L,c)	throw(c)#define LUAI_TRY(L,c,a)	try { a } catch(...) \	{ if ((c)->status == 0) (c)->status = -1; }#define luai_jmpbuf	int  /* dummy variable */#elif defined(LUA_USE_ULONGJMP)/* in Unix, try _longjmp/_setjmp (more efficient) */#define LUAI_THROW(L,c)	_longjmp((c)->b, 1)#define LUAI_TRY(L,c,a)	if (_setjmp((c)->b) == 0) { a }#define luai_jmpbuf	jmp_buf#else/* default handling with long jumps */#define LUAI_THROW(L,c)	longjmp((c)->b, 1)#define LUAI_TRY(L,c,a)	if (setjmp((c)->b) == 0) { a }#define luai_jmpbuf	jmp_buf#endif/*@@ LUA_MAXCAPTURES is the maximum number of captures that a pattern@* can do during pattern-matching.** CHANGE it if you need more captures. This limit is arbitrary.*/#define LUA_MAXCAPTURES		32/*@@ lua_tmpnam is the function that the OS library uses to create a@* temporary name.@@ LUA_TMPNAMBUFSIZE is the maximum size of a name created by lua_tmpnam.** CHANGE them if you have an alternative to tmpnam (which is considered** insecure) or if you want the original tmpnam anyway.  By default, Lua** uses tmpnam except when POSIX is available, where it uses mkstemp.*/#if defined(loslib_c) || defined(luaall_c)#if defined(LUA_USE_MKSTEMP)#include <unistd.h>#define LUA_TMPNAMBUFSIZE	32#define lua_tmpnam(b,e)	{ \	strcpy(b, "/tmp/lua_XXXXXX"); \	e = mkstemp(b); \	if (e != -1) close(e); \	e = (e == -1); }#else#define LUA_TMPNAMBUFSIZE	L_tmpnam#define lua_tmpnam(b,e)		{ e = (tmpnam(b) == NULL); }#endif#endif/*@@ lua_popen spawns a new process connected to the current one through@* the file streams.** CHANGE it if you have a way to implement it in your system.*/#if defined(LUA_USE_POPEN)#define lua_popen(L,c,m)	((void)L, popen(c,m))#define lua_pclose(L,file)	((void)L, (pclose(file) != -1))#elif defined(LUA_WIN)#define lua_popen(L,c,m)	((void)L, _popen(c,m))#define lua_pclose(L,file)	((void)L, (_pclose(file) != -1))#else#define lua_popen(L,c,m)	((void)((void)c, m),  \		luaL_error(L, LUA_QL("popen") " not supported"), (FILE*)0)#define lua_pclose(L,file)		((void)((void)L, file), 0)#endif/*@@ LUA_DL_* define which dynamic-library system Lua should use.** CHANGE here if Lua has problems choosing the appropriate** dynamic-library system for your platform (either Windows' DLL, Mac's** dyld, or Unix's dlopen). If your system is some kind of Unix, there** is a good chance that it has dlopen, so LUA_DL_DLOPEN will work for** it.  To use dlopen you also need to adapt the src/Makefile (probably** adding -ldl to the linker options), so Lua does not select it** automatically.  (When you change the makefile to add -ldl, you must** also add -DLUA_USE_DLOPEN.)** If you do not want any kind of dynamic library, undefine all these** options.** By default, _WIN32 gets LUA_DL_DLL and MAC OS X gets LUA_DL_DYLD.*/#if defined(LUA_USE_DLOPEN)#define LUA_DL_DLOPEN#endif#if defined(LUA_WIN)#define LUA_DL_DLL#endif/*@@ LUAI_EXTRASPACE allows you to add user-specific data in a lua_State@* (the data goes just *before* the lua_State pointer).** CHANGE (define) this if you really need that. This value must be** a multiple of the maximum alignment required for your machine.*/#define LUAI_EXTRASPACE		0/*@@ luai_userstate* allow user-specific actions on threads.** CHANGE them if you defined LUAI_EXTRASPACE and need to do something** extra when a thread is created/deleted/resumed/yielded.*/#define luai_userstateopen(L)		((void)L)#define luai_userstateclose(L)		((void)L)#define luai_userstatethread(L,L1)	((void)L)#define luai_userstatefree(L)		((void)L)#define luai_userstateresume(L,n)	((void)L)#define luai_userstateyield(L,n)	((void)L)/*@@ LUA_INTFRMLEN is the length modifier for integer conversions@* in 'string.format'.@@ LUA_INTFRM_T is the integer type correspoding to the previous length@* modifier.** CHANGE them if your system supports long long or does not support long.*/#if defined(LUA_USELONGLONG)#define LUA_INTFRMLEN		"ll"#define LUA_INTFRM_T		long long#else#define LUA_INTFRMLEN		"l"#define LUA_INTFRM_T		long#endif/* =================================================================== *//*** Local configuration. You can use this space to add your redefinitions** without modifying the main part of the file.*/#endif