mudgangster

Tiny, scriptable MUD client
Log | Files | Refs | README

luaconf.h (21644B)


      1 /*
      2 ** $Id: luaconf.h,v 1.259.1.1 2017/04/19 17:29:57 roberto Exp $
      3 ** Configuration file for Lua
      4 ** See Copyright Notice in lua.h
      5 */
      6 
      7 
      8 #ifndef luaconf_h
      9 #define luaconf_h
     10 
     11 #include <limits.h>
     12 #include <stddef.h>
     13 
     14 
     15 /*
     16 ** ===================================================================
     17 ** Search for "@@" to find all configurable definitions.
     18 ** ===================================================================
     19 */
     20 
     21 
     22 /*
     23 ** {====================================================================
     24 ** System Configuration: macros to adapt (if needed) Lua to some
     25 ** particular platform, for instance compiling it with 32-bit numbers or
     26 ** restricting it to C89.
     27 ** =====================================================================
     28 */
     29 
     30 /*
     31 @@ LUA_32BITS enables Lua with 32-bit integers and 32-bit floats. You
     32 ** can also define LUA_32BITS in the make file, but changing here you
     33 ** ensure that all software connected to Lua will be compiled with the
     34 ** same configuration.
     35 */
     36 /* #define LUA_32BITS */
     37 
     38 
     39 /*
     40 @@ LUA_USE_C89 controls the use of non-ISO-C89 features.
     41 ** Define it if you want Lua to avoid the use of a few C99 features
     42 ** or Windows-specific features on Windows.
     43 */
     44 /* #define LUA_USE_C89 */
     45 
     46 
     47 /*
     48 ** By default, Lua on Windows use (some) specific Windows features
     49 */
     50 #if !defined(LUA_USE_C89) && defined(_WIN32) && !defined(_WIN32_WCE)
     51 #define LUA_USE_WINDOWS  /* enable goodies for regular Windows */
     52 #endif
     53 
     54 
     55 #if defined(LUA_USE_WINDOWS)
     56 #define LUA_DL_DLL	/* enable support for DLL */
     57 #define LUA_USE_C89	/* broadly, Windows is C89 */
     58 #endif
     59 
     60 
     61 #if defined(LUA_USE_LINUX)
     62 #define LUA_USE_POSIX
     63 #define LUA_USE_DLOPEN		/* needs an extra library: -ldl */
     64 #define LUA_USE_READLINE	/* needs some extra libraries */
     65 #endif
     66 
     67 
     68 #if defined(LUA_USE_MACOSX)
     69 #define LUA_USE_POSIX
     70 #define LUA_USE_DLOPEN		/* MacOS does not need -ldl */
     71 #define LUA_USE_READLINE	/* needs an extra library: -lreadline */
     72 #endif
     73 
     74 
     75 /*
     76 @@ LUA_C89_NUMBERS ensures that Lua uses the largest types available for
     77 ** C89 ('long' and 'double'); Windows always has '__int64', so it does
     78 ** not need to use this case.
     79 */
     80 #if defined(LUA_USE_C89) && !defined(LUA_USE_WINDOWS)
     81 #define LUA_C89_NUMBERS
     82 #endif
     83 
     84 
     85 
     86 /*
     87 @@ LUAI_BITSINT defines the (minimum) number of bits in an 'int'.
     88 */
     89 /* avoid undefined shifts */
     90 #if ((INT_MAX >> 15) >> 15) >= 1
     91 #define LUAI_BITSINT	32
     92 #else
     93 /* 'int' always must have at least 16 bits */
     94 #define LUAI_BITSINT	16
     95 #endif
     96 
     97 
     98 /*
     99 @@ LUA_INT_TYPE defines the type for Lua integers.
    100 @@ LUA_FLOAT_TYPE defines the type for Lua floats.
    101 ** Lua should work fine with any mix of these options (if supported
    102 ** by your C compiler). The usual configurations are 64-bit integers
    103 ** and 'double' (the default), 32-bit integers and 'float' (for
    104 ** restricted platforms), and 'long'/'double' (for C compilers not
    105 ** compliant with C99, which may not have support for 'long long').
    106 */
    107 
    108 /* predefined options for LUA_INT_TYPE */
    109 #define LUA_INT_INT		1
    110 #define LUA_INT_LONG		2
    111 #define LUA_INT_LONGLONG	3
    112 
    113 /* predefined options for LUA_FLOAT_TYPE */
    114 #define LUA_FLOAT_FLOAT		1
    115 #define LUA_FLOAT_DOUBLE	2
    116 #define LUA_FLOAT_LONGDOUBLE	3
    117 
    118 #if defined(LUA_32BITS)		/* { */
    119 /*
    120 ** 32-bit integers and 'float'
    121 */
    122 #if LUAI_BITSINT >= 32  /* use 'int' if big enough */
    123 #define LUA_INT_TYPE	LUA_INT_INT
    124 #else  /* otherwise use 'long' */
    125 #define LUA_INT_TYPE	LUA_INT_LONG
    126 #endif
    127 #define LUA_FLOAT_TYPE	LUA_FLOAT_FLOAT
    128 
    129 #elif defined(LUA_C89_NUMBERS)	/* }{ */
    130 /*
    131 ** largest types available for C89 ('long' and 'double')
    132 */
    133 #define LUA_INT_TYPE	LUA_INT_LONG
    134 #define LUA_FLOAT_TYPE	LUA_FLOAT_DOUBLE
    135 
    136 #endif				/* } */
    137 
    138 
    139 /*
    140 ** default configuration for 64-bit Lua ('long long' and 'double')
    141 */
    142 #if !defined(LUA_INT_TYPE)
    143 #define LUA_INT_TYPE	LUA_INT_LONGLONG
    144 #endif
    145 
    146 #if !defined(LUA_FLOAT_TYPE)
    147 #define LUA_FLOAT_TYPE	LUA_FLOAT_DOUBLE
    148 #endif
    149 
    150 /* }================================================================== */
    151 
    152 
    153 
    154 
    155 /*
    156 ** {==================================================================
    157 ** Configuration for Paths.
    158 ** ===================================================================
    159 */
    160 
    161 /*
    162 ** LUA_PATH_SEP is the character that separates templates in a path.
    163 ** LUA_PATH_MARK is the string that marks the substitution points in a
    164 ** template.
    165 ** LUA_EXEC_DIR in a Windows path is replaced by the executable's
    166 ** directory.
    167 */
    168 #define LUA_PATH_SEP            ";"
    169 #define LUA_PATH_MARK           "?"
    170 #define LUA_EXEC_DIR            "!"
    171 
    172 
    173 /*
    174 @@ LUA_PATH_DEFAULT is the default path that Lua uses to look for
    175 ** Lua libraries.
    176 @@ LUA_CPATH_DEFAULT is the default path that Lua uses to look for
    177 ** C libraries.
    178 ** CHANGE them if your machine has a non-conventional directory
    179 ** hierarchy or if you want to install your libraries in
    180 ** non-conventional directories.
    181 */
    182 #define LUA_VDIR	LUA_VERSION_MAJOR "." LUA_VERSION_MINOR
    183 #if defined(_WIN32)	/* { */
    184 /*
    185 ** In Windows, any exclamation mark ('!') in the path is replaced by the
    186 ** path of the directory of the executable file of the current process.
    187 */
    188 #define LUA_LDIR	"!\\lua\\"
    189 #define LUA_CDIR	"!\\"
    190 #define LUA_SHRDIR	"!\\..\\share\\lua\\" LUA_VDIR "\\"
    191 #define LUA_PATH_DEFAULT  \
    192 		LUA_LDIR"?.lua;"  LUA_LDIR"?\\init.lua;" \
    193 		LUA_CDIR"?.lua;"  LUA_CDIR"?\\init.lua;" \
    194 		LUA_SHRDIR"?.lua;" LUA_SHRDIR"?\\init.lua;" \
    195 		".\\?.lua;" ".\\?\\init.lua"
    196 #define LUA_CPATH_DEFAULT \
    197 		LUA_CDIR"?.dll;" \
    198 		LUA_CDIR"..\\lib\\lua\\" LUA_VDIR "\\?.dll;" \
    199 		LUA_CDIR"loadall.dll;" ".\\?.dll"
    200 
    201 #else			/* }{ */
    202 
    203 #define LUA_ROOT	"/usr/local/"
    204 #define LUA_LDIR	LUA_ROOT "share/lua/" LUA_VDIR "/"
    205 #define LUA_CDIR	LUA_ROOT "lib/lua/" LUA_VDIR "/"
    206 #define LUA_PATH_DEFAULT  \
    207 		LUA_LDIR"?.lua;"  LUA_LDIR"?/init.lua;" \
    208 		LUA_CDIR"?.lua;"  LUA_CDIR"?/init.lua;" \
    209 		"./?.lua;" "./?/init.lua"
    210 #define LUA_CPATH_DEFAULT \
    211 		LUA_CDIR"?.so;" LUA_CDIR"loadall.so;" "./?.so"
    212 #endif			/* } */
    213 
    214 
    215 /*
    216 @@ LUA_DIRSEP is the directory separator (for submodules).
    217 ** CHANGE it if your machine does not use "/" as the directory separator
    218 ** and is not Windows. (On Windows Lua automatically uses "\".)
    219 */
    220 #if defined(_WIN32)
    221 #define LUA_DIRSEP	"\\"
    222 #else
    223 #define LUA_DIRSEP	"/"
    224 #endif
    225 
    226 /* }================================================================== */
    227 
    228 
    229 /*
    230 ** {==================================================================
    231 ** Marks for exported symbols in the C code
    232 ** ===================================================================
    233 */
    234 
    235 /*
    236 @@ LUA_API is a mark for all core API functions.
    237 @@ LUALIB_API is a mark for all auxiliary library functions.
    238 @@ LUAMOD_API is a mark for all standard library opening functions.
    239 ** CHANGE them if you need to define those functions in some special way.
    240 ** For instance, if you want to create one Windows DLL with the core and
    241 ** the libraries, you may want to use the following definition (define
    242 ** LUA_BUILD_AS_DLL to get it).
    243 */
    244 #if defined(LUA_BUILD_AS_DLL)	/* { */
    245 
    246 #if defined(LUA_CORE) || defined(LUA_LIB)	/* { */
    247 #define LUA_API __declspec(dllexport)
    248 #else						/* }{ */
    249 #define LUA_API __declspec(dllimport)
    250 #endif						/* } */
    251 
    252 #else				/* }{ */
    253 
    254 #define LUA_API		extern
    255 
    256 #endif				/* } */
    257 
    258 
    259 /* more often than not the libs go together with the core */
    260 #define LUALIB_API	LUA_API
    261 #define LUAMOD_API	LUALIB_API
    262 
    263 
    264 /*
    265 @@ LUAI_FUNC is a mark for all extern functions that are not to be
    266 ** exported to outside modules.
    267 @@ LUAI_DDEF and LUAI_DDEC are marks for all extern (const) variables
    268 ** that are not to be exported to outside modules (LUAI_DDEF for
    269 ** definitions and LUAI_DDEC for declarations).
    270 ** CHANGE them if you need to mark them in some special way. Elf/gcc
    271 ** (versions 3.2 and later) mark them as "hidden" to optimize access
    272 ** when Lua is compiled as a shared library. Not all elf targets support
    273 ** this attribute. Unfortunately, gcc does not offer a way to check
    274 ** whether the target offers that support, and those without support
    275 ** give a warning about it. To avoid these warnings, change to the
    276 ** default definition.
    277 */
    278 #if defined(__GNUC__) && ((__GNUC__*100 + __GNUC_MINOR__) >= 302) && \
    279     defined(__ELF__)		/* { */
    280 #define LUAI_FUNC	__attribute__((visibility("hidden"))) extern
    281 #else				/* }{ */
    282 #define LUAI_FUNC	extern
    283 #endif				/* } */
    284 
    285 #define LUAI_DDEC	LUAI_FUNC
    286 #define LUAI_DDEF	/* empty */
    287 
    288 /* }================================================================== */
    289 
    290 
    291 /*
    292 ** {==================================================================
    293 ** Compatibility with previous versions
    294 ** ===================================================================
    295 */
    296 
    297 /*
    298 @@ LUA_COMPAT_5_2 controls other macros for compatibility with Lua 5.2.
    299 @@ LUA_COMPAT_5_1 controls other macros for compatibility with Lua 5.1.
    300 ** You can define it to get all options, or change specific options
    301 ** to fit your specific needs.
    302 */
    303 #if defined(LUA_COMPAT_5_2)	/* { */
    304 
    305 /*
    306 @@ LUA_COMPAT_MATHLIB controls the presence of several deprecated
    307 ** functions in the mathematical library.
    308 */
    309 #define LUA_COMPAT_MATHLIB
    310 
    311 /*
    312 @@ LUA_COMPAT_BITLIB controls the presence of library 'bit32'.
    313 */
    314 #define LUA_COMPAT_BITLIB
    315 
    316 /*
    317 @@ LUA_COMPAT_IPAIRS controls the effectiveness of the __ipairs metamethod.
    318 */
    319 #define LUA_COMPAT_IPAIRS
    320 
    321 /*
    322 @@ LUA_COMPAT_APIINTCASTS controls the presence of macros for
    323 ** manipulating other integer types (lua_pushunsigned, lua_tounsigned,
    324 ** luaL_checkint, luaL_checklong, etc.)
    325 */
    326 #define LUA_COMPAT_APIINTCASTS
    327 
    328 #endif				/* } */
    329 
    330 
    331 #if defined(LUA_COMPAT_5_1)	/* { */
    332 
    333 /* Incompatibilities from 5.2 -> 5.3 */
    334 #define LUA_COMPAT_MATHLIB
    335 #define LUA_COMPAT_APIINTCASTS
    336 
    337 /*
    338 @@ LUA_COMPAT_UNPACK controls the presence of global 'unpack'.
    339 ** You can replace it with 'table.unpack'.
    340 */
    341 #define LUA_COMPAT_UNPACK
    342 
    343 /*
    344 @@ LUA_COMPAT_LOADERS controls the presence of table 'package.loaders'.
    345 ** You can replace it with 'package.searchers'.
    346 */
    347 #define LUA_COMPAT_LOADERS
    348 
    349 /*
    350 @@ macro 'lua_cpcall' emulates deprecated function lua_cpcall.
    351 ** You can call your C function directly (with light C functions).
    352 */
    353 #define lua_cpcall(L,f,u)  \
    354 	(lua_pushcfunction(L, (f)), \
    355 	 lua_pushlightuserdata(L,(u)), \
    356 	 lua_pcall(L,1,0,0))
    357 
    358 
    359 /*
    360 @@ LUA_COMPAT_LOG10 defines the function 'log10' in the math library.
    361 ** You can rewrite 'log10(x)' as 'log(x, 10)'.
    362 */
    363 #define LUA_COMPAT_LOG10
    364 
    365 /*
    366 @@ LUA_COMPAT_LOADSTRING defines the function 'loadstring' in the base
    367 ** library. You can rewrite 'loadstring(s)' as 'load(s)'.
    368 */
    369 #define LUA_COMPAT_LOADSTRING
    370 
    371 /*
    372 @@ LUA_COMPAT_MAXN defines the function 'maxn' in the table library.
    373 */
    374 #define LUA_COMPAT_MAXN
    375 
    376 /*
    377 @@ The following macros supply trivial compatibility for some
    378 ** changes in the API. The macros themselves document how to
    379 ** change your code to avoid using them.
    380 */
    381 #define lua_strlen(L,i)		lua_rawlen(L, (i))
    382 
    383 #define lua_objlen(L,i)		lua_rawlen(L, (i))
    384 
    385 #define lua_equal(L,idx1,idx2)		lua_compare(L,(idx1),(idx2),LUA_OPEQ)
    386 #define lua_lessthan(L,idx1,idx2)	lua_compare(L,(idx1),(idx2),LUA_OPLT)
    387 
    388 /*
    389 @@ LUA_COMPAT_MODULE controls compatibility with previous
    390 ** module functions 'module' (Lua) and 'luaL_register' (C).
    391 */
    392 #define LUA_COMPAT_MODULE
    393 
    394 #endif				/* } */
    395 
    396 
    397 /*
    398 @@ LUA_COMPAT_FLOATSTRING makes Lua format integral floats without a
    399 @@ a float mark ('.0').
    400 ** This macro is not on by default even in compatibility mode,
    401 ** because this is not really an incompatibility.
    402 */
    403 /* #define LUA_COMPAT_FLOATSTRING */
    404 
    405 /* }================================================================== */
    406 
    407 
    408 
    409 /*
    410 ** {==================================================================
    411 ** Configuration for Numbers.
    412 ** Change these definitions if no predefined LUA_FLOAT_* / LUA_INT_*
    413 ** satisfy your needs.
    414 ** ===================================================================
    415 */
    416 
    417 /*
    418 @@ LUA_NUMBER is the floating-point type used by Lua.
    419 @@ LUAI_UACNUMBER is the result of a 'default argument promotion'
    420 @@ over a floating number.
    421 @@ l_mathlim(x) corrects limit name 'x' to the proper float type
    422 ** by prefixing it with one of FLT/DBL/LDBL.
    423 @@ LUA_NUMBER_FRMLEN is the length modifier for writing floats.
    424 @@ LUA_NUMBER_FMT is the format for writing floats.
    425 @@ lua_number2str converts a float to a string.
    426 @@ l_mathop allows the addition of an 'l' or 'f' to all math operations.
    427 @@ l_floor takes the floor of a float.
    428 @@ lua_str2number converts a decimal numeric string to a number.
    429 */
    430 
    431 
    432 /* The following definitions are good for most cases here */
    433 
    434 #define l_floor(x)		(l_mathop(floor)(x))
    435 
    436 #define lua_number2str(s,sz,n)  \
    437 	l_sprintf((s), sz, LUA_NUMBER_FMT, (LUAI_UACNUMBER)(n))
    438 
    439 /*
    440 @@ lua_numbertointeger converts a float number to an integer, or
    441 ** returns 0 if float is not within the range of a lua_Integer.
    442 ** (The range comparisons are tricky because of rounding. The tests
    443 ** here assume a two-complement representation, where MININTEGER always
    444 ** has an exact representation as a float; MAXINTEGER may not have one,
    445 ** and therefore its conversion to float may have an ill-defined value.)
    446 */
    447 #define lua_numbertointeger(n,p) \
    448   ((n) >= (LUA_NUMBER)(LUA_MININTEGER) && \
    449    (n) < -(LUA_NUMBER)(LUA_MININTEGER) && \
    450       (*(p) = (LUA_INTEGER)(n), 1))
    451 
    452 
    453 /* now the variable definitions */
    454 
    455 #if LUA_FLOAT_TYPE == LUA_FLOAT_FLOAT		/* { single float */
    456 
    457 #define LUA_NUMBER	float
    458 
    459 #define l_mathlim(n)		(FLT_##n)
    460 
    461 #define LUAI_UACNUMBER	double
    462 
    463 #define LUA_NUMBER_FRMLEN	""
    464 #define LUA_NUMBER_FMT		"%.7g"
    465 
    466 #define l_mathop(op)		op##f
    467 
    468 #define lua_str2number(s,p)	strtof((s), (p))
    469 
    470 
    471 #elif LUA_FLOAT_TYPE == LUA_FLOAT_LONGDOUBLE	/* }{ long double */
    472 
    473 #define LUA_NUMBER	long double
    474 
    475 #define l_mathlim(n)		(LDBL_##n)
    476 
    477 #define LUAI_UACNUMBER	long double
    478 
    479 #define LUA_NUMBER_FRMLEN	"L"
    480 #define LUA_NUMBER_FMT		"%.19Lg"
    481 
    482 #define l_mathop(op)		op##l
    483 
    484 #define lua_str2number(s,p)	strtold((s), (p))
    485 
    486 #elif LUA_FLOAT_TYPE == LUA_FLOAT_DOUBLE	/* }{ double */
    487 
    488 #define LUA_NUMBER	double
    489 
    490 #define l_mathlim(n)		(DBL_##n)
    491 
    492 #define LUAI_UACNUMBER	double
    493 
    494 #define LUA_NUMBER_FRMLEN	""
    495 #define LUA_NUMBER_FMT		"%.14g"
    496 
    497 #define l_mathop(op)		op
    498 
    499 #define lua_str2number(s,p)	strtod((s), (p))
    500 
    501 #else						/* }{ */
    502 
    503 #error "numeric float type not defined"
    504 
    505 #endif					/* } */
    506 
    507 
    508 
    509 /*
    510 @@ LUA_INTEGER is the integer type used by Lua.
    511 **
    512 @@ LUA_UNSIGNED is the unsigned version of LUA_INTEGER.
    513 **
    514 @@ LUAI_UACINT is the result of a 'default argument promotion'
    515 @@ over a lUA_INTEGER.
    516 @@ LUA_INTEGER_FRMLEN is the length modifier for reading/writing integers.
    517 @@ LUA_INTEGER_FMT is the format for writing integers.
    518 @@ LUA_MAXINTEGER is the maximum value for a LUA_INTEGER.
    519 @@ LUA_MININTEGER is the minimum value for a LUA_INTEGER.
    520 @@ lua_integer2str converts an integer to a string.
    521 */
    522 
    523 
    524 /* The following definitions are good for most cases here */
    525 
    526 #define LUA_INTEGER_FMT		"%" LUA_INTEGER_FRMLEN "d"
    527 
    528 #define LUAI_UACINT		LUA_INTEGER
    529 
    530 #define lua_integer2str(s,sz,n)  \
    531 	l_sprintf((s), sz, LUA_INTEGER_FMT, (LUAI_UACINT)(n))
    532 
    533 /*
    534 ** use LUAI_UACINT here to avoid problems with promotions (which
    535 ** can turn a comparison between unsigneds into a signed comparison)
    536 */
    537 #define LUA_UNSIGNED		unsigned LUAI_UACINT
    538 
    539 
    540 /* now the variable definitions */
    541 
    542 #if LUA_INT_TYPE == LUA_INT_INT		/* { int */
    543 
    544 #define LUA_INTEGER		int
    545 #define LUA_INTEGER_FRMLEN	""
    546 
    547 #define LUA_MAXINTEGER		INT_MAX
    548 #define LUA_MININTEGER		INT_MIN
    549 
    550 #elif LUA_INT_TYPE == LUA_INT_LONG	/* }{ long */
    551 
    552 #define LUA_INTEGER		long
    553 #define LUA_INTEGER_FRMLEN	"l"
    554 
    555 #define LUA_MAXINTEGER		LONG_MAX
    556 #define LUA_MININTEGER		LONG_MIN
    557 
    558 #elif LUA_INT_TYPE == LUA_INT_LONGLONG	/* }{ long long */
    559 
    560 /* use presence of macro LLONG_MAX as proxy for C99 compliance */
    561 #if defined(LLONG_MAX)		/* { */
    562 /* use ISO C99 stuff */
    563 
    564 #define LUA_INTEGER		long long
    565 #define LUA_INTEGER_FRMLEN	"ll"
    566 
    567 #define LUA_MAXINTEGER		LLONG_MAX
    568 #define LUA_MININTEGER		LLONG_MIN
    569 
    570 #elif defined(LUA_USE_WINDOWS) /* }{ */
    571 /* in Windows, can use specific Windows types */
    572 
    573 #define LUA_INTEGER		__int64
    574 #define LUA_INTEGER_FRMLEN	"I64"
    575 
    576 #define LUA_MAXINTEGER		_I64_MAX
    577 #define LUA_MININTEGER		_I64_MIN
    578 
    579 #else				/* }{ */
    580 
    581 #error "Compiler does not support 'long long'. Use option '-DLUA_32BITS' \
    582   or '-DLUA_C89_NUMBERS' (see file 'luaconf.h' for details)"
    583 
    584 #endif				/* } */
    585 
    586 #else				/* }{ */
    587 
    588 #error "numeric integer type not defined"
    589 
    590 #endif				/* } */
    591 
    592 /* }================================================================== */
    593 
    594 
    595 /*
    596 ** {==================================================================
    597 ** Dependencies with C99 and other C details
    598 ** ===================================================================
    599 */
    600 
    601 /*
    602 @@ l_sprintf is equivalent to 'snprintf' or 'sprintf' in C89.
    603 ** (All uses in Lua have only one format item.)
    604 */
    605 #if !defined(LUA_USE_C89)
    606 #define l_sprintf(s,sz,f,i)	snprintf(s,sz,f,i)
    607 #else
    608 #define l_sprintf(s,sz,f,i)	((void)(sz), sprintf(s,f,i))
    609 #endif
    610 
    611 
    612 /*
    613 @@ lua_strx2number converts an hexadecimal numeric string to a number.
    614 ** In C99, 'strtod' does that conversion. Otherwise, you can
    615 ** leave 'lua_strx2number' undefined and Lua will provide its own
    616 ** implementation.
    617 */
    618 #if !defined(LUA_USE_C89)
    619 #define lua_strx2number(s,p)		lua_str2number(s,p)
    620 #endif
    621 
    622 
    623 /*
    624 @@ lua_pointer2str converts a pointer to a readable string in a
    625 ** non-specified way.
    626 */
    627 #define lua_pointer2str(buff,sz,p)	l_sprintf(buff,sz,"%p",p)
    628 
    629 
    630 /*
    631 @@ lua_number2strx converts a float to an hexadecimal numeric string.
    632 ** In C99, 'sprintf' (with format specifiers '%a'/'%A') does that.
    633 ** Otherwise, you can leave 'lua_number2strx' undefined and Lua will
    634 ** provide its own implementation.
    635 */
    636 #if !defined(LUA_USE_C89)
    637 #define lua_number2strx(L,b,sz,f,n)  \
    638 	((void)L, l_sprintf(b,sz,f,(LUAI_UACNUMBER)(n)))
    639 #endif
    640 
    641 
    642 /*
    643 ** 'strtof' and 'opf' variants for math functions are not valid in
    644 ** C89. Otherwise, the macro 'HUGE_VALF' is a good proxy for testing the
    645 ** availability of these variants. ('math.h' is already included in
    646 ** all files that use these macros.)
    647 */
    648 #if defined(LUA_USE_C89) || (defined(HUGE_VAL) && !defined(HUGE_VALF))
    649 #undef l_mathop  /* variants not available */
    650 #undef lua_str2number
    651 #define l_mathop(op)		(lua_Number)op  /* no variant */
    652 #define lua_str2number(s,p)	((lua_Number)strtod((s), (p)))
    653 #endif
    654 
    655 
    656 /*
    657 @@ LUA_KCONTEXT is the type of the context ('ctx') for continuation
    658 ** functions.  It must be a numerical type; Lua will use 'intptr_t' if
    659 ** available, otherwise it will use 'ptrdiff_t' (the nearest thing to
    660 ** 'intptr_t' in C89)
    661 */
    662 #define LUA_KCONTEXT	ptrdiff_t
    663 
    664 #if !defined(LUA_USE_C89) && defined(__STDC_VERSION__) && \
    665     __STDC_VERSION__ >= 199901L
    666 #include <stdint.h>
    667 #if defined(INTPTR_MAX)  /* even in C99 this type is optional */
    668 #undef LUA_KCONTEXT
    669 #define LUA_KCONTEXT	intptr_t
    670 #endif
    671 #endif
    672 
    673 
    674 /*
    675 @@ lua_getlocaledecpoint gets the locale "radix character" (decimal point).
    676 ** Change that if you do not want to use C locales. (Code using this
    677 ** macro must include header 'locale.h'.)
    678 */
    679 #if !defined(lua_getlocaledecpoint)
    680 #define lua_getlocaledecpoint()		(localeconv()->decimal_point[0])
    681 #endif
    682 
    683 /* }================================================================== */
    684 
    685 
    686 /*
    687 ** {==================================================================
    688 ** Language Variations
    689 ** =====================================================================
    690 */
    691 
    692 /*
    693 @@ LUA_NOCVTN2S/LUA_NOCVTS2N control how Lua performs some
    694 ** coercions. Define LUA_NOCVTN2S to turn off automatic coercion from
    695 ** numbers to strings. Define LUA_NOCVTS2N to turn off automatic
    696 ** coercion from strings to numbers.
    697 */
    698 /* #define LUA_NOCVTN2S */
    699 /* #define LUA_NOCVTS2N */
    700 
    701 
    702 /*
    703 @@ LUA_USE_APICHECK turns on several consistency checks on the C API.
    704 ** Define it as a help when debugging C code.
    705 */
    706 #if defined(LUA_USE_APICHECK)
    707 #include <assert.h>
    708 #define luai_apicheck(l,e)	assert(e)
    709 #endif
    710 
    711 /* }================================================================== */
    712 
    713 
    714 /*
    715 ** {==================================================================
    716 ** Macros that affect the API and must be stable (that is, must be the
    717 ** same when you compile Lua and when you compile code that links to
    718 ** Lua). You probably do not want/need to change them.
    719 ** =====================================================================
    720 */
    721 
    722 /*
    723 @@ LUAI_MAXSTACK limits the size of the Lua stack.
    724 ** CHANGE it if you need a different limit. This limit is arbitrary;
    725 ** its only purpose is to stop Lua from consuming unlimited stack
    726 ** space (and to reserve some numbers for pseudo-indices).
    727 */
    728 #if LUAI_BITSINT >= 32
    729 #define LUAI_MAXSTACK		1000000
    730 #else
    731 #define LUAI_MAXSTACK		15000
    732 #endif
    733 
    734 
    735 /*
    736 @@ LUA_EXTRASPACE defines the size of a raw memory area associated with
    737 ** a Lua state with very fast access.
    738 ** CHANGE it if you need a different size.
    739 */
    740 #define LUA_EXTRASPACE		(sizeof(void *))
    741 
    742 
    743 /*
    744 @@ LUA_IDSIZE gives the maximum size for the description of the source
    745 @@ of a function in debug information.
    746 ** CHANGE it if you want a different size.
    747 */
    748 #define LUA_IDSIZE	60
    749 
    750 
    751 /*
    752 @@ LUAL_BUFFERSIZE is the buffer size used by the lauxlib buffer system.
    753 ** CHANGE it if it uses too much C-stack space. (For long double,
    754 ** 'string.format("%.99f", -1e4932)' needs 5034 bytes, so a
    755 ** smaller buffer would force a memory allocation for each call to
    756 ** 'string.format'.)
    757 */
    758 #if LUA_FLOAT_TYPE == LUA_FLOAT_LONGDOUBLE
    759 #define LUAL_BUFFERSIZE		8192
    760 #else
    761 #define LUAL_BUFFERSIZE   ((int)(0x80 * sizeof(void*) * sizeof(lua_Integer)))
    762 #endif
    763 
    764 /* }================================================================== */
    765 
    766 
    767 /*
    768 @@ LUA_QL describes how error messages quote program elements.
    769 ** Lua does not use these macros anymore; they are here for
    770 ** compatibility only.
    771 */
    772 #define LUA_QL(x)	"'" x "'"
    773 #define LUA_QS		LUA_QL("%s")
    774 
    775 
    776 
    777 
    778 /* =================================================================== */
    779 
    780 /*
    781 ** Local configuration. You can use this space to add your redefinitions
    782 ** without modifying the main part of the file.
    783 */
    784 
    785 
    786 
    787 
    788 
    789 #endif
    790